package lib

import (
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"github.com/nats-io/nats.go"
	"github.com/thinkeridea/go-extend/exunicode/exutf8"

	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
	"io/ioutil"
	"math/rand"

	"reflect"
	"runtime"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"
)

var Nats *nats.Conn

func init() {

}

const Success = 200
const Error = 201

type JSONR struct {
	//必须的大写开头
	Code int16
	Msg  string
	Data interface{} // 泛型
}
type JSONS struct {
	//必须的大写开头
	Code      int16
	Msg       string
	List      interface{}
	Total     int16
	PageIndex int
	PageSize  int
}

func C_Page(list interface{}, PageIndex, PageSize int, Total int64) (Jsons JSONS) {
	Jsons.List = list
	Jsons.Total = int16(Total)
	Jsons.PageIndex = PageIndex
	Jsons.PageSize = PageSize
	//Jsons.PageSize = int16(math.Ceil(float64(Total) / float64(PageSize)))
	return Jsons
}

func Strval(value interface{}) string {
	var key string
	if value == nil {
		return key
	}

	switch value.(type) {
	case float64:
		ft := value.(float64)
		key = strconv.FormatFloat(ft, 'f', -1, 64)
	case float32:
		ft := value.(float32)
		key = strconv.FormatFloat(float64(ft), 'f', -1, 64)
	case int:
		it := value.(int)
		key = strconv.Itoa(it)
	case uint:
		it := value.(uint)
		key = strconv.Itoa(int(it))
	case int8:
		it := value.(int8)
		key = strconv.Itoa(int(it))
	case uint8:
		it := value.(uint8)
		key = strconv.Itoa(int(it))
	case int16:
		it := value.(int16)
		key = strconv.Itoa(int(it))
	case uint16:
		it := value.(uint16)
		key = strconv.Itoa(int(it))
	case int32:
		it := value.(int32)
		key = strconv.Itoa(int(it))
	case uint32:
		it := value.(uint32)
		key = strconv.Itoa(int(it))
	case int64:
		it := value.(int64)
		key = strconv.FormatInt(it, 10)
	case uint64:
		it := value.(uint64)
		key = strconv.FormatUint(it, 10)
	case string:
		key = value.(string)
	case []byte:
		key = string(value.([]byte))
	default:
		newValue, _ := json.Marshal(value)
		key = string(newValue)
	}

	return key
}

func To_int(value interface{}) int {
	var key int
	if value == nil {
		return key
	}
	switch value.(type) {
	case float64:
		key = int(value.(float64))
	case float32:
		key = int(value.(float32))
	case int:
		key = int(value.(int))
	case uint:
		key = int(value.(uint))
	case int8:
		key = int(value.(int8))
	case uint8:
		key = int(value.(uint8))
	case int16:
		key = int(value.(int16))
	case uint16:
		key = int(value.(uint16))
	case int32:
		key = int(value.(int32))
	case uint32:
		key = int(value.(uint32))
	case int64:
		key = int(value.(int64))
	case uint64:
		key = int(value.(uint64))
	case string:
		key, _ = strconv.Atoi(value.(string))
	case []byte:
		key, _ = strconv.Atoi(string(value.([]byte)))
	default:
		newValue, _ := json.Marshal(value)
		key, _ = strconv.Atoi(string(newValue))
	}
	return key
}
func To_int64(value interface{}) int64 {
	var key int64
	if value == nil {
		return key
	}
	switch value.(type) {
	case float64:
		key = int64(value.(float64))
	case float32:
		key = int64(value.(float32))
	case int:
		key = int64(value.(int))
	case uint:
		key = int64(value.(uint))
	case int8:
		key = int64(value.(int8))
	case uint8:
		key = int64(value.(uint8))
	case int16:
		key = int64(value.(int16))
	case uint16:
		key = int64(value.(uint16))
	case int32:
		key = int64(value.(int32))
	case uint32:
		key = int64(value.(uint32))
	case int64:
		key = int64(value.(int64))
	case uint64:
		key = int64(value.(uint64))
	case string:
		key, _ = strconv.ParseInt(value.(string), 10, 64)
	case []byte:
		key, _ = strconv.ParseInt(string(value.([]byte)), 10, 64)
	default:
		newValue, _ := json.Marshal(value)
		key, _ = strconv.ParseInt(string(newValue), 10, 64)
	}
	return key
}

