types

type APIServerLatency struct {
	LatencyMs float64 `json:"latency_ms"`
	Reachable bool    `json:"reachable"`
}

type AnnotationConfig struct {
	Key   string `json:"key" yaml:"key"`
	Value string `json:"value" yaml:"value"`
}

type AuthConfig struct {
	Type     string `json:"type" yaml:"type"`                             // "none", "bearer", "basic"
	Token    string `json:"token,omitempty" yaml:"token,omitempty"`       // Bearer token
	Username string `json:"username,omitempty" yaml:"username,omitempty"` // Basic auth username
	Password string `json:"password,omitempty" yaml:"password,omitempty"` // Basic auth password
}

type CircuitBreakerConfig struct {
	Enabled          bool          `json:"enabled" yaml:"enabled"`
	Threshold        int           `json:"threshold,omitempty" yaml:"threshold,omitempty"`
	TimeoutString    string        `json:"timeout,omitempty" yaml:"timeout,omitempty"`
	Timeout          time.Duration `json:"-" yaml:"-"`
	SuccessThreshold int           `json:"successThreshold,omitempty" yaml:"successThreshold,omitempty"`
}

type Condition struct {
	// Type is the type of condition (e.g., "KubeletReady", "DiskPressure").
	Type string

	// Status is the current status of the condition (True, False, Unknown).
	Status ConditionStatus

	// Transition is when the condition last transitioned.
	Transition time.Time

	// Reason is a brief machine-readable string explaining the condition.
	Reason string

	// Message is a human-readable explanation of the condition.
	Message string
}

type ConditionConfig struct {
	Type           string `json:"type" yaml:"type"`
	DefaultStatus  string `json:"defaultStatus,omitempty" yaml:"defaultStatus,omitempty"`
	DefaultReason  string `json:"defaultReason,omitempty" yaml:"defaultReason,omitempty"`
	DefaultMessage string `json:"defaultMessage,omitempty" yaml:"defaultMessage,omitempty"`
}

type ConditionStatus string

type ConfigMetadata struct {
	Name      string            `json:"name" yaml:"name"`
	Namespace string            `json:"namespace,omitempty" yaml:"namespace,omitempty"`
	Labels    map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"`
}

type ControllerWebhookConfig struct {
	// Enabled indicates whether to send reports to the controller
	Enabled bool `json:"enabled" yaml:"enabled"`

	// URL is the controller's report ingestion endpoint
	URL string `json:"url" yaml:"url"`

	// IntervalString is the interval between reports (stored as string)
	IntervalString string        `json:"interval,omitempty" yaml:"interval,omitempty"`
	Interval       time.Duration `json:"-" yaml:"-"`

	// TimeoutString is the request timeout (stored as string)
	TimeoutString string        `json:"timeout,omitempty" yaml:"timeout,omitempty"`
	Timeout       time.Duration `json:"-" yaml:"-"`

	// Auth configuration for authenticating with the controller
	Auth AuthConfig `json:"auth,omitempty" yaml:"auth,omitempty"`

	// Headers are custom headers to include in requests
	Headers map[string]string `json:"headers,omitempty" yaml:"headers,omitempty"`

	// Retry configuration for failed requests
	Retry *RetryConfig `json:"retry,omitempty" yaml:"retry,omitempty"`
}

type DNSLatency struct {
	DNSServer  string  `json:"dns_server"`
	Domain     string  `json:"domain"`
	RecordType string  `json:"record_type"`
	DomainType string  `json:"domain_type"` // "cluster", "external", "custom"
	LatencyMs  float64 `json:"latency_ms"`
	Success    bool    `json:"success"`
}

type Event struct {
	// Severity indicates the importance of the event (Info, Warning, Error).
	Severity EventSeverity

	// Timestamp when the event occurred.
	Timestamp time.Time

	// Reason is a short, machine-readable string that describes the event.
	Reason string

	// Message is a human-readable description of the event.
	Message string
}

