package util

import (
	"basic.com/valib/logger.git"
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"crypto/md5"
	"crypto/rand"
	"crypto/tls"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/pkg/errors"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"
	"vamicro/config"
	"vamicro/extend/code"
)

const TimeFmtStr = "2006-01-02 15:04:05"

// iterater field of struct to lowcast.
// return type: string slice.
func FiledbyStuct(stuct interface{}) []string {
	var strtmp []string
	t := reflect.TypeOf(stuct)
	for i := 0; i < t.NumField(); i++ {
		strtmp = append(strtmp, strings.ToLower(string(t.Field(i).Name)))
	}
	return strtmp
}

//
// ResponseFormat 返回数据格式化
func ResponseFormat(c *gin.Context, respStatus *code.Code, data interface{}) {
	if respStatus == nil {
		respStatus = code.RequestParamError
	}
	c.JSON(respStatus.Status, gin.H{
		"code":    respStatus.Status,
		"success": respStatus.Success,
		"msg":     respStatus.Message,
		"data":    data,
	})
	return
}

func PseudoUuid() (uuid string) {
	b := make([]byte, 16)
	rand.Read(b)
	uuid = fmt.Sprintf("%X-%X-%X-%X-%X", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])

	return
}

var commonIV = []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}
var encryptKey = "beijingcompanybasicvideoanalysis"

func Encrypt(pwd string) (string, error) {
	key := []byte(encryptKey)
	pwdBytes := []byte(pwd)
	c, err := aes.NewCipher(key)
	if err != nil {
		return "", err
	}
	cfb := cipher.NewCFBEncrypter(c, commonIV)

	ciphertext := make([]byte, len(pwdBytes))
	cfb.XORKeyStream(ciphertext, pwdBytes)
	pwdStr := base64.StdEncoding.EncodeToString(ciphertext)
	return pwdStr, nil
}

func Struct2Map(obj interface{}) map[string]interface{} {
	resultMap := make(map[string]interface{}, 0)
	bytesData, err := json.Marshal(obj)
	if err != nil {
		return resultMap
	}
	json.Unmarshal(bytesData, &resultMap)
	return resultMap
}

// 获取本机网卡IP
func GetLocalIP(networkName string) (ipv4 string, mask string, err error) {
	interfaces, err := net.Interfaces()
	if err != nil {
		return "", "", err
	}

	for _, i := range interfaces {
		byName, err := net.InterfaceByName(i.Name)
		if err != nil {
			return "", "", err
		}
		addresses, err := byName.Addrs()
		for _, v := range addresses {
			if ipnet, ok := v.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
				if ipnet.IP.To4() != nil {
					if byName.Name == networkName {
						maskStr := ipnet.Mask.String()
						mask64, _ := strconv.ParseUint(maskStr, 16, 32)
						return ipnet.IP.String(), IpIntToString(int(mask64)), nil
					}
				}
			}
		}
	}
	return "", "", errors.New("ipv4 not found")
}

func GetDefaultRoute(networkName string) (route string, err error) {
	cmdStr := fmt.Sprintf("route | grep -P \"^default.*%s$\" | awk '{print $2}'", networkName)
	cmd := exec.Command("/bin/sh", "-c", cmdStr)
	b, err := cmd.Output()
	if err != nil {
		return "", err
	}
	return string(b), nil

}

func StringIpToInt(ipstring string) int {
	ipSegs := strings.Split(ipstring, ".")
	var ipInt int = 0
	var pos uint = 24
	for _, ipSeg := range ipSegs {
		tempInt, _ := strconv.Atoi(ipSeg)
		tempInt = tempInt << pos
		ipInt = ipInt | tempInt
		pos -= 8
	}
	return ipInt
}

func IpIntToString(ipInt int) string {
	ipSegs := make([]string, 4)
	var len int = len(ipSegs)
	buffer := bytes.NewBufferString("")
	for i := 0; i < len; i++ {
		tempInt := ipInt & 0xFF
		ipSegs[len-i-1] = strconv.Itoa(tempInt)

		ipInt = ipInt >> 8
	}
	for i := 0; i < len; i++ {
		buffer.WriteString(ipSegs[i])
		if i < len-1 {
			buffer.WriteString(".")
		}
	}
	return buffer.String()
}

const ipReg = `^(([1-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.)(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){2}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$`

