protocol

type FindNode struct {
	// RequestID is a unique identifier for matching request/response pairs
	RequestID []byte

	// Distances is a list of Kademlia distances to query
	// Each distance is a bucket index (0-256)
	// Special case: [256] means return all known nodes
	Distances []uint
}

type Handler struct {
	// contains filtered or unexported fields
}

type HandlerConfig struct {
	// LocalNode is our node information
	LocalNode *node.Node

	// Sessions is the session cache
	Sessions *session.Cache

	// PrivateKey is the node's private key (for handshake signatures)
	PrivateKey *ecdsa.PrivateKey

	// Callbacks (all optional, can be nil)
	OnHandshakeComplete OnHandshakeCompleteCallback
	OnNodeUpdate        OnNodeUpdateCallback
	OnNodeSeen          OnNodeSeenCallback
	OnFindNode          OnFindNodeCallback
	OnTalkReq           OnTalkReqCallback
	OnPongReceived      OnPongReceivedCallback

	// RequestTimeout is the timeout for requests
	RequestTimeout time.Duration

	// MaxPendingHandshakes is the maximum number of pending outgoing handshakes (0 = 2000)
	MaxPendingHandshakes int

	// MaxPendingChallenges is the maximum number of pending incoming challenges (0 = 500)
	MaxPendingChallenges int

	// MaxPendingPerIP is the maximum number of pending entries per IP address (0 = 10)
	MaxPendingPerIP int

	// Logger for debug messages
	Logger logrus.FieldLogger
}

type HandlerStats struct {
	PacketsReceived    int
	PacketsSent        int
	InvalidPackets     int
	FilteredResponses  int
	FindNodeReceived   int
	PendingHandshakes  int
	PendingChallenges  int
	RejectedHandshakes int
	RejectedChallenges int
	EvictedHandshakes  int
	EvictedChallenges  int
	PendingPerIPCount  int
	RequestStats       RequestStats
}

type HandshakeData struct {
	// SourceNodeID is the sender's node ID (32 bytes)
	SourceNodeID []byte

	// Signature proves ownership of the node ID
	Signature []byte

	// EphemeralPubKey is the ephemeral public key for session establishment
	EphemeralPubKey []byte

	// ENR is the sender's ENR record (optional, only if seq changed)
	ENR []byte
}

type Message interface {
	// Type returns the message type byte
	Type() byte

	// Encode returns the RLP encoding of the message
	Encode() ([]byte, error)
}

type Nodes struct {
	// RequestID matches the request ID from the FINDNODE
	RequestID []byte

	// Total is the total number of NODES messages for this response
	Total uint

	// Records contains the ENR records in this message
	Records []*enr.Record
}

type OnFindNodeCallback func(msg *FindNode, sourceNode *node.Node, requester *net.UDPAddr) []*node.Node

type OnHandshakeCompleteCallback func(n *node.Node, incoming bool)

type OnNodeSeenCallback func(n *node.Node, timestamp time.Time)

type OnNodeUpdateCallback func(n *node.Node)

type OnPongReceivedCallback func(remoteNodeID node.ID, sourceIP net.IP, reportedIP net.IP, reportedPort uint16)

type OnTalkReqCallback func(msg *TalkReq) []byte

type Packet struct {
	// PacketType is the type of packet (Ordinary, WHOAREYOU, or Handshake)
	PacketType byte

	// Header contains packet metadata (nonce, auth data, etc.)
	Header *PacketHeader

	// HeaderData is the raw packet data from start to end of authdata (IV + masked header + masked authdata)
	// This is used as additional data (AD) for AES-GCM encryption/decryption
	HeaderData []byte

	// SrcID is the source node ID (extracted from authdata for ordinary/random packets)
	SrcID []byte

	// Message is the encrypted message payload (for Ordinary packets)
	Message []byte

	// Challenge is the challenge data (for WHOAREYOU packets)
	Challenge *WHOAREYOUChallenge

	// Handshake is the handshake data (for Handshake packets)
	Handshake *HandshakeData
}

