package tools

import (
	"archive/zip"
	"bytes"
	"encoding/binary"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"rtzh_elec_temperature/conf"
	"rtzh_elec_temperature/logger"
	"runtime"
	"strconv"
	"strings"
	"time"
	"unicode"

	uuid "github.com/satori/go.uuid"
	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
)

var MbTable = []uint16{0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040}

func NowTime() string {
	//大坑一个：必须使用这个时间格式化，忘记YYYY mm ss hh mi ss这些吧
	return time.Now().Format("2006-01-02 15:04:05")
}

//日期时间字符串转成unix时间戳
func DateString2Unix(d string) int64 {
	x, err := time.ParseInLocation(d, "2006-01-02 15:04:05", time.Local)
	if err != nil {
		return 0
	}
	return x.Unix()
}

func Unix2TimeString(d int64) string {
	return time.Unix(d, 0).Format("2006-01-02 15:04:05")
}

func TimeSeq(bit ...int) int {
	if bit != nil && bit[0] == 13 {
		return int(time.Now().UnixNano() / 1e6)
	}
	return int(time.Now().Unix())
}

func Typeof(v interface{}) string {
	return fmt.Sprintf("%T", v)
}
func IsEmpty(p interface{}, defaultvalue ...string) string {
	if p == nil {
		if defaultvalue != nil && len(defaultvalue) > 0 {
			return defaultvalue[0]
		}
		return ""
	}
	objtype := Typeof(p)
	if objtype == "int" {
		return strconv.Itoa(p.(int))
	} else if objtype == "int32" {
		return strconv.FormatInt(int64(p.(int32)), 10)
	} else if objtype == "int64" {
		return strconv.FormatInt(p.(int64), 10)
	} else if objtype == "float64" {
		return strconv.FormatFloat(p.(float64), 'f', -1, 64)
	} else if objtype == "json.Number" {
		return p.(json.Number).String()
	}
	v := p.(string)
	if v == "" {
		if defaultvalue != nil && len(defaultvalue) > 0 {
			return defaultvalue[0]
		}
	}
	return strings.Trim(v, " ")
}

func CheckErr(err error) {
	if err != nil {
		log.Println(err.Error())
	}
}

func Log(logdata interface{}) {
	if conf.GlobalConfig["loglevel"] == "4" || conf.GlobalConfig["loglevel"] == "5" {
		log.Println(logdata)
	}

}

func Error(logdata interface{}) {
	log.Println(logdata)
}

func CalCheckXor(command16 string) string {
	var a int64 = 0
	for i := 0; i < len(command16); i++ {
		a1, _ := strconv.ParseInt(command16[i:i+2], 16, 16)
		a2, _ := strconv.ParseInt(command16[i+2:i+4], 16, 16)
		a = a ^ (a1 ^ a2)
		i = i + 3
	}
	h := fmt.Sprintf("%X", a)
	return h
}

func CalCheckCrc16_Modbus(data []byte) string {
	var crc16 uint16
	crc16 = 0xffff
	for _, v := range data {
		n := uint8(uint16(v) ^ crc16)
		crc16 >>= 8
		crc16 ^= MbTable[n]
	}
	int16buf := new(bytes.Buffer)
	binary.Write(int16buf, binary.LittleEndian, crc16)
	r := fmt.Sprintf("%+X", int16buf.Bytes())
	return r
}

func CalCheckCRC(commd string) (r string) {
	var i = 0
	var sum = 0
	for {
		h1 := commd[i : i+2]
		n, _ := strconv.ParseUint(h1, 16, 32)
		//fmt.Println(h1 + "=====" + strconv.Itoa(int(n)))
		sum = sum + int(n)
		i = i + 2
		if i >= len(commd) {
			break
		}
	}
	if sum > 256 {
		sum = sum - 256
	}
	var hexStr = strconv.FormatInt(int64(sum), 16)
	return hexStr
}

