package central

import (
	"testing"

	centralapi "github.com/tidbcloud/core-svc/idl/pbgen/proto/central"

	globaldedicatedv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/dedicated/v1"
)

func TestProviderConversion(t *testing.T) {
	for _, test := range []struct {
		name      string
		input     string
		expected  centralapi.CloudRegion_CloudProvider
		dedicated string
		wantErr   bool
	}{
		{name: "lowercase AWS", input: "aws", expected: centralapi.CloudRegion_AWS, dedicated: "aws"},
		{name: "uppercase GCP", input: "GCP", expected: centralapi.CloudRegion_GCP, dedicated: "gcp"},
		{name: "uppercase Azure", input: "AZURE", expected: centralapi.CloudRegion_AZURE, dedicated: "azure"},
		{name: "unsupported", input: "oracle", wantErr: true},
		{name: "unspecified", input: "cloud_provider_unspecified", wantErr: true},
	} {
		t.Run(test.name, func(t *testing.T) {
			actual, err := providerFromString(test.input)
			if test.wantErr {
				if err == nil {
					t.Fatalf("providerFromString(%q) returned no error", test.input)
				}
				return
			}
			if err != nil {
				t.Fatalf("providerFromString(%q): %v", test.input, err)
			}
			if actual != test.expected {
				t.Fatalf("providerFromString(%q) = %v, want %v", test.input, actual, test.expected)
			}
			if providerToDedicated(actual) != test.dedicated {
				t.Fatalf("providerToDedicated(%v) = %q, want %q", actual, providerToDedicated(actual), test.dedicated)
			}
		})
	}
}

func TestCidrToCentral(t *testing.T) {
	actual := cidrToCentral(&globaldedicatedv1.Cidr{
		Id:                42,
		ProjectId:         1440002003,
		Cidr:              "10.250.0.0/16",
		CloudProviderName: "aws",
		RegionName:        "us-west-2",
		RegionDisplayName: "Oregon (us-west-2)",
		State:             globaldedicatedv1.Cidr_STATE_ACTIVE,
		VpcId:             "vpc-123",
	})

	if actual.Id != 42 || actual.ProjectId != 1440002003 || actual.Cidr != "10.250.0.0/16" {
		t.Fatalf("unexpected CIDR identity: %+v", actual)
	}
	if actual.Provider != centralapi.CloudRegion_AWS || actual.Region == nil || actual.Region.Provider != centralapi.CloudRegion_AWS {
		t.Fatalf("unexpected provider conversion: %+v", actual)
	}
	if actual.Region.Name != "us-west-2" || actual.Region.DisplayName != "Oregon (us-west-2)" {
		t.Fatalf("unexpected region conversion: %+v", actual.Region)
	}
	if actual.State != centralapi.Cidr_State(globaldedicatedv1.Cidr_STATE_ACTIVE) || actual.VpcId != "vpc-123" {
		t.Fatalf("unexpected state conversion: %+v", actual)
	}
}

func TestOverlapsToCentral(t *testing.T) {
	actual := overlapsToCentral([]*globaldedicatedv1.CidrOverlap{{
		ProjectId: 1440002003,
		Regions: []*globaldedicatedv1.CidrOverlap_CloudRegion{{
			Name: "us-west-2", DisplayName: "Oregon (us-west-2)", CloudProviderName: "aws",
		}},
	}})

	if len(actual) != 1 || actual[0].ProjectId != 1440002003 || len(actual[0].Regions) != 1 {
		t.Fatalf("unexpected overlap conversion: %+v", actual)
	}
	region := actual[0].Regions[0]
	if region.Name != "us-west-2" || region.DisplayName != "Oregon (us-west-2)" || region.Provider != centralapi.CloudRegion_AWS {
		t.Fatalf("unexpected overlap region: %+v", region)
	}
}