// go-venus-plug project go-venus-plug.go
package main

import (
	"bytes"
	"encoding/binary"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"go-venus-plug/models"
	"io"
	"net"
	"os"
	"strings"
)

var (
	clientId int32
	nick     string
)

func main() {
	conn := Conncect("10.32.172.124:16800")
	AuthByDummy("venus", conn)
	var userData models.FindNameData
	userData.UserName = "cscadmin"
	body, err := json.Marshal(userData)
	if err != nil {
		panic(err.Error())
	}
	Request("permissionServiceOP.findUserByUserName", "1", string(body), conn)
}

func Request(apiName, version, jsonData string, conn *net.TCPConn) (string, string) {
	reserved := make([]byte, 8)
	apiNameByte := []byte(apiName)
	apiNameLength := fromInt32toByte(int32(len(apiNameByte)))
	versionByte := fromInt32toByte(1)
	dataByte := []byte(jsonData)
	dataByteLength := fromInt32toByte(int32(len(dataByte)))
	//计算报文体长度
	//8+4+38+4+4+23+16
	requestCount := len(reserved) + 4 + len(apiNameByte) + 4 + 4 + len(dataByte) + 16
	//组装报文体
	requestData := make([]byte, requestCount)
	writeData2Byte(&requestData, 0, 8, requestData)
	writeData2Byte(&requestData, 8, 12, apiNameLength)
	lenCur := 12 + len(apiNameByte)
	writeData2Byte(&requestData, 12, lenCur, apiNameByte)
	writeData2Byte(&requestData, lenCur, lenCur+4, versionByte)
	lenCur = lenCur + 4
	writeData2Byte(&requestData, lenCur, lenCur+4, dataByteLength)
	lenCur = lenCur + 4
	writeData2Byte(&requestData, lenCur, lenCur+len(dataByte), dataByte)
	lenCur = lenCur + len(dataByte)
	writeData2Byte(&requestData, lenCur, lenCur+16, make([]byte, 16))

	requestHead := makeHead(requestCount, []byte{0x02, 0x00, 0x00, 0x01})

	msg := make([]byte, 24+requestCount)
	writeData2Byte(&msg, 0, 24, requestHead)
	writeData2Byte(&msg, 24, 24+requestCount, requestData)

	conn.Write(msg)
	//printData(msg)
	data := make([]byte, 24)
	conn.Read(data)
	//printData(data)
	//fmt.Printf("DummyPacket Msg:%q\n", data)
	head := createHead(data)
	fmt.Printf("DummyPacket:%+v\n", head)

	if string(head.CommondType) == string([]byte{0xff, 0xff, 0xff, 0xff}) {
		fmt.Printf("System Error:\n")
		os.Exit(1)
	}

	data = make([]byte, head.PacketLength)
	conn.Read(data)

	returnMsg := string(data[4 : len(data)-16])
	traceId := string(data[len(data)-16:])
	fmt.Printf("Return Msg:%+v ,TraceId:%+v", returnMsg, traceId)
	return returnMsg, traceId
}