func To_float32(value interface{}) float32 {
	var key float32
	if value == nil {
		return key
	}

	switch value.(type) {
	case float64:
		key = float32(value.(float64))
	case float32:
		key = float32(value.(float32))
	case int:
		key = float32(value.(int))
	case uint:
		key = float32(value.(uint))
	case int8:
		key = float32(value.(int8))
	case uint8:
		key = float32(value.(uint8))
	case int16:
		key = float32(value.(int16))
	case uint16:
		key = float32(value.(uint16))
	case int32:
		key = float32(value.(int32))
	case uint32:
		key = float32(value.(uint32))
	case int64:
		key = float32(value.(int64))
	case uint64:
		key = float32(value.(uint64))
	case string:
		key_float64, _ := strconv.ParseFloat(value.(string), 32/64)
		key = float32(key_float64)
	case []byte:
		key_float64, _ := strconv.ParseFloat(string(value.([]byte)), 32/64)
		key = float32(key_float64)
	default:
		newValue, _ := json.Marshal(value)
		key_float64, _ := strconv.ParseFloat(string(newValue), 32/64)
		key = float32(key_float64)
	}

	key_float64, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", key), 32/64)
	key = float32(key_float64)

	return key
}

func To_string(value interface{}) string {
	var key string
	if value == nil {
		return key
	}

	switch value.(type) {
	case float64:
		ft := value.(float64)
		key = strconv.FormatFloat(ft, 'f', -1, 64)
	case float32:
		ft := value.(float32)
		key = strconv.FormatFloat(float64(ft), 'f', -1, 64)
	case int:
		it := value.(int)
		key = strconv.Itoa(it)
	case uint:
		it := value.(uint)
		key = strconv.Itoa(int(it))
	case int8:
		it := value.(int8)
		key = strconv.Itoa(int(it))
	case uint8:
		it := value.(uint8)
		key = strconv.Itoa(int(it))
	case int16:
		it := value.(int16)
		key = strconv.Itoa(int(it))
	case uint16:
		it := value.(uint16)
		key = strconv.Itoa(int(it))
	case int32:
		it := value.(int32)
		key = strconv.Itoa(int(it))
	case uint32:
		it := value.(uint32)
		key = strconv.Itoa(int(it))
	case int64:
		it := value.(int64)
		key = strconv.FormatInt(it, 10)
	case uint64:
		it := value.(uint64)
		key = strconv.FormatUint(it, 10)
	case string:
		key = value.(string)
	case []byte:
		key = string(value.([]byte))
	default:
		newValue, _ := json.Marshal(value)
		key = string(newValue)
	}
	return key
}

func Random(min, max int) int {
	rand.Seed(time.Now().Unix()) //Seed生成的随机数
	return rand.Intn(max-min) + min
}

// 取文本（字符串）中间
func GetBetweenStr(str, start, end string) string {
	n := strings.Index(str, start)
	if n == -1 {
		n = 0
	} else {
		n = n + len(start) // 增加了else，不加的会把start带上
	}
	str = string([]byte(str)[n:])
	m := strings.Index(str, end)
	if m == -1 {
		m = len(str)
	}
	str = string([]byte(str)[:m])
	return str
}

// getYearMonthToDay 查询指定年份指定月份有多少天
// @params year int 指定年份
// @params month int 指定月份
func GetYearMonthToDay(year int, month int) int {
	// 有31天的月份
	day31 := map[int]bool{
		1:  true,
		3:  true,
		5:  true,
		7:  true,
		8:  true,
		10: true,
		12: true,
	}
	if day31[month] == true {
		return 31
	}
	// 有30天的月份
	day30 := map[int]bool{
		4:  true,
		6:  true,
		9:  true,
		11: true,
	}
	if day30[month] == true {
		return 30
	}
	// 计算是平年还是闰年
	if (year%4 == 0 && year%100 != 0) || year%400 == 0 {
		// 得出2月的天数
		return 29
	}
	// 得出2月的天数
	return 28
}

