config.go

package pgpool

import (
	"fmt"
	"time"
)

// Config represents the complete plugin configuration structure
type Config struct {
	// Enabled determines if the plugin is active
	Enabled bool `mapstructure:"enabled"`

	// Proxy configuration for PostgreSQL wire protocol server
	Proxy ProxyConfig `mapstructure:"proxy"`

	// Backends defines database connections
	Backends BackendsConfig `mapstructure:"backends"`

	// Routing configuration for read/write splitting
	Routing RoutingConfig `mapstructure:"routing"`

	// Monitoring and metrics configuration
	Monitoring MonitoringConfig `mapstructure:"monitoring"`

	// Logging configuration
	Logging LoggingConfig `mapstructure:"logging"`

	// Advanced features configuration
	Features FeaturesConfig `mapstructure:"features"`

	// Additional database configurations
	Databases map[string]DatabaseConfig `mapstructure:"databases"`
}

// ProxyConfig defines the local proxy server settings
type ProxyConfig struct {
	// Address where the proxy listens (e.g., "tcp://127.0.0.1:5433")
	Address string `mapstructure:"address"`

	// MaxClients limits concurrent client connections
	MaxClients int `mapstructure:"max_clients"`

	// ClientTimeout for idle client connections
	ClientTimeout time.Duration `mapstructure:"client_timeout"`

	// AuthMode specifies authentication method: "none", "password", "trust"
	AuthMode string `mapstructure:"auth_mode"`
}

// BackendsConfig defines primary and replica database connections
type BackendsConfig struct {
	// Primary database configuration
	Primary BackendConfig `mapstructure:"primary"`

	// Replicas for read scaling (optional)
	Replicas []ReplicaConfig `mapstructure:"replicas"`
}

// BackendConfig defines a single database backend configuration
type BackendConfig struct {
	// DSN is the PostgreSQL connection string
	DSN string `mapstructure:"dsn"`

	// Alternative structured configuration
	Host     string `mapstructure:"host"`
	Port     int    `mapstructure:"port"`
	Database string `mapstructure:"database"`
	User     string `mapstructure:"user"`
	Password string `mapstructure:"password"`
	SSLMode  string `mapstructure:"sslmode"`

	// Pool configuration
	Pool PoolConfig `mapstructure:"pool"`

	// Behavior configuration
	Behavior BehaviorConfig `mapstructure:"behavior"`
}

// PoolConfig defines connection pool parameters
type PoolConfig struct {
	// MaxConnections is the maximum number of connections in the pool
	MaxConnections int `mapstructure:"max_connections"`

	// MinConnections is the minimum idle connections to maintain
	MinConnections int `mapstructure:"min_connections"`

	// MaxLifetime is the maximum connection lifetime
	MaxLifetime time.Duration `mapstructure:"max_lifetime"`

	// MaxIdleTime is the maximum idle time before closing
	MaxIdleTime time.Duration `mapstructure:"max_idle_time"`

	// HealthCheckPeriod for periodic connection validation
	HealthCheckPeriod time.Duration `mapstructure:"health_check_period"`

	// AcquireTimeout when waiting for available connection
	AcquireTimeout time.Duration `mapstructure:"acquire_timeout"`

	// WaitQueueSize limits pending connection requests
	WaitQueueSize int `mapstructure:"wait_queue_size"`
}

// BehaviorConfig defines connection behavior settings
type BehaviorConfig struct {
	// Mode specifies pooling mode: "session", "transaction", "statement", "auto"
	Mode string `mapstructure:"mode"`

	// ResetOnReturn resets connection state when returned to pool
	ResetOnReturn bool `mapstructure:"reset_on_return"`

	// LazyConnect delays connection establishment until first use
	LazyConnect bool `mapstructure:"lazy_connect"`

	// StatementCacheSize for prepared statements per connection
	StatementCacheSize int `mapstructure:"statement_cache_size"`

	// QueryTimeout for individual queries (0 = no timeout)
	QueryTimeout time.Duration `mapstructure:"query_timeout"`
}

// ReplicaConfig extends BackendConfig with replica-specific settings
type ReplicaConfig struct {
	BackendConfig `mapstructure:",squash"`

	// Weight for load balancing (higher = more traffic)
	Weight int `mapstructure:"weight"`
}

// RoutingConfig defines query routing behavior
type RoutingConfig struct {
	// ReadWriteSplit enables automatic read/write query routing
	ReadWriteSplit bool `mapstructure:"read_write_split"`

	// ReadPatterns are regex patterns identifying read queries
	ReadPatterns []string `mapstructure:"read_patterns"`

	// WritePatterns are regex patterns identifying write queries
	WritePatterns []string `mapstructure:"write_patterns"`

	// LoadBalance strategy: "round_robin", "least_connections", "random", "weighted"
	LoadBalance string `mapstructure:"load_balance"`

	// Failover configuration
	Failover FailoverConfig `mapstructure:"failover"`
}

