package server

import (
	"context"
	"fmt"
	"net"
	"sync"
	"time"

	"github.com/noahlann/nnet/internal/connection"
	"github.com/noahlann/nnet/internal/logger"
	codecpkg "github.com/noahlann/nnet/pkg/codec"
	"github.com/noahlann/nnet/pkg/lifecycle"
	protocolpkg "github.com/noahlann/nnet/pkg/protocol"
	routerpkg "github.com/noahlann/nnet/pkg/router"
	unpackerpkg "github.com/noahlann/nnet/pkg/unpacker"
	"github.com/panjf2000/gnet/v2"
)

// unifiedEventHandler 统一的事件处理器（支持TCP和UDP）
type unifiedEventHandler struct {
	connManager          connection.ManagerInterface
	router               routerpkg.Router
	logger               logger.Logger
	codecRegistry        codecpkg.Registry
	codecResolverChain   *codecpkg.ResolverChain
	defaultCodec         string
	protocolManager      protocolpkg.Manager
	protocolName         string
	enableProtocolEncode bool
	cloneHeader          bool
	handlerTimeout       time.Duration
	protocol             TransportProtocol
	unpackerManager      *unpackerManager
	connLifecycleHooks   []lifecycle.ConnectionLifecycleHook
	engine               gnet.Engine
	engineMu             sync.RWMutex
	engineSet            bool
	bootCh               chan error
	bootOnce             *sync.Once
	msgHandler           *messageHandler
}

// newUnifiedEventHandler 创建统一的事件处理器
func newUnifiedEventHandler(connManager connection.ManagerInterface, r routerpkg.Router, logger logger.Logger, codecRegistry codecpkg.Registry, codecResolverChain *codecpkg.ResolverChain, defaultCodec string, protocolManager protocolpkg.Manager, protocolName string, enableProtocolEncode bool, cloneHeader bool, handlerTimeout time.Duration, protocol TransportProtocol, bootCh chan error, bootOnce *sync.Once) *unifiedEventHandler {
	return &unifiedEventHandler{
		connManager:          connManager,
		router:               r,
		logger:               logger,
		codecRegistry:        codecRegistry,
		codecResolverChain:   codecResolverChain,
		defaultCodec:         defaultCodec,
		protocolManager:      protocolManager,
		protocolName:         protocolName,
		enableProtocolEncode: enableProtocolEncode,
		cloneHeader:          cloneHeader,
		handlerTimeout:       handlerTimeout,
		protocol:             protocol,
		unpackerManager:      newUnpackerManager(),
		connLifecycleHooks:   make([]lifecycle.ConnectionLifecycleHook, 0),
		bootCh:               bootCh,
		bootOnce:             bootOnce,
		msgHandler:           newMessageHandler(logger, codecRegistry, codecResolverChain, defaultCodec, r, cloneHeader),
	}
}

// OnBoot 服务器启动时调用
func (h *unifiedEventHandler) OnBoot(eng gnet.Engine) (action gnet.Action) {
	h.engineMu.Lock()
	h.engine = eng
	h.engineSet = true
	h.engineMu.Unlock()
	if h.bootCh != nil && h.bootOnce != nil {
		h.bootOnce.Do(func() {
			select {
			case h.bootCh <- nil:
			default:
			}
		})
	}
	h.logger.Info("%s server booted", h.protocol.String())
	return gnet.None
}

// setBootSignal 设置启动信号通道
func (h *unifiedEventHandler) setBootSignal(ch chan error, once *sync.Once) {
	h.engineMu.Lock()
	h.bootCh = ch
	h.bootOnce = once
	h.engineMu.Unlock()
}

// OnShutdown 服务器关闭时调用
func (h *unifiedEventHandler) OnShutdown(eng gnet.Engine) {
	h.logger.Info("%s server shutdown", h.protocol.String())
}

