infra

type BindConfig struct {
	Logger       *log.Logger
	V4Conn       *net.UDPConn
	V6Conn       *net.UDPConn
	PassThrough  <-chan PassThroughPacket // non-STUN v4 packets from FilteringUDPMux
	PassThrough6 <-chan PassThroughPacket // non-STUN v6 packets from FilteringUDPMux (v6)
	RelayClient  RelayChannel
	KeyManager   KeyManager
}

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

type Config struct {
	DrpHttpListen string `json:"drp_http_listen"`
}

type ConnectionState int

type ContextKey int

type DefaultBind struct {
	PublicKey wgtypes.Key
	// contains filtered or unexported fields
}

type DetailsInfo struct {
	// Node info changes
	AddressChanged  bool `json:"addressChanged,omitempty"`  // IP address change
	KeyChanged      bool `json:"keyChanged,omitempty"`      // key change
	EndpointChanged bool `json:"endpointChanged,omitempty"` // remote endpoint change

	// Network topology changes
	PeersAdded   []*Peer  `json:"peersAdded,omitempty"`   // list of added peers
	PeersRemoved []*Peer  `json:"peersRemoved,omitempty"` // list of removed peers
	PeersUpdated []string `json:"peersUpdated,omitempty"` // list of updated peers

	// Policy changes
	PoliciesAdded   []*Policy `json:"policiesAdded,omitempty"`
	PoliciesRemoved []*Policy `json:"policiesRemoved,omitempty"`
	PoliciesUpdated []*Policy `json:"policiesUpdated,omitempty"`

	// Network config changes
	NetworkJoined        []string `json:"networkJoined,omitempty"`
	NetworkLeft          []string `json:"networkLeft,omitempty"`
	NetworkConfigChanged bool     `json:"networkConfigChanged,omitempty"`

	Reason       []*Entry `json:"reason,omitempty"`       // change reason description
	TotalChanges int      `json:"totalChanges,omitempty"` // total change count
}

type DeviceConf struct {
	DrpUrl string        `json:"drpUrl,omitempty"` // a drp server user created.
	Device *DeviceConfig `json:"device,omitempty"`
	Nodes  []*Peer       `json:"list,omitempty"`
}

type DeviceConfig struct {
	PrivateKey   string `json:"privateKey,omitempty"`
	Address      string `json:"address,omitempty"`
	Fwmark       int    `json:"fwmark,omitempty"`
	ListenPort   int    `json:"listenPort,omitempty"`
	ReplacePeers bool   `json:"replacePeers,omitempty"`
}

type Dialer interface {
	// Prepare prepares to send offer to remoteId.
	Prepare(ctx context.Context, remoteId PeerIdentity) error

	// Handle handles incoming signal packets from remoteId.
	Handle(ctx context.Context, remoteId PeerIdentity, packet *signal.SignalPacket) error

	// Dial dials remoteId when offer is received.
	Dial(ctx context.Context) (Transport, error)

	// Close tears down the dialer and releases all resources.
	Close() error

	// Type returns the dialer type.
	Type() DialerType
}

type DialerType string

type Entry struct {
	Type    string `json:"type"`
	Action  string `json:"action"`
	Message string `json:"message"`
}

type EventType int

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

type FirewallRule struct {
	Platform   string        `json:"platform"`
	PolicyName string        `json:"policyName"`
	Ingress    []TrafficRule `json:"ingress,omitempty"`
	Egress     []TrafficRule `json:"egress,omitempty"`
}

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

type KeyManager interface {
	// UpdateKey updates the private key used for encryption.
	UpdateKey(privateKey wgtypes.Key)
	// GetKey retrieves the current private key.
	GetKey() wgtypes.Key
	// GetPublicKey retrieves the public key derived from the current private key.
	GetPublicKey() wgtypes.Key
}

type ManagementClient interface {
	GetNetMap(token string) (*Message, error)
	Register(ctx context.Context, token, interfaceName, publicKey string) (*Peer, error)
	AddPeer(p *Peer) error
}

type Message struct {
	EventType     EventType         `json:"eventType"`               // main event type
	ConfigVersion string            `json:"configVersion"`           // version number
	Timestamp     int64             `json:"timestamp"`               // timestamp
	Changes       *DetailsInfo      `json:"changes"`                 // config change details
	Current       *Peer             `json:"peer"`                    // current node info
	Network       *Network          `json:"network"`                 // current node network info
	Policies      []*Policy         `json:"policies,omitempty"`      // current node's policies
	ComputedPeers []*Peer           `json:"computedpeers,omitempty"` // peers to connect to, computed by controller and returned to lattice
	ComputedRules *FirewallRule     `json:"computedrules,omitempty"`
	Labels        map[string]string `json:"labels,omitempty"`
}

type Network struct {
	Address     string   `json:"address"`
	AllowedIps  []string `json:"allowedIps"`
	Port        int      `json:"port"`
	NetworkId   string   `json:"NetworkId"`
	NetworkName string   `json:"networkName"`
	Peers       []*Peer  `json:"peers"`
}

type NodeInterface interface {
	// Start the engine
	Start(ctx context.Context) error

	GetDeviceName() string

	// Stop the engine
	Stop() error

	// AddPeer adds a peer to the WireGuard device, add peer from contrl client, then will start connect to peer
	AddPeer(peer *Peer) error

	// RemovePeer removes a peer from the WireGuard device
	RemovePeer(peer *Peer) error

	RemoveAllPeers()

	// PrunePeersExcept removes every known peer whose AppID is not in keep
	// (peers that dropped out of the current netmap must not linger in the
	// manager/wg — stale entries kept probing and polluting peer states).
	PrunePeersExcept(keep map[string]struct{})
}

