network

type CNIConfigResult struct {
	Healthy       bool
	ConfigPath    string
	ConfigFiles   []string
	ValidConfigs  int
	InvalidFiles  []string
	Errors        []string
	PrimaryConfig string
	CNIType       string
}

type CNIHealthChecker interface {
	// CheckHealth performs CNI health validation.
	CheckHealth() *CNIHealthResult
	// CheckConfigFiles validates CNI config files exist and are readable.
	CheckConfigFiles() *CNIConfigResult
	// CheckInterfaces validates expected network interfaces exist.
	CheckInterfaces() *CNIInterfaceResult
}

type CNIHealthConfig struct {
	// Enabled indicates whether CNI health checks are enabled.
	Enabled bool
	// ConfigPath is the path to CNI configuration directory.
	ConfigPath string
	// CheckInterfaces enables interface health checking.
	CheckInterfaces bool
	// ExpectedInterfaces is a list of expected CNI interfaces.
	ExpectedInterfaces []string
}

type CNIHealthResult struct {
	Healthy      bool
	ConfigResult *CNIConfigResult
	IfaceResult  *CNIInterfaceResult
	Issues       []string
}

type CNIInterface struct {
	Name    string
	Type    string // e.g., "calico", "flannel", "weave", "bridge", "veth"
	Up      bool
	MTU     int
	HasIPv4 bool
	HasIPv6 bool
	Addrs   []string
}

type CNIInterfaceResult struct {
	Healthy            bool
	ExpectedInterfaces []string
	FoundInterfaces    []string
	MissingInterfaces  []string
	CNIInterfaces      []CNIInterface
	Errors             []string
}

type CNIMonitor struct {
	*monitors.BaseMonitor
	// contains filtered or unexported fields
}

type CNIMonitorConfig struct {
	// Discovery configuration
	Discovery DiscoveryConfig

	// Connectivity configuration
	Connectivity ConnectivityConfig

	// CNI health check configuration
	CNIHealth CNIHealthConfig
}

type CheckResult struct {
	Timestamp time.Time
	Success   bool
	Latency   time.Duration
}

type ConnectivityConfig struct {
	// PingCount is the number of pings to send per peer.
	PingCount int
	// PingTimeout is the timeout for each ping.
	PingTimeout time.Duration
	// WarningLatency is the latency threshold for warnings.
	WarningLatency time.Duration
	// CriticalLatency is the latency threshold for critical conditions.
	CriticalLatency time.Duration
	// FailureThreshold is consecutive failures before marking peer unreachable.
	FailureThreshold int
	// MinReachablePeers is the percentage of peers that must be reachable.
	MinReachablePeers int
	// ProbeMethod is the connectivity probe method: "http" or "icmp".
	// Empty string means auto-detect based on OverlayTestEnabled.
	ProbeMethod string
	// ProbePort is the HTTP probe port (default 8023).
	ProbePort int
	// ProbePath is the HTTP probe path (default "/healthz").
	ProbePath string
}

type ConnectivityMonitor struct {
	*monitors.BaseMonitor
	// contains filtered or unexported fields
}

type ConnectivityMonitorConfig struct {
	// Endpoints is the list of endpoints to check for connectivity.
	Endpoints []EndpointConfig
	// FailureThreshold is the number of consecutive failures before reporting NetworkUnreachable.
	FailureThreshold int
}

type ConsistencyCheckConfig struct {
	Enabled                bool          `json:"enabled"`
	QueriesPerCheck        int           `json:"queriesPerCheck"`        // Number of rapid queries (default: 5)
	IntervalBetweenQueries time.Duration `json:"intervalBetweenQueries"` // Delay between queries (default: 200ms)
}

type DNSErrorType string

type DNSMonitor struct {

	// BaseMonitor for lifecycle management
	*monitors.BaseMonitor
	// contains filtered or unexported fields
}

