package rfid

import (
	"context"
	"encoding/binary"
	"encoding/hex"
	"fmt"
	"io"
	"time"

	"github.com/tarm/serial"
)

func NewReader(devName string, baud, readDuration int) *Reader {
	return &Reader{
		DevName:       devName,
		Baud:          baud,
		ReadTimeout:   readDuration,
		Alive:         true,
		HeartbeatTime: time.Now().Unix(),
	}
}

type Reader struct {
	DevName       string
	Baud          int
	EPCData       string
	ReadTimeout   int
	Alive         bool
	HeartbeatTime int64
	DevPort       *serial.Port
}

func (r *Reader) OpenSerial() (err error) {
	config := &serial.Config{
		Name:        r.DevName,
		Baud:        r.Baud,
		ReadTimeout: 2 * time.Second,
	}

	r.DevPort, err = serial.OpenPort(config)

	return err
}

func (r *Reader) CloseSerial() error {
	return r.DevPort.Close()
}

// AutoReadStart 开启自动读取, 返回写入的指令长度和错误
func (r *Reader) StartAutoRead() error {
	cmd := "5A0001010B00100001000B0001021000050000000101005EE2"

	data, _ := hex.DecodeString(cmd)

	_, err := r.DevPort.Write(data)
	if err != nil {
		return nil
	}

	// todo parse response
	r.ReadResponse()

	return err
}

// StopAutoRead 停止读取
func (r *Reader) StopAutoRead() error {
	cmd := "5A000102FF0000885A"

	data, _ := hex.DecodeString(cmd)

	_, err := r.DevPort.Write(data)
	if err != nil {
		return nil
	}

	// todo parse response
	r.ReadResponse()

	return err
}

func (r *Reader) ReadResponse() (int, error) {
	buf := make([]byte, 1024) // 根据协议最大数据长度调整缓冲区
	n, err := r.DevPort.Read(buf)
	fmt.Printf("Recive message %X\n", buf[:n])

	return n, err
}

func (r *Reader) ScanSpecificEPC(target string, minCount int) (bool, error) {
	err := r.StartAutoRead()
	if err != nil {
		return false, err
	}

	defer r.StopAutoRead()

	stop := time.After(time.Duration(r.ReadTimeout) * time.Second)

	// 根据协议最大数据长度调整缓冲区
	buf := make([]byte, 1024)
	scanCount := 0
	for {
		select {
		case <-stop:
			return false, nil
		default:
			for i := 0; i < 1024; i++ {
				buf[i] = 0 // 清零或其他处理
			}

			n, err := r.DevPort.Read(buf)
			if err != nil {
				return false, err
			}

			if n == 0 || n < 8 {
				continue // 如果没有读取到数据
			}

			// 检查帧头
			if buf[0] != 0x5A {
				continue // 忽略错误帧
			}
			fmt.Printf("Recive message %X\n", buf[:n]) // 打印协议控制字进行调试

			// 校验CRC
			//fmt.Printf("Crc %x\n",buf[n-2 : n])
			receivedCrc := binary.BigEndian.Uint16(buf[n-2 : n])
			computedCrc := CRC16XMODEM(buf[1 : n-2])
			if receivedCrc != (computedCrc & 0xFFFF) {
				fmt.Println("CRC check failed")
				continue
			}

			// 解析协议控制字 (仅在需要时使用)
			//fmt.Printf("Control Word: %x\n", buf[1:5]) // 打印协议控制字进行调试

			controlWord := binary.BigEndian.Uint32(buf[1:5])
			if controlWord != ControlWordEPCReadResponse6C {
				fmt.Printf("Control Word: %d, rec word %d\n", ControlWordEPCReadResponse6C, controlWord)
				continue
			}

			// 解析EPC数据长度
			epcLength := binary.BigEndian.Uint16(buf[7:9])
			//fmt.Printf("EPC length %d, EPC %x \n", epcLength, buf[9:9+epcLength])

			// 回调传送epc数据
			//callBack(buf[9 : 9+epcLength])
			epcData := fmt.Sprintf("%X", buf[9:9+epcLength])
			if epcData == target {
				scanCount++
				if scanCount > minCount {
					return true, nil
				}
			}

			fmt.Printf("read epc %s, target epc: %s\n", epcData, target)
		}
	}
}

