plugin

type ClientCertInfo struct {
	Subject   string
	Issuer    string
	NotBefore time.Time
	NotAfter  time.Time
	Serial    string
}

type ConnectionContext struct {
	// LocalAddr is the local address
	LocalAddr string
	// RemoteAddr is the remote client address
	RemoteAddr string
	// RemotePort is the remote client port
	RemotePort int
	// LocalPort is the local server port
	LocalPort int
	// IsEncrypted indicates if the connection is TLS encrypted
	IsEncrypted bool
	// ConnectionID is a unique identifier for this connection
	ConnectionID string
	// Metadata is additional context metadata
	Metadata map[string]interface{}
}

type ConnectionHandler interface {
	// OnConnectionOpen is called when a connection opens
	OnConnectionOpen(ctx context.Context, connCtx *ConnectionContext) error
	// OnConnectionClose is called when a connection closes
	OnConnectionClose(ctx context.Context, connCtx *ConnectionContext) error
}

type ErrorContext struct {
	// Error is the actual error
	Error error
	// Hook is the hook type where the error occurred
	Hook HookType
	// Request is the associated request (if available)
	Request *http.Request
	// ConnectionID is the connection where error occurred
	ConnectionID string
	// Timestamp when the error occurred
	Timestamp time.Time
	// Metadata is additional context metadata
	Metadata map[string]interface{}
}

type ErrorHandler interface {
	// OnError is called when an error occurs
	OnError(ctx context.Context, errCtx *ErrorContext) error
}

type FilterPlugin interface {
	Plugin
	RequestProcessor
	ResponseProcessor
}

type HookResult struct {
	// Continue indicates whether to continue to the next plugin/hook
	Continue bool
	// Stop indicates whether to stop the entire pipeline
	Stop bool
	// Error contains any error that occurred
	Error error
	// ModifiedRequest is a modified request (for request hooks)
	ModifiedRequest *http.Request
	// ModifiedBody is a modified body (for body-processing hooks)
	ModifiedBody []byte
	// Metadata is additional data to pass to subsequent hooks
	Metadata map[string]interface{}
	// ResponseHeaders headers to add/modify
	ResponseHeaders http.Header
	// StatusCode to set (for response hooks)
	StatusCode int
}

type HookType string

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

type ManagerConfig struct {
	// PluginDirs directories to search for plugins
	PluginDirs []string
	// PluginConfig configuration for each plugin
	PluginConfig map[string]PluginConfig
	// EnabledPluginTypes only load plugins of these types (empty = all)
	EnabledPluginTypes []Type
	// DisabledPlugins list of plugin IDs to skip loading
	DisabledPlugins []string
	// WatchDir watch for plugin changes (development)
	WatchDir bool
	// PluginTimeout default timeout for plugin operations
	PluginTimeout time.Duration
	// EnablePeriodic enable periodic hook processing
	EnablePeriodic bool
}

type PeriodicContext struct {
	// Timestamp is when the hook is being executed
	Timestamp time.Time
	// Interval is the configured interval
	Interval time.Duration
	// Metadata is additional context metadata
	Metadata map[string]interface{}
}

type PeriodicTask interface {
	// OnPeriodic is called at regular intervals
	OnPeriodic(ctx context.Context, periodicCtx *PeriodicContext) error
	// Interval returns the interval at which OnPeriodic should be called
	Interval() time.Duration
}

type Plugin interface {
	// Metadata returns plugin information
	Metadata() PluginMetadata

	// Init is called once when the plugin is loaded
	Init(ctx context.Context, config PluginConfig) error

	// Start is called when the plugin should begin operation
	Start(ctx context.Context) error

	// Stop is called when the plugin should gracefully shut down
	Stop(ctx context.Context) error

	// Hooks returns the hooks this plugin implements
	Hooks() []HookType
}

type PluginConfig struct {
	Enabled     bool                   `json:"enabled" yaml:"enabled"`
	Priority    int                    `json:"priority" yaml:"priority"` // Lower = earlier execution
	Settings    map[string]interface{} `json:"settings" yaml:"settings"`
	Timeout     time.Duration          `json:"timeout" yaml:"timeout"`
	RetryConfig *RetryConfig           `json:"retry,omitempty" yaml:"retry,omitempty"`
}

type PluginMetadata struct {
	ID          string   `json:"id" yaml:"id"`
	Name        string   `json:"name" yaml:"name"`
	Version     string   `json:"version" yaml:"version"`
	Description string   `json:"description" yaml:"description"`
	Author      string   `json:"author" yaml:"author"`
	Website     string   `json:"website,omitempty" yaml:"website,omitempty"`
	Type        Type     `json:"type" yaml:"type"`
	Tags        []string `json:"tags,omitempty" yaml:"tags,omitempty"`
	// Dependencies lists plugin IDs that must be loaded before this one
	Dependencies []string `json:"dependencies,omitempty" yaml:"dependencies,omitempty"`
	// Capabilities lists what this plugin provides
	Capabilities []string `json:"capabilities,omitempty" yaml:"capabilities,omitempty"`
}

type PluginState struct {
	Metadata  PluginMetadata
	Config    PluginConfig
	Status    Status
	Plugin    Plugin
	StartedAt time.Time
	LastError error
}

type RequestContext struct {
	// Request is the HTTP request (may be modified by plugins)
	Request *http.Request
	// ResponseWriter is the response (plugins can write to it)
	ResponseWriter http.ResponseWriter
	// Body is the request body (for request hooks)
	Body []byte
	// Upstream is the target upstream URL
	Upstream string
	// ClientIP is the client's IP address
	ClientIP string
	// Protocol is the protocol used (HTTP/1.1, HTTP/2, HTTP/3)
	Protocol string
	// TLSInfo contains TLS connection details
	TLSInfo *TLSInfo
	// Metadata is additional context metadata
	Metadata map[string]interface{}
	// Timestamp when the request was received
	Timestamp time.Time
}

type RequestProcessor interface {
	// ProcessRequest is called for request hooks
	ProcessRequest(ctx context.Context, reqCtx *RequestContext) (*HookResult, error)
}

type ResponseContext struct {
	// StatusCode is the HTTP status code
	StatusCode int
	// Status is the HTTP status string
	Status string
	// Headers are the response headers
	Headers http.Header
	// Body is the response body
	Body []byte
	// Latency is the time taken to get the response from upstream
	Latency time.Duration
	// Error contains any error that occurred
	Error error
	// Metadata is additional context metadata
	Metadata map[string]interface{}
}

type ResponseProcessor interface {
	// ProcessResponse is called for response hooks
	ProcessResponse(ctx context.Context, reqCtx *RequestContext, respCtx *ResponseContext) (*HookResult, error)
}

type RetryConfig struct {
	MaxAttempts  int           `json:"max_attempts" yaml:"max_attempts"`
	InitialDelay time.Duration `json:"initial_delay" yaml:"initial_delay"`
	MaxDelay     time.Duration `json:"max_delay" yaml:"max_delay"`
	Multiplier   float64       `json:"multiplier" yaml:"multiplier"`
}

type Status int

type TLSInfo struct {
	Version     string
	CipherSuite string
	ServerName  string
	Verified    bool
	// For mTLS - client certificate info
	ClientCert *ClientCertInfo
}

type Type string