func IpCheck(ipStr string) (string, bool) {
	idx := strings.LastIndex(ipStr, ":")
	if idx > -1 {
		ipStr = ipStr[:idx]
	}
	if match, _ := regexp.MatchString(ipReg, ipStr); match {
		return ipStr, true
	}
	return "", false
}

func PathExists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	}
	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err
}

func IsFileExist(path string) bool {
	_, err := os.Stat(path)
	if err != nil {
		if os.IsNotExist(err) {
			return false
		}
	}
	return true
}

const imgReg = `^\.(jpg|png|jpeg)$`

func ImgCheck(ext string) bool {
	lowerStr := strings.ToLower(ext)
	if match, _ := regexp.MatchString(imgReg, lowerStr); match {
		return true
	}
	return false
}

const videoReg = `^\.(mp4|rmvb|flv|mpeg|avi)$`

func VideoCheck(ext string) bool {
	lowerStr := strings.ToLower(ext)
	if match, _ := regexp.MatchString(videoReg, lowerStr); match {
		return true
	}
	return false
}

// 判断所给路径文件/文件夹是否存在
func Exists(path string) bool {
	_, err := os.Stat(path) //os.Stat获取文件信息
	if err != nil {
		if os.IsExist(err) {
			return true
		}
		return false
	}
	return true
}

func CreateDirectory(path string) bool {
	if path == "" {
		return false
	}
	if Exists(path) {
		return true
	}
	err := os.MkdirAll(path, os.ModePerm)
	if err != nil {
		return false
	}
	return true
}

//日期转字符串
func FormatDate(date time.Time, layout string) string {
	layout = strings.Replace(layout, "yyyy", "2006", 1)
	layout = strings.Replace(layout, "yy", "06", 1)
	layout = strings.Replace(layout, "MM", "01", 1)
	layout = strings.Replace(layout, "dd", "02", 1)
	layout = strings.Replace(layout, "HH", "15", 1)
	layout = strings.Replace(layout, "mm", "04", 1)
	layout = strings.Replace(layout, "ss", "05", 1)
	layout = strings.Replace(layout, "SSS", "000", -1)

	return date.Format(layout)
}

//计算持续时长
func TimeSpan(startTime time.Time) string {
	sp := time.Since(startTime)
	day := strconv.Itoa(int(sp.Hours() / 24))      //天数
	hour := strconv.Itoa(int(sp.Hours()) % 24)     //小时数
	minute := strconv.Itoa(int(sp.Minutes()) % 60) //分钟数
	sec := strconv.Itoa(int(sp.Seconds()) % 60)    //秒数
	return day + "天" + hour + "时" + minute + "分" + sec + "秒"
}

func ComputeFileMd5(filepath string) string {

	f, err := os.Open(filepath)
	if err != nil {
		logger.Debug("ComputeFileMd5 Open err:", err)
		return ""
	}

	defer f.Close()

	md5hash := md5.New()
	if _, err := io.Copy(md5hash, f); err != nil {
		logger.Debug("ComputeFileMd5 Copy err:", err)
		return ""
	}

	md5hash.Sum(nil)
	return fmt.Sprintf("%x", md5hash.Sum(nil))
}

func ParseScore64(compareScore float64) float64 {
	if compareScore < 1 {
		compareScore = compareScore * 100
	}
	f, _ := strconv.ParseFloat(fmt.Sprintf("%2.2f", compareScore), 64)
	return f
}

func GetAppRootPath() string {
	file, err := exec.LookPath(os.Args[0])
	if err != nil {
		return ""
	}
	p, err := filepath.Abs(file)
	if err != nil {
		return ""
	}
	return filepath.Dir(p)
}

func FormatNum(oNum int, n int) string {
	m := 0
	for {
		oNum = oNum / 10
		m++
		if oNum == 0 {
			break
		}
	}
	fmtStr := "%0" + strconv.Itoa(m) + "d"
	return fmt.Sprintf(fmtStr, n)
}

func FileMd5(path string) (string, error) {
	file, err := os.Open(path)
	if err != nil {
		return "", err
	}

	defer file.Close()

	_md5 := md5.New()
	if _, err := io.Copy(_md5, file); err != nil {
		return "", err
	}

	return hex.EncodeToString(_md5.Sum(nil)), nil
}