type PacketHeader struct {
	// ProtocolID should always be "discv5"
	ProtocolID []byte

	// Version is the protocol version (currently 0x0001)
	Version uint16

	// Flag indicates the packet type
	Flag byte

	// Nonce is used for encryption (12 bytes)
	Nonce []byte

	// AuthDataSize is the size of the authentication data in bytes
	AuthDataSize uint16
}

type PendingChallenge struct {
	ToAddr        *net.UDPAddr
	ToNodeID      node.ID
	ChallengeData []byte
	PacketBytes   []byte // Raw WHOAREYOU packet bytes for resending
	CreatedAt     time.Time
}

type PendingHandshake struct {
	Message    Message
	ToNode     *node.Node
	ToAddr     *net.UDPAddr
	ToNodeID   node.ID
	CreatedAt  time.Time
	LastRetry  time.Time // When we last sent a retry
	RetryCount int       // Number of retries attempted
	MaxRetries int       // Maximum number of retries (default 3)
}

type PendingRequest struct {
	// RequestID is the unique ID for this request
	RequestID []byte

	// NodeID is the target node
	NodeID node.ID

	// Node is the target node reference (for handshakes after session becomes stale)
	Node *node.Node

	// Message is the original message that was sent (for replay after re-handshake)
	Message Message

	// Timeout is when the request expires
	Timeout time.Time

	// ResponseChan receives the response or error
	ResponseChan chan *Response

	// Retries is the number of retry attempts
	Retries int

	// For multi-packet NODES responses
	ExpectedTotal    uint   // Total number of NODES packets expected
	ReceivedCount    uint   // Number of NODES packets received so far
	AccumulatedNodes *Nodes // Accumulated NODES message
}

type Ping struct {
	// RequestID is a unique identifier for matching request/response pairs
	RequestID []byte

	// ENRSeq is the sender's current ENR sequence number
	ENRSeq uint64
}

type Pong struct {
	// RequestID matches the request ID from the PING
	RequestID []byte

	// ENRSeq is the responder's current ENR sequence number
	ENRSeq uint64

	// IP is the responder's IP address as seen by the recipient
	IP []byte

	// Port is the responder's UDP port
	Port uint16
}

type ProtocolError struct {
	Code    string
	Message string
}

type RegConfirmation struct {
	RequestID []byte
	Topic     []byte
}

type RegTopic struct {
	RequestID []byte
	Topic     []byte
	ENR       *enr.Record
	Ticket    []byte
}

type RequestStats struct {
	PendingRequests    int
	TotalRequests      int
	TimedOutRequests   int
	SuccessfulRequests int
	SuccessRate        float64
}

type RequestTracker struct {
	// contains filtered or unexported fields
}

type Response struct {
	// Message is the decoded response message
	Message Message

	// NodeID is the responding node
	NodeID node.ID

	// Error is set if the request failed
	Error error
}

type TalkReq struct {
	// RequestID is a unique identifier for matching request/response pairs
	RequestID []byte

	// Protocol identifies the application protocol (e.g., "eth2")
	Protocol []byte

	// Request is the application-specific request data
	Request []byte
}

type TalkResp struct {
	// RequestID matches the request ID from the TALKREQ
	RequestID []byte

	// Response is the application-specific response data
	Response []byte
}

type Ticket struct {
	RequestID []byte
	Ticket    []byte
	WaitTime  uint64
}

type TopicQuery struct {
	RequestID []byte
	Topic     []byte
}

type Transport interface {
	SendTo(data []byte, to *net.UDPAddr) error
	Send(data []byte, to *net.UDPAddr, from *net.UDPAddr) error
}

type WHOAREYOUChallenge struct {
	// IDNonce is a random challenge value (16 bytes)
	IDNonce []byte

	// ENRSeq is the highest ENR sequence number we have
	// The peer should send their ENR if their sequence is higher
	ENRSeq uint64
}