package finder

import (
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils"
	"fmt"
	"strings"
)

type IFuserLayer interface {
	DST() (dft, spt string) // 默认支持数据，所有支持数据
}

type FuserLayer struct {
	rewardGroup int8

	lang      Lang
	level     Level
	langLevel LangLevel
	country   Country
}

// NewFuserLayer 用户分层结构
func NewFuserLayer(conf *model.FissionCampaignConfig) (ful FuserLayer) {
	switch conf.RewardGroup {
	case mtype.FissionRewardGroupUserLevel:
		ful.level.Default = utils.StrToInt64(conf.DefaultRewardMark)
		var srm = strings.Split(conf.SupportRewardMark, ",")
		ful.level.Support = make([]int64, 0, len(srm))
		for _, v := range srm {
			ful.level.Support = append(ful.level.Support, utils.StrToInt64(v))
		}
	case mtype.FissionRewardGroupLang:
		ful.lang.Support = strings.Split(conf.SupportRewardMark, ",")
		ful.lang.Default = conf.DefaultRewardMark
	case mtype.FissionRewardGroupLangAndUserLevel:
		var dfs = strings.Split(conf.DefaultRewardMark, ",")
		ful.langLevel.Default = make([]DefaultLangLevel, 0, len(dfs))
		for _, v := range dfs {
			lang, level, _ := strings.Cut(v, "_")
			ful.langLevel.Default = append(ful.langLevel.Default, DefaultLangLevel{
				Lang:  lang,
				Level: utils.StrToInt64(level),
			})
		}

		var srm = strings.Split(conf.SupportRewardMark, ";")
		ful.langLevel.Support = make([]SupportLangLevel, 0, len(srm))
		for _, v := range srm {
			lang, levels, _ := strings.Cut(v, "=")

			one := SupportLangLevel{
				Lang:  lang,
				Level: make([]int64, 0, len(levels)),
			}

			uls := strings.Split(levels, ",")
			for _, ul := range uls {
				one.Level = append(one.Level, utils.StrToInt64(ul))
			}

			ful.langLevel.Support = append(ful.langLevel.Support, one)
		}
	case mtype.FissionRewardGroupCountry:
		ful.country.Support = strings.Split(conf.SupportRewardMark, ",")
		ful.country.Default = conf.DefaultRewardMark
	case mtype.FissionRewardGroupNormal:

	}

	ful.rewardGroup = conf.RewardGroup
	return
}

func (s *FuserLayer) Lang() Lang           { return s.lang }
func (s *FuserLayer) Level() Level         { return s.level }
func (s *FuserLayer) LangLevel() LangLevel { return s.langLevel }
func (s *FuserLayer) Country() Country     { return s.country }

// GetFirstSupportLang 获取首层的语言支持
func (s *FuserLayer) GetFirstSupportLang() []string {
	switch s.rewardGroup {
	case mtype.FissionRewardGroupLang:
		return s.lang.Support
	case mtype.FissionRewardGroupLangAndUserLevel:
		var spt = make([]string, 0, len(s.langLevel.Support))
		for _, v := range s.langLevel.Support {
			spt = append(spt, v.Lang)
		}
		return spt
	}
	return nil
}

type Lang struct {
	Default string
	Support []string
}

func (s Lang) DST() (dft, spt string) { return s.Default, split(s.Support, ",") }

func (s Lang) Selected(lang string) (string, bool) {
	for _, v := range s.Support {
		if v == lang {
			return lang, false
		}
	}

	return s.Default, true
}

type Level struct {
	Default int64
	Support []int64
}

func (s Level) DST() (dft, spt string) { return fmt.Sprint(s.Default), split(s.Support, ",") }

func (s Level) Selected(level int64) (int64, bool) {
	for _, v := range s.Support {
		if v == level {
			return level, false
		}
	}

	return s.Default, true
}

type DefaultLangLevel struct {
	Lang  string
	Level int64
}
type SupportLangLevel struct {
	Lang  string
	Level []int64
}

type LangLevel struct {
	Default []DefaultLangLevel
	Support []SupportLangLevel
}

func (s LangLevel) DST() (dft, spt string) {
	for _, v := range s.Default {
		dft += fmt.Sprintf("%s_%d,", v.Lang, v.Level)
	}

	for _, v := range s.Support {
		spt += fmt.Sprintf("%s=%s;", v.Lang, split(v.Level, ","))
	}

	return strings.TrimSuffix(dft, ","), strings.TrimSuffix(spt, ";")
}

func (s LangLevel) Selected(lang string, level int64) (alang string, alevel int64, dflang, dflevel bool) {
	alang, dflang = s.GetLang(lang)

	alevel, dflevel = s.GetLevel(alang, level)
	return
}

func (s LangLevel) GetLang(lang string) (string, bool) {
	for _, v := range s.Default {
		if v.Lang == lang {
			return v.Lang, false
		}
	}

	return s.Default[0].Lang, true
}

func (s LangLevel) GetLevel(lang string, level int64) (int64, bool) {
	for _, v := range s.Support {
		if v.Lang != lang {
			continue
		}

		for _, lv := range v.Level {
			if lv == level {
				return lv, false
			}
		}

		return v.Level[0], true
	}

	return s.Default[0].Level, true
}

type Country struct {
	Default string
	Support []string
}

func (s Country) DST() (dft, spt string) { return s.Default, split(s.Support, ",") }

func (s Country) Selected(country string) (string, bool) {
	for _, v := range s.Support {
		if v == country {
			return country, false
		}
	}

	return s.Default, true
}

func split[T any](vals []T, sep string) (st string) {
	if len(vals) == 0 {
		return
	}
	for _, v := range vals {
		st += fmt.Sprintf("%v%s", v, sep)
	}
	return strings.TrimSuffix(st, sep)
}