type DNSMonitorConfig struct {
	// ClusterDomains are Kubernetes cluster internal domains to test
	ClusterDomains []string `json:"clusterDomains"`

	// ExternalDomains are external domains to test for internet connectivity
	ExternalDomains []string `json:"externalDomains"`

	// CustomQueries are additional custom DNS queries to perform
	CustomQueries []DNSQuery `json:"customQueries"`

	// LatencyThreshold is the maximum acceptable DNS query latency
	LatencyThreshold time.Duration `json:"latencyThreshold"`

	// NameserverCheckEnabled enables checking nameserver reachability
	NameserverCheckEnabled bool `json:"nameserverCheckEnabled"`

	// ResolverPath is the path to the resolver configuration file
	ResolverPath string `json:"resolverPath"`

	// FailureCountThreshold is the number of consecutive failures before reporting NetworkUnreachable
	FailureCountThreshold int `json:"failureCountThreshold"`

	// SuccessRateTracking configures sliding window success rate tracking
	SuccessRateTracking *SuccessRateConfig `json:"successRateTracking"`

	// ConsistencyChecking configures DNS consistency verification via multiple rapid queries
	ConsistencyChecking *ConsistencyCheckConfig `json:"consistencyChecking"`
}

type DNSQuery struct {
	Domain             string
	RecordType         string // Currently only "A" is supported
	TestEachNameserver bool   // Test this domain against each nameserver individually
	ConsistencyCheck   bool   // Enable consistency checking with multiple rapid queries
}

type DiscoveryConfig struct {
	// Method is the discovery method ("kubernetes" or "static").
	Method string
	// Namespace to search for peers (for kubernetes method).
	Namespace string
	// LabelSelector for filtering pods (for kubernetes method).
	LabelSelector string
	// RefreshInterval is how often to refresh the peer list.
	RefreshInterval time.Duration
	// StaticPeers is a list of static peer IPs (for static method).
	StaticPeers []string
	// OverlayTestEnabled enables overlay network testing mode.
	// When enabled, discovers overlay-test pods and pings their overlay IPs
	// instead of node IPs. This provides accurate CNI/overlay network testing.
	OverlayTestEnabled bool
	// OverlayTestLabelSelector is the label selector for overlay test pods.
	OverlayTestLabelSelector string
}

type EndpointConfig struct {
	// Name is a human-readable identifier for this endpoint.
	Name string
	// URL is the endpoint URL to check.
	URL string
	// Method is the HTTP method to use (GET, HEAD, POST, etc.).
	Method string
	// ExpectedStatusCode is the HTTP status code expected for a successful check.
	ExpectedStatusCode int
	// Timeout is the maximum duration for the HTTP request.
	Timeout time.Duration
	// Headers are optional HTTP headers to include in the request.
	Headers map[string]string
	// FollowRedirects determines whether to follow HTTP redirects.
	FollowRedirects bool
}

type EndpointResult struct {
	// Success indicates whether the endpoint check succeeded.
	Success bool
	// StatusCode is the HTTP response status code (0 if request failed).
	StatusCode int
	// ResponseTime is the duration of the HTTP request.
	ResponseTime time.Duration
	// Error contains any error that occurred during the check.
	Error error
	// ErrorType classifies the error (DNS, Connection, HTTP, Timeout, etc.).
	ErrorType string
}

type GatewayMonitor struct {
	*monitors.BaseMonitor
	// contains filtered or unexported fields
}

type GatewayMonitorConfig struct {
	// PingCount is the number of pings to send per check cycle.
	PingCount int
	// PingTimeout is the timeout for each individual ping.
	PingTimeout time.Duration
	// LatencyThreshold is the threshold above which latency is considered high.
	LatencyThreshold time.Duration
	// AutoDetectGateway enables automatic gateway detection from route table.
	AutoDetectGateway bool
	// ManualGateway allows manual specification of gateway IP (overrides auto-detection).
	ManualGateway string
	// FailureCountThreshold is the number of consecutive failures before reporting NetworkUnreachable.
	FailureCountThreshold int
}

