mesh

type BroadcastConfig struct {
	// SeenMsgsTTL is how long to remember seen messages.
	SeenMsgsTTL time.Duration

	// DefaultTTL is the default TTL for broadcasts.
	DefaultTTL int

	// CleanupInterval is the interval for cleaning up seen messages.
	CleanupInterval time.Duration
}

type BroadcastHandler func(msg *BroadcastMessage)

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

type BroadcastMessage struct {
	// ID is a unique message identifier.
	ID string `json:"id"`

	// Type is the broadcast type.
	Type BroadcastType `json:"type"`

	// SrcPeerID is the source peer ID.
	SrcPeerID string `json:"src_peer_id"`

	// GroupID is the multicast group (for multicast/anycast).
	GroupID string `json:"group_id,omitempty"`

	// TTL is the time-to-live (hop count).
	TTL int `json:"ttl"`

	// Timestamp is when the message was created.
	Timestamp time.Time `json:"timestamp"`

	// Payload is the message data.
	Payload []byte `json:"payload"`
}

type BroadcastType int

type Config struct {
	// Enabled controls whether mesh networking is active (default: false).
	Enabled bool `yaml:"enabled" json:"enabled"`

	// NetworkID is the unique identifier for this mesh network.
	NetworkID string `yaml:"network_id" json:"network_id"`

	// NetworkCIDR is the CIDR block for virtual IP allocation (e.g., "10.100.0.0/16").
	NetworkCIDR string `yaml:"network_cidr" json:"network_cidr"`

	// PeerName is the friendly name for this peer in the network.
	PeerName string `yaml:"peer_name" json:"peer_name"`

	// Device contains network device configuration.
	Device DeviceConfig `yaml:"device" json:"device"`

	// Discovery contains peer discovery settings.
	Discovery DiscoveryConfig `yaml:"discovery" json:"discovery"`

	// STUN contains STUN server configuration for NAT traversal.
	STUN STUNConfig `yaml:"stun" json:"stun"`

	// TURN contains TURN server configuration for relay.
	TURN TURNConfig `yaml:"turn" json:"turn"`

	// Connection contains P2P connection settings.
	Connection ConnectionConfig `yaml:"connection" json:"connection"`

	// Security contains security settings.
	Security SecurityConfig `yaml:"security" json:"security"`
}

type ConnectionConfig struct {
	// DirectConnect controls whether to attempt direct P2P connections (default: true).
	DirectConnect bool `yaml:"direct_connect" json:"direct_connect"`

	// RelayEnabled controls whether to use relay when direct fails (default: true).
	RelayEnabled bool `yaml:"relay_enabled" json:"relay_enabled"`

	// RelayViaPeers controls whether to relay through other peers (default: true).
	RelayViaPeers bool `yaml:"relay_via_peers" json:"relay_via_peers"`

	// ConnectTimeout is the timeout for establishing connections (default: 30s).
	ConnectTimeout time.Duration `yaml:"connect_timeout" json:"connect_timeout"`

	// KeepAliveInterval is the interval for keep-alive packets (default: 25s).
	KeepAliveInterval time.Duration `yaml:"keep_alive_interval" json:"keep_alive_interval"`
}

type ConnectionType string

type DeviceConfig struct {
	// Type is the device type: "tun" (Layer 3) or "tap" (Layer 2).
	Type string `yaml:"type" json:"type"`

	// Name is the interface name (e.g., "mesh0").
	Name string `yaml:"name" json:"name"`

	// MTU is the Maximum Transmission Unit (default: 1400).
	MTU int `yaml:"mtu" json:"mtu"`

	// MACAddress is the MAC address for TAP devices (auto-generated if empty).
	MACAddress string `yaml:"mac_address,omitempty" json:"mac_address,omitempty"`
}

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

type DiscoveryConfig struct {
	// Server is the discovery server address (e.g., "bifrost.example.com:8080").
	Server string `yaml:"server" json:"server"`

	// HeartbeatInterval is how often to send heartbeats (default: 30s).
	HeartbeatInterval time.Duration `yaml:"heartbeat_interval" json:"heartbeat_interval"`

	// PeerTimeout is how long before a peer is considered offline (default: 90s).
	PeerTimeout time.Duration `yaml:"peer_timeout" json:"peer_timeout"`

	// Token is the authentication token for the discovery server.
	Token string `yaml:"token,omitempty" json:"token,omitempty"`
}

type Endpoint struct {
	// Address is the IP address or hostname.
	Address string `json:"address"`

	// Port is the port number.
	Port uint16 `json:"port"`

	// Type is the endpoint type: "local", "reflexive", "relay".
	Type string `json:"type"`

	// Priority is used for endpoint selection.
	Priority int `json:"priority"`
}

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

type ForwardingEntry struct {
	DestIP    netip.Prefix
	NextHopIP netip.Addr
	Interface string
	Metric    int
}