//解析datatable参数为Map对象
func ParseDatatableParamByFormdata(reqStr url.Values) map[string]interface{} {
	var result = map[string]interface{}{"datatable": map[string]interface{}{}}
	datatable := map[string]interface{}{"sort": map[string]interface{}{"sort": reqStr.Get("datatable[sort][sort]"), "field": reqStr.Get("datatable[sort][field]")}, "pagination": map[string]interface{}{"page": reqStr.Get("datatable[pagination][page]"), "perpage": reqStr.Get("datatable[pagination][perpage]")}}
	for k, v := range reqStr {
		if strings.HasPrefix(k, "datatable") {
			if !strings.HasPrefix(k, "datatable[pagination]") && !strings.HasPrefix(k, "datatable[sort]") {
				newKey := strings.Replace(k, "datatable", "", 1)
				newKey = strings.Replace(newKey, "[", "", 1)
				newKey = strings.Replace(newKey, "]", "", 1)
				datatable[newKey], _ = url.QueryUnescape(v[0])
			}
		} else {
			datatable[k], _ = url.QueryUnescape(v[0])
		}
	}
	result["datatable"] = datatable
	return result
}

//解析datatable参数为Map对象
func ParseFormParam(reqStr url.Values) map[string]interface{} {
	var result = map[string]interface{}{"datatable": map[string]interface{}{}}
	datatable := map[string]interface{}{"sort": map[string]interface{}{"sort": reqStr.Get("datatable[sort][sort]"), "field": reqStr.Get("datatable[sort][field]")}, "pagination": map[string]interface{}{"page": reqStr.Get("datatable[pagination][page]"), "perpage": reqStr.Get("datatable[pagination][perpage]")}}
	result["datatable"] = datatable
	for k, v := range reqStr {
		if strings.Index(k, "datatable") == -1 {
			result[k] = v[0]
		} else if strings.Index(k, "datatable[sort]") == -1 && strings.Index(k, "datatable[pagination]") == -1 {
			k1 := strings.ReplaceAll(k, "datatable[", "")
			k1 = strings.ReplaceAll(k1, "]", "")
			result[k1] = v[0]
		}
	}
	return result
}

func OriginalCode(password interface{}) string {
	var result string
	pwd := strings.Split(password.(string), "0000")
	if len(pwd) == 2 {
		password2 := pwd[1]
		for i := 0; i < len(password2)/3; i++ {
			number := password2[i*3 : (i+1)*3]
			p, _ := strconv.ParseInt(number, 16, 32)
			result += string(p)
		}
	}
	return result
}

//解析datatable参数为Map对象
func ParseDatatableParam(reqStr string) map[string]interface{} {
	var result = map[string]interface{}{"datatable": map[string]interface{}{}}
	tmp, _ := url.QueryUnescape(reqStr)
	datatable := map[string]interface{}{"sort": map[string]interface{}{"sort": "", "field": ""}, "pagination": map[string]interface{}{"page": 1, "perpage": 20}}
	if strings.HasPrefix(tmp, "datatable") {
		pl := strings.Split(tmp, "&")
		for _, item := range pl {
			vs := strings.Split(item, "=")
			re, _ := regexp.Compile(`\[.*?\]`)
			all := re.FindAll([]byte(vs[0]), -1)
			if len(all) == 1 {
				key := strings.Replace(strings.Replace(string(all[0]), "[", "", 1), "]", "", 1)
				datatable[key] = vs[1]
			} else if len(all) == 2 {
				ele := strings.Replace(strings.Replace(string(all[0]), "[", "", 1), "]", "", 1)
				key := strings.Replace(strings.Replace(string(all[1]), "[", "", 1), "]", "", 1)
				if _, ok := datatable[ele]; ok {
					tmp := datatable[ele].(map[string]interface{})
					tmp[key] = vs[1]
				} else {
					datatable[ele] = map[string]interface{}{key: vs[1]}
				}
			}
		}

		result["datatable"] = datatable
	}
	return result
}

