package nnet

import (
	"context"
	"encoding/binary"
	"fmt"
	"sync"

	internalprotocol "github.com/noahlann/nnet/internal/protocol"
	internalunpacker "github.com/noahlann/nnet/internal/unpacker"
	protocolpkg "github.com/noahlann/nnet/pkg/protocol"
	unpackerpkg "github.com/noahlann/nnet/pkg/unpacker"
)

// NNetProtocol nnet协议实现
type NNetProtocol struct {
	version  string
	unpacker unpackerpkg.Unpacker
	once     sync.Once
}

// NewNNetProtocol 创建nnet协议
func NewNNetProtocol(version string) protocolpkg.Protocol {
	return &NNetProtocol{
		version: version,
	}
}

// Name 获取协议名称
func (p *NNetProtocol) Name() string {
	return "nnet"
}

// Version 获取协议版本
func (p *NNetProtocol) Version() string {
	return p.version
}

// HasHeader 是否有帧头（nnet协议有帧头）
func (p *NNetProtocol) HasHeader() bool {
	return true
}

// Encode 编码数据
func (p *NNetProtocol) Encode(data []byte, header protocolpkg.FrameHeader) ([]byte, error) {
	// nnet协议格式：
	// [Magic(4 bytes)][Version(1 byte)][Length(4 bytes)][Data(N bytes)][Checksum(2 bytes)]

	magic := []byte("NNET")
	versionByte := byte(1) // 版本1
	if header != nil {
		if versionVal := header.Get("version"); versionVal != nil {
			if v, ok := versionVal.(byte); ok {
				versionByte = v
			}
		}
	}
	dataLength := uint32(len(data))

	// 计算校验和（简单实现：数据字节和）
	checksum := uint16(0)
	for _, b := range data {
		checksum += uint16(b)
	}

	// 构建消息
	packet := make([]byte, 0, 11+len(data))
	packet = append(packet, magic...)
	packet = append(packet, versionByte)

	// 长度（4字节，大端序）
	lengthBytes := make([]byte, 4)
	binary.BigEndian.PutUint32(lengthBytes, dataLength)
	packet = append(packet, lengthBytes...)

	// 数据
	packet = append(packet, data...)

	// 校验和（2字节，大端序）
	checksumBytes := make([]byte, 2)
	binary.BigEndian.PutUint16(checksumBytes, checksum)
	packet = append(packet, checksumBytes...)

	return packet, nil
}

// Decode 解码数据
// 优化：当数据来自unpacker时（数据已经完整），可以跳过长度验证，因为unpacker已经验证过
// 但为了保持接口的通用性，我们仍然进行基本的验证
func (p *NNetProtocol) Decode(data []byte) (protocolpkg.FrameHeader, []byte, error) {
	// 检查最小长度（Magic 4 + Version 1 + Length 4 + 最小数据 0 + Checksum 2 = 11）
	if len(data) < 11 {
		return nil, nil, fmt.Errorf("invalid packet length: %d < 11", len(data))
	}

	// 检查Magic
	if len(data) < 4 {
		return nil, nil, fmt.Errorf("invalid packet: too short for magic")
	}
	magic := data[0:4]
	if string(magic) != "NNET" {
		return nil, nil, fmt.Errorf("invalid magic: %s", string(magic))
	}

	// 创建帧头
	header := internalprotocol.NewFrameHeader()
	header.Set("magic", string(magic))

	// 读取版本
	if len(data) < 5 {
		return nil, nil, fmt.Errorf("invalid packet: too short for version")
	}
	version := data[4]
	header.Set("version", version)
	// 注意：这里不检查版本值，因为版本识别由版本识别器或服务器逻辑处理
	// 这样可以支持多版本协议

	// 读取长度字段（偏移5-8）
	if len(data) < 9 {
		return nil, nil, fmt.Errorf("invalid packet: too short for length field")
	}
	dataLength := binary.BigEndian.Uint32(data[5:9])
	header.Set("length", dataLength)

	// 计算预期的总长度：Magic(4) + Version(1) + Length(4) + Data(dataLength) + Checksum(2)
	expectedTotalLength := 9 + int(dataLength) + 2
	
	// 优化：如果数据长度正好等于预期长度，说明数据来自unpacker（已经完整），可以跳过长度验证
	// 否则，需要进行长度验证（数据可能不完整）
	if len(data) != expectedTotalLength {
		// 数据长度不匹配，可能是数据不完整或数据错误
		if len(data) < expectedTotalLength {
			return nil, nil, fmt.Errorf("invalid data length: expected %d, got %d", expectedTotalLength, len(data))
		}
		// 如果数据长度大于预期，可能是多个包，但我们只处理第一个包
		// 这种情况应该由unpacker处理，不应该到达这里
	}

	// 读取数据部分（偏移9到9+dataLength）
	messageDataStart := 9
	messageDataEnd := 9 + int(dataLength)
	if len(data) < messageDataEnd {
		return nil, nil, fmt.Errorf("invalid packet: data section incomplete")
	}
	messageData := data[messageDataStart:messageDataEnd]

	// 读取校验和（偏移9+dataLength到11+dataLength）
	checksumStart := messageDataEnd
	checksumEnd := checksumStart + 2
	if len(data) < checksumEnd {
		return nil, nil, fmt.Errorf("invalid packet: checksum incomplete")
	}
	checksum := binary.BigEndian.Uint16(data[checksumStart:checksumEnd])
	header.Set("checksum", checksum)

	// 验证校验和
	calculatedChecksum := uint16(0)
	for _, b := range messageData {
		calculatedChecksum += uint16(b)
	}
	if checksum != calculatedChecksum {
		return nil, nil, fmt.Errorf("checksum mismatch: expected %d, got %d", calculatedChecksum, checksum)
	}

	return header, messageData, nil
}

