package task

import (
	"dsbqj-admin/model/mongo/version"
	"testing"
)

func TestVersionsCheckEnvVersionAndDefault(t *testing.T) {
	versions := VersionInit()
	platform := new(PlatformVersions)

	releaseDefault := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.0", Url: "正式服默认地址", Default: true}
	releaseExact := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.1", Url: "正式服版本地址"}
	trialDefault := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "1.0.0", Url: "体验服默认地址", Default: true}
	trialExact := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "1.0.1", Url: "体验服版本地址"}

	for _, v := range []*version.Version{releaseDefault, releaseExact, trialDefault, trialExact} {
		platform.VList.Push(v)
		platform.VMap.Set(versionMapKey(v.Version, NormalizeEnvVersion(v.EnvVersion)), v)
	}

	versions.VPlatforms.Set("wx", platform)

	if got := versions.Check("1.0.1", "wx", "trial"); got != trialExact {
		t.Fatalf("传入版本号和体验版环境时应精确匹配体验版版本，实际返回 %#v", got)
	}

	if got := versions.Check("1.0.1", "wx", "release"); got != releaseExact {
		t.Fatalf("传入版本号和正式服环境时应精确匹配正式服版本，实际返回 %#v", got)
	}

	if got := versions.Check("1.0.1", "wx", ""); got != releaseExact {
		t.Fatalf("未传环境版本应返回正式服地址，实际返回 %#v", got)
	}

	if got := versions.Check("1.0.1", "wx", ""); got == nil || got.Version != "1.0.1" {
		t.Fatalf("未传环境版本时应优先按版本号返回任意环境版本，实际返回 %#v", got)
	}

	if got := versions.Check("9.9.9", "wx", "trial"); got != trialDefault {
		t.Fatalf("体验版版本号未命中应返回体验版默认版本，实际返回 %#v", got)
	}

	if got := versions.Check("9.9.9", "wx", "develop"); got != trialDefault {
		t.Fatalf("develop 版本号未命中应返回体验版默认版本，实际返回 %#v", got)
	}
}

func TestVersionsCheckWithoutEnvVersionUsesVersionFirst(t *testing.T) {
	versions := VersionInit()
	platform := new(PlatformVersions)

	releaseDefault := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.0", Url: "正式服默认地址", Default: true}
	trialExact := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "0.2.0", Url: "体验版版本地址"}

	for _, v := range []*version.Version{releaseDefault, trialExact} {
		platform.VList.Push(v)
		platform.VMap.Set(versionMapKey(v.Version, NormalizeEnvVersion(v.EnvVersion)), v)
	}
	versions.VPlatforms.Set("wx", platform)

	if got := versions.Check("0.2.0", "wx", ""); got != trialExact {
		t.Fatalf("未传环境版本时应按版本号命中体验版版本，实际返回 %#v", got)
	}

	if got := versions.Check("9.9.9", "wx", ""); got != releaseDefault {
		t.Fatalf("传入不存在的版本号应回退到正式服默认地址，实际返回 %#v", got)
	}
}

func TestVersionsCheckVersionConditionOverridesDefault(t *testing.T) {
	versions := VersionInit()
	platform := new(PlatformVersions)

	releaseDefault := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.0", Url: "正式服默认地址", Default: true}
	releaseExact := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.1", Url: "正式服版本地址"}
	trialDefault := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "2.0.0", Url: "体验版默认地址", Default: true}
	trialExact := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "1.0.1", Url: "体验版版本地址"}

	for _, v := range []*version.Version{releaseDefault, releaseExact, trialDefault, trialExact} {
		platform.VList.Push(v)
		platform.VMap.Set(versionMapKey(v.Version, NormalizeEnvVersion(v.EnvVersion)), v)
	}
	versions.VPlatforms.Set("wx", platform)

	if got := versions.Check("1.0.1", "wx", "release"); got != releaseExact {
		t.Fatalf("传入正式服版本号时应匹配指定版本，实际返回 %#v", got)
	}

	if got := versions.Check("1.0.1", "wx", "trial"); got != trialExact {
		t.Fatalf("传入体验版版本号时应匹配指定版本，实际返回 %#v", got)
	}
	if got := versions.Check("", "wx", "release"); got != releaseDefault {
		t.Fatalf("不传版本号时应返回正式服默认版本，实际返回 %#v", got)
	}
	if got := versions.Check("", "wx", "trial"); got != trialDefault {
		t.Fatalf("不传版本号时应返回体验版默认版本，实际返回 %#v", got)
	}
}

