package task

import (
	"dsbqj-admin/model/mongo/version"
	"dsbqj-admin/pkg/util"
	"strings"
	"sync"

	"github.com/kamva/mgm/v3"
	"go.mongodb.org/mongo-driver/bson"
)

const (
	releaseEnvVersion = "release"
	trialEnvVersion   = "trial"
)

var VersionTask *Versions

type Versions struct {
	sync.Mutex
	VChannels util.SafeMap[string, *ChannelVersions]
}

type ChannelVersions struct {
	VList util.SafeArray[*version.Version]
	VMap  util.SafeMap[string, *version.Version]
}

func NormalizeEnvVersion(envVersion string) string {
	if strings.EqualFold(strings.TrimSpace(envVersion), trialEnvVersion) {
		return trialEnvVersion
	}
	return releaseEnvVersion
}

func VersionInit() *Versions {
	VersionTask = new(Versions)
	return VersionTask
}

func (this *Versions) Exec() {
	var versions = make([]*version.Version, 0)
	err := mgm.Coll(&version.Version{}).SimpleFind(&versions, bson.M{})
	if err == nil {
		this.VChannels.Clear()
		for _, v := range versions {
			if _, ok := this.VChannels.Get(v.Channel); !ok {
				this.VChannels.Set(v.Channel, new(ChannelVersions))
			}

			channelVersion, _ := this.VChannels.Get(v.Channel)
			channelVersion.VList.Push(v)
			channelVersion.VMap.Set(versionMapKey(v.Version, NormalizeEnvVersion(v.EnvVersion)), v)
		}
	}
}

func (this *Versions) Check(version string, channel string, envVersion string) *version.Version {
	envVersionRequired := strings.TrimSpace(envVersion) != ""
	envVersion = NormalizeEnvVersion(envVersion)

	channelVersions, ok := this.VChannels.Get(channel)
	if !ok { // 遍历列表
		return nil
	}

	if envVersionRequired {
		if data := this.defaultVersion(channelVersions, channel, envVersion); data != nil {
			return data
		}
		if data, ok := channelVersions.VMap.Get(versionMapKey(version, envVersion)); ok {
			return data
		}
		return nil
	}

	if data := this.version(channelVersions, channel, version); data != nil {
		return data
	}

	return this.defaultVersion(channelVersions, channel, envVersion)
}

func (this *Versions) version(channelVersions *ChannelVersions, channel string, version string) *version.Version {
	for _, v := range channelVersions.VList.View() {
		if v.Channel == channel && v.Version == version {
			return v
		}
	}
	return nil
}

func (this *Versions) defaultVersion(channelVersions *ChannelVersions, channel string, envVersion string) *version.Version {
	for _, v := range channelVersions.VList.View() {
		if v.Default && v.Channel == channel && NormalizeEnvVersion(v.EnvVersion) == envVersion {
			return v
		}
	}
	return nil
}

func versionMapKey(version string, envVersion string) string {
	return envVersion + ":" + version
}

func (this *Versions) Servers(channel string) []*version.Version {
	var res = make([]*version.Version, 0)
	if channelVersions, ok := this.VChannels.Get(channel); ok {
		for _, v := range channelVersions.VList.View() {
			if v.Channel == channel {
				res = append(res, v)
			}
		}
	}
	return res
}