alert

type Acknowledgment struct {
	By string
	At time.Time
}

type Alert struct {
	ID             string     `json:"id"`
	Source         string     `json:"source"`
	AlertType      string     `json:"alert_type"`
	Severity       string     `json:"severity"`
	Status         string     `json:"status"`
	Message        string     `json:"message"`
	EntityType     string     `json:"entity_type"`
	EntityID       string     `json:"entity_id"`
	EntityName     string     `json:"entity_name"`
	Details        string     `json:"details"`
	ResolvedByID   *string    `json:"resolved_by_id"`
	FiredAt        time.Time  `json:"fired_at"`
	ResolvedAt     *time.Time `json:"resolved_at"`
	AcknowledgedAt *time.Time `json:"acknowledged_at,omitempty"`
	AcknowledgedBy string     `json:"acknowledged_by,omitempty"`
	EscalatedAt    *time.Time `json:"escalated_at,omitempty"`
	CreatedAt      time.Time  `json:"created_at"`
}

type AlertStore interface {
	InsertAlert(ctx context.Context, a *Alert) (string, error)
	GetAlert(ctx context.Context, id string) (*Alert, error)
	ListAlerts(ctx context.Context, opts ListAlertsOpts) ([]*Alert, error)
	UpdateAlertStatus(ctx context.Context, id string, status string, resolvedAt *time.Time, resolvedByID *string) error
	// UpdateAlertOnEscalation refreshes a live alert to the latest event:
	// severity, message AND entity name/details, so an escalation never leaves a
	// record mixing two events' fields.
	UpdateAlertOnEscalation(ctx context.Context, id, severity, message, entityName, details string) error
	GetActiveAlert(ctx context.Context, source, alertType, entityType string, entityID string) (*Alert, error)
	ListActiveAlerts(ctx context.Context) ([]*Alert, error)
	DeleteAlertsOlderThan(ctx context.Context, before time.Time) (int64, error)
	AcknowledgeAlert(ctx context.Context, id string, by string, at time.Time) error
	SetEscalatedAt(ctx context.Context, id string, at time.Time) error
	ListUnacknowledgedActiveAlerts(ctx context.Context) ([]*Alert, error)
}

type AlertTrigger struct {
	ID               string    `json:"id"`
	Name             string    `json:"name"`
	FilterSeverities string    `json:"filter_severities"`
	FilterSources    string    `json:"filter_sources"`
	FilterScopes     string    `json:"filter_scopes"`
	FilterTags       string    `json:"filter_tags"`
	Enabled          bool      `json:"enabled"`
	NotifyOnResolve  bool      `json:"notify_on_resolve"`
	ChannelIDs       []string  `json:"channel_ids"`
	CreatedAt        time.Time `json:"created_at"`
	UpdatedAt        time.Time `json:"updated_at"`
}

type ChannelStore interface {
	InsertChannel(ctx context.Context, ch *NotificationChannel) (string, error)
	GetChannel(ctx context.Context, id string) (*NotificationChannel, error)
	ListChannels(ctx context.Context) ([]*NotificationChannel, error)
	UpdateChannel(ctx context.Context, ch *NotificationChannel) error
	DeleteChannel(ctx context.Context, id string) error
	GetChannelHealth(ctx context.Context, channelID string) (string, error)

	InsertDelivery(ctx context.Context, d *NotificationDelivery) (string, error)
	UpdateDelivery(ctx context.Context, d *NotificationDelivery) error
	ListDeliveriesByAlert(ctx context.Context, alertID string) ([]*NotificationDelivery, error)
}

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

type EndpointAlert struct {
	EndpointID    string
	ContainerName string
	Target        string
	Type          string // "alert" or "recovery"
	NewAlertState endpoint.AlertState
	Failures      int
	Successes     int
	Threshold     int
	LastError     string
	Timestamp     time.Time
}

type EndpointAlertDetector struct{}

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

type EngineDeps struct {
	AlertStore   AlertStore     // required
	ChannelStore ChannelStore   // required
	TriggerStore TriggerStore   // required
	SilenceStore SilenceStore   // required
	Logger       *slog.Logger   // required
	Notifier     *Notifier      // optional — nil-safe
	Broadcaster  SSEBroadcaster // optional — nil-safe
}

type EntityRouter interface {
	Route(ctx context.Context, entityType string, entityID string, severity string) ([]string, error)
}

type Escalator interface {
	EvaluateCycle(ctx context.Context) error
	OnAlertCreated(ctx context.Context, a *Alert) error
	OnAlertAcknowledged(ctx context.Context, alertID string, ack Acknowledgment) error
	OnAlertResolved(ctx context.Context, alertID string, resolvedAt time.Time) error
	OnEditionDowngraded(ctx context.Context) error
}