func TestVersionsCheckEnvVersionWithoutDefault(t *testing.T) {
	versions := VersionInit()
	platform := new(PlatformVersions)

	releaseExact := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.1", Url: "正式服版本地址"}
	trialExact := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "1.0.1", Url: "体验版版本地址"}

	for _, v := range []*version.Version{releaseExact, trialExact} {
		platform.VList.Push(v)
		platform.VMap.Set(versionMapKey(v.Version, NormalizeEnvVersion(v.EnvVersion)), v)
	}
	versions.VPlatforms.Set("wx", platform)

	if got := versions.Check("1.0.1", "wx", "release"); got != releaseExact {
		t.Fatalf("正式服没有默认地址时应返回正式服版本地址，实际返回 %#v", got)
	}

	if got := versions.Check("1.0.1", "wx", "trial"); got != trialExact {
		t.Fatalf("体验版没有默认地址时应返回体验版版本地址，实际返回 %#v", got)
	}
}

func TestVersionsCheckFallsBackToLegacyRecords(t *testing.T) {
	versions := VersionInit()
	legacy := new(PlatformVersions)
	record := &version.Version{Channel: "bb", Version: "1.0.0", EnvVersion: "release", Url: "历史地址"}
	legacy.VList.Push(record)
	legacy.VMap.Set(versionMapKey(record.Version, NormalizeEnvVersion(record.EnvVersion)), record)
	versions.VPlatforms.Set("", legacy)

	if got := versions.Check("1.0.0", "wx", ""); got != record {
		t.Fatalf("平台记录不存在时应兼容读取历史空平台记录，实际返回 %#v", got)
	}
}

func TestVersionsCheckWithoutVersionUsesEnvironmentDefault(t *testing.T) {
	versions := VersionInit()
	platform := new(PlatformVersions)
	releaseDefault := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.0", Default: true}
	trialDefault := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "1.0.1", Default: true}
	otherPlatformDefault := &version.Version{Platform: "dy", EnvVersion: "trial", Version: "9.9.9", Default: true}
	platform.VList.Push(releaseDefault)
	platform.VList.Push(trialDefault)
	versions.VPlatforms.Set("wx", platform)
	other := new(PlatformVersions)
	other.VList.Push(otherPlatformDefault)
	versions.VPlatforms.Set("dy", other)

	if got := versions.Check("", "wx", "trial"); got != trialDefault {
		t.Fatalf("empty version should use the trial default for the requested platform: %#v", got)
	}
	if got := versions.Check("", "wx", "release"); got != releaseDefault {
		t.Fatalf("empty version should use the release default for the requested platform: %#v", got)
	}
	if got := versions.Check("", "wx", ""); got != releaseDefault {
		t.Fatalf("empty version and environment should use the release default: %#v", got)
	}
	if got := versions.Check("", "dy", "trial"); got != otherPlatformDefault {
		t.Fatalf("empty version should not cross platform boundaries: %#v", got)
	}
}

func TestVersionsCheckWithoutVersionFallsBackToLatestEnvironmentVersion(t *testing.T) {
	versions := VersionInit()
	platform := new(PlatformVersions)
	releaseOld := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.2"}
	releaseLatest := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.10"}
	trial := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "2.0.0"}
	for _, item := range []*version.Version{releaseOld, trial, releaseLatest} {
		platform.VList.Push(item)
	}
	versions.VPlatforms.Set("wx", platform)

	if got := versions.Check("", "wx", ""); got != releaseLatest {
		t.Fatalf("空版本号和环境应返回最新正式服版本，实际返回 %#v", got)
	}
	if got := versions.Check("", "wx", "trial"); got != trial {
		t.Fatalf("空版本号应只在指定环境内选择，实际返回 %#v", got)
	}
	if got := versions.Check("9.9.9", "wx", "trial"); got != trial {
		t.Fatalf("指定版本未命中应返回体验版最新版本，实际返回 %#v", got)
	}
	if got := versions.Check("", "dy", ""); got != nil {
		t.Fatalf("不应跨平台返回版本，实际返回 %#v", got)
	}

	releaseOld.Default = true
	if got := versions.Check("", "wx", ""); got != releaseOld {
		t.Fatalf("正式服默认标记应优先于最新版本，实际返回 %#v", got)
	}
}