type EventConfig struct {
	MaxEventsPerMinute        int           `json:"maxEventsPerMinute,omitempty" yaml:"maxEventsPerMinute,omitempty"`
	EventTTLString            string        `json:"eventTTL,omitempty" yaml:"eventTTL,omitempty"`
	EventTTL                  time.Duration `json:"-" yaml:"-"`
	DeduplicationWindowString string        `json:"deduplicationWindow,omitempty" yaml:"deduplicationWindow,omitempty"`
	DeduplicationWindow       time.Duration `json:"-" yaml:"-"`
}

type EventSeverity string

type Exporter interface {
	// ExportStatus publishes a status update.
	ExportStatus(ctx context.Context, status *Status) error

	// ExportProblem publishes a problem report.
	ExportProblem(ctx context.Context, problem *Problem) error
}

type ExporterConfigs struct {
	Kubernetes *KubernetesExporterConfig `json:"kubernetes,omitempty" yaml:"kubernetes,omitempty"`
	HTTP       *HTTPExporterConfig       `json:"http,omitempty" yaml:"http,omitempty"`
	Prometheus *PrometheusExporterConfig `json:"prometheus,omitempty" yaml:"prometheus,omitempty"`
}

type ExporterReloadResult struct {
	ExporterType string // Type of exporter (e.g., "kubernetes", "http", "prometheus")
	Success      bool   // Whether the reload was successful
	Error        error  // Error details if reload failed
	Message      string // Additional information about the reload
}

type ExporterReloadSummary struct {
	TotalExporters    int                    // Total number of exporters
	ReloadableCount   int                    // Number of exporters that support reload
	SuccessfulReloads int                    // Number of successful reloads
	FailedReloads     int                    // Number of failed reloads
	Results           []ExporterReloadResult // Detailed results for each exporter
}

type FeatureFlags struct {
	EnableMetrics   bool   `json:"enableMetrics,omitempty" yaml:"enableMetrics,omitempty"`
	EnableProfiling bool   `json:"enableProfiling,omitempty" yaml:"enableProfiling,omitempty"`
	ProfilingPort   int    `json:"profilingPort,omitempty" yaml:"profilingPort,omitempty"`
	EnableTracing   bool   `json:"enableTracing,omitempty" yaml:"enableTracing,omitempty"`
	TracingEndpoint string `json:"tracingEndpoint,omitempty" yaml:"tracingEndpoint,omitempty"`
}

type GatewayLatency struct {
	GatewayIP    string  `json:"gateway_ip"`
	LatencyMs    float64 `json:"latency_ms"`
	AvgLatencyMs float64 `json:"avg_latency_ms"`
	MaxLatencyMs float64 `json:"max_latency_ms"`
	Reachable    bool    `json:"reachable"`
	PingCount    int     `json:"ping_count"`
	SuccessCount int     `json:"success_count"`
}

type GlobalSettings struct {
	// NodeName is the Kubernetes node name (usually from ${NODE_NAME})
	NodeName string `json:"nodeName" yaml:"nodeName"`

	// Logging configuration
	LogLevel  string `json:"logLevel,omitempty" yaml:"logLevel,omitempty"`
	LogFormat string `json:"logFormat,omitempty" yaml:"logFormat,omitempty"`
	LogOutput string `json:"logOutput,omitempty" yaml:"logOutput,omitempty"`
	LogFile   string `json:"logFile,omitempty" yaml:"logFile,omitempty"`

	// Update intervals (stored as strings, parsed to time.Duration)
	UpdateIntervalString    string `json:"updateInterval,omitempty" yaml:"updateInterval,omitempty"`
	ResyncIntervalString    string `json:"resyncInterval,omitempty" yaml:"resyncInterval,omitempty"`
	HeartbeatIntervalString string `json:"heartbeatInterval,omitempty" yaml:"heartbeatInterval,omitempty"`

	// Parsed duration fields (not in JSON/YAML)
	UpdateInterval    time.Duration `json:"-" yaml:"-"`
	ResyncInterval    time.Duration `json:"-" yaml:"-"`
	HeartbeatInterval time.Duration `json:"-" yaml:"-"`

	// Remediation master switches
	EnableRemediation bool `json:"enableRemediation,omitempty" yaml:"enableRemediation,omitempty"`
	DryRunMode        bool `json:"dryRunMode,omitempty" yaml:"dryRunMode,omitempty"`

	// Kubernetes client configuration
	Kubeconfig string  `json:"kubeconfig,omitempty" yaml:"kubeconfig,omitempty"`
	QPS        float32 `json:"qps,omitempty" yaml:"qps,omitempty"`
	Burst      int     `json:"burst,omitempty" yaml:"burst,omitempty"`
}