type HelloAckMessage struct {
	PeerID       string     `json:"peer_id"`
	VirtualIP    netip.Addr `json:"virtual_ip"`
	RequestTime  time.Time  `json:"request_time"`
	ResponseTime time.Time  `json:"response_time"`
}

type HelloMessage struct {
	PeerID    string     `json:"peer_id"`
	VirtualIP netip.Addr `json:"virtual_ip"`
	Timestamp time.Time  `json:"timestamp"`
	Neighbors []string   `json:"neighbors,omitempty"`
}

type IPAllocator interface {
	// Allocate allocates an IP address for a peer.
	Allocate(peerID string) (netip.Addr, error)

	// AllocateSpecific allocates a specific IP address for a peer.
	AllocateSpecific(peerID string, addr netip.Addr) error

	// Release releases an IP address allocation.
	Release(peerID string) error

	// GetIP returns the IP address for a peer.
	GetIP(peerID string) (netip.Addr, bool)

	// GetPeer returns the peer ID for an IP address.
	GetPeer(addr netip.Addr) (string, bool)

	// Available returns the number of available addresses.
	Available() int

	// Used returns the number of used addresses.
	Used() int
}

type Lease struct {
	PeerID    string     `json:"peer_id"`
	Address   netip.Addr `json:"address"`
	Allocated time.Time  `json:"allocated"`
	Expires   time.Time  `json:"expires,omitempty"`
	Static    bool       `json:"static"`
}

type LinkInfo struct {
	NeighborID string        `json:"neighbor_id"`
	Latency    time.Duration `json:"latency"`
	State      string        `json:"state"` // up, down, degraded
}

type LinkStateUpdate struct {
	PeerID    string     `json:"peer_id"`
	SeqNum    uint64     `json:"seq_num"`
	Links     []LinkInfo `json:"links"`
	Timestamp time.Time  `json:"timestamp"`
}

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

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

type MulticastGroup struct {
	// ID is the group identifier.
	ID string

	// Name is the human-readable group name.
	Name string

	// Members are the peer IDs in the group.
	Members map[string]bool

	// JoinedAt is when this peer joined the group.
	JoinedAt time.Time
}

type NodeStats struct {
	Status             NodeStatus    `json:"status"`
	PeerCount          int           `json:"peer_count"`
	ConnectedPeers     int           `json:"connected_peers"`
	DirectConnections  int           `json:"direct_connections"`
	RelayedConnections int           `json:"relayed_connections"`
	BytesSent          int64         `json:"bytes_sent"`
	BytesReceived      int64         `json:"bytes_received"`
	PacketsSent        int64         `json:"packets_sent"`
	PacketsReceived    int64         `json:"packets_received"`
	Uptime             time.Duration `json:"uptime"`
}

type NodeStatus string

type PathCostFunc func(latency time.Duration, hopCount int) int

type Peer struct {
	// ID is the unique identifier for this peer.
	ID string `json:"id"`

	// Name is the friendly name for this peer.
	Name string `json:"name"`

	// VirtualIP is the virtual IP address assigned to this peer.
	VirtualIP netip.Addr `json:"virtual_ip"`

	// VirtualMAC is the virtual MAC address for TAP mode.
	VirtualMAC net.HardwareAddr `json:"virtual_mac,omitempty"`

	// PublicKey is the peer's Ed25519 public key (base64 encoded).
	PublicKey string `json:"public_key"`

	// Endpoints is the list of known endpoints for this peer.
	Endpoints []Endpoint `json:"endpoints"`

	// Status is the current connection status.
	Status PeerStatus `json:"status"`

	// ConnectionType is how we're connected to this peer.
	ConnectionType ConnectionType `json:"connection_type,omitempty"`

	// Latency is the measured latency to this peer.
	Latency time.Duration `json:"latency,omitempty"`

	// LastSeen is when we last saw activity from this peer.
	LastSeen time.Time `json:"last_seen"`

	// JoinedAt is when this peer joined the network.
	JoinedAt time.Time `json:"joined_at"`

	// Metadata contains arbitrary peer metadata.
	Metadata map[string]string `json:"metadata,omitempty"`

	// BytesSent is the number of bytes sent to this peer.
	BytesSent int64 `json:"bytes_sent"`

	// BytesReceived is the number of bytes received from this peer.
	BytesReceived int64 `json:"bytes_received"`
	// contains filtered or unexported fields
}

type PeerEvent struct {
	Type      string    `json:"type"` // "join", "leave", "update"
	Peer      PeerInfo  `json:"peer"`
	Timestamp time.Time `json:"timestamp"`
}

type PeerInfo struct {
	ID        string            `json:"id"`
	Name      string            `json:"name"`
	PublicKey string            `json:"public_key"`
	VirtualIP string            `json:"virtual_ip,omitempty"`
	Endpoints []Endpoint        `json:"endpoints,omitempty"`
	Metadata  map[string]string `json:"metadata,omitempty"`
}

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

type PeerStatus string

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

