pgpool

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"`
}

type BackendsConfig struct {
	// Primary database configuration
	Primary BackendConfig `mapstructure:"primary"`

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

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"`
}

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"`
}

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

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"`
}

type CircuitBreakerState int32

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

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"`
}

type Configurer interface {
	// UnmarshalKey reads configuration section into provided structure
	UnmarshalKey(name string, out interface{}) error
	// Has checks if configuration key exists
	Has(name string) bool
}

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"`
}

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

type DatabaseStats struct {
	// Connection counts
	TotalConnections  int32 `json:"total_connections"`
	IdleConnections   int32 `json:"idle_connections"`
	ActiveConnections int32 `json:"active_connections"`
	MaxConnections    int32 `json:"max_connections"`

	// Acquisition statistics
	TotalAcquired        int64 `json:"total_acquired"`
	TotalReleased        int64 `json:"total_released"`
	AverageAcquireTimeMs int64 `json:"average_acquire_time_ms"`

	// Query statistics
	QueryCount         int64 `json:"query_count"`
	AverageQueryTimeMs int64 `json:"average_query_time_ms"`
	ErrorCount         int64 `json:"error_count"`
	SlowQueryCount     int64 `json:"slow_query_count"`

	// Health status
	HealthChecksPassed int64  `json:"health_checks_passed"`
	HealthChecksFailed int64  `json:"health_checks_failed"`
	LastHealthCheck    string `json:"last_health_check"`
	LastError          string `json:"last_error,omitempty"`
}

type ExecuteRequest struct {
	// Database name to execute query against (default: "primary")
	Database string `json:"database"`

	// SQL query to execute
	Query string `json:"query"`

	// Query parameters (positional)
	Args []interface{} `json:"args,omitempty"`

	// Timeout in milliseconds (0 = use default)
	Timeout int `json:"timeout,omitempty"`
}

type ExecuteResponse struct {
	// Rows returned by query (for SELECT queries)
	Rows []map[string]interface{} `json:"rows,omitempty"`

	// RowsAffected for INSERT/UPDATE/DELETE
	RowsAffected int64 `json:"rows_affected,omitempty"`

	// Error message if query failed
	Error string `json:"error,omitempty"`

	// Query execution time in milliseconds
	ExecutionTime int64 `json:"execution_time"`
}

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"`
}

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"`
}

type HealthCheckRequest struct {
	// Database name (default: "primary", "*" for all)
	Database string `json:"database"`
}

type HealthCheckResponse struct {
	// Health status per database
	Health map[string]bool `json:"health"`

	// Error messages per database
	Errors map[string]string `json:"errors,omitempty"`
}

type Logger interface {
	NamedLogger(name string) *zap.Logger
}

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"`
}

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

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"`
}

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

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"`
}

type PoolStats struct {
	// Connection statistics
	TotalConnections     int32
	IdleConnections      int32
	ActiveConnections    int32
	WaitingClients       int32
	TotalAcquired        int64
	TotalReleased        int64
	AcquireCount         int64
	AcquireDuration      time.Duration
	CanceledAcquireCount int64
	ConstructingConns    int32
	MaxConnections       int32

	// Query statistics
	QueryCount     int64
	QueryDuration  time.Duration
	ErrorCount     int64
	SlowQueryCount int64

	// Pool health
	HealthChecksPassed int64
	HealthChecksFailed int64
	LastHealthCheck    time.Time
	LastError          error
	// contains filtered or unexported fields
}

type PoolStatsRequest struct {
	// Database name (default: "primary", "*" for all)
	Database string `json:"database"`
}

type PoolStatsResponse struct {
	// Statistics per database
	Stats map[string]DatabaseStats `json:"stats"`

	// Error message if stats retrieval failed
	Error string `json:"error,omitempty"`
}

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"`
}

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"`
}

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

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"`
}

type ReplicaConfig struct {
	BackendConfig `mapstructure:",squash"`

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

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"`
}

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

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

type TransactionBeginRequest struct {
	// Database name (default: "primary")
	Database string `json:"database"`

	// Transaction ID for tracking (generated if not provided)
	TxID string `json:"tx_id,omitempty"`

	// Isolation level: "read_committed", "repeatable_read", "serializable"
	IsolationLevel string `json:"isolation_level,omitempty"`

	// Read only transaction
	ReadOnly bool `json:"read_only,omitempty"`
}

type TransactionBeginResponse struct {
	// Transaction ID for subsequent operations
	TxID string `json:"tx_id"`

	// Error message if transaction start failed
	Error string `json:"error,omitempty"`
}

type TransactionCommitRequest struct {
	// Transaction ID to commit
	TxID string `json:"tx_id"`
}

type TransactionCommitResponse struct {
	// Success indicator
	Success bool `json:"success"`

	// Error message if commit failed
	Error string `json:"error,omitempty"`
}

type TransactionRollbackRequest struct {
	// Transaction ID to rollback
	TxID string `json:"tx_id"`
}

type TransactionRollbackResponse struct {
	// Success indicator
	Success bool `json:"success"`

	// Error message if rollback failed
	Error string `json:"error,omitempty"`
}