type HTTPExporterConfig struct {
	Enabled   bool              `json:"enabled" yaml:"enabled"`
	Webhooks  []WebhookEndpoint `json:"webhooks,omitempty" yaml:"webhooks,omitempty"`
	Workers   int               `json:"workers,omitempty" yaml:"workers,omitempty"`
	QueueSize int               `json:"queueSize,omitempty" yaml:"queueSize,omitempty"`

	// Default timeout for all webhooks (can be overridden per webhook)
	TimeoutString string        `json:"timeout,omitempty" yaml:"timeout,omitempty"`
	Timeout       time.Duration `json:"-" yaml:"-"`

	// Default retry configuration for all webhooks (can be overridden per webhook)
	Retry   RetryConfig       `json:"retry,omitempty" yaml:"retry,omitempty"`
	Headers map[string]string `json:"headers,omitempty" yaml:"headers,omitempty"`

	// Controller webhook for sending aggregated reports to the controller
	Controller *ControllerWebhookConfig `json:"controller,omitempty" yaml:"controller,omitempty"`
}

type KubernetesExporterConfig struct {
	Enabled bool `json:"enabled" yaml:"enabled"`

	// Update intervals
	UpdateIntervalString    string `json:"updateInterval,omitempty" yaml:"updateInterval,omitempty"`
	ResyncIntervalString    string `json:"resyncInterval,omitempty" yaml:"resyncInterval,omitempty"`
	HeartbeatIntervalString string `json:"heartbeatInterval,omitempty" yaml:"heartbeatInterval,omitempty"`

	UpdateInterval    time.Duration `json:"-" yaml:"-"`
	ResyncInterval    time.Duration `json:"-" yaml:"-"`
	HeartbeatInterval time.Duration `json:"-" yaml:"-"`

	// Namespace for events
	Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty"`

	// Custom node conditions
	Conditions []ConditionConfig `json:"conditions,omitempty" yaml:"conditions,omitempty"`

	// Node annotations to manage
	Annotations []AnnotationConfig `json:"annotations,omitempty" yaml:"annotations,omitempty"`

	// Event configuration
	Events EventConfig `json:"events,omitempty" yaml:"events,omitempty"`
}

type LatencyMetrics struct {
	// Gateway latency metrics
	Gateway *GatewayLatency `json:"gateway,omitempty"`

	// Peer latency metrics (CNI/cross-node connectivity)
	Peers []PeerLatency `json:"peers,omitempty"`

	// DNS latency metrics
	DNS []DNSLatency `json:"dns,omitempty"`

	// API server latency
	APIServer *APIServerLatency `json:"apiserver,omitempty"`
}

type Monitor interface {
	// Start begins the monitoring process and returns a channel for status updates.
	// The monitor runs asynchronously and sends Status updates through the channel.
	Start() (<-chan *Status, error)

	// Stop gracefully stops the monitor.
	Stop()
}

