package event

import (
	"encoding/hex"
	"errors"
	"fmt"
	"git.rosy.net.cn/jx-callback/business/model/dao"
	"git.rosy.net.cn/jx-print/globals"
	"io"
	"net"
	"strings"
	"time"
)

// ConnRead 获取链接数据
func ConnRead(c net.Conn) ([]byte, int, error) {
	buffer := make([]byte, 1024*2)
	n, err := c.Read(buffer)
	return buffer, n, err
}

// ListenTcp 入口
func ListenTcp() {
	l, err := net.Listen("tcp", ":8000")
	if err != nil {
		fmt.Println("listen error:", err)
		return
	}

	for {
		c, err := l.Accept()
		if err != nil || c == nil {
			fmt.Println("accept error:", err)
			break
		}

		fn := func() {
			// 捕获异常 防止waitGroup阻塞
			defer func() {
				if err := recover(); err != nil {
					fmt.Println("recover err = ", err)
					return
				}
			}()

			if err := handleConn(c); err != nil {
				c.Close()
				Pool.Wait()
				Pool.Stop()
				return
			}
		}
		Pool.AddJob(fn)
	}
}

func handleConn(c net.Conn) error {
	if c == nil {
		return errors.New("conn is nil")
	}
	for {
		buffer, n, err := ConnRead(c)

		remoteAddr := c.RemoteAddr().(*net.TCPAddr)
		remoteIP := remoteAddr.IP.String() // 打印机IP
		remotePort := remoteAddr.Port      // 打印机端口
		globals.SugarLogger.Debugf("remoteIP1: %s", remoteIP)
		globals.SugarLogger.Debugf("remotePort1: %d", remotePort)

		// 重连
		if err != nil {
			if err == io.EOF {
				fmt.Println("connection close")
			} else {
				fmt.Println("ReadString err:", err)
			}
			printRemoteAddr22 := c.RemoteAddr().String()
			printRemoteAddr22 = strings.Split(printRemoteAddr22, ":")[0]
			globals.SugarLogger.Debugf("printRemoteAddr22: %s", printRemoteAddr22)
			return err
		}

		//看是心跳还是打印回调
		data := hex.EncodeToString(buffer[:n])
		var (
			printNo   string     = "" //打印机编号
			heartbeat bool       = false
			callback  bool       = false
			t         *TcpClient = nil
		)
		if strings.Contains(data, heartText) || strings.Contains(data, heartTextNew) {
			printNoData, _ := hex.DecodeString(data[len(heartText) : len(data)-8])
			printNo = string(printNoData)
			heartbeat = true
		} else if strings.Contains(data, printText) || strings.Contains(data, printTextNew) { //打印回调
			_, printNo = getCallbackMsgInfo(data)
			callback = true
		}
		globals.SugarLogger.Debugf("printNoData------: %s", printNo)

		if value, have := TcpClientList.Load(printNo); !have {
			t = NewTcpClient()
			TcpClientList.Store(printNo, t)
		} else {
			t = value.(*TcpClient)
		}
		if heartbeat {
			// 证明是心跳
			Heartbeat(c, t, data, printNo, "")
		} else if callback {
			// 打印回调
			Callback(c, t, data, printNo)
		}
	}
}

func (t *TcpClient) printFail() (err error) {
	//新开机的打印失败和错误的
	var (
		db = dao.GetDB()
	)
	prints, _ := dao.GetPrintMsgs(db, "", []int{printMsgFail, printMsgErr, PrintMsgAlreadyLoad, printMsgAlreadySend}, time.Now().Add(-time.Hour*3), time.Now(), 0, 999)
	for _, printMsg := range prints {
		t.addMsgChan(printMsg)
	}
	return err
}

func (t *TcpClient) readTimeoutMap(key string) bool {
	t.Lock()
	defer t.Unlock()
	return t.TimeoutMap[key]
}