package main

import (
	"sync"
	"net"
	"fmt"
	"time"
	"strings"
	"math/rand"
	"encoding/hex"
)

var msg = []string{
	"2461707550350150412506182253068502114303167c000000ffffb9ff000000000000000001cc002639131c0e",
	"*HQ,000,00,00000,0000#",
	"1212231273862178963863217984abc12863879a8c6a6c76a98c6ac9a6c798a6c76a",
}

func init() {
	rand.Seed(time.Now().UnixNano())
}
func main() {
	li, err := net.Listen("tcp", ":2277")
	if err != nil {
		panic(err)
	}
	defer li.Close()

	go func() {
		data1, _ := hex.DecodeString(msg[0])
		data2, _ := hex.DecodeString(msg[2])
		var datas = [][]byte{
			[]byte(msg[1]),
			data1,
			data2,
		}

		for {
			for i := 0; i < len(datas); i++ {
				go func(i int) {
					li, _ := net.Dial("tcp", ":2277")
					li.Write(datas[i])
					li.Close()
				}(i)
			}
			time.Sleep(time.Second)
		}
	}()

	for {
		conn, err := li.Accept()
		if err != nil {
			fmt.Println(err)
			time.Sleep(5 * time.Second)
			continue
		}
		go recvConnMsg(conn)
	}
}
func recvConnMsg(conn net.Conn) {
	var (
		aMap sync.Map
		bMap sync.Map
	)
	buf := make([]byte, 4096)
	defer conn.Close()
	aMap.Store(conn, "")
	go InitData(conn, aMap, bMap)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			fmt.Println("conn closed")
			return
		}
		Hex := fmt.Sprintf("%x", buf[0:n])
		if strings.Contains(Hex, "1212") {
			connMsgVal, _ := aMap.Load(conn)
			aMap.Store(conn, connMsgVal.(string)+Hex)
		} else {
			if strings.HasPrefix(string(buf[0:n]), "*") {
				Heartbeat(conn, bMap, string(buf[0:n]))
			} else {
				Basic(conn, bMap, Hex)
			}
		}
	}
}

func Heartbeat(conn net.Conn, connMap sync.Map, connMsgValStr string) {
	startIndex := strings.Index(connMsgValStr, "*")
	endIndex := strings.Index(connMsgValStr, "#")
	if endIndex < startIndex {
		endIndex = strings.Index(connMsgValStr[endIndex+1:], "#")
	}
	connMap.Store(conn, rand.Intn(100))
	fmt.Println(startIndex, endIndex)
}
func Basic(conn net.Conn, connMap sync.Map, connMsgValStr string) {
	startIndex := strings.Index(connMsgValStr, "24")
	if startIndex < 0 {
		return
	}
	connMap.Store(conn, rand.Intn(100))
	fmt.Println(startIndex)
}
func InitData(conn net.Conn, aMap, bMap sync.Map) {
	for {
		aData, ok := aMap.Load(conn)
		if !ok || aData == "" {
			continue
		}
		connMsgValStr := aData.(string)
		currentIndex := strings.Index(connMsgValStr, "1212") 
		if currentIndex == -1 {
			continue
		}
		AnalyzePackage(conn, bMap)
		aMap.Store(conn, string(connMsgValStr[currentIndex:]))
		time.Sleep(time.Second)
	}
}
func AnalyzePackage(conn net.Conn, bMap sync.Map) {
	key, ok := bMap.Load(conn)
	if ok {
		fmt.Println(key)
	} else {
		bMap.Store(key, rand.Intn(100))
	}
}