type MonitorConfig struct {
	// Name is the unique identifier for this monitor
	Name string `json:"name" yaml:"name"`

	// Type is the monitor type (e.g., "system-disk-check")
	Type string `json:"type" yaml:"type"`

	// Enabled indicates whether this monitor is active
	Enabled bool `json:"enabled" yaml:"enabled"`

	// Interval and timeout (stored as strings)
	IntervalString string `json:"interval,omitempty" yaml:"interval,omitempty"`
	TimeoutString  string `json:"timeout,omitempty" yaml:"timeout,omitempty"`

	// Parsed duration fields
	Interval time.Duration `json:"-" yaml:"-"`
	Timeout  time.Duration `json:"-" yaml:"-"`

	// Config contains monitor-specific configuration as a map
	// Each monitor type will parse this according to its needs
	Config map[string]interface{} `json:"config,omitempty" yaml:"config,omitempty"`

	// Remediation contains optional remediation configuration for this monitor
	Remediation *MonitorRemediationConfig `json:"remediation,omitempty" yaml:"remediation,omitempty"`

	// DependsOn specifies monitors that must complete successfully before this monitor starts
	// Used for dependency ordering and circular dependency detection during validation
	DependsOn []string `json:"dependsOn,omitempty" yaml:"dependsOn,omitempty"`
}

type MonitorRegistryValidator interface {
	// IsRegistered returns true if the given monitor type is registered
	IsRegistered(monitorType string) bool

	// GetRegisteredTypes returns a sorted list of all registered monitor types
	GetRegisteredTypes() []string
}

type MonitorRemediationConfig struct {
	// Enabled indicates whether remediation is enabled for this monitor
	Enabled bool `json:"enabled" yaml:"enabled"`

	// Strategy is the remediation strategy type
	Strategy string `json:"strategy,omitempty" yaml:"strategy,omitempty"`

	// Action is the specific action to take
	Action string `json:"action,omitempty" yaml:"action,omitempty"`

	// Service is the systemd service name (for systemd-restart strategy)
	Service string `json:"service,omitempty" yaml:"service,omitempty"`

	// ScriptPath is the path to remediation script (for custom-script strategy)
	ScriptPath string `json:"scriptPath,omitempty" yaml:"scriptPath,omitempty"`

	// Args are arguments to pass to the script
	Args []string `json:"args,omitempty" yaml:"args,omitempty"`

	// Cooldown period (stored as string)
	CooldownString string        `json:"cooldown,omitempty" yaml:"cooldown,omitempty"`
	Cooldown       time.Duration `json:"-" yaml:"-"`

	// MaxAttempts is the maximum remediation attempts
	MaxAttempts int `json:"maxAttempts,omitempty" yaml:"maxAttempts,omitempty"`

	// Priority for multiple remediation strategies
	Priority int `json:"priority,omitempty" yaml:"priority,omitempty"`

	// GracefulStop indicates whether to stop gracefully
	GracefulStop bool `json:"gracefulStop,omitempty" yaml:"gracefulStop,omitempty"`

	// WaitTimeout for graceful stop (stored as string)
	WaitTimeoutString string        `json:"waitTimeout,omitempty" yaml:"waitTimeout,omitempty"`
	WaitTimeout       time.Duration `json:"-" yaml:"-"`

	// Additional strategies for multi-step remediation
	Strategies []MonitorRemediationConfig `json:"strategies,omitempty" yaml:"strategies,omitempty"`
}

type NodeDoctorConfig struct {
	// APIVersion of the configuration schema
	APIVersion string `json:"apiVersion" yaml:"apiVersion"`

	// Kind of resource (always "NodeDoctorConfig")
	Kind string `json:"kind" yaml:"kind"`

	// Metadata contains name, namespace, labels, etc.
	Metadata ConfigMetadata `json:"metadata" yaml:"metadata"`

	// Settings contains global configuration
	Settings GlobalSettings `json:"settings" yaml:"settings"`

	// Monitors contains all monitor configurations
	Monitors []MonitorConfig `json:"monitors" yaml:"monitors"`

	// Exporters contains exporter configurations
	Exporters ExporterConfigs `json:"exporters" yaml:"exporters"`

	// Remediation contains global remediation settings
	Remediation RemediationConfig `json:"remediation" yaml:"remediation"`

	// Features contains feature flags
	Features FeatureFlags `json:"features,omitempty" yaml:"features,omitempty"`

	// Reload contains configuration hot reload settings
	Reload ReloadConfig `json:"reload,omitempty" yaml:"reload,omitempty"`
}

