package utils

import (
	"container/list"
	"encoding/json"
	"github.com/gogf/gf/frame/g"
	"strings"

	"github.com/gogf/gf/container/gvar"
	"github.com/gogf/gf/util/gconv"
)

// 将带分隔符的字符串切成int数组
func ToIntArray(str string, split ...string) []int {
	splitChar := ","
	if len(split) > 0 {
		splitChar = split[0]
	}
	result := make([]int, 0)
	if str == "" {
		return result
	}

	arr := strings.Split(str, splitChar)

	if len(arr) > 0 {
		for i := range arr {
			if arr[i] != "" {
				result = append(result, gconv.Int(arr[i]))
			}
		}
	}
	return result
}

// 将带分隔符的字符串切成int64数组
func ToInt64Array(str string, split ...string) []int64 {
	splitChar := ","
	if len(split) > 0 {
		splitChar = split[0]
	}
	result := make([]int64, 0)
	if str == "" {
		return result
	}

	arr := strings.Split(str, splitChar)

	if len(arr) > 0 {
		for i := range arr {
			if arr[i] != "" {
				result = append(result, gconv.Int64(arr[i]))
			}
		}
	}
	return result
}

// 将带分隔符的字符串切成string数组
func ToStringArray(str string, split ...string) []string {
	if str == "" {
		return nil
	}
	splitChar := ","
	if len(split) > 0 {
		splitChar = split[0]
	}
	result := strings.Split(str, splitChar)
	return result
}

// 将数据表查询返回的ID数据转换成带分隔符的Ids字符串，形如：1,2,3
func ToIdsString(array []*gvar.Var, split ...string) string {
	splitChar := ","
	if len(split) > 0 {
		splitChar = split[0]
	}
	result := ""
	for _, v := range array {
		result = result + v.String() + splitChar
	}
	result = result[0 : len(result)-1]
	return result
}

// 将数据表查询返回的ID数组（整数数组,支持int,int32,int64）数据转换成带分隔符的Ids字符串，形如：1,2,3
func IntArrayToIdsString(array interface{}, split ...string) string {
	if array == nil {
		return ""
	}

	splitChar := ","
	if len(split) > 0 {
		splitChar = split[0]
	}

	result := ""
	switch value := array.(type) {
	case []int:
		if len(value) == 0 {
			return ""
		}
		for _, v := range value {
			result = result + gconv.String(v) + splitChar
		}
	case []int32:
		if len(value) == 0 {
			return ""
		}
		for _, v := range value {
			result = result + gconv.String(v) + splitChar
		}
	case []int64:
		if len(value) == 0 {
			return ""
		}
		for _, v := range value {
			result = result + gconv.String(v) + splitChar
		}
	case []string:
		if len(value) == 0 {
			return ""
		}
		for _, v := range value {
			result = result + v + splitChar
		}
	}

	result = result[0 : len(result)-1]
	return result
}

// 将数据表查询返回的ID数据转换成带分隔符的Ids字符串，形如：1,2,3
func Int64ArrayToIdsString(array []int64, split ...string) string {
	splitChar := ","
	if len(split) > 0 {
		splitChar = split[0]
	}
	result := ""
	for _, v := range array {
		result = result + gconv.String(v) + splitChar
	}
	result = result[0 : len(result)-1]
	return result
}

// 过滤收尾有分隔符的数字字符串
func ReplaceHeadAndEndStr(str string, split ...string) string {
	splitChar := ","
	if len(split) > 0 {
		splitChar = split[0]
	}
	result := ""
	arr := strings.Split(str, splitChar)
	if len(arr) <= 0 {
		return result
	}

	for i := range arr {
		if arr[i] != "" {
			if i == 0 {
				result = arr[i]
			} else {
				result += "," + arr[i]
			}
		}
	}
	return result
}

// ToJsonStr 对象转字符串
func ToJsonString(data interface{}) (string, error) {
	result, err := json.Marshal(data)
	return string(result), err
}

// Json字符串转对象
func JsonToStruct(source string, destination interface{}) error {
	err := json.Unmarshal([]byte(source), destination)
	return err
}

// Json字符串转Map
func JsonToMap(source string) (map[string]string, error) {
	resultMap := make(map[string]string)
	err := json.Unmarshal([]byte(source), &resultMap)
	if err != nil {
		return nil, err
	}
	return resultMap, nil
}

// list对象转数组
func ListToArray(list *list.List) []interface{} {
	var len = list.Len()
	if len == 0 {
		return nil
	}
	var arr []interface{}
	for e := list.Front(); e != nil; e = e.Next() {
		arr = append(arr, e.Value)
	}
	return arr
}

// Map key字符串转驼峰 snake：下划线；upperCamel：大驼峰；默认：小驼峰
func MapKeySnakeCamelCase(oldMap g.Map, convType ...string) g.Map {
	newMap := make(g.Map)
	for k, v := range oldMap {
		if len(convType) == 0 {
			newMap[camelString(k)] = v
		} else {
			if convType[0] == "snake" {
				newMap[camelString(k)] = v
			} else if convType[0] == "upperCamel" {
				newMap[camelString(k, "upperCamel")] = v
			} else {
				newMap[camelString(k)] = v
			}
		}
	}
	return newMap
}

// 驼峰转下划线
func snakeString(s string) string {
	if s == "" {
		return ""
	}
	data := make([]byte, 0, len(s)*2)
	j := false
	num := len(s)
	for i := 0; i < num; i++ {
		d := s[i]
		// or通过ASCII码进行大小写的转化
		// 65-90（A-Z），97-122（a-z）
		//判断如果字母为大写的A-Z就在前面拼接一个_
		if i > 0 && d >= 'A' && d <= 'Z' && j {
			data = append(data, '_')
		}
		if d != '_' {
			j = true
		}
		data = append(data, d)
	}
	//ToLower把大写字母统一转小写
	return strings.ToLower(string(data[:]))
}

// 下划线转驼峰
func camelString(s string, convType ...string) string {
	if s == "" {
		return ""
	}
	data := make([]byte, 0, len(s))
	j := false
	k := false
	num := len(s) - 1
	for i := 0; i <= num; i++ {
		d := s[i]
		if k == false && d >= 'A' && d <= 'Z' {
			k = true
		}
		if d >= 'a' && d <= 'z' && (j || k == false) {
			d = d - 32
			j = false
			k = true
		}
		if k && d == '_' && num > i && s[i+1] >= 'a' && s[i+1] <= 'z' {
			j = true
			continue
		}
		data = append(data, d)
	}
	if len(convType) > 0 {
		return string(data[:])
	}
	data[0] += 32
	return string(data[:])
}