// FailoverConfig defines failover behavior
type FailoverConfig struct {
	// Enabled allows automatic failover to replicas
	Enabled bool `mapstructure:"enabled"`

	// RetryInterval before retrying failed backend
	RetryInterval time.Duration `mapstructure:"retry_interval"`

	// MaxFailures before marking backend as down
	MaxFailures int `mapstructure:"max_failures"`
}

// MonitoringConfig defines metrics and monitoring settings
type MonitoringConfig struct {
	// Enabled activates metrics collection
	Enabled bool `mapstructure:"enabled"`

	// Interval between metrics updates
	Interval time.Duration `mapstructure:"interval"`

	// ExposeRPC makes metrics available via RPC
	ExposeRPC bool `mapstructure:"expose_rpc"`

	// Prometheus configuration
	Prometheus PrometheusConfig `mapstructure:"prometheus"`

	// Collect specifies which metrics to gather
	Collect []string `mapstructure:"collect"`
}

// PrometheusConfig defines Prometheus metrics settings
type PrometheusConfig struct {
	// Enabled exposes Prometheus metrics
	Enabled bool `mapstructure:"enabled"`

	// Namespace for metrics
	Namespace string `mapstructure:"namespace"`

	// Subsystem for metrics
	Subsystem string `mapstructure:"subsystem"`
}

// LoggingConfig defines logging behavior
type LoggingConfig struct {
	// Level specifies log level: "debug", "info", "warn", "error"
	Level string `mapstructure:"level"`

	// SlowQuery logging configuration
	SlowQuery SlowQueryConfig `mapstructure:"slow_query"`

	// LogQueries enables query logging (debug mode)
	LogQueries bool `mapstructure:"log_queries"`

	// LogParams includes query parameters in logs
	LogParams bool `mapstructure:"log_params"`
}

// SlowQueryConfig defines slow query logging
type SlowQueryConfig struct {
	// Enabled activates slow query logging
	Enabled bool `mapstructure:"enabled"`

	// Threshold for slow query detection
	Threshold time.Duration `mapstructure:"threshold"`
}

// FeaturesConfig defines optional advanced features
type FeaturesConfig struct {
	// Cache configuration for query results
	Cache CacheConfig `mapstructure:"cache"`

	// CircuitBreaker for backend failure handling
	CircuitBreaker CircuitBreakerConfig `mapstructure:"circuit_breaker"`

	// RateLimit per client configuration
	RateLimit RateLimitConfig `mapstructure:"rate_limit"`
}

// CacheConfig defines query caching layer
type CacheConfig struct {
	// Enabled activates query caching
	Enabled bool `mapstructure:"enabled"`

	// TTL for cached results
	TTL time.Duration `mapstructure:"ttl"`

	// MaxSize limits cache memory usage
	MaxSize string `mapstructure:"max_size"`
}

// CircuitBreakerConfig defines circuit breaker behavior
type CircuitBreakerConfig struct {
	// Enabled activates circuit breaker
	Enabled bool `mapstructure:"enabled"`

	// Threshold of failures to open circuit
	Threshold int `mapstructure:"threshold"`

	// Timeout before attempting reset
	Timeout time.Duration `mapstructure:"timeout"`
}

// RateLimitConfig defines rate limiting per client
type RateLimitConfig struct {
	// Enabled activates rate limiting
	Enabled bool `mapstructure:"enabled"`

	// RequestsPerSecond allowed per client
	RequestsPerSecond int `mapstructure:"requests_per_second"`

	// Burst allows temporary exceeding of rate limit
	Burst int `mapstructure:"burst"`
}

// DatabaseConfig defines configuration for additional databases
type DatabaseConfig struct {
	// Primary backend for this database
	Primary BackendConfig `mapstructure:"primary"`

	// Routing configuration (optional, inherits from global if not set)
	Routing *RoutingConfig `mapstructure:"routing"`
}

// Validate checks configuration for errors and applies defaults
func (c *Config) Validate() error {
	if !c.Enabled {
		return fmt.Errorf("plugin is disabled")
	}

	// Validate proxy configuration
	if c.Proxy.Address == "" {
		return fmt.Errorf("proxy.address is required")
	}

	// Apply default values
	c.applyDefaults()

	// Validate primary backend
	if err := c.Backends.Primary.Validate(); err != nil {
		return fmt.Errorf("primary backend validation failed: %w", err)
	}

	// Validate replicas
	for i, replica := range c.Backends.Replicas {
		if err := replica.BackendConfig.Validate(); err != nil {
			return fmt.Errorf("replica %d validation failed: %w", i, err)
		}
	}

	// Validate additional databases
	for name, dbConfig := range c.Databases {
		if err := dbConfig.Primary.Validate(); err != nil {
			return fmt.Errorf("database %s validation failed: %w", name, err)
		}
	}

	return nil
}