func Decimal(value float64) float64 {
	value, _ = strconv.ParseFloat(fmt.Sprintf("%.1f", value), 64)
	return value
}

func Strconv_Atoi(string string) int {
	int, _ := strconv.Atoi(string)
	return int
}

// 获取正在运行的函数名
func FuncName() string {
	pc := make([]uintptr, 1)
	runtime.Callers(2, pc)
	f := runtime.FuncForPC(pc[0])
	return f.Name()
}

func Limit_len(str string, lenx int) string {
	if utf8.RuneCountInString(str) > lenx {
		return exutf8.RuneSubString(str, 0, lenx-3) + "..."
	}
	return exutf8.RuneSubString(str, 0, lenx)
}

func Utf8ToGbk(s []byte) ([]byte, error) {
	reader := transform.NewReader(bytes.NewReader(s), simplifiedchinese.GBK.NewEncoder())
	d, e := ioutil.ReadAll(reader)
	if e != nil {
		return nil, e
	}
	return d, nil
}

// #取得随机字符串：通过打乱slice来操作
func GetRandstring(length int, char string, rand_x int64) string {
	if length < 1 {
		return ""
	}

	if len(char) <= 6 || len(char) <= length {
		char = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	}

	charArr := strings.Split(char, "")
	ran := rand.New(rand.NewSource(time.Now().Unix() + rand_x))

	l := len(charArr)
	for i := l - 1; i > 0; i-- {
		r := ran.Intn(i)
		charArr[r], charArr[i] = charArr[i], charArr[r]
	}
	rchar := charArr[:length]
	return strings.Join(rchar, "")
}

// Sha256加密
func Sha256(src string) string {
	m := sha256.New()
	m.Write([]byte(src))
	res := hex.EncodeToString(m.Sum(nil))
	return res
}

// 判断时间是当年的第几周
func WeekByDate() string {
	t := time.Now()
	yearDay := t.YearDay()
	yearFirstDay := t.AddDate(0, 0, -yearDay+1)
	firstDayInWeek := int(yearFirstDay.Weekday())

	//今年第一周有几天
	firstWeekDays := 1
	if firstDayInWeek != 0 {
		firstWeekDays = 7 - firstDayInWeek + 1
	}
	var week int
	if yearDay <= firstWeekDays {
		week = 1
	} else {
		week = (yearDay-firstWeekDays)/7 + 2
	}
	return fmt.Sprintf("%d%02d", t.Year(), week) // 202253
}

// 获取json指定参数   [AAAA BBBB],0,JSON    ！！！如果失败，返回已找到的全部json
func Json_key(topicNameList []string, topicNameI int, articleSlide map[string]interface{}) interface{} {
	if len(topicNameList) > topicNameI {
		a, is := articleSlide[topicNameList[topicNameI]]
		if !is {
			return articleSlide
		}
		if reflect.TypeOf(a).String() == "map[string]interface {}" {
			return Json_key(topicNameList, topicNameI+1, a.(map[string]interface{}))
		}
	}

	if len(topicNameList) == topicNameI {
		return articleSlide
	}

	return articleSlide[topicNameList[topicNameI]]
}

// 导出map到文件
func MapToFile(data map[string]map[string]string, filePath string) error {
	jsonData, err := json.Marshal(data)
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(filePath, jsonData, 0644)
	if err != nil {
		return err
	}
	return nil
}

// 从文件中导入map数据
func MapFromFile(filePath string) map[string]map[string]string {
	jsonData, err := ioutil.ReadFile(filePath)
	if err != nil {
		return nil
	}
	var importedMap map[string]map[string]string
	err = json.Unmarshal(jsonData, &importedMap)
	if err != nil {
		fmt.Println("Error unmarshalling JSON:", err)
		return nil
	}
	return importedMap
}