//从请求参数中解析分页数据，组装成SQL格式
func ParsePaginationToSqlPart(param map[string]interface{}, alias ...string) (string, map[string]interface{}) {
	var limit = ""
	var hasfield bool
	var t_alias = ""
	var t_id_alias = "id"
	if alias != nil {
		t_alias = alias[0] + "."
	}
	if alias != nil && len(alias) > 1 {
		t_id_alias = alias[1]
	}
	var meta = map[string]interface{}{"field": "", "sort": "", "page": "1", "pages": "0", "perpage": "1000000", "total": "0"}
	if datatable, ok := param["datatable"]; ok {
		dt := datatable.(map[string]interface{})
		var field, sorttype interface{}
		if sort, hassort := dt["sort"]; hassort {
			sortmap := sort.(map[string]interface{})
			if field, hasfield = sortmap["field"]; !hasfield || IsEmpty(field) == "" {
				field = t_id_alias
			}
			if sorttype, hasfield = sortmap["sort"]; !hasfield || IsEmpty(field) == "" {
				sorttype = "desc"
			}
			meta["field"] = field
			meta["sort"] = sorttype
			limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
		}
		if pagination, has := dt["pagination"]; has {
			paginationmap := pagination.(map[string]interface{})
			if limit == "" {
				if field, hasfield = paginationmap["field"]; hasfield && IsEmpty(field) != "" {
					if sorttype, hasfield = paginationmap["sort"]; !hasfield || IsEmpty(sorttype) != "" {
						meta["field"] = field
						meta["sort"] = sorttype
						limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
					}
				}
			}
			var page, perpage interface{}
			if page, hasfield = paginationmap["page"]; !hasfield || IsEmpty(page) == "" {
				page = "1"
			}
			if perpage, hasfield = paginationmap["perpage"]; !hasfield || IsEmpty(perpage) == "" {
				perpage = "50"
			}
			var pageno, pagesize int
			if Typeof(page) == "int" {
				pageno = page.(int)
			} else {
				pageno, _ = strconv.Atoi(page.(string))
			}
			if Typeof(perpage) == "int" {
				pagesize = perpage.(int)
			} else {
				pagesize, _ = strconv.Atoi(perpage.(string))
			}
			meta["page"] = pageno
			meta["perpage"] = pagesize
			//limit = limit + " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pageno*pagesize)
			limit = limit + " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pagesize)
		} else {
			limit = limit + " limit 0,1000000"
		}
	}
	return limit, meta
}

//从请求参数中解析分页数据，组装成不包含排序的SQL格式
func ParsePaginationToSqlPartNoOrderBY(param map[string]interface{}, alias ...string) (string, map[string]interface{}) {
	var limit = ""
	var hasfield bool
	var t_alias = ""
	var t_id_alias = ""
	if alias != nil {
		t_alias = alias[0] + "."
	}
	if alias != nil && len(alias) > 1 {
		t_id_alias = alias[1]
	}
	var meta = map[string]interface{}{"field": "", "sort": "", "page": "1", "pages": "0", "perpage": "1000000", "total": "0"}
	if datatable, ok := param["datatable"]; ok {
		dt := datatable.(map[string]interface{})
		var field, sorttype interface{}
		if sort, hassort := dt["sort"]; hassort {
			sortmap := sort.(map[string]interface{})
			if field, hasfield = sortmap["field"]; !hasfield || IsEmpty(field) == "" {
				field = t_id_alias
			}
			if sorttype, hasfield = sortmap["sort"]; !hasfield || IsEmpty(field) == "" {
				sorttype = "desc"
			}
			meta["field"] = field
			meta["sort"] = sorttype
			if field != "" {
				limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
			}
		}
		if pagination, has := dt["pagination"]; has {
			paginationmap := pagination.(map[string]interface{})
			if limit == "" {
				if field, hasfield = paginationmap["field"]; hasfield && IsEmpty(field) != "" {
					if sorttype, hasfield = paginationmap["sort"]; !hasfield || IsEmpty(sorttype) != "" {
						meta["field"] = field
						meta["sort"] = sorttype
						if field != "" {
							limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
						}
					}
				}
			}
			var page, perpage interface{}
			if page, hasfield = paginationmap["page"]; !hasfield || IsEmpty(page) == "" {
				page = "1"
			}
			if perpage, hasfield = paginationmap["perpage"]; !hasfield || IsEmpty(perpage) == "" {
				perpage = "50"
			}
			var pageno, pagesize int
			if Typeof(page) == "int" {
				pageno = page.(int)
			} else {
				pageno, _ = strconv.Atoi(page.(string))
			}
			if Typeof(perpage) == "int" {
				pagesize = perpage.(int)
			} else {
				pagesize, _ = strconv.Atoi(perpage.(string))
			}
			meta["page"] = pageno
			meta["perpage"] = pagesize
			//limit = limit + " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pageno*pagesize)
			limit = " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pagesize)
		} else {
			limit = limit + " limit 0,1000000"
		}
	}
	return limit, meta
}

func HasChineseChar(str string) bool {
	for _, r := range str {
		if unicode.Is(unicode.Han, r) || (regexp.MustCompile("[\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]").MatchString(string(r))) {
			return true
		}
	}
	return false
}

