package validate

import (
	"gitee.com/aivi/validate/i18n"
	"strconv"
	"strings"
)

type Validater[T any] interface {
	Check(data []Value, group ...string) error
	Rule(r MapStr) *T
	SetRule(name string, rule string) *T
	Message(m MapStr) *T
	SetMessage(cases ...string) *T
	Scene(name string) *T
	Lang(lang i18n.Lang) *T
}

func NewValidate() Validater[Validate] {
	return &Validate{
		Rules:    make(MapStr, 0),
		Messages: make(MapStr, 0),
		Groups:   make(map[string]MapStr),
		Scenes:   make(map[string][]string, 0),
		data:     make(map[string]any, 0),
	}
}

type Validate struct {
	Rules        MapStr
	Messages     MapStr
	Groups       map[string]MapStr
	Scenes       map[string][]string
	CurrentScene string
	data         map[string]any
}

func (v *Validate) Check(data []Value, group ...string) error {
	var _group string
	if len(group) > 0 && group[0] != "" {
		_group = group[0]
	}

	if v.Rules == nil || data == nil {
		return nil
	}

	// 如果设置场景，并且有场景的情况下
	var sceneArr = make([]string, 0)
	if len(v.CurrentScene) > 0 && v.Scenes != nil {
		scene, ok := v.Scenes[v.CurrentScene]
		if !ok || scene == nil {
			return nil
		}
		sceneArr = append(sceneArr, scene...)
	}

	// 如果设置分组，则验证分组
	if len(_group) > 0 && v.Scenes != nil {
		gp, ok := v.Groups[_group]
		if !ok || gp == nil {
			return nil
		}
		v.Rules = gp
	}

	// v.data 内容只保存规则中“eq=”包含对应字段的内容
	eqContains := v.Rules.GetEqContent()
	for _, val := range data {
		if eqContains != nil && InArray(val.Key, eqContains) {
			v.data[val.Key] = val.Val
		}
	}

	i18n.SetCustom(v.Messages)

	for _, val := range data {
		k, vv := val.Key, val.Val
		if sceneArr != nil && len(sceneArr) > 0 {
			if !InArray(k, sceneArr) {
				continue
			}
		}
		if err := v.__checkData(k, vv); err != nil {
			return err
		}
	}

	return nil
}

func (v *Validate) Rule(r MapStr) *Validate {
	if r != nil {
		v.Rules = r
	}

	return v
}

func (v *Validate) SetRule(name string, rule string) *Validate {
	v.Rules[name] = rule

	return v
}

func (v *Validate) Lang(l i18n.Lang) *Validate {
	i18n.Set(l)

	return v
}

func (v *Validate) Message(m MapStr) *Validate {
	if m != nil {
		v.Messages = m
	}

	return v
}

func (v *Validate) SetMessage(cases ...string) *Validate {
	for i, l := 0, len(cases)-1; i < l; i += 2 {
		v.Messages[cases[i]] = cases[i+1]
	}

	if l := len(cases); l%2 == 1 {
		v.Messages[cases[l-1]] = i18n.Get("404").Error()
	}

	return v
}

// Scene 验证场景仅针对结构体内嵌验证器有效，独立验证不存在验证场景的概念
func (v *Validate) Scene(name string) *Validate {
	if len(name) > 0 {
		v.CurrentScene = name
	}

	return v
}

func (v *Validate) __checkData(key string, val any) error {
	ruleStr := v.Rules.Get(key)
	if ruleStr == "" {
		return nil
	}
	if strings.Contains(ruleStr, "require") {
		if IsEmpty(val) {
			return i18n.Get(key + ".require")
		}
	} else {
		if IsEmpty(val) {
			return nil
		}
	}
	ruleStr = strings.NewReplacer("|require", "", "require|", "", "require", "").Replace(ruleStr)
	ruleStr = strings.TrimSpace(ruleStr)
	if ruleStr == "" {
		return nil
	}

	ruleArr := strings.Split(ruleStr, "|")

	for _, vchar := range ruleArr {
		if vchar == "require" {
			continue
		}

		before, after := "", ""
		if callback, ok := mapCallback[vchar]; ok {
			return callback(key, val)
		} else if inx := strings.Index(vchar, "="); inx != -1 {
			before, after = vchar[:inx+1], vchar[inx+1:]
		} else if eqinx := strings.Index(vchar, ":"); eqinx != -1 {
			before, after = vchar[:eqinx+1], vchar[eqinx+1:]
		}

		if callback, ok := mapMatchCallback[before]; ok {
			return callback(after, key, val)
		}

		if callback, ok := dataMatchCallback[before]; ok {
			return callback(v.data, after, key, val)
		}
	}

	return nil
}

func cmpVal(val any, comArr []string) bool {
	var flag bool
	if t, ok := val.(string); ok {
		flag = InArray(t, comArr)
	} else if t, ok := val.(int); ok {
		t := strconv.Itoa(t)
		flag = InArray(t, comArr)
	} else if t, ok := val.(float64); ok {
		t := strconv.FormatFloat(t, 'g', -1, 64)
		flag = InArray(t, comArr)
	}

	return flag
}