type PeerLatency struct {
	PeerNode     string  `json:"peer_node"`
	PeerIP       string  `json:"peer_ip"`
	LatencyMs    float64 `json:"latency_ms"`
	AvgLatencyMs float64 `json:"avg_latency_ms"`
	Reachable    bool    `json:"reachable"`
}

type Problem struct {
	// Type categorizes the problem (e.g., "systemd-service-failed").
	Type string

	// Resource identifies the affected resource (e.g., "kubelet.service").
	Resource string

	// Severity indicates how critical the problem is.
	Severity ProblemSeverity

	// Message describes the problem in detail.
	Message string

	// DetectedAt is when the problem was first detected.
	DetectedAt time.Time

	// Metadata contains additional context about the problem.
	Metadata map[string]string
}

type ProblemSeverity string

type PrometheusExporterConfig struct {
	Enabled   bool              `json:"enabled" yaml:"enabled"`
	Port      int               `json:"port,omitempty" yaml:"port,omitempty"`
	Path      string            `json:"path,omitempty" yaml:"path,omitempty"`
	Namespace string            `json:"namespace,omitempty" yaml:"namespace,omitempty"`
	Subsystem string            `json:"subsystem,omitempty" yaml:"subsystem,omitempty"`
	Labels    map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"`
}

type ReloadConfig struct {
	// Enabled indicates whether hot reload is enabled
	Enabled bool `json:"enabled" yaml:"enabled"`

	// DebounceIntervalString is the debounce interval as a string (e.g., "500ms")
	DebounceIntervalString string `json:"debounceInterval,omitempty" yaml:"debounceInterval,omitempty"`

	// DebounceInterval is the parsed debounce duration
	DebounceInterval time.Duration `json:"-" yaml:"-"`
}

type ReloadableExporter interface {
	Exporter

	// Reload updates the exporter configuration without restarting the exporter.
	// The config parameter should be the exporter-specific configuration struct.
	// Returns an error if the reload fails or if the configuration is invalid.
	Reload(config interface{}) error

	// IsReloadable returns true if this exporter supports configuration reload.
	// This is primarily used for runtime checks and debugging.
	IsReloadable() bool
}

type RemediationConfig struct {
	// Master switches
	Enabled bool `json:"enabled" yaml:"enabled"`
	DryRun  bool `json:"dryRun,omitempty" yaml:"dryRun,omitempty"`

	// Safety limits
	MaxRemediationsPerHour   int `json:"maxRemediationsPerHour,omitempty" yaml:"maxRemediationsPerHour,omitempty"`
	MaxRemediationsPerMinute int `json:"maxRemediationsPerMinute,omitempty" yaml:"maxRemediationsPerMinute,omitempty"`

	// Cooldown configuration
	CooldownPeriodString string        `json:"cooldownPeriod,omitempty" yaml:"cooldownPeriod,omitempty"`
	CooldownPeriod       time.Duration `json:"-" yaml:"-"`

	// Global max attempts
	MaxAttemptsGlobal int `json:"maxAttemptsGlobal,omitempty" yaml:"maxAttemptsGlobal,omitempty"`

	// Circuit breaker settings
	CircuitBreaker CircuitBreakerConfig `json:"circuitBreaker,omitempty" yaml:"circuitBreaker,omitempty"`

	// History configuration
	HistorySize int `json:"historySize,omitempty" yaml:"historySize,omitempty"`

	// Problem-specific overrides
	Overrides []RemediationOverride `json:"overrides,omitempty" yaml:"overrides,omitempty"`

	// Coordination with controller for cluster-wide remediation safety
	Coordination *RemediationCoordinationConfig `json:"coordination,omitempty" yaml:"coordination,omitempty"`
}