// OnOpen 连接打开时调用（TCP和Unix）
func (h *unifiedEventHandler) OnOpen(c gnet.Conn) ([]byte, gnet.Action) {
	if !h.protocol.IsConnectionOriented() {
		// UDP下不会调用此方法
		return nil, gnet.None
	}

	// TCP/Unix连接处理逻辑（gnet的Unix连接和TCP连接使用相同的接口）
	remoteAddr := c.RemoteAddr().String()
	conn := connection.NewConnection("", c)
	connID := conn.ID()

	if err := h.connManager.Add(conn); err != nil {
		h.logger.Error("Failed to add connection: %v", err)
		return nil, gnet.Close
	}

	// 执行连接生命周期钩子
	for _, hook := range h.connLifecycleHooks {
		if err := hook.OnOpen(connID, remoteAddr); err != nil {
			h.logger.Error("OnOpen hook error: %v", err)
		}
	}

	var protocol protocolpkg.Protocol
	var protocolVersion string
	if h.enableProtocolEncode {
		protocol, _ = h.protocolManager.Get(h.protocolName, "")
	}

	var unpacker unpackerpkg.Unpacker
	if protocol != nil {
		unpacker = h.unpackerManager.getOrCreateUnpacker(connID, protocol)
	}

	connData := &connectionData{
		conn:            conn,
		unpacker:        unpacker,
		protocol:        protocol,
		protocolVersion: protocolVersion,
	}
	setConnectionData(c, connData)

	h.logger.Debug("Connection opened: %s from %s", connID, remoteAddr)
	return nil, gnet.None
}

// OnClose 连接关闭时调用（TCP和Unix）
func (h *unifiedEventHandler) OnClose(c gnet.Conn, err error) (action gnet.Action) {
	if !h.protocol.IsConnectionOriented() {
		// UDP下不会调用此方法
		return gnet.None
	}

	connData := getConnectionData(c)
	if connData == nil {
		return gnet.None
	}

	connID := connData.conn.ID()
	
	// 执行连接生命周期钩子
	for _, hook := range h.connLifecycleHooks {
		if hookErr := hook.OnClose(connID, err); hookErr != nil {
			h.logger.Error("OnClose hook error: %v", hookErr)
		}
	}

	h.connManager.Remove(connID)
	h.unpackerManager.removeUnpacker(connID)

	h.logger.Debug("Connection closed: %s", connID)
	return gnet.None
}

// OnTraffic 数据到达时调用（TCP和Unix）
func (h *unifiedEventHandler) OnTraffic(c gnet.Conn) (action gnet.Action) {
	if !h.protocol.IsConnectionOriented() {
		// UDP下不会调用此方法，使用React代替
		return gnet.None
	}

	return h.handleTraffic(c, nil)
}

// React UDP数据到达时调用（仅UDP）
func (h *unifiedEventHandler) React(packet []byte, c gnet.Conn) (out []byte, action gnet.Action) {
	if !h.protocol.IsDatagram() {
		// TCP/Unix下不会调用此方法
		return nil, gnet.None
	}

	if len(packet) == 0 {
		return nil, gnet.None
	}

	// UDP处理：直接调用handleTraffic，由handleTraffic统一处理UDP连接创建
	return nil, h.handleTraffic(c, packet)
}