type PoolConfig struct {
	// NetworkCIDR is the network CIDR (e.g., "10.100.0.0/16").
	NetworkCIDR string

	// GatewayAddress is the gateway IP (usually first usable address).
	// If empty, it won't be reserved.
	GatewayAddress string

	// LeaseTTL is the lease duration (0 = no expiry).
	LeaseTTL time.Duration

	// ReservedAddresses is a list of additional addresses to reserve.
	ReservedAddresses []string
}

type ProtocolConfig struct {
	// HelloInterval is the interval between hello messages.
	HelloInterval time.Duration

	// RouteAnnounceInterval is the interval between route announcements.
	RouteAnnounceInterval time.Duration

	// RouteExpiryInterval is the route expiry check interval.
	RouteExpiryInterval time.Duration

	// DefaultTTL is the default TTL for messages.
	DefaultTTL int

	// MaxRouteAge is the maximum age of a route before expiry.
	MaxRouteAge time.Duration

	// SplitHorizon enables split horizon (don't announce routes back to source).
	SplitHorizon bool

	// PoisonReverse enables poison reverse (announce withdrawn routes with infinite metric).
	PoisonReverse bool
}

type ProtocolMessage struct {
	Type      ProtocolMessageType `json:"type"`
	SrcPeerID string              `json:"src_peer_id"`
	SeqNum    uint64              `json:"seq_num"`
	TTL       int                 `json:"ttl"`
	Timestamp time.Time           `json:"timestamp"`
	Payload   json.RawMessage     `json:"payload,omitempty"`
}

type ProtocolMessageType byte

type RegistrationRequest struct {
	NetworkID string   `json:"network_id"`
	Peer      PeerInfo `json:"peer"`
}

type RegistrationResponse struct {
	Success   bool       `json:"success"`
	VirtualIP string     `json:"virtual_ip"`
	Message   string     `json:"message,omitempty"`
	Peers     []PeerInfo `json:"peers,omitempty"`
}

type Route struct {
	// DestPeerID is the destination peer ID.
	DestPeerID string

	// DestIP is the destination virtual IP.
	DestIP netip.Addr

	// NextHop is the next hop peer ID (empty for direct routes).
	NextHop string

	// Type is the route type.
	Type RouteType

	// Metric is the route cost (lower is better).
	Metric int

	// Latency is the measured latency.
	Latency time.Duration

	// HopCount is the number of hops.
	HopCount int

	// LastUpdated is when the route was last updated.
	LastUpdated time.Time

	// Active indicates if the route is currently active.
	Active bool
}

type RouteAnnouncement struct {
	DestPeerID string     `json:"dest_peer_id"`
	DestIP     netip.Addr `json:"dest_ip"`
	Metric     int        `json:"metric"`
	HopCount   int        `json:"hop_count"`
	Path       []string   `json:"path,omitempty"` // For loop prevention
}

type RouteTableStats struct {
	TotalRoutes   int
	DirectRoutes  int
	NextHopRoutes int
	RelayRoutes   int
	Destinations  int
}

type RouteType int

type RouteWithdrawal struct {
	DestPeerID string `json:"dest_peer_id"`
}

type RouterConfig struct {
	// LocalPeerID is the local peer ID.
	LocalPeerID string

	// LocalIP is the local virtual IP.
	LocalIP netip.Addr

	// MaxHops is the maximum number of hops.
	MaxHops int

	// RouteTimeout is the route expiry timeout.
	RouteTimeout time.Duration

	// PathCostFunc calculates path costs.
	PathCostFunc PathCostFunc
}

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

type STUNConfig struct {
	// Servers is a list of STUN server addresses.
	Servers []string `yaml:"servers" json:"servers"`

	// Timeout is the timeout for STUN requests (default: 5s).
	Timeout time.Duration `yaml:"timeout" json:"timeout"`
}

type SecurityConfig struct {
	// PrivateKey is the Ed25519 private key for this peer (base64 encoded).
	// If empty, a new key pair will be generated.
	PrivateKey string `yaml:"private_key,omitempty" json:"private_key,omitempty"`

	// AllowedPeers is a list of allowed peer public keys (empty = allow all).
	AllowedPeers []string `yaml:"allowed_peers,omitempty" json:"allowed_peers,omitempty"`

	// RequireEncryption controls whether all connections must be encrypted (default: true).
	RequireEncryption bool `yaml:"require_encryption" json:"require_encryption"`
}

type TURNConfig struct {
	// Servers is a list of TURN server configurations.
	Servers []TURNServer `yaml:"servers" json:"servers"`

	// Enabled controls whether TURN relay is enabled (default: true).
	Enabled bool `yaml:"enabled" json:"enabled"`
}

type TURNServer struct {
	// URL is the TURN server URL (e.g., "turn:turn.example.com:3478").
	URL string `yaml:"url" json:"url"`

	// Username for TURN authentication.
	Username string `yaml:"username" json:"username"`

	// Password for TURN authentication.
	Password string `yaml:"password" json:"password"`
}