// applyDefaults sets default values for unspecified configuration options
func (c *Config) applyDefaults() {
	// Proxy defaults
	if c.Proxy.MaxClients == 0 {
		c.Proxy.MaxClients = 100
	}
	if c.Proxy.ClientTimeout == 0 {
		c.Proxy.ClientTimeout = 30 * time.Second
	}
	if c.Proxy.AuthMode == "" {
		c.Proxy.AuthMode = "trust"
	}

	// Monitoring defaults
	if c.Monitoring.Interval == 0 {
		c.Monitoring.Interval = 10 * time.Second
	}
	if c.Monitoring.Prometheus.Namespace == "" {
		c.Monitoring.Prometheus.Namespace = "roadrunner"
	}
	if c.Monitoring.Prometheus.Subsystem == "" {
		c.Monitoring.Prometheus.Subsystem = "pgpool"
	}

	// Logging defaults
	if c.Logging.Level == "" {
		c.Logging.Level = "info"
	}
	if c.Logging.SlowQuery.Threshold == 0 {
		c.Logging.SlowQuery.Threshold = 100 * time.Millisecond
	}

	// Apply defaults to backends
	c.Backends.Primary.applyDefaults()
	for i := range c.Backends.Replicas {
		c.Backends.Replicas[i].BackendConfig.applyDefaults()
		if c.Backends.Replicas[i].Weight == 0 {
			c.Backends.Replicas[i].Weight = 1
		}
	}
}

// Validate checks backend configuration for errors
func (b *BackendConfig) Validate() error {
	// Must have either DSN or structured config
	if b.DSN == "" && b.Host == "" {
		return fmt.Errorf("either dsn or host must be specified")
	}

	// Validate pool configuration
	if b.Pool.MaxConnections <= 0 {
		return fmt.Errorf("pool.max_connections must be positive")
	}
	if b.Pool.MinConnections < 0 {
		return fmt.Errorf("pool.min_connections cannot be negative")
	}
	if b.Pool.MinConnections > b.Pool.MaxConnections {
		return fmt.Errorf("pool.min_connections cannot exceed max_connections")
	}

	// Validate behavior mode
	validModes := map[string]bool{
		"session":     true,
		"transaction": true,
		"statement":   true,
		"auto":        true,
	}
	if b.Behavior.Mode != "" && !validModes[b.Behavior.Mode] {
		return fmt.Errorf("invalid behavior.mode: %s", b.Behavior.Mode)
	}

	return nil
}

// applyDefaults sets default values for backend configuration
func (b *BackendConfig) applyDefaults() {
	// Pool defaults
	if b.Pool.MaxConnections == 0 {
		b.Pool.MaxConnections = 25
	}
	if b.Pool.MinConnections == 0 {
		b.Pool.MinConnections = 5
	}
	if b.Pool.MaxLifetime == 0 {
		b.Pool.MaxLifetime = 1 * time.Hour
	}
	if b.Pool.MaxIdleTime == 0 {
		b.Pool.MaxIdleTime = 30 * time.Minute
	}
	if b.Pool.HealthCheckPeriod == 0 {
		b.Pool.HealthCheckPeriod = 30 * time.Second
	}
	if b.Pool.AcquireTimeout == 0 {
		b.Pool.AcquireTimeout = 5 * time.Second
	}
	if b.Pool.WaitQueueSize == 0 {
		b.Pool.WaitQueueSize = 100
	}

	// Behavior defaults
	if b.Behavior.Mode == "" {
		b.Behavior.Mode = "transaction"
	}
	if b.Behavior.StatementCacheSize == 0 {
		b.Behavior.StatementCacheSize = 100
	}
	if b.Behavior.QueryTimeout == 0 {
		b.Behavior.QueryTimeout = 30 * time.Second
	}

	// SSL mode default
	if b.SSLMode == "" {
		b.SSLMode = "prefer"
	}

	// Port default
	if b.Port == 0 {
		b.Port = 5432
	}
}

// BuildDSN constructs a PostgreSQL DSN from structured configuration
func (b *BackendConfig) BuildDSN() string {
	if b.DSN != "" {
		return b.DSN
	}

	return fmt.Sprintf(
		"postgres://%s:%s@%s:%d/%s?sslmode=%s",
		b.User,
		b.Password,
		b.Host,
		b.Port,
		b.Database,
		b.SSLMode,
	)
}