func (r *Reader) ReadEPCData(ctx context.Context) error {
	err := r.StartAutoRead()
	if err != nil {
		return err
	}

	go func() {
		for {
			err := r.SendAck()
			if err != nil {
				fmt.Println("send ack.", err.Error())
			}
			time.Sleep(30 * time.Second)

			if time.Now().Unix()-r.HeartbeatTime > 120 {
				r.Alive = false
			}
		}
	}()

	// 根据协议最大数据长度调整缓冲区
	buf := make([]byte, 1024)
	for {
		select {
		case <-ctx.Done():
			return nil
		default:
			for i := 0; i < 1024; i++ {
				buf[i] = 0 // 清零或其他处理
			}

			n, err := r.DevPort.Read(buf)
			if err != nil && err != io.EOF {
				return err
			}

			if n == 0 || n < 8 {
				continue // 如果没有读取到数据
			}

			// 检查帧头
			if buf[0] != 0x5A {
				continue // 忽略错误帧
			}

			fmt.Printf("Read message %X\n", buf[:n]) // 打印协议控制字进行调试

			// 校验CRC
			receivedCrc := binary.BigEndian.Uint16(buf[n-2 : n])
			computedCrc := CRC16XMODEM(buf[1 : n-2])
			if receivedCrc != (computedCrc & 0xFFFF) {
				fmt.Println("CRC check failed")
				continue
			}

			r.HeartbeatTime = time.Now().Unix()
			r.Alive = true

			// 解析协议控制字
			controlWord := binary.BigEndian.Uint32(buf[1:5])

			switch controlWord {
			case ControlWordDeviceInfo:
				parseDeviceInfo(buf)
			case ControlWordEPCReadResponse6C:
				// 解析EPC数据长度
				epcLength := binary.BigEndian.Uint16(buf[7:9])

				r.EPCData = fmt.Sprintf("%X", buf[9:9+epcLength])

				// 回调传送epc数据
				//callBack(buf[9 : 9+epcLength])

				fmt.Printf("Read epc %s\n", r.EPCData)
			}
		}
	}
}

func (r *Reader) GetPower() error {
	cmd := "5A0001020200002959"
	data, _ := hex.DecodeString(cmd)

	_, err := r.DevPort.Write(data)
	if err != nil {
		return err
	}

	// todo parse response
	r.ReadResponse()

	return nil
}

func (r *Reader) SendAck() error {
	cmd := "5A000101000000DCE5"
	//cmd := "5A000111120004000000015FFB"
	data, _ := hex.DecodeString(cmd)

	_, err := r.DevPort.Write(data)
	return err
}

func (r *Reader) SetPower(val int) error {
	if val < 10 || val > 33 {
		return fmt.Errorf("value out of range, must be between 0 and 255")
	}

	frame := []byte{0x5A, 0x00, 0x01, 0x02, 0x01, 0x00, 0x02, 0x01}
	frame = append(frame, byte(val))

	crc := CRC16XMODEM(frame[1:])
	crcBytes := make([]byte, 2)
	binary.BigEndian.PutUint16(crcBytes, crc)
	frame = append(frame, crcBytes...)

	fmt.Printf("set power %d, cmd %2X\n", val, frame)

	_, err := r.DevPort.Write(frame)
	if err != nil {
		return nil
	}

	// todo parse response
	r.ReadResponse()

	return err
}

func (r *Reader) SetBuzzer(enable bool) error {
	cmd := "5A0001011E000100653D"
	if !enable {
		cmd = "5A0001011E000101751C"
	}
	data, _ := hex.DecodeString(cmd)

	_, err := r.DevPort.Write(data)
	if err != nil {
		return err
	}

	// todo parse response
	r.ReadResponse()

	return nil
}

func parseDeviceInfo(bytes []byte) {
	// 初始化解析的偏移量
	offset := 1

	// 解析协议控制字
	controlWord := bytes[offset : offset+4]
	offset += 4

	// 解析数据长度
	dataLength := int(bytes[offset])*256 + int(bytes[offset+1])
	offset += 2

	// 解析读写器序列号
	serialNumberLen := int(bytes[offset])*256 + int(bytes[offset+1])
	offset += 2
	serialNumber := bytes[offset : offset+serialNumberLen]
	offset += serialNumberLen

	// 解析上电时间（4字节）
	upTimeBytes := bytes[offset : offset+4]
	offset += 4

	// 解析基带编译时间长度（2字节）
	baseBandTimeLen := int(bytes[offset])*256 + int(bytes[offset+1])
	offset += 2

	// 解析基带编译时间（根据长度字段解析）
	baseBandTime := bytes[offset : offset+baseBandTimeLen]
	offset += baseBandTimeLen

	// 解析应用软件版本（4字节）
	appVer := bytes[offset : offset+4]
	offset += 4

	// 将字节数组转换为可读字符串
	serialNumberStr := string(serialNumber)
	baseBandTimeStr := string(baseBandTime)
	appVerStr := fmt.Sprintf("%d.%d.%d.%d", appVer[0], appVer[1], appVer[2], appVer[3])

	// 解析上电时间（将字节数组转为整数）
	upTime := int(upTimeBytes[0])<<24 + int(upTimeBytes[1])<<16 + int(upTimeBytes[2])<<8 + int(upTimeBytes[3])

	// 打印结果
	fmt.Printf("协议控制字: %X\n", controlWord)
	fmt.Printf("数据长度: %d\n", dataLength)
	fmt.Printf("读写器序列号: %s\n", serialNumberStr)
	fmt.Printf("读写器上电时间: %d秒\n", upTime)
	fmt.Printf("基带编译时间: %s\n", baseBandTimeStr)
	fmt.Printf("应用软件版本: %s\n", appVerStr)
}