type RemediationCoordinationConfig struct {
	// Enabled indicates whether to coordinate remediations with the controller
	Enabled bool `json:"enabled" yaml:"enabled"`

	// ControllerURL is the URL of the node-doctor controller
	ControllerURL string `json:"controllerURL" yaml:"controllerURL"`

	// LeaseTimeoutString is the requested duration for remediation leases (stored as string)
	LeaseTimeoutString string        `json:"leaseTimeout,omitempty" yaml:"leaseTimeout,omitempty"`
	LeaseTimeout       time.Duration `json:"-" yaml:"-"`

	// RequestTimeoutString is the timeout for lease requests to the controller (stored as string)
	RequestTimeoutString string        `json:"requestTimeout,omitempty" yaml:"requestTimeout,omitempty"`
	RequestTimeout       time.Duration `json:"-" yaml:"-"`

	// FallbackOnUnreachable determines behavior when controller is unreachable
	// If true, proceed with remediation; if false, block and wait for controller
	FallbackOnUnreachable bool `json:"fallbackOnUnreachable,omitempty" yaml:"fallbackOnUnreachable,omitempty"`

	// MaxRetries is the maximum number of lease request retries
	MaxRetries int `json:"maxRetries,omitempty" yaml:"maxRetries,omitempty"`

	// RetryIntervalString is the interval between lease request retries (stored as string)
	RetryIntervalString string        `json:"retryInterval,omitempty" yaml:"retryInterval,omitempty"`
	RetryInterval       time.Duration `json:"-" yaml:"-"`
}

type RemediationOverride struct {
	Problem                 string        `json:"problem" yaml:"problem"`
	CooldownString          string        `json:"cooldown,omitempty" yaml:"cooldown,omitempty"`
	Cooldown                time.Duration `json:"-" yaml:"-"`
	MaxAttempts             int           `json:"maxAttempts,omitempty" yaml:"maxAttempts,omitempty"`
	CircuitBreakerThreshold int           `json:"circuitBreakerThreshold,omitempty" yaml:"circuitBreakerThreshold,omitempty"`
}

type Remediator interface {
	// CanRemediate returns true if this remediator can handle the given problem.
	CanRemediate(problem Problem) bool

	// Remediate attempts to fix the problem.
	// Returns an error if remediation fails or is not allowed (cooldown, rate limit, etc.).
	Remediate(ctx context.Context, problem Problem) error

	// GetCooldown returns the minimum time between remediation attempts for this remediator.
	GetCooldown() time.Duration
}

type RetryConfig struct {
	MaxAttempts int `json:"maxAttempts,omitempty" yaml:"maxAttempts,omitempty"`

	// Base delay between retries (stored as string)
	BaseDelayString string        `json:"baseDelay,omitempty" yaml:"baseDelay,omitempty"`
	BaseDelay       time.Duration `json:"-" yaml:"-"`

	// Maximum delay between retries (stored as string)
	MaxDelayString string        `json:"maxDelay,omitempty" yaml:"maxDelay,omitempty"`
	MaxDelay       time.Duration `json:"-" yaml:"-"`
}

type Status struct {
	// Source identifies the monitor that generated this status.
	Source string

	// Events are notable occurrences detected by the monitor.
	Events []Event

	// Conditions represent the current state of the monitored resource.
	Conditions []Condition

	// Timestamp when this status was generated.
	Timestamp time.Time

	// Metadata holds monitor-specific observability data (metrics, diagnostics, etc.)
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type WebhookEndpoint struct {
	Name string     `json:"name" yaml:"name"`
	URL  string     `json:"url" yaml:"url"`
	Auth AuthConfig `json:"auth,omitempty" yaml:"auth,omitempty"`

	// Per-webhook timeout (overrides default)
	TimeoutString string        `json:"timeout,omitempty" yaml:"timeout,omitempty"`
	Timeout       time.Duration `json:"-" yaml:"-"`

	// Per-webhook retry config (overrides default)
	Retry *RetryConfig `json:"retry,omitempty" yaml:"retry,omitempty"`

	// Per-webhook headers (merged with default headers)
	Headers map[string]string `json:"headers,omitempty" yaml:"headers,omitempty"`

	// Control what gets sent to this webhook
	SendStatus   bool `json:"sendStatus,omitempty" yaml:"sendStatus,omitempty"`
	SendProblems bool `json:"sendProblems,omitempty" yaml:"sendProblems,omitempty"`
}