variable

var GetAllVariable = func(hostName string) GetFunc {
	return func(v Variable) (any, error) {
		vv, ok := v.(*variable)
		if !ok {
			return nil, errors.New("variable type error")
		}
		result := make(map[string]any)

		result = combineVariables(result, vv.value.Hosts[hostName].RuntimeVars)

		result = combineVariables(result, vv.value.Hosts[hostName].RemoteVars)

		if vv, ok := vv.value.getParameterVariable()[hostName]; ok {
			if vvd, ok := vv.(map[string]any); ok {
				result = combineVariables(result, vvd)
			}
		}

		return result, nil
	}
}

var GetHostMaxLength = func() GetFunc {
	return func(v Variable) (any, error) {
		vv, ok := v.(*variable)
		if !ok {
			return nil, errors.New("variable type error")
		}
		var hostNameMaxLen int
		for k := range vv.value.Hosts {
			hostNameMaxLen = max(len(k), hostNameMaxLen)
		}

		return hostNameMaxLen, nil
	}
}

var GetHostnames = func(name []string) GetFunc {
	if len(name) == 0 {
		return emptyGetFunc
	}

	return func(v Variable) (any, error) {
		vv, ok := v.(*variable)
		if !ok {
			return nil, errors.New("variable type error")
		}
		var hs []string
		for _, n := range name {

			if _, ok := vv.value.Hosts[n]; ok {
				hs = append(hs, n)
			}

			for gn, gv := range convertGroup(vv.value.Inventory) {
				if gn == n {
					if gvd, ok := gv.([]string); ok {
						hs = mergeSlice(hs, gvd)
					}

					break
				}
			}

			regexForIndex := regexp.MustCompile(`^(.*)\[\d\]$`)
			if match := regexForIndex.FindStringSubmatch(strings.TrimSpace(n)); match != nil {
				index, err := strconv.Atoi(match[2])
				if err != nil {
					klog.V(4).ErrorS(err, "convert index to int error", "index", match[2])

					return nil, err
				}
				if group, ok := convertGroup(vv.value.Inventory)[match[1]].([]string); ok {
					if index >= len(group) {
						return nil, fmt.Errorf("index %v out of range for group %s", index, group)
					}
					hs = append(hs, group[index])
				}
			}

			regexForRandom := regexp.MustCompile(`^(.+?)\s*\|\s*random$`)
			if match := regexForRandom.FindStringSubmatch(strings.TrimSpace(n)); match != nil {
				if group, ok := convertGroup(vv.value.Inventory)[match[1]].([]string); ok {
					hs = append(hs, group[rand.Intn(len(group))])
				}
			}
		}

		return hs, nil
	}
}

var GetParamVariable = func(hostname string) GetFunc {
	return func(v Variable) (any, error) {
		vv, ok := v.(*variable)
		if !ok {
			return nil, errors.New("variable type error")
		}
		if hostname == "" {
			return vv.value.getParameterVariable(), nil
		}

		return vv.value.getParameterVariable()[hostname], nil
	}
}

var MergeAllRuntimeVariable = func(data map[string]any, hostName string) MergeFunc {
	return func(v Variable) error {
		vv, ok := v.(*variable)
		if !ok {
			return errors.New("variable type error")
		}

		curVariable, err := v.Get(GetAllVariable(hostName))
		if err != nil {
			return err
		}

		if err := parseVariable(data, func(s string) (string, error) {

			cv, ok := curVariable.(map[string]any)
			if !ok {
				return "", errors.New("variable type error")
			}

			return tmpl.ParseString(combineVariables(data, cv), s)
		}); err != nil {
			return err
		}

		for h := range vv.value.Hosts {
			if _, ok := v.(*variable); !ok {
				return errors.New("variable type error")
			}
			hv := vv.value.Hosts[h]
			hv.RuntimeVars = combineVariables(hv.RuntimeVars, data)
			vv.value.Hosts[h] = hv
		}

		return nil
	}
}

var MergeRemoteVariable = func(data map[string]any, hostname string) MergeFunc {
	return func(v Variable) error {
		vv, ok := v.(*variable)
		if !ok {
			return errors.New("variable type error")
		}

		if hostname == "" {
			return errors.New("when merge source is remote. HostName cannot be empty")
		}
		if _, ok := vv.value.Hosts[hostname]; !ok {
			return fmt.Errorf("when merge source is remote. HostName %s not exist", hostname)
		}

		if hv := vv.value.Hosts[hostname]; len(hv.RemoteVars) == 0 {
			hv.RemoteVars = data
			vv.value.Hosts[hostname] = hv
		}

		return nil
	}
}

var MergeRuntimeVariable = func(data map[string]any, hosts ...string) MergeFunc {
	if len(data) == 0 || len(hosts) == 0 {

		return emptyMergeFunc
	}

	return func(v Variable) error {
		for _, hostName := range hosts {
			vv, ok := v.(*variable)
			if !ok {
				return errors.New("variable type error")
			}

			curVariable, err := v.Get(GetAllVariable(hostName))
			if err != nil {
				return err
			}

			if err := parseVariable(data, func(s string) (string, error) {

				cv, ok := curVariable.(map[string]any)
				if !ok {
					return "", errors.New("variable type error")
				}

				return tmpl.ParseString(combineVariables(data, cv), s)
			}); err != nil {
				return err
			}

			if _, ok := v.(*variable); !ok {
				return errors.New("variable type error")
			}
			hv := vv.value.Hosts[hostName]
			hv.RuntimeVars = combineVariables(hv.RuntimeVars, data)
			vv.value.Hosts[hostName] = hv
		}

		return nil
	}
}