config

type Client struct {
	ClientID          string        `yaml:"client_id"`
	Server            ClientServer  `yaml:"server"`
	Local             LocalService  `yaml:"local"`
	Quic              Quic          `yaml:"quic"`
	TLS               ClientTLS     `yaml:"tls"`
	UDP               UDPConfig     `yaml:"udp"`
	HeartbeatInterval time.Duration `yaml:"heartbeat_interval"` // Heartbeat interval, default 30s
	HealthTimeout     time.Duration `yaml:"health_timeout"`     // Health timeout for received heartbeats, default 90s
}

type ClientServer struct {
	Servers []ServerEndpoint `yaml:"servers"`
}

type ClientTLS struct {
	CACertFile     string `yaml:"ca_cert_file"`
	ClientCertFile string `yaml:"client_cert_file"`
	ClientKeyFile  string `yaml:"client_key_file"`

	// Loaded certificates (not from YAML)
	CACertPool *x509.CertPool  `yaml:"-"`
	ClientCert tls.Certificate `yaml:"-"`
}

type Listen struct {
	IP   string `mapstructure:"ip"`
	Port int    `mapstructure:"port"`
}

type LocalService struct {
	Host string `yaml:"host"` // localhost or 127.0.0.1
	Port int    `yaml:"port"` // local service port
}

type Quic struct {
	InitialStreamReceiveWindow     uint64
	MaxStreamReceiveWindow         uint64
	InitialConnectionReceiveWindow uint64
	MaxConnectionReceiveWindow     uint64
	MaxIncomingStreams             int64
	KeepAlivePeriod                time.Duration
	HandshakeIdleTimeout           time.Duration
	MaxIdleTimeout                 time.Duration
	Allow0RTT                      bool
}

type QuicListener struct {
	QuicAddr    string `yaml:"quic_addr"`    // Address for QUIC control connections (e.g., "0.0.0.0:8443")
	TrafficAddr string `yaml:"traffic_addr"` // Address for forwarded traffic (e.g., "0.0.0.0:8080")
	Protocol    string `yaml:"protocol"`     // "tcp", "udp", or "both"
	Quic        `yaml:",inline"`
	UDP         UDPConfig `yaml:"udp"` // UDP-specific configuration
}

type Server struct {
	Listeners []QuicListener `yaml:"listeners"`
	Auth      ServerAuth     `yaml:"auth"`
	TLS       ServerTLS      `yaml:"tls"`

	// Load balancer algorithm: "least-connections" (default) or "round-robin"
	LoadBalancer string `yaml:"load_balancer"`

	// Heartbeat configuration
	HeartbeatInterval time.Duration `yaml:"heartbeat_interval"` // Interval between server heartbeats to clients, default 10s
	HealthTimeout     time.Duration `yaml:"health_timeout"`     // Time without heartbeat before marking unhealthy, default 30s
}

type ServerAuth struct {
	Method     string `yaml:"method"`       // "mtls", "token", etc.
	CACertFile string `yaml:"ca_cert_file"` // Path to CA certificate file (for mTLS)
	Token      string `yaml:"token"`        // Token for challenge-response auth

	// Loaded certificate (not from YAML)
	CACertPool *x509.CertPool `yaml:"-"`
}

type ServerEndpoint struct {
	Address    string `yaml:"address"`     // host:port
	ServerName string `yaml:"server_name"` // TLS server name for verification
}

type ServerTLS struct {
	ServerCertFile string `yaml:"server_cert_file"`
	ServerKeyFile  string `yaml:"server_key_file"`

	// Rotation interval for session ticket encryption keys.
	// Recommended: 24h for production, 0 to disable rotation.
	// Keys are rotated periodically to limit the exposure window if compromised.
	SessionTicketEncryptionKeyRotationInterval time.Duration `yaml:"session_ticket_encryption_key_rotation_interval"`

	// Number of keys to maintain during rotation (current + old keys).
	// Recommended: 2-3 for smooth rotation, default: 2 if not specified.
	// Higher values allow clients with older tickets to still resume sessions.
	SessionTicketEncryptionKeyRotationOverlap uint8 `yaml:"session_ticket_encryption_key_rotation_overlap"`

	// Loaded certificate (not from YAML)
	ServerCert tls.Certificate `yaml:"-"`
}

type UDPConfig struct {
	// EnableFragmentation enables automatic fragmentation of large UDP packets.
	// When enabled, packets larger than ~1196 bytes will be split into multiple
	// QUIC datagrams and reassembled on the other side.
	// Default: true
	EnableFragmentation *bool `yaml:"enable_fragmentation"`

	// FragmentAssemblerShards is the number of shards for the fragment assembler.
	// Higher values reduce lock contention but use more memory.
	// Default: 16
	FragmentAssemblerShards int `yaml:"fragment_assembler_shards"`

	// EnableBufferPooling enables buffer pooling for UDP operations.
	// Default: true
	EnableBufferPooling *bool `yaml:"enable_buffer_pooling"`

	// ReadBufferSize is the size of the UDP read buffer in bytes.
	// This should be large enough to receive any UDP packet.
	// Default: 65535 (maximum UDP packet size)
	ReadBufferSize int `yaml:"read_buffer_size"`

	// DatagramBufferSize is the size of QUIC datagram buffers in bytes.
	// This is typically set to the QUIC max datagram size.
	// Default: 1200
	DatagramBufferSize int `yaml:"datagram_buffer_size"`
}