package testdata

import (
	"time"

	"github.com/samber/lo"
	"gorm.io/gorm"

	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/infra/repoimpl/schema"
)

func GetRegionRecords() []*schema.Region {
	return []*schema.Region{
		// AWS Regions
		{
			Model: gorm.Model{
				ID: 1,
				CreatedAt: func() time.Time {
					t, _ := time.Parse("2006-01-02 15:04:05", "2024-06-01 10:00:00")
					return t
				}(),
			},
			Name:              "us-west-2-a0",
			RegionName:        "us-west-2",
			ProviderId:        1, // AWS
			DisplayName:       "Oregon (us-west-2)",
			CountryCode:       "US",
			Area:              "Americas",
			Priority:          100,
			Status:            "active",
			IsPublic:          lo.ToPtr(true),
			DefaultBackupTime: "10:00",
			ServiceAddress:    "https://a0-us-west-2.tidbcloud.com",
			ServicePlan:       "Premium",
			RegionTenants:     []*schema.RegionTenant{},
		},
		{
			Model: gorm.Model{
				ID: 2,
				CreatedAt: func() time.Time {
					t, _ := time.Parse("2006-01-02 15:04:05", "2024-06-02 10:00:00")
					return t
				}(),
			},
			Name:              "us-west-2-a1",
			RegionName:        "us-west-2",
			ProviderId:        1, // AWS
			DisplayName:       "Oregon (us-west-2)",
			CountryCode:       "US",
			Area:              "Americas",
			Priority:          9999991,
			Status:            "active",
			IsPublic:          lo.ToPtr(true),
			DefaultBackupTime: "10:00",
			ServiceAddress:    "https://a1-us-west-2.tidbcloud.com",
			ServicePlan:       "Premium",
			RegionTenants:     []*schema.RegionTenant{},
		},
		{
			Model: gorm.Model{
				ID: 3,
				CreatedAt: func() time.Time {
					t, _ := time.Parse("2006-01-02 15:04:05", "2024-06-03 10:00:00")
					return t
				}(),
			},
			Name:              "us-west-2-a2",
			RegionName:        "us-west-2",
			ProviderId:        1, // AWS
			DisplayName:       "Oregon (us-west-2)",
			CountryCode:       "US",
			Area:              "Americas",
			Priority:          9999991,
			Status:            "active",
			IsPublic:          lo.ToPtr(true),
			DefaultBackupTime: "10:00",
			ServiceAddress:    "https://a2-us-west-2.tidbcloud.com",
			ServicePlan:       "Premium",
			RegionTenants:     []*schema.RegionTenant{},
		},
		{
			Model: gorm.Model{
				ID: 4,
				CreatedAt: func() time.Time {
					t, _ := time.Parse("2006-01-02 15:04:05", "2024-06-03 10:00:00")
					return t
				}(),
			},
			Name:              "us-east-1",
			RegionName:        "us-east-1",
			ProviderId:        1, // AWS
			DisplayName:       "Virginia (us-east-1)",
			CountryCode:       "US",
			Area:              "Americas",
			Priority:          9999991,
			Status:            "active",
			IsPublic:          lo.ToPtr(true),
			DefaultBackupTime: "10:00",
			ServiceAddress:    "https://a2-us-east-1.tidbcloud.com",
			ServicePlan:       "Premium",
			RegionTenants:     []*schema.RegionTenant{},
		},
		{
			Model: gorm.Model{
				ID: 5,
				CreatedAt: func() time.Time {
					t, _ := time.Parse("2006-01-02 15:04:05", "2024-06-03 10:00:00")
					return t
				}(),
			},
			Name:              "us-east1-a0",
			RegionName:        "us-east1",
			ProviderId:        3, // GCP
			DisplayName:       "Virginia (us-east1)",
			CountryCode:       "US",
			Area:              "Americas",
			Priority:          9999992,
			Status:            "active",
			IsPublic:          lo.ToPtr(false),
			DefaultBackupTime: "10:00",
			ServiceAddress:    "https://a0-us-east1.tidbcloud.com",
			ServicePlan:       "BYOC",
			RegionTenants:     []*schema.RegionTenant{},
		},
	}
}

