"""baseline schema (ADR-0004)

Revision ID: 0001_baseline
Revises:
Create Date: 2026-05-26

"""

from collections.abc import Sequence

from alembic import op

revision: str = "0001_baseline"
down_revision: str | None = None
branch_labels: str | Sequence[str] | None = None
depends_on: str | Sequence[str] | None = None


def upgrade() -> None:
    op.execute(
        """
        CREATE TABLE agents (
            agent_id      TEXT PRIMARY KEY,
            hostname      TEXT NOT NULL,
            status        TEXT NOT NULL CHECK (status IN ('alive','stale','dead')) DEFAULT 'alive',
            last_seen_at  TIMESTAMPTZ NOT NULL,
            features      JSONB NOT NULL DEFAULT jsonb_build_object('push', false, 'metrics', false),
            labels        JSONB NOT NULL DEFAULT '{}'::jsonb,
            created_at    TIMESTAMPTZ NOT NULL DEFAULT now()
        );
        """
    )
    op.execute("CREATE INDEX agents_status_idx ON agents (status);")
    op.execute("CREATE INDEX agents_last_seen_idx ON agents (last_seen_at);")

    op.execute(
        """
        CREATE TABLE checks (
            agent_id          TEXT NOT NULL REFERENCES agents(agent_id) ON DELETE CASCADE,
            check_id          TEXT NOT NULL,
            status            TEXT NOT NULL CHECK (status IN ('ok','warning','critical','unknown')),
            exit_code         INTEGER NOT NULL,
            last_observed_at  TIMESTAMPTZ NOT NULL,
            last_event_id     UUID NOT NULL,
            incident_key      TEXT NOT NULL,
            summary           TEXT,
            PRIMARY KEY (agent_id, check_id)
        );
        """
    )
    op.execute("CREATE INDEX checks_status_idx ON checks (status);")

    # events: partitioned by RANGE(received_at). Partition key is part of PK per Postgres.
    # Global idempotency by event_id is enforced via event_ingest_dedup, not this table.
    op.execute(
        """
        CREATE TABLE events (
            event_id            UUID NOT NULL,
            agent_id            TEXT NOT NULL,
            check_id            TEXT NOT NULL,
            observed_at         TIMESTAMPTZ NOT NULL,
            received_at         TIMESTAMPTZ NOT NULL DEFAULT now(),
            status              TEXT NOT NULL CHECK (status IN ('ok','warning','critical','unknown')),
            exit_code           INTEGER NOT NULL,
            duration_ms         INTEGER NOT NULL CHECK (duration_ms >= 0),
            output              TEXT,
            output_truncated    BOOLEAN NOT NULL DEFAULT FALSE,
            notifications_enabled BOOLEAN NOT NULL DEFAULT TRUE,
            incident_key        TEXT NOT NULL,
            PRIMARY KEY (event_id, received_at)
        ) PARTITION BY RANGE (received_at);
        """
    )
    op.execute(
        "CREATE INDEX events_agent_check_observed_idx ON events (agent_id, check_id, observed_at DESC);"
    )
    op.execute("CREATE INDEX events_observed_at_idx ON events (observed_at DESC);")
    op.execute("CREATE INDEX events_received_at_idx ON events (received_at DESC);")

    # Global idempotency table: server enforces event_id uniqueness here, not on the
    # partitioned events table. Pruned by retention TTL (event_dedup_retention_days).
    op.execute(
        """
        CREATE TABLE event_ingest_dedup (
            event_id     UUID PRIMARY KEY,
            received_at  TIMESTAMPTZ NOT NULL DEFAULT now()
        );
        """
    )
    op.execute(
        "CREATE INDEX event_ingest_dedup_received_at_idx ON event_ingest_dedup (received_at);"
    )

    op.execute(
        """
        CREATE TABLE incidents (
            id            UUID PRIMARY KEY,
            incident_key  TEXT NOT NULL,
            agent_id      TEXT NOT NULL,
            check_id      TEXT NOT NULL,
            state         TEXT NOT NULL CHECK (state IN ('open','resolved')),
            severity      TEXT NOT NULL CHECK (severity IN ('warning','critical','unknown')),
            opened_at     TIMESTAMPTZ NOT NULL,
            resolved_at   TIMESTAMPTZ,
            summary       TEXT,
            last_event_id UUID NOT NULL
        );
        """
    )
    op.execute(
        "CREATE UNIQUE INDEX incidents_open_key_idx ON incidents (incident_key) WHERE state = 'open';"
    )
    op.execute("CREATE INDEX incidents_state_opened_idx ON incidents (state, opened_at DESC);")

    op.execute(
        """
        CREATE TABLE notification_outbox (
            id              UUID PRIMARY KEY,
            incident_id     UUID NOT NULL REFERENCES incidents(id) ON DELETE CASCADE,
            notifier        TEXT NOT NULL,
            event_type      TEXT NOT NULL CHECK (event_type IN ('firing','resolved')),
            state           TEXT NOT NULL CHECK (state IN ('pending','sending','sent','retry','failed','discarded')),
            attempts        INTEGER NOT NULL DEFAULT 0,
            next_attempt_at TIMESTAMPTZ,
            last_error      TEXT,
            payload         JSONB NOT NULL,
            created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
            updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
        );
        """
    )
    op.execute(
        "CREATE INDEX outbox_pending_idx ON notification_outbox (state, next_attempt_at) WHERE state IN ('pending','retry');"
    )


def downgrade() -> None:
    op.execute("DROP TABLE IF EXISTS notification_outbox CASCADE;")
    op.execute("DROP TABLE IF EXISTS incidents CASCADE;")
    op.execute("DROP TABLE IF EXISTS event_ingest_dedup CASCADE;")
    op.execute("DROP TABLE IF EXISTS events CASCADE;")
    op.execute("DROP TABLE IF EXISTS checks CASCADE;")
    op.execute("DROP TABLE IF EXISTS agents CASCADE;")