type PassThroughPacket struct {
	Data []byte
	Addr *net.UDPAddr
}

type Peer struct {
	Name                string            `json:"name,omitempty"`
	InterfaceName       string            `json:"interfaceName,omitempty"`
	Platform            string            `json:"platform,omitempty"`
	Description         string            `json:"description,omitempty"`
	NetworkId           string            `json:"NetworkId,omitempty"` // belong to which group
	CreatedBy           string            `json:"createdBy,omitempty"` // ownerID
	UserId              uint64            `json:"userId,omitempty"`
	Hostname            string            `json:"hostname,omitempty"`
	AppID               string            `json:"appId,omitempty"`
	Address             *string           `json:"address,omitempty"`
	Endpoint            string            `json:"endpoint,omitempty"`
	Remove              bool              `json:"remove,omitempty"` // whether to remove node
	PresharedKey        string            `json:"presharedKey,omitempty"`
	PersistentKeepalive int               `json:"persistentKeepalive,omitempty"`
	PrivateKey          string            `json:"privateKey,omitempty"`
	PublicKey           string            `json:"publicKey,omitempty"`
	PeerID              uint64            `json:"peerId,omitempty"`
	AllowedIPs          string            `json:"allowedIps,omitempty"`
	ReplacePeers        bool              `json:"replacePeers,omitempty"` // whether to replace all peers when updating this node
	Port                int               `json:"port"`
	GroupName           string            `json:"groupName"`
	Version             uint64            `json:"version"`
	LastUpdatedAt       string            `json:"lastUpdatedAt"`
	Token               string            `json:"token,omitempty"`
	RelayURL            string            `json:"lrpUrl,omitempty"`         // wire name kept as lrpUrl for old-server compatibility
	EnforcerMode        string            `json:"enforcerMode,omitempty"`   // user personal setting from registration
	Tier                string            `json:"tier,omitempty"`           // account tier from registration: community or pro
	ApprovalStatus      string            `json:"approvalStatus,omitempty"` // pending / approved / revoked (ADR-0003)
	Labels              map[string]string `json:"labels,omitempty"`
	// AdvertisedRoutes is this peer's own route advertisement (exit-node /
	// subnet-gateway role). The server fills it on every netmap entry so the
	// owning agent can install the corresponding forwarding rules.
	AdvertisedRoutes []string `json:"advertisedRoutes,omitempty"`
}

type PeerID [8]byte

type PeerIdentity struct {
	AppID     string
	PublicKey wgtypes.Key
}

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

type Policy struct {
	PolicyName string  `json:"policyName"`
	Action     string  `json:"action,omitempty"` // "ALLOW" or "DENY"
	Ingress    []*Rule `json:"ingress"`
	Egress     []*Rule `json:"egress"`
}

type Probe interface {
	Start(ctx context.Context, remoteId PeerIdentity) error

	Handle(ctx context.Context, remoteId PeerIdentity, packet *signal.SignalPacket) error

	// 2. Health check: periodically send probe packets after the connection is established
	Ping(ctx context.Context) error
}

type RelayChannel interface {
	ReceiveFunc() conn.ReceiveFunc
	Send(ctx context.Context, remoteId uint64, relayType uint8, data []byte) error
	Connect() error
	// Connected reports whether a relay session is currently up, so callers can
	// decide whether relaying a signaling packet is worth trying.
	Connected() bool
	RemoteAddr() net.Addr
	Close() error
}

type RelayEndpoint struct {
	// Physical layer info (for standard UDP/ICE)
	Addr netip.AddrPort

	// Protocol layer info (for Relay)
	RemoteId uint64

	// Flag: which path to use currently
	TransportType TransportType
}

type Rule struct {
	PeerNames    []string `json:"peerNames"`
	CIDRs        []string `json:"cidrs,omitempty"`        // from IPBlock
	IdentityRefs []string `json:"identityRefs,omitempty"` // from PeerIdentity
	Protocol     string   `json:"protocol"`
	Port         int      `json:"port"`
	Action       string   `json:"action,omitempty"` // "ALLOW" or "DENY"
}

type SignalService interface {
	// Send routes a packet to the peer identified by PeerID (NATS subject level).
	// PeerID is sufficient here — full PeerIdentity is not needed for routing.
	Send(ctx context.Context, peerId PeerID, data []byte) error

	// Publish sends a raw payload to an arbitrary subject, for control-plane-
	// initiated notifications that don't fit the peer-to-peer Send() pattern
	// (e.g. "your netmap changed, refresh now").
	Publish(ctx context.Context, subject string, data []byte) error

	//req/resp
	Request(ctx context.Context, subject, method string, data []byte) ([]byte, error)

	// server service
	Service(subject, queue string, service func(data []byte) ([]byte, error))

	Flush() error

	// Close drains in-flight messages and closes the underlying connection.
	Close() error
}

type Status string

type TrafficRule struct {
	ChainName string   `json:"chainName"`
	Peers     []string `json:"peers,omitempty"` // ip list
	Protocol  string   `json:"protocol,omitempty"`
	Port      int      `json:"port,omitempty"`
	Action    string   `json:"action,omitempty"` // Accept or drop
}

type Transport interface {
	Write(data []byte) error
	Read(buff []byte) (int, error)
	RemoteAddr() string
	Type() TransportType
	Close() error
	Priority() uint8
}

type TransportType int