func DownLoad(url string) ([]byte, error) {
	connectTimeout := 5 * time.Second
	readWriteTimeout := 10000 * time.Millisecond
	c := &http.Client{
		Transport: &http.Transport{
			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
			Dial:            TimeoutDialer(connectTimeout, readWriteTimeout),
		},
	}
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	resp, err := c.Do(req)

	body, err1 := ioutil.ReadAll(resp.Body)
	if err1 != nil {
		resp.Body.Close()
		return nil, err
	} else {
		logger.Debug("Download success")
	}
	resp.Body.Close()
	return body, nil
}

func TimeoutDialer(cTimeout time.Duration, rwTimeout time.Duration) func(net, addr string) (c net.Conn, err error) {
	return func(netw, addr string) (net.Conn, error) {
		conn, err := net.DialTimeout(netw, addr, cTimeout)
		if err != nil {
			return nil, err
		}
		conn.SetDeadline(time.Now().Add(rwTimeout))
		return conn, nil
	}
}

//判断一个数组是否包含某个元素
func ArrayContains(list []string, ele string) bool {
	if list == nil {
		return false
	}
	for _, s := range list {
		if s == ele {
			return true
		}
	}
	return false
}

//获取当前平台的CPU-GPU架构
func GetPlatform() string {
	dt := config.Server.DeviceType
	if len(dt) >= 6 {
		s := dt[4:6]
		if s == "01" {
			return "X86-NVIDIA"
		} else if s == "02" {
			return "X86-Bitmain"
		} else if s == "03" {
			return "ARM-NVIDIA"
		} else if s == "04" {
			return "ARM-Bitmain"
		}
	}
	return ""
}

//验证platform是否匹配
func PlatformMatch(pt string) bool {
	curPt := GetPlatform()
	if pt == "" || curPt == "" {
		return false
	}
	i1 := strings.Index(pt, "-")
	i2 := strings.Index(curPt, "-")
	if i1 == -1 || i2 == -1 {
		return false
	}
	return pt[:i1] == curPt[:i2]
}

func GetVGpu() string {
	plat := GetPlatform()
	if strings.HasPrefix(plat, "X86") {
		rGpu, _ := NvidiaVGpu()
		return rGpu
	}
	return ""
}

/*
   获取英伟达显卡的型号
*/
func NvidiaVGpu() (vGpu string, err error) {
	resultMsg, e := ExeCmd("nvidia-smi -L")
	if e != nil {
		return vGpu, errors.New("无可用GPU!请检查是否正常安显卡及显卡驱动，通过nvidia-smi查询状态")
	}
	indeces := strings.Split(string(resultMsg), "\n")[0]
	if len(indeces) > 0 {
		vGpu = strings.Split(strings.Split(indeces, " (")[0], ": ")[1]
	} else {
		return vGpu, errors.New("无可用GPU!请检查是否正常安显卡及显卡驱动，通过nvidia-smi查询状态")
	}
	return vGpu, nil
}

/*
   ARM机器不用匹配显卡
   X86需要检验显卡型号是否与算法匹配
*/
func GpuMatch(vus string) bool {
	platform := GetPlatform()
	arr := strings.Split(vus, ",")
	if strings.HasPrefix(platform, "X86") {
		//获取机器实际的显卡型号
		vGpu, err := NvidiaVGpu()
		if err == nil {
			isTi := strings.Contains(vGpu, " Ti")
			for _, s := range arr {
				aliasGpu := s
				tix := strings.Index(aliasGpu, "ti")
				if tix > 0 {
					aliasGpu = aliasGpu[:tix] + " Ti"
				}
				if isTi {
					if strings.Contains(vGpu, aliasGpu) && strings.Contains(aliasGpu, " Ti") {
						return true
					}
				} else {
					if strings.Contains(vGpu, aliasGpu) && !strings.Contains(aliasGpu, " Ti") {
						return true
					}
				}

			}
			return false
		}
		return false
	} else if strings.HasPrefix(platform, "ARM") {
		return true
	}
	return false
}

func PortInUse(port string) bool {
	number, err := strconv.Atoi(port)
	if err != nil || number < 1 || number > 65535 {
		return true
	}
	timeout := time.Second
	conn, err := net.DialTimeout("tcp", net.JoinHostPort("127.0.0.1", port), timeout)
	if conn != nil {
		conn.Close()
	}
	//logger.Debug("port:", port, " err", err)
	return err == nil
}

//获取商城地址，如果本地商城配置不为空，则取本地，否则取云端
func GetShopUrl() string {
	s := config.ShopConf.Url
	if config.ShopConf.LocalShop != "" {
		s = config.ShopConf.LocalShop
	}
	logger.Debug("GetShopUrl addr:", s)
	return s
}