// Handle 处理消息
func (p *NNetProtocol) Handle(ctx context.Context, data []byte) ([]byte, error) {
	// nnet协议的处理逻辑
	// 这里可以添加协议特定的处理逻辑
	return data, nil
}

// Unpacker 获取协议的拆包器
// nnet协议使用LengthFieldUnpacker来处理粘包拆包
func (p *NNetProtocol) Unpacker() unpackerpkg.Unpacker {
	p.once.Do(func() {
		// nnet协议格式：[Magic(4)][Version(1)][Length(4)][Data(N)][Checksum(2)]
		// 长度字段在偏移5的位置（Magic 4字节 + Version 1字节）
		// 长度字段是4字节，表示Data部分的长度
		// 总长度 = 5（Magic+Version） + 4（Length字段） + Length（数据长度） + 2（Checksum）
		config := unpackerpkg.LengthFieldUnpacker{
			LengthFieldOffset:  5,  // Magic(4) + Version(1) = 5
			LengthFieldLength:  4,  // Length字段是4字节
			LengthAdjustment:   2,  // 需要加上Checksum(2字节)
			InitialBytesToStrip: 0, // 不跳过任何字节，保留完整包
		}
		p.unpacker = internalunpacker.NewLengthFieldUnpacker(config)
	})
	return p.unpacker
}

// DecodeHeader 解码帧头（增量解析，即使数据不完整）
// 实现IncrementalDecoder接口，支持在数据不完整时解析帧头
func (p *NNetProtocol) DecodeHeader(data []byte) (protocolpkg.FrameHeader, int, error) {
	// nnet协议帧头格式：[Magic(4)][Version(1)][Length(4)]
	// 完整的帧头需要9字节：Magic(4) + Version(1) + Length(4)
	minHeaderLength := 9

	// 检查最小长度
	if len(data) < 4 {
		return nil, minHeaderLength, fmt.Errorf("invalid packet: too short for magic, need at least 4 bytes")
	}

	// 检查Magic
	magic := data[0:4]
	if string(magic) != "NNET" {
		return nil, minHeaderLength, fmt.Errorf("invalid magic: %s", string(magic))
	}

	// 如果数据不足9字节，返回需要的字节数
	if len(data) < minHeaderLength {
		return nil, minHeaderLength, nil
	}

	// 创建帧头
	header := internalprotocol.NewFrameHeader()
	header.Set("magic", string(magic))

	// 读取版本
	version := data[4]
	header.Set("version", version)
	// 注意：这里不检查版本值，因为版本识别由版本识别器或服务器逻辑处理
	// 这样可以支持多版本协议

	// 读取长度字段
	dataLength := binary.BigEndian.Uint32(data[5:9])
	header.Set("length", dataLength)

	// 计算完整消息需要的总字节数
	// 总长度 = 9（帧头） + dataLength（数据） + 2（Checksum）
	totalLength := minHeaderLength + int(dataLength) + 2

	// 返回解析的帧头和完整消息需要的总字节数
	return header, totalLength, nil
}

// DecodeBody 解码消息体（假设帧头已经解析）
// 实现IncrementalDecoder接口，支持重用已解析的帧头
// 优化：如果header不为nil，可以跳过帧头解析，直接解析数据体和校验和，避免重复解析帧头
func (p *NNetProtocol) DecodeBody(data []byte, header protocolpkg.FrameHeader) ([]byte, error) {
	// 如果header为nil，需要从data中解析帧头（回退到标准Decode方法）
	if header == nil {
		_, body, err := p.Decode(data)
		return body, err
	}

	// 优化：从header中获取长度（避免重复读取长度字段）
	lengthVal := header.Get("length")
	if lengthVal == nil {
		return nil, fmt.Errorf("header missing length field")
	}
	dataLength, ok := lengthVal.(uint32)
	if !ok {
		return nil, fmt.Errorf("invalid length field type in header")
	}

	// 计算预期的总长度：Magic(4) + Version(1) + Length(4) + Data(dataLength) + Checksum(2)
	expectedTotalLength := 9 + int(dataLength) + 2
	
	// 验证数据长度（数据应该来自unpacker，已经完整）
	if len(data) != expectedTotalLength {
		if len(data) < expectedTotalLength {
			return nil, fmt.Errorf("invalid data length: expected %d, got %d", expectedTotalLength, len(data))
		}
		// 如果数据长度大于预期，可能是多个包，但我们只处理第一个包
		// 这种情况应该由unpacker处理，不应该到达这里
	}

	// 读取数据部分（偏移9到9+dataLength）
	// 优化：直接使用header中的长度信息，避免重复读取长度字段
	messageDataStart := 9
	messageDataEnd := 9 + int(dataLength)
	messageData := data[messageDataStart:messageDataEnd]

	// 读取校验和（偏移9+dataLength到11+dataLength）
	checksumStart := messageDataEnd
	checksumEnd := checksumStart + 2
	checksum := binary.BigEndian.Uint16(data[checksumStart:checksumEnd])

	// 将校验和设置到header中（保持与Decode方法的一致性）
	header.Set("checksum", checksum)

	// 验证校验和
	calculatedChecksum := uint16(0)
	for _, b := range messageData {
		calculatedChecksum += uint16(b)
	}
	if checksum != calculatedChecksum {
		return nil, fmt.Errorf("checksum mismatch: expected %d, got %d", calculatedChecksum, checksum)
	}

	return messageData, nil
}