type HTTPClient interface {
	// CheckEndpoint performs a connectivity check against the given endpoint.
	CheckEndpoint(ctx context.Context, endpoint EndpointConfig) (*EndpointResult, error)
}

type IPForwardingConfig struct {
	// CheckIPv4 enables checking /proc/sys/net/ipv4/ip_forward.
	CheckIPv4 bool
	// CheckIPv6 enables checking /proc/sys/net/ipv6/conf/all/forwarding.
	CheckIPv6 bool
	// CheckPerInterface enables checking per-interface forwarding settings.
	CheckPerInterface bool
	// Interfaces limits per-interface checks to these specific interfaces.
	// Empty means check all interfaces found via glob.
	Interfaces []string
	// ProcPath is the base path for the proc filesystem.
	// Defaults to "/proc", but can be set to "/host/proc" for containerized deployments.
	ProcPath string
}

type IPForwardingMonitor struct {
	*monitors.BaseMonitor
	// contains filtered or unexported fields
}

type NameserverDomainStatus struct {
	Nameserver   string
	Domain       string
	FailureCount int
	LastSuccess  time.Time
	LastLatency  time.Duration
}

type Peer struct {
	// Name is the pod name.
	Name string
	// NodeName is the Kubernetes node the peer is running on.
	NodeName string
	// NodeIP is the IP address of the node (used for pinging since hostNetwork=true).
	NodeIP string
	// PodIP is the pod IP (same as NodeIP when using hostNetwork).
	PodIP string
	// LastSeen is when this peer was last seen in discovery.
	LastSeen time.Time
}

type PeerDiscovery interface {
	// GetPeers returns the current list of discovered peers.
	GetPeers() []Peer
	// Refresh forces an immediate refresh of the peer list.
	Refresh(ctx context.Context) error
	// Start begins background peer discovery.
	Start(ctx context.Context) error
	// Stop stops background peer discovery.
	Stop()
}

type PeerDiscoveryConfig struct {
	// Namespace to search for peers.
	Namespace string
	// LabelSelector for filtering pods (e.g., "app=node-doctor").
	LabelSelector string
	// RefreshInterval is how often to refresh the peer list.
	RefreshInterval time.Duration
	// SelfNodeName is the name of the current node (to exclude self).
	SelfNodeName string
	// Kubeconfig path (optional, uses in-cluster config if empty).
	Kubeconfig string
}

type PeerStatus struct {
	Peer             Peer
	Reachable        bool
	LastLatency      time.Duration
	AvgLatency       time.Duration
	FailureCount     int
	LastCheck        time.Time
	LastSuccess      time.Time
	ConsecutiveFails int
}

type PingResult struct {
	// Success indicates whether the ping succeeded.
	Success bool
	// RTT is the round-trip time for successful pings.
	RTT time.Duration
	// Error contains the error if the ping failed.
	Error error
}

type Pinger interface {
	// Ping sends connectivity probes to the target IP address.
	// It returns a slice of results, one for each probe attempt.
	Ping(ctx context.Context, target string, count int, timeout time.Duration) ([]PingResult, error)
}

type Resolver interface {
	// LookupHost looks up the given host using the local resolver.
	// It returns a slice of that host's addresses.
	LookupHost(ctx context.Context, host string) ([]string, error)

	// LookupAddr performs a reverse lookup for the given address,
	// returning a list of names mapping to that address.
	LookupAddr(ctx context.Context, addr string) ([]string, error)
}

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

type SuccessRateConfig struct {
	Enabled              bool    `json:"enabled"`
	WindowSize           int     `json:"windowSize"`           // Number of checks to track (default: 10)
	FailureRateThreshold float64 `json:"failureRateThreshold"` // Alert if failure rate exceeds this (default: 0.3 = 30%)
	MinSamplesRequired   int     `json:"minSamplesRequired"`   // Minimum samples before alerting (default: 5)
}