func GetProviderRecords() []*schema.Provider {
	return []*schema.Provider{
		{
			Model:       gorm.Model{ID: 1},
			Name:        "aws",
			DisplayName: "AWS",
			Status:      "active",
			IsPublic:    true,
			ServicePlan: "Premium",
		},
		{
			Model:       gorm.Model{ID: 2},
			Name:        "alicloud",
			DisplayName: "Alibaba Cloud",
			Status:      "inactive",
			IsPublic:    true,
			ServicePlan: "Premium",
		},
		{
			Model:       gorm.Model{ID: 3},
			Name:        "gcp",
			DisplayName: "GCP",
			Status:      "inactive",
			IsPublic:    true,
			ServicePlan: "BYOC",
		},
		{
			Model:       gorm.Model{ID: 4},
			Name:        "azure",
			DisplayName: "Azure",
			Status:      "active",
			IsPublic:    true,
			ServicePlan: "BYOC",
		},
		{
			Model:       gorm.Model{ID: 5},
			Name:        "aws",
			DisplayName: "AWS",
			Status:      "active",
			IsPublic:    true,
			ServicePlan: "BYOC",
		},
		{
			Model:       gorm.Model{ID: 6},
			Name:        "aws",
			DisplayName: "AWS",
			Status:      "active",
			IsPublic:    true,
			ServicePlan: "Essential_V2",
		},
	}
}

const (
	TestOrgID = 1001
)

func GetRegionTenantRecords() []*schema.RegionTenant {
	return []*schema.RegionTenant{
		{
			Model:               gorm.Model{ID: 1},
			TenantId:            TestOrgID,
			RegionId:            1,
			RegionServicePlanId: 1,
		},
		{
			Model:               gorm.Model{ID: 2},
			TenantId:            TestOrgID,
			RegionId:            2,
			RegionServicePlanId: 2,
		},
		{
			Model:               gorm.Model{ID: 3},
			TenantId:            TestOrgID,
			RegionId:            3,
			RegionServicePlanId: 3,
		},
		{
			Model:               gorm.Model{ID: 5},
			TenantId:            TestOrgID,
			RegionId:            5,
			RegionServicePlanId: 5,
		},
	}
}

func GetRegionServicePlanRecords() []*schema.RegionServicePlan {
	return []*schema.RegionServicePlan{
		{Model: gorm.Model{ID: 1}, RegionId: 1, ServicePlan: "Premium", IsPublic: lo.ToPtr(true)},
		{Model: gorm.Model{ID: 2}, RegionId: 2, ServicePlan: "Premium", IsPublic: lo.ToPtr(true)},
		{Model: gorm.Model{ID: 3}, RegionId: 3, ServicePlan: "Premium", IsPublic: lo.ToPtr(true)},
		{Model: gorm.Model{ID: 4}, RegionId: 4, ServicePlan: "Premium", IsPublic: lo.ToPtr(true)},
		{Model: gorm.Model{ID: 5}, RegionId: 5, ServicePlan: "BYOC", IsPublic: lo.ToPtr(false)},
		{Model: gorm.Model{ID: 6}, RegionId: 1, ServicePlan: "Essential_V2", IsPublic: lo.ToPtr(true)},
	}
}

// GetRegionByID returns a region by its ID
func GetRegionByID(id uint) *schema.Region {
	regions := GetRegionRecords()
	for _, region := range regions {
		if region.ID == id {
			return region
		}
	}
	return nil
}

// GetProviderByID returns a provider by its ID
func GetProviderByID(id uint) *schema.Provider {
	providers := GetProviderRecords()
	for _, provider := range providers {
		if provider.ID == id {
			return provider
		}
	}
	return nil
}

// GetRegionsByProvider returns all regions for a specific provider
func GetRegionsByProvider(providerID uint64) []*schema.Region {
	regions := GetRegionRecords()
	var result []*schema.Region
	for _, region := range regions {
		if region.ProviderId == providerID {
			result = append(result, region)
		}
	}
	return result
}

// GetActiveRegions returns all active regions
func GetActiveRegions() []*schema.Region {
	regions := GetRegionRecords()
	var result []*schema.Region
	for _, region := range regions {
		if region.Status == "active" {
			result = append(result, region)
		}
	}
	return result
}

// GetPublicRegions returns all public regions
func GetPublicRegions() []*schema.Region {
	regions := GetRegionRecords()
	var result []*schema.Region
	for _, region := range regions {
		if region.IsPublic != nil && *region.IsPublic {
			result = append(result, region)
		}
	}
	return result
}

// GetPrivateRegions returns all private regions
func GetPrivateRegions() []*schema.Region {
	regions := GetRegionRecords()
	var result []*schema.Region
	for _, region := range regions {
		if region.IsPublic != nil && !*region.IsPublic {
			result = append(result, region)
		}
	}
	return result
}

// GetRegionsByServicePlan returns all regions for a specific service plan
func GetRegionsByServicePlan(servicePlan string) []*schema.Region {
	regions := GetRegionRecords()
	var result []*schema.Region
	for _, region := range regions {
		if region.ServicePlan == servicePlan {
			result = append(result, region)
		}
	}
	return result
}

// GetActiveProviders returns all active providers
func GetActiveProviders() []*schema.Provider {
	providers := GetProviderRecords()
	var result []*schema.Provider
	for _, provider := range providers {
		if provider.Status == "active" {
			result = append(result, provider)
		}
	}
	return result
}