func TestVersionsCheckTrialMissFallsBackToMatchingReleaseVersion(t *testing.T) {
	versions := VersionInit()
	platform := new(PlatformVersions)
	releaseDefault := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.0", Default: true}
	releaseExact := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.1"}
	for _, item := range []*version.Version{releaseDefault, releaseExact} {
		platform.VList.Push(item)
		platform.VMap.Set(versionMapKey(item.Version, releaseEnvVersion), item)
	}
	versions.VPlatforms.Set("wx", platform)

	if got := versions.Check("1.0.1", "wx", "trial"); got != releaseExact {
		t.Fatalf("体验服环境未命中时应优先返回同版本正式服配置，实际返回 %#v", got)
	}
	if got := versions.Check("9.9.9", "wx", "trial"); got != releaseDefault {
		t.Fatalf("版本号未命中时应返回正式服默认配置，实际返回 %#v", got)
	}
}

func TestVersionsCheckDevelopAndEnvironmentFallback(t *testing.T) {
	releaseDefault := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.0", Default: true}
	releaseExact := &version.Version{Platform: "wx", EnvVersion: "release", Version: "1.0.3"}
	trialDefault := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "1.0.1", Default: true}
	trialLatest := &version.Version{Platform: "wx", EnvVersion: "trial", Version: "1.0.2"}
	legacyTrial := &version.Version{EnvVersion: "trial", Version: "1.0.3"}
	otherTrial := &version.Version{Platform: "dy", EnvVersion: "trial", Version: "1.0.3"}
	cases := []struct {
		name    string
		records []*version.Version
		number  string
		env     string
		want    *version.Version
	}{
		{"develop exact", []*version.Version{releaseExact, trialLatest}, "1.0.2", "develop", trialLatest},
		{"develop normalized", []*version.Version{releaseExact, trialLatest}, "1.0.2", " DeVeLoP ", trialLatest},
		{"develop default before matching release", []*version.Version{releaseExact, trialDefault, trialLatest}, "1.0.3", "develop", trialDefault},
		{"trial default before matching release", []*version.Version{releaseExact, trialDefault, trialLatest}, "1.0.3", "trial", trialDefault},
		{"trial latest before matching release", []*version.Version{releaseExact, trialLatest}, "1.0.3", "trial", trialLatest},
		{"develop latest before matching release", []*version.Version{releaseExact, trialLatest}, "1.0.3", "develop", trialLatest},
		{"develop empty version", []*version.Version{releaseDefault, trialDefault, trialLatest}, "", "develop", trialDefault},
		{"develop missing trial", []*version.Version{releaseDefault, releaseExact}, "1.0.3", "develop", releaseExact},
		{"develop missing version and trial", []*version.Version{releaseDefault, releaseExact}, "9.9.9", "develop", releaseDefault},
		{"develop release latest", []*version.Version{releaseExact}, "9.9.9", "develop", releaseExact},
		{"develop empty version without trial", []*version.Version{releaseDefault}, "", "develop", releaseDefault},
		{"platform isolation", []*version.Version{releaseExact, otherTrial}, "1.0.3", "develop", releaseExact},
		{"legacy trial before release", []*version.Version{releaseExact, legacyTrial}, "1.0.3", "develop", legacyTrial},
		{"platform default before legacy exact", []*version.Version{trialDefault, legacyTrial}, "1.0.3", "develop", trialDefault},
		{"release miss stays release", []*version.Version{releaseDefault, trialLatest}, "1.0.2", "release", releaseDefault},
		{"no records", nil, "1.0.3", "develop", nil},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			versions := new(Versions)
			for _, record := range tc.records {
				platform, ok := versions.VPlatforms.Get(record.Platform)
				if !ok {
					platform = new(PlatformVersions)
					versions.VPlatforms.Set(record.Platform, platform)
				}
				platform.VList.Push(record)
				platform.VMap.Set(versionMapKey(record.Version, NormalizeEnvVersion(record.EnvVersion)), record)
			}
			if got := versions.Check(tc.number, "wx", tc.env); got != tc.want {
				t.Fatalf("Check(%q, wx, %q) = %#v, want %#v", tc.number, tc.env, got, tc.want)
			}
		})
	}
	if got := NormalizeEnvVersion("develop"); got != releaseEnvVersion {
		t.Fatalf("query alias must not change stored environment normalization: %q", got)
	}
}