type Event struct {
	Source     string         // "container", "endpoint", "heartbeat", "certificate", "resource"
	AlertType  string         // source-specific type
	Severity   string         // "critical", "warning", "info"
	IsRecover  bool           // true if this is a recovery event
	Message    string         // human-readable description
	EntityType string         // "container", "endpoint", "heartbeat", "certificate"
	EntityID   string         // UUID of the referenced entity in its source table
	EntityName string         // display name
	Details    map[string]any // source-specific metadata
	Timestamp  time.Time      // when condition was detected
}

type HealthAlert struct {
	ContainerID    string
	ContainerName  string
	PreviousHealth *container.HealthStatus
	NewHealth      container.HealthStatus
	Severity       container.AlertSeverity
	Channels       string
	Timestamp      time.Time
}

type ListAlertsOpts struct {
	Source   string
	Severity string
	Status   string
	Before   *time.Time
	Limit    int
}

type MaintenanceSuppressor interface {
	IsSuppressed(ctx context.Context, source string, entityType string, entityID string) (bool, error)
}

type NotificationChannel struct {
	ID      string `json:"id"`
	Name    string `json:"name"`
	Type    string `json:"type"`
	URL     string `json:"url"`
	Headers string `json:"headers,omitempty"`
	// Secret holds the channel credential (a Telegram bot token, today). It is
	// tagged "-" and not omitempty: omitempty would still serialize a non-empty
	// token, which is exactly the value that must never leave the process.
	Secret string `json:"-"`
	// Config holds non-secret per-type settings as JSON, e.g. {"thread_id":"42"}.
	Config string `json:"config,omitempty"`
	// HasSecret is derived at scan time, never stored. It lets the interface show
	// "token on file" without receiving the token.
	HasSecret bool      `json:"has_secret"`
	Enabled   bool      `json:"enabled"`
	Health    string    `json:"health,omitempty"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type NotificationDelivery struct {
	ID        string    `json:"id"`
	AlertID   string    `json:"alert_id"`
	ChannelID string    `json:"channel_id"`
	Status    string    `json:"status"`
	Attempts  int       `json:"attempts"`
	LastError string    `json:"last_error,omitempty"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type NotificationJob struct {
	Delivery *NotificationDelivery
	Channel  *NotificationChannel
	Alert    *Alert
	// Body, when non-nil, is the pre-rendered request body sent verbatim
	// (used by webhook subscriptions, which dispatch the raw event payload
	// they already marshalled and signed). When nil, the body is formatted
	// from Alert.
	Body []byte
}

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

type RestartAlert struct {
	ContainerID   string
	ContainerName string
	RestartCount  int
	Threshold     int
	Severity      container.AlertSeverity
	Channels      string
	Timestamp     time.Time
	AgentID       string
}

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

type SMTPConfig struct {
	Host     string
	Port     string
	Username string
	Password string
	From     string
}

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

type SSEBroadcaster interface {
	Broadcast(eventType string, data interface{})
}

type SilenceRule struct {
	ID              string     `json:"id"`
	EntityType      string     `json:"entity_type,omitempty"`
	EntityID        *string    `json:"entity_id,omitempty"`
	Source          string     `json:"source,omitempty"`
	Reason          string     `json:"reason,omitempty"`
	StartsAt        time.Time  `json:"starts_at"`
	DurationSeconds int        `json:"duration_seconds"`
	ExpiresAt       time.Time  `json:"expires_at"`
	IsActive        bool       `json:"is_active"`
	CancelledAt     *time.Time `json:"cancelled_at,omitempty"`
	CreatedAt       time.Time  `json:"created_at"`
}

type SilenceStore interface {
	InsertSilenceRule(ctx context.Context, rule *SilenceRule) (string, error)
	ListSilenceRules(ctx context.Context, activeOnly bool) ([]*SilenceRule, error)
	CancelSilenceRule(ctx context.Context, id string) error
	GetActiveSilenceRules(ctx context.Context) ([]*SilenceRule, error)
}

type TelegramConfig struct {
	ThreadID string `json:"thread_id,omitempty"`
}

type TelegramRateLimitError struct {
	RetryAfter time.Duration
	Reason     string
}

type TriggerStore interface {
	InsertTrigger(ctx context.Context, t *AlertTrigger) (string, error)
	GetTrigger(ctx context.Context, id string) (*AlertTrigger, error)
	ListTriggers(ctx context.Context) ([]*AlertTrigger, error)
	ListEnabledTriggers(ctx context.Context) ([]*AlertTrigger, error)
	UpdateTrigger(ctx context.Context, t *AlertTrigger) error
	DeleteTrigger(ctx context.Context, id string) error
	SetChannels(ctx context.Context, triggerID string, channelIDs []string) error
	ListChannelsForTrigger(ctx context.Context, triggerID string) ([]string, error)
	ListTriggersForChannel(ctx context.Context, channelID string) ([]*AlertTrigger, error)
}

type WebhookPayload struct {
	Event     string                 `json:"event"`
	Alert     map[string]interface{} `json:"alert"`
	Timestamp string                 `json:"timestamp"`
}