func Unzip(zipFile string, destDir string) error {
	zipReader, err := zip.OpenReader(zipFile)
	if err != nil {
		return err
	}
	defer zipReader.Close()
	decodeName := ""
	for _, f := range zipReader.File {
		if f.Flags == 0 {
			//如果标致位是0  则是默认的本地编码   默认为gbk
			i := bytes.NewReader([]byte(f.Name))
			decoder := transform.NewReader(i, simplifiedchinese.GB18030.NewDecoder())
			content, _ := ioutil.ReadAll(decoder)
			decodeName = string(content)
		} else {
			//如果标志为是 1 << 11也就是 2048  则是utf-8编码
			decodeName = f.Name
		}
		fpath := filepath.Join(destDir, decodeName)
		if f.FileInfo().IsDir() {
			os.MkdirAll(fpath, os.ModePerm)
		} else {
			if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
				return err
			}

			inFile, err := f.Open()
			if err != nil {
				return err
			}
			defer inFile.Close()

			outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
			if err != nil {
				return err
			}
			defer outFile.Close()

			_, err = io.Copy(outFile, inFile)
			if err != nil {
				return err
			}
		}
	}
	return nil
}

func Zip(srcFile string, destZip string) error {
	zipfile, err := os.Create(destZip)
	if err != nil {
		return err
	}
	defer zipfile.Close()

	archive := zip.NewWriter(zipfile)
	defer archive.Close()

	filepath.Walk(srcFile, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		header, err := zip.FileInfoHeader(info)
		if err != nil {
			return err
		}

		header.Name = strings.TrimPrefix(path, filepath.Dir(srcFile)+"/")
		// header.Name = path
		if info.IsDir() {
			header.Name += "/"
		} else {
			header.Method = zip.Deflate
		}

		writer, err := archive.CreateHeader(header)
		if err != nil {
			return err
		}

		if !info.IsDir() {
			file, err := os.Open(path)
			if err != nil {
				return err
			}
			defer file.Close()
			_, err = io.Copy(writer, file)
		}
		return err
	})

	return err
}

func Utf8ToGBK(text string) (string, error) {
	dst := make([]byte, len(text)*2)
	tr := simplifiedchinese.GB18030.NewEncoder()
	nDst, _, err := tr.Transform(dst, []byte(text), true)
	if err != nil {
		return text, err
	}
	return string(dst[:nDst]), nil
}

//获得uuid
func GetUid() string {
	UUID := uuid.NewV4()
	return UUID.String()
}

func LocalIPv4() (string, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return "", err
	}
	for _, iface := range ifaces {
		if iface.Flags&net.FlagUp == 0 {
			continue
		}
		if iface.Flags&net.FlagLoopback != 0 {
			continue
		}
		addrs, err := iface.Addrs()
		if err != nil {
			return "", err
		}
		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}
			if ip == nil || ip.IsLoopback() {
				continue
			}
			ip = ip.To4()
			if ip == nil {
				continue
			}
			return ip.String(), nil
		}
	}
	return "", errors.New("未连接网络")
}

//获取当前运行程序版本号
func GetVersion() string {
	exename := conf.GlobalConfig["appid"]
	if exename == "" {
		logger.Logger.Println("系统还未配置appid属性，请正确设置后再试！")
		os.Exit(0)
		return ""
	}
	if string(runtime.GOOS) == "windows" {
		exename = exename + ".exe"
		return ""
	}
	f, err1 := os.Open(exename)
	if err1 != nil {
		logger.Logger.Println("获取版本号失败,请检查appid是否与程序名称匹配！")
		logger.Logger.Error(err1)
		os.Exit(0)
		return ""
	}
	fi, err2 := f.Stat()
	if err2 != nil {
		logger.Logger.Info("获取版本号失败:")
		logger.Logger.Error(err2)
		return ""
	}
	return fi.ModTime().Format("20060102-15")
}

func GetAppCurPath() string {
	file, _ := exec.LookPath(os.Args[0])
	execpath, _ := filepath.Abs(file)
	execpath = filepath.Dir(execpath)
	if execpath[len(execpath)-1:] != string(os.PathSeparator) {
		execpath = execpath + string(os.PathSeparator)
	}
	return execpath
}

// 转化string数组为int数组
func String2Int64(strArr []string) []int64 {
	res := make([]int64, len(strArr))
	for index, val := range strArr {
		i, err := strconv.ParseInt(val, 10, 64)
		if err == nil {
			res[index] = i
		}
	}
	return res
}