// handleTraffic 统一的数据处理逻辑（TCP和UDP共享）
func (h *unifiedEventHandler) handleTraffic(c gnet.Conn, udpPacket []byte) gnet.Action {
	var data []byte
	var connData *connectionData
	var connID string
	var conn connection.ConnectionInterface

	if h.protocol.IsDatagram() {
		// UDP：直接使用传入的数据包
		data = udpPacket
		if len(data) == 0 {
			return gnet.None
		}

		// 创建UDP虚拟连接
		remoteAddr := c.RemoteAddr()
		if remoteAddr == nil {
			h.logger.Debug("UDP packet with nil remote address, ignoring")
			return gnet.None
		}

		udpAddr, ok := remoteAddr.(*net.UDPAddr)
		if !ok {
			addr, err := net.ResolveUDPAddr("udp", remoteAddr.String())
			if err != nil {
				h.logger.Debug("Failed to resolve UDP address: %v", err)
				return gnet.None
			}
			udpAddr = addr
		}

		udpConn := connection.NewUDPConnection("", udpAddr, nil)
		udpConn.SetAttribute("gnet_conn", c)
		conn = udpConn
		connID = udpConn.ID()

		// UDP下创建临时连接数据
		var protocol protocolpkg.Protocol
		if h.enableProtocolEncode {
			protocol, _ = h.protocolManager.Get(h.protocolName, "")
		}
		connData = &connectionData{
			conn:            conn,
			unpacker:        nil, // UDP通常不需要unpacker
			protocol:        protocol,
			protocolVersion: "",
		}
	} else {
		// TCP：从gnet buffer读取数据
		connData = getConnectionData(c)
		if connData == nil {
			h.logger.Error("Connection data not found in context")
			return gnet.Close
		}

		connID = connData.conn.ID()
		conn = connData.conn

		inBuffer := c.InboundBuffered()
		if inBuffer == 0 {
			return gnet.None
		}

		peekData, _ := c.Peek(-1)
		if len(peekData) == 0 {
			return gnet.None
		}
		data = peekData
	}

	// 获取协议和unpacker
	protocol := connData.protocol
	unpacker := connData.unpacker

	// 版本识别（仅面向连接的协议，UDP通常不需要）
	if h.protocol.IsConnectionOriented() && h.enableProtocolEncode && connData.protocolVersion == "" {
		if identifiedVersion, err := h.identifyProtocolVersion(connData, data, c); err == nil && identifiedVersion != "" {
			newProtocol, err := h.protocolManager.Get(h.protocolName, identifiedVersion)
			if err == nil {
				connData.protocol = newProtocol
				connData.protocolVersion = identifiedVersion
				if newProtocol != nil {
					connData.unpacker = h.unpackerManager.getOrCreateUnpacker(connID, newProtocol)
				}
				protocol = newProtocol
				unpacker = connData.unpacker
			}
		}
	}

	// 处理数据：拆包（仅面向连接的协议需要，UDP数据包已经是完整的）
	var messages [][]byte
	var totalProcessed int
	if h.protocol.IsConnectionOriented() {
		// 使用统一的拆包处理函数
		var err error
		messages, totalProcessed, _, err = processDataWithUnpacker(data, unpacker)
		if err != nil {
			c.Discard(c.InboundBuffered())
			return gnet.Close
		}
		if len(messages) == 0 {
			// 没有完整消息，等待更多数据（gnet会自动保留数据在缓冲区中）
			return gnet.None
		}
	} else {
		// UDP数据包已经是完整的，不需要拆包
		messages = [][]byte{data}
			totalProcessed = len(data)
	}

	// 处理每个完整的消息
	ctxConn := toContextConnection(conn)
	for _, message := range messages {
		h.msgHandler.handleMessageWithContext(
			context.Background(),
			ctxConn,
			message,
			protocol,
			h.codecRegistry,
			h.handlerTimeout,
		)
	}

	// 丢弃已处理的数据（仅面向连接的协议）
	if h.protocol.IsConnectionOriented() && totalProcessed > 0 {
		c.Discard(totalProcessed)
	}

	return gnet.None
}

// OnTick 定时器触发时调用
func (h *unifiedEventHandler) OnTick() (delay time.Duration, action gnet.Action) {
	h.connManager.CleanupInactive(30 * time.Second)
	return 10 * time.Second, gnet.None
}

// getEngine 获取engine引用（用于优雅关闭）
func (h *unifiedEventHandler) getEngine() (gnet.Engine, bool) {
	h.engineMu.RLock()
	defer h.engineMu.RUnlock()
	return h.engine, h.engineSet
}

// identifyProtocolVersion 识别协议版本（仅TCP）
func (h *unifiedEventHandler) identifyProtocolVersion(connData *connectionData, data []byte, c gnet.Conn) (string, error) {
	protocol := connData.protocol
	if protocol == nil && h.enableProtocolEncode {
		var err error
		protocol, err = h.protocolManager.Get(h.protocolName, "")
		if err != nil {
			return "", fmt.Errorf("failed to get default protocol: %w", err)
		}
		if protocol == nil {
			return "", nil
		}
	}

	if protocol != nil {
		header, _, err := protocol.Decode(data)
		if err != nil {
			return "", nil
		}
		if header != nil {
			versionVal := header.Get("version")
			if versionVal != nil {
				var version string
				switch v := versionVal.(type) {
				case string:
					version = v
				case byte:
						version = fmt.Sprintf("%d.0", v)
				default:
					version = fmt.Sprintf("%v", v)
				}
				if version != "" {
					_, err := h.protocolManager.Get(h.protocolName, version)
					if err == nil {
						return version, nil
					}
				}
			}
		}
	}

	identifier := h.protocolManager.GetVersionIdentifier(h.protocolName)
	if identifier == nil {
		return "", nil
	}

	ctx := context.Background()
	version, err := h.protocolManager.IdentifyVersion(h.protocolName, data, ctx)
	if err != nil {
		return "", nil
	}

	return version, nil
}