package main

import (
	"bytes"
	"crypto/md5"
	"encoding/binary"
	"encoding/hex"
	"errors"
	"fmt"
	"git.qianqiusoft.com/library/glog"
	"net"
	"strconv"
	"time"
)

// md5 哈希
func hash(str string)string{
	h := md5.New()
	h.Write([]byte(str))
	return hex.EncodeToString(h.Sum(nil))
}

// 读取字符串
func readString(conn net.Conn)(string, error){
	// 读长度
	size, err := readUInt32(conn)
	if err != nil{
		fmt.Println("读取长度失败，", err.Error())
		return "", err
	}

	glog.Infoln("读取长度-", size)

	// 读字符串
	b := make([]byte, size)
	n, err := conn.Read(b)
	if n != int(size){
		return "", errors.New("读取长度不是" + strconv.Itoa(int(size)))
	}
	return string(b), nil
}

// 写入字符串
func writeString(conn net.Conn, str string)error{
	if str == ""{
		return errors.New("字符串为空")
	}

	bytess := []byte(str)
	size := len(bytess)

	// 发送长度
	err := writeUInt32(conn, uint32(size))
	if err != nil{
		fmt.Println("发送长度失败，", err.Error())
		return err
	}

	// 发送内容
	n, err := conn.Write(bytess)
	if err != nil{
		fmt.Println("发送内容失败，", err.Error())
		return err
	}
	if n != size{
		return errors.New("发送长度不是" + strconv.Itoa(int(size)))
	}

	return nil
}

// 读取bytes
func readBytes(conn net.Conn)([]byte, error){
	// 读长度
	size, err := readUInt32(conn)
	if err != nil{
		fmt.Println("读取长度失败，", err.Error())
		return nil, err
	}

	fmt.Println("读取长度", size)

	// 读字符串
	b := make([]byte, size)
	n, err := conn.Read(b)
	if n != int(size){
		return nil, errors.New("读取长度不是" + strconv.Itoa(int(size)))
	}
	return b, nil
}

// 读取uint64
func readUInt32(conn net.Conn)(uint32, error){
	b := make([]byte, 4)
	n, err := conn.Read(b)
	if err != nil{
		fmt.Println("读取长度失败，", err.Error())
		return 0, err
	}
	if n != 4{
		return 0, errors.New("读取长度不是4")
	}
	size := binary.BigEndian.Uint32(b)

	return size, nil
}

// 读取uint64
func readUInt64(conn net.Conn)(uint64, error){
	b := make([]byte, 8)
	n, err := conn.Read(b)
	if err != nil{
		fmt.Println("读取长度失败，", err.Error())
		return 0, err
	}
	if n != 8{
		return 0, errors.New("读取长度不是8")
	}
	size := binary.BigEndian.Uint64(b)

	return size, nil
}

// 写入长度
func writeUInt32(conn net.Conn, v uint32)error{
	// 发送长度
	b := make([]byte, 4)
	binary.BigEndian.PutUint32(b, v)
	n, err := conn.Write(b)
	if err != nil{
		fmt.Println("发送长度失败，", err.Error())
		return err
	}
	if n != 4{
		return errors.New("发送长度不是4")
	}

	return nil
}

// 转byte数组
func uint32ToBytes(v uint32) []byte {
	b := make([]byte, 4)
	binary.BigEndian.PutUint32(b, v)

	return b
}

// 校验
func checkSign(conn net.Conn)(bool, error){
	glog.Infoln("校验")
	timestamp, err := readUInt64(conn)
	if err != nil{
		fmt.Println("读取时间戳错误", err.Error())
		return false, err
	}
	glog.Infoln("校验1")
	sign, err := readString(conn)
	if err != nil{
		fmt.Println("读取sign错误", err.Error())
		return false, err
	}
	seed := strconv.Itoa(int(timestamp)) + __KEY
	hashVal := hash(seed)

	glog.Infoln("校验2")
	if hashVal != sign{
		fmt.Println("校验码错误", hashVal, sign)
		return false, nil
	}

	glog.Infoln("校验3")
	if time.Now().Sub(time.Unix(int64(timestamp) / 1000000000, 0)).Seconds() > 60 {
		fmt.Println("校验码已失效")
		return false, nil
	}

	return  true, nil
}

// cmd 和 内容转字节数组
func cmdContentToBytes(cmd string, content []byte)[]byte{
	buf := bytes.NewBuffer([]byte{})

	// 命令
	bytess := []byte(cmd)
	size := len(bytess)
	b := make([]byte, 4)
	binary.BigEndian.PutUint32(b, uint32(size))
	buf.Write(b)
	buf.Write(bytess)

	// 内容
	size = len(content)
	b = make([]byte, 4)
	binary.BigEndian.PutUint32(b, uint32(size))
	buf.Write(b)
	buf.Write(content)

	return buf.Bytes()
}