//Package migrate this only use in migrate data from v1 to v2, will delete after migrated data.
package migrate

import (
	"fmt"
	"strings"

	"github.com/pingcap/dbaas/billing2/forms"
	"github.com/pingcap/dbaas/billing2/model/billing"
	"github.com/shopspring/decimal"
)

type MigrateModel struct{}

func (s *MigrateModel) CreateNewPackages() error {
	// must called first and keep orders to have same id config in central
	packageModel := &billing.PackageModel{}
	_, err := packageModel.CreatePackage(&forms.PackageInfo{
		Description:          "POC Package",
		CreditsEnable:        true,
		CreditsOnly:          true,
		TenantMaxBindedTimes: 1,
		Labels: map[string]string{
			"poc": "true",
		},
		Discount: decimal.NewFromInt(1),
	})
	if err != nil {
		return err
	}
	_, err = packageModel.CreatePackage(&forms.PackageInfo{
		Description:          "OnDemand Package",
		CreditsEnable:        false,
		CreditsOnly:          false,
		TenantMaxBindedTimes: 1,
		Labels:               map[string]string{},
		Discount:             decimal.RequireFromString("0.7"),
	})
	if err != nil {
		return err
	}
	_, err = packageModel.CreatePackage(&forms.PackageInfo{
		Description:          "DevTier Package",
		CreditsEnable:        true,
		CreditsOnly:          true,
		TenantMaxBindedTimes: 1,
		Labels: map[string]string{
			"devTier": "true",
		},
		Discount: decimal.NewFromInt(0),
	})
	if err != nil {
		return err
	}
	return nil
}

func (s *MigrateModel) CreateGlobalPricePackage() error {
	// should not be binded to customer, only for show price in dryrun
	packageModel := &billing.PackageModel{}
	_, err := packageModel.CreatePackage(&forms.PackageInfo{
		Description:   "Global Price Package",
		CreditsEnable: false,
		CreditsOnly:   false,
		Discount:      decimal.NewFromInt(1),
	})
	return err
}

func (*MigrateModel) CreateMigratePackageForLegacyData() (uint, error) {
	unitModel := &billing.UnitModel{}

	_, err := unitModel.CreateUnit(&forms.UnitInfo{
		UnitKey:     "LegacyNodeUsage",
		Description: "LegacyNodeUsage",
		Category:    "Node Usage Cost",
	})
	if err != nil {
		return 0, err
	}
	_, err = unitModel.CreateUnit(&forms.UnitInfo{
		UnitKey:     "LegacyBackupUsage",
		Description: "LegacyBackupUsage",
		Category:    "Data Backup Cost",
	})
	if err != nil {
		return 0, err
	}
	_, err = unitModel.CreateUnit(&forms.UnitInfo{
		UnitKey:     "LegacyDataTransferUsage",
		Description: "LegacyDataTransferUsage",
		Category:    "Data Transfer Cost",
	})
	if err != nil {
		return 0, err
	}

	packageModel := &billing.PackageModel{}
	info, err := packageModel.CreatePackage(
		&forms.PackageInfo{
			UnitPrices: forms.UnitPrices{
				"LegacyNodeUsage":         {Price: decimal.RequireFromString("0.001")},
				"LegacyBackupUsage":       {Price: decimal.RequireFromString("0.001")},
				"LegacyDataTransferUsage": {Price: decimal.RequireFromString("0.001")},
			},
			Discount:    decimal.NewFromInt(1),
			Description: "Migrate Package from v1 billing",
			Labels: map[string]string{
				"legacyData": "true",
			},
		})
	if err != nil {
		return 0, err
	}
	return info.PackageID, nil
}

func (*MigrateModel) CreateSystemSKU() error {
	unitModel := &billing.UnitModel{}

	_, err := unitModel.CreateUnit(&forms.UnitInfo{
		UnitKey:     "network-traffic:all",
		Description: "Data Transfer Cost - Load Balancing",
		Category:    "Data Transfer Cost - Load Balancing",
	})
	if err != nil {
		return err
	}
	_, err = unitModel.CreateUnit(&forms.UnitInfo{
		UnitKey:     "backup-storage:all",
		Description: "Data Backup Cost",
		Category:    "Data Backup Cost",
	})
	if err != nil {
		return err
	}
	return nil
}

func (*MigrateModel) UpdateDataTransferCategory() error {
	_, err := (&billing.UnitModel{}).UpdateUnit(&forms.UnitInfo{
		UnitKey:     "network-traffic:all",
		Description: "Data Transfer Cost - Load Balancing",
		Category:    "Data Transfer Cost - Load Balancing",
	})
	return err
}

func (*MigrateModel) CreateCDCSKU() error {
	unitModel := &billing.UnitModel{}
	_, err := unitModel.CreateUnit(&forms.UnitInfo{
		UnitKey:     "ticdc:network-traffic",
		Description: "TiCDC Data Transfer Cost",
		Category:    "TiCDC Data Transfer Cost",
	})
	if err != nil {
		return err
	}
	return nil
}

func (*MigrateModel) CreateNetworkDetailSKU() error {
	unitModel := &billing.UnitModel{}
	providers := []string{"aws", "gcp"}
	categories := map[string]string{"lb": "Load Balancing", "cross_az": "Same Region", "cross_region": "Cross Region", "internet": "Internet"}
	for _, provider := range providers {
		for key, value := range categories {
			_, err := unitModel.CreateUnit(&forms.UnitInfo{
				UnitKey:     fmt.Sprintf("network-traffic:%s:%s", provider, key),
				Description: fmt.Sprintf("Data Transfer Cost - %s %s", strings.ToUpper(provider), value),
				Category:    fmt.Sprintf("Data Transfer Cost - %s %s", strings.ToUpper(provider), value),
			})
			if err != nil {
				return err
			}
		}
	}

	return nil
}