package region

import (
	"testing"
)

func TestToUserFace(t *testing.T) {
	tests := []struct {
		name   string
		region string
		want   string
	}{
		{
			name:   "already user face format",
			region: "aws-us-east-1",
			want:   "aws-us-east-1",
		},
		{
			name:   "enum format to user face",
			region: "AWS_US_EAST_1",
			want:   "aws-us-east-1",
		},
		{
			name:   "empty string",
			region: "",
			want:   "",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := ToUserFace(tt.region); got != tt.want {
				t.Errorf("ToUserFace(%q) = %q, want %q", tt.region, got, tt.want)
			}
		})
	}
}

func TestToEnumFormat(t *testing.T) {
	tests := []struct {
		name   string
		region string
		want   string
	}{
		{
			name:   "already enum format",
			region: "AWS_US_EAST_1",
			want:   "AWS_US_EAST_1",
		},
		{
			name:   "user face format to enum",
			region: "aws-us-east-1",
			want:   "AWS_US_EAST_1",
		},
		{
			name:   "empty string",
			region: "",
			want:   "",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := ToEnumFormat(tt.region); got != tt.want {
				t.Errorf("ToEnumFormat(%q) = %q, want %q", tt.region, got, tt.want)
			}
		})
	}
}

func TestToEnumFormats(t *testing.T) {
	tests := []struct {
		name    string
		regions []string
		want    []string
	}{
		{
			name:    "empty slice",
			regions: []string{},
			want:    nil,
		},
		{
			name:    "single region",
			regions: []string{"aws-us-east-1"},
			want:    []string{"AWS_US_EAST_1"},
		},
		{
			name:    "multiple regions",
			regions: []string{"aws-us-east-1", "gcp-us-central1", "azure-eastus"},
			want:    []string{"AWS_US_EAST_1", "GCP_US_CENTRAL1", "AZURE_EASTUS"},
		},
		{
			name:    "mixed formats",
			regions: []string{"aws-us-east-1", "GCP_US_CENTRAL1", "azure-eastus"},
			want:    []string{"AWS_US_EAST_1", "GCP_US_CENTRAL1", "AZURE_EASTUS"},
		},
		{
			name:    "nil slice",
			regions: nil,
			want:    nil,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := ToEnumFormats(tt.regions)
			if len(got) != len(tt.want) {
				t.Errorf("ToEnumFormats() length = %d, want %d", len(got), len(tt.want))
				return
			}
			for i, v := range got {
				if v != tt.want[i] {
					t.Errorf("ToEnumFormats()[%d] = %q, want %q", i, v, tt.want[i])
				}
			}
		})
	}
}

func TestIsEqual(t *testing.T) {
	tests := []struct {
		name    string
		region1 string
		region2 string
		want    bool
	}{
		{
			name:    "same user face format",
			region1: "us-east-1",
			region2: "us-east-1",
			want:    true,
		},
		{
			name:    "different regions",
			region1: "us-east-1",
			region2: "us-east-2",
			want:    false,
		},
		{
			name:    "enum format equals user face",
			region1: "AWS_US_EAST_1",
			region2: "aws-us-east-1",
			want:    true,
		},
		{
			name:    "both enum format",
			region1: "AWS_US_EAST_1",
			region2: "AWS_US_EAST_1",
			want:    true,
		},
		{
			name:    "one empty string",
			region1: "us-east-1",
			region2: "",
			want:    false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := IsEqual(tt.region1, tt.region2); got != tt.want {
				t.Errorf("IsEqual(%q, %q) = %t, want %t", tt.region1, tt.region2, got, tt.want)
			}
		})
	}
}

func TestValidate(t *testing.T) {
	tests := []struct {
		name    string
		region  string
		wantErr bool
		errMsg  string
	}{
		{
			name:    "valid AWS region",
			region:  "AWS_US_EAST_1",
			wantErr: false,
		},
		{
			name:    "valid GCP region",
			region:  "GCP_US_CENTRAL1",
			wantErr: false,
		},
		{
			name:    "valid Azure region",
			region:  "AZURE_EASTUS",
			wantErr: false,
		},
		{
			name:    "valid AliCloud region",
			region:  "ALICLOUD_AP_SOUTHEAST_1",
			wantErr: false,
		},
		{
			name:    "empty region",
			region:  "",
			wantErr: true,
			errMsg:  "region is empty",
		},
		{
			name:    "invalid region",
			region:  "INVALID_REGION",
			wantErr: true,
			errMsg:  "region is not valid",
		},
		{
			name:    "unspecified region",
			region:  "NAME_UNSPECIFIED",
			wantErr: true,
			errMsg:  "region is not valid",
		},
		{
			name:    "valid user face format",
			region:  "aws-us-east-1",
			wantErr: false,
		},
		{
			name:    "invalid user face format",
			region:  "aws-us-east-1-invalid",
			wantErr: true,
			errMsg:  "region is not valid",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := Validate(tt.region)
			if (err != nil) != tt.wantErr {
				t.Errorf("Validate(%q) error = %v, wantErr %v", tt.region, err, tt.wantErr)
				return
			}
			if tt.wantErr && err != nil && tt.errMsg != "" && err.Error() != tt.errMsg {
				t.Errorf("Validate(%q) error message = %q, want %q", tt.region, err.Error(), tt.errMsg)
			}
		})
	}
}