func AuthByDummy(userName string, conn *net.TCPConn) {
	authType := []byte{0x01}
	capabilities := []byte{0x00, 0x00, 0x00, 0x10}
	shakeSerializeType := []byte{0x00}
	client := []byte("VENUS-GO-CLIENT")
	version := []byte("2.0.0-BETA")
	userNameByte := []byte(userName)
	dummyDataCount := len(authType) + len(capabilities) + len(shakeSerializeType) + 4 + len(client) + 4 + len(version) + 4 + len(userNameByte)
	dummyData := make([]byte, dummyDataCount)
	writeData2Byte(&dummyData, 0, 1, authType)
	writeData2Byte(&dummyData, 1, 5, capabilities)
	writeData2Byte(&dummyData, 5, 6, shakeSerializeType)
	writeData2Byte(&dummyData, 6, 10, fromInt32toByte(int32(len(client))))
	writeData2Byte(&dummyData, 10, 10+len(client), client)
	writeData2Byte(&dummyData, 10+len(client), 14+len(client), fromInt32toByte(int32(len(version))))
	writeData2Byte(&dummyData, 14+len(client), 14+len(client)+len(version), version)
	writeData2Byte(&dummyData, 14+len(client)+len(version), 18+len(client)+len(version), fromInt32toByte(int32(len(userNameByte))))
	writeData2Byte(&dummyData, 18+len(client)+len(version), 18+len(client)+len(userNameByte), userNameByte)
	dummyHead := makeHead(dummyDataCount, []byte{0x03, 0x10, 0x00, 0x00})
	msg := make([]byte, 24+dummyDataCount)
	writeData2Byte(&msg, 0, 24, dummyHead)
	writeData2Byte(&msg, 24, 24+dummyDataCount, dummyData)
	//fmt.Printf("head length:%v\n", dummyDataCount)
	//fmt.Printf("send data:%q\n", msg)
	conn.Write(msg)
	//printData(msg)
	data := make([]byte, 24)
	conn.Read(data)
	//printData(data)
	//fmt.Printf("DummyPacket Msg:%q\n", data)
	head := createHead(data)
	fmt.Printf("DummyPacket:%+v\n", head)

	if string(head.CommondType) == string([]byte{0xff, 0xff, 0xff, 0xff}) {
		fmt.Printf("System Error:\n")
		os.Exit(1)
	}

}

func makeHead(dummyLength int, commondType []byte) []byte {
	head := make([]byte, 24)
	packetLength := fromInt32toByte(int32(dummyLength + 24))
	PacketVersion := []byte{0x00, 0x02}
	serializeType := []byte{0x00}
	flag := []byte{0x00}
	writeData2Byte(&head, 0, 4, packetLength)
	writeData2Byte(&head, 4, 6, PacketVersion)
	writeData2Byte(&head, 6, 10, commondType)
	writeData2Byte(&head, 10, 11, serializeType)
	writeData2Byte(&head, 11, 12, flag)
	writeData2Byte(&head, 12, 16, fromInt32toByte(clientId))
	return head
}

func writeData2Byte(dummyData *[]byte, start, end int, addType []byte) {
	j := 0
	for i := start; i < end; i++ {
		(*dummyData)[i] = addType[j]
		j++
	}

}

func Conncect(address string) *net.TCPConn {
	addr, err := net.ResolveTCPAddr("tcp", address)
	checkErr(err)
	conn, err := net.DialTCP("tcp", nil, addr)
	checkErr(err)
	// 读取提示
	data := make([]byte, 24)
	conn.Read(data)

	//printData(data)
	head := createHead(data)
	fmt.Printf("Head:%+v\n", head)
	//判断是否握手协议
	if string(head.CommondType) != string([]byte{0x03, 0x00, 0x00, 0x01}) {
		fmt.Println("Commond Type ERROR\n")
		os.Exit(1)
	}

	clientId = head.ClientId
	data = make([]byte, head.DateLength)
	conn.Read(data)
	//printData(data)
	shake := createShake(data)

	fmt.Printf("Shake:%+v\n", shake)

	return conn
}

func createShake(data []byte) (shake *models.PacketHandShake) {
	capabilities := fromByte2Int(data[:4])
	supportAuthenMethod := fromByte2Int(data[4:8])
	randomCharsLen := fromByte2Int(data[8:12])
	challenge := string(data[12 : 12+randomCharsLen])
	//versionCharsLen := fromByte2Int(data[12+randomCharsLen+1 : 16+randomCharsLen])
	version := string(data[16+randomCharsLen:])

	//初始化头对象
	pShake := models.PacketHandShake{capabilities, supportAuthenMethod, challenge, version}

	return &pShake

}

func createHead(data []byte) (head *models.PacketHead) {
	pLength := fromByte2Int(data[:4])
	pVersion := fromByte2Int(data[4:6])
	commondType := data[6:10]
	serializeType := data[10]
	flags := data[11]
	clientId := fromByte2Int(data[12:16])
	clientRequestId := fromByte2Int(data[16:24])
	dateLength := pLength - 24

	//初始化头对象
	pHead := models.PacketHead{pLength, pVersion, commondType, serializeType, flags, clientId, clientRequestId, dateLength}

	return &pHead

}

func fromInt32toByte(num int32) []byte {
	b_buf := bytes.NewBuffer([]byte{})
	binary.Write(b_buf, binary.BigEndian, num)

	//	b := make([]byte, 4)
	//	binary.LittleEndian.PutUint32(b, uint32(num))
	return b_buf.Bytes()
}

func fromByte2Int(data []byte) int32 {
	b_buf := bytes.NewBuffer(data)
	var length int32
	binary.Read(b_buf, binary.BigEndian, &length)
	return length
}

func ByteToBinaryString(data byte) (str string) {
	var a byte
	for i := 0; i < 8; i++ {
		a = data
		data <<= 1
		data >>= 1

		switch a {
		case data:
			str += "0"
		default:
			str += "1"
		}

		data <<= 1
	}
	return str
}

func mainbBak() {
	addr, err := net.ResolveTCPAddr("tcp", "10.32.172.124:16800")
	checkErr(err)
	conn, err := net.DialTCP("tcp", nil, addr)
	checkErr(err)
	// 读取提示
	data := make([]byte, 1024)
	conn.Read(data)
	fmt.Println(string(data))
	// 输入昵称
	fmt.Print("输入昵称:")
	fmt.Scanf("%v", &nick)
	fmt.Println("Hello " + nick)
	conn.Write([]byte("nick|" + nick))

	go Handle(conn)

	for {
		someTex := ""
		fmt.Scanf("%v", &someTex)
		conn.Write([]byte("say|" + nick + "|" + someTex))
	}
}

const BufLength = 128

func Handle(conn net.Conn) {
	for {
		data := make([]byte, 1024)
		buf := make([]byte, BufLength)
		for {
			n, err := conn.Read(buf)
			if err != nil && err != io.EOF {
				checkErr(err)
			}
			data = append(data, buf[:n]...)
			if n != BufLength {
				break
			}
		}

		fmt.Println(string(data))
	}
}

func printData(data []byte) {
	for _, tmpData := range data {
		fmt.Printf("结果输出:%q\n", ByteToBinaryString(tmpData))
		fmt.Printf("结果输出:%q\n", tmpData&0xff)
	}
}

func checkErr(err error) {
	if err != nil {
		fmt.Println(err)
		os.Exit(-1)
	}
}

func mainTest() {
	addr, err := net.ResolveTCPAddr("tcp", "10.32.172.124:16800")
	checkErr(err)
	conn, err := net.DialTCP("tcp", nil, addr)
	checkErr(err)
	// 读取提示
	data := make([]byte, 16)
	conn.Read(data)
	for _, tmpData := range data {
		fmt.Printf("结果输出:%q\n", ByteToBinaryString(tmpData))
		fmt.Printf("结果输出:%q\n", tmpData&0xff)
	}
	tag := make([]byte, 32)
	res := hex.Encode(tag, data)

	fmt.Println(res)

	for _, tmpTag := range tag {
		fmt.Printf("结果输出:%q\n", tmpTag)
	}

	fmt.Printf("结果输出:%#q\n", tag)

	fmt.Printf("结果输出:%+v\n", data)
	fmt.Printf("结果输出:%b\n", data)
	fmt.Printf("结果输出:%x\n", data)
	fmt.Printf("结果输出:%q\n", data)
	fmt.Printf("结果输出:%#q\n", data)

	b := []byte{0x00, 0x00, 0x00, 0x47}
	b_buf := bytes.NewBuffer(b)
	var x int32
	binary.Read(b_buf, binary.BigEndian, &x)
	fmt.Println(x)

	fmt.Println(strings.Repeat("-", 100))

	x = 71
	b_buf = bytes.NewBuffer([]byte{})
	binary.Write(b_buf, binary.BigEndian, x)
	fmt.Println(b_buf.Bytes())

}