"""Schedule models and file store: revisions, lifecycle, history (T07)."""

from __future__ import annotations

from datetime import UTC, datetime
from pathlib import Path

import pytest
from pydantic import ValidationError

from wf_scheduling.models import (
    CronTrigger,
    OccurrenceRecord,
    PendingCandidate,
    Schedule,
)
from wf_scheduling.store import (
    FileScheduleStore,
    ScheduleExistsError,
    StaleScheduleRevisionError,
)


def _schedule(sid: str = "sched-1", **over: object) -> Schedule:
    now = datetime(2026, 9, 8, 12, 0, tzinfo=UTC)
    base: dict[str, object] = {
        "id": sid,
        "deployment_id": "dep-1",
        "trigger": {"kind": "cron", "expression": "0 * * * *", "timezone": "UTC"},
        "input_bindings": [],
        "created_at": now.isoformat(),
        "updated_at": now.isoformat(),
    }
    base.update(over)
    return Schedule.model_validate(base)


def test_schedule_defaults_match_settled_policies() -> None:
    sched = _schedule()
    assert sched.overlap == "skip"
    assert sched.misfire == "skip"
    assert sched.lateness_allowance_s == 60.0
    assert sched.revision == 1
    assert not sched.paused and not sched.deleted and not sched.exhausted
    assert sched.enabled


def test_cron_trigger_and_lateness_validation() -> None:
    assert (
        CronTrigger.model_validate(
            {"kind": "cron", "expression": "* * * * *", "timezone": "UTC"}
        ).timezone
        == "UTC"
    )
    with pytest.raises(ValidationError):
        _schedule(lateness_allowance_s=-1.0)
    with pytest.raises(ValidationError):
        _schedule(lateness_allowance_s=float("inf"))
    with pytest.raises(ValidationError):
        Schedule.model_validate(
            {
                "id": "s",
                "deployment_id": "d",
                "trigger": {"kind": "oneshot", "at": "2026-09-08T12:00:00"},
                "input_bindings": [],
                "created_at": "2026-09-08T12:00:00+00:00",
                "updated_at": "2026-09-08T12:00:00+00:00",
            }
        )


def test_parallel_requires_positive_max_active() -> None:
    with pytest.raises(ValidationError):
        _schedule(overlap="parallel", max_active_runs=0)


def test_create_get_list_and_id_never_reused(tmp_path: Path) -> None:
    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    store.create_schedule(_schedule("b"))
    assert [s.id for s in store.list_schedules()] == ["a", "b"]
    with pytest.raises(ScheduleExistsError):
        store.create_schedule(_schedule("a"))
    # Delete clears future admission but keeps history; id stays taken.
    doomed = store.get_schedule("a")
    doomed.deleted = True
    store.save_schedule(doomed)
    assert [s.id for s in store.list_schedules()] == ["b"]
    assert [s.id for s in store.list_schedules(include_deleted=True)] == ["a", "b"]
    with pytest.raises(ScheduleExistsError):
        store.create_schedule(_schedule("a"))


def test_stale_revision_edits_rejected(tmp_path: Path) -> None:
    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    current = store.get_schedule("a")
    updated = current.model_copy(update={"revision": 2, "paused": True})
    store.update_schedule(updated, expected_revision=1)
    assert store.get_schedule("a").revision == 2
    with pytest.raises(StaleScheduleRevisionError):
        store.update_schedule(updated, expected_revision=1)


def test_pause_and_disable_exclude_interval_no_backfill(tmp_path: Path) -> None:
    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    now = datetime(2026, 9, 8, 12, 30, tzinfo=UTC)
    sched = store.get_schedule("a")
    # Pause clears the pending candidate and advances the watermark; resume
    # starts from the next future instant (poll semantics tested in T08).
    store.save_candidate(
        PendingCandidate(
            schedule_id="a",
            intended_at=datetime(2026, 9, 8, 12, 0, tzinfo=UTC),
            revision=sched.revision,
        ),
        schedule_id="a",
    )
    paused = sched.model_copy(update={"paused": True, "updated_at": now})
    store.save_schedule(paused)
    store.save_candidate(None, schedule_id="a")
    store.save_consumed("a", now)
    assert store.get_candidate("a") is None
    assert store.get_consumed("a") == now


def test_candidate_is_at_most_one(tmp_path: Path) -> None:
    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    first = PendingCandidate(
        schedule_id="a",
        intended_at=datetime(2026, 9, 8, 12, 0, tzinfo=UTC),
        revision=1,
    )
    second = PendingCandidate(
        schedule_id="a",
        intended_at=datetime(2026, 9, 8, 13, 0, tzinfo=UTC),
        revision=1,
    )
    store.save_candidate(first, schedule_id="a")
    store.save_candidate(second, schedule_id="a")
    candidate = store.get_candidate("a")
    assert candidate is not None
    assert candidate.intended_at == datetime(2026, 9, 8, 13, 0, tzinfo=UTC)


def test_history_pagination_over_resolved_utc(tmp_path: Path) -> None:
    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    for hour in (12, 13, 14):
        store.append_history(
            OccurrenceRecord(
                schedule_id="a",
                occurrence_id=f"a|2026-09-08T{hour:02d}:00:00+00:00",
                kind="admitted",
                resolved_at=datetime(2026, 9, 8, hour, 0, tzinfo=UTC),
                run_id=f"run-{hour}",
                revision=1,
                created_at=datetime(2026, 9, 8, hour, 0, tzinfo=UTC),
            )
        )
    page = store.list_occurrences("a", limit=2)
    assert page["total"] == 3
    next_cursor = page["next_cursor"]
    assert isinstance(next_cursor, str)
    assert "|" in next_cursor
    assert len(page["occurrences"]) == 2  # type: ignore[arg-type]
    second = store.list_occurrences(
        "a",
        cursor=next_cursor,
        limit=2,  # type: ignore[arg-type]
    )
    assert second["next_cursor"] is None
    assert len(second["occurrences"]) == 1  # type: ignore[arg-type]
    # Legacy integer offsets remain accepted.
    legacy = store.list_occurrences("a", cursor="2", limit=2)
    assert len(legacy["occurrences"]) == 1  # type: ignore[arg-type]


def test_inspection_payload_carries_contract_fields(tmp_path: Path) -> None:
    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    store.append_history(
        OccurrenceRecord(
            schedule_id="a",
            occurrence_id="a|2026-09-08T12:00:00+00:00",
            kind="skipped-overlap",
            resolved_at=datetime(2026, 9, 8, 12, 0, tzinfo=UTC),
            revision=2,
            reason="active=['run-1']",
            admitted_at=None,
            started_at=None,
            created_at=datetime(2026, 9, 8, 12, 0, tzinfo=UTC),
        )
    )
    page = store.list_occurrences("a", limit=10)
    row = page["occurrences"][0]  # type: ignore[index]
    assert row["resolved_at"] is not None
    assert row["revision"] == 2
    assert row["reason"] == "active=['run-1']"


def _tied_entry(
    kind: str,
    checkpoint_id: str | None,
    created_minute: int,
) -> OccurrenceRecord:
    """One history entry for the shared 12:00 occurrence of schedule a."""
    return OccurrenceRecord(
        schedule_id="a",
        occurrence_id="a|2026-09-08T12:00:00+00:00",
        kind=kind,  # type: ignore[arg-type]
        resolved_at=datetime(2026, 9, 8, 12, 0, tzinfo=UTC),
        run_id="run-1",
        revision=1,
        checkpoint_id=checkpoint_id,
        created_at=datetime(2026, 9, 8, 12, created_minute, tzinfo=UTC),
    )


def _traverse(store: FileScheduleStore, limit: int) -> list[dict]:
    """Walk every page to the end, returning all rows in visit order."""
    rows: list[dict] = []
    cursor: str | None = None
    for _ in range(1000):
        page = store.list_occurrences("a", cursor=cursor, limit=limit)
        rows.extend(page["occurrences"])  # type: ignore[arg-type]
        cursor = page["next_cursor"]  # type: ignore[assignment]
        if cursor is None:
            assert page["total"] == len(rows)
            return rows
    raise AssertionError(f"pagination did not terminate; visited {len(rows)} rows")


def test_history_pagination_visits_every_tied_entry_once(tmp_path: Path) -> None:
    """Admission + repeated interruptions + completion share one cursor tie.

    Every stored entry must appear exactly once across small-page
    traversal (B4): the cursor carries the entry ordinal, not just the
    shared ``(resolved_at, occurrence_id)`` tie.
    """
    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    store.append_history(_tied_entry("admitted", None, 0))
    store.append_history(_tied_entry("interrupted", "run-1.000001", 5))
    store.append_history(_tied_entry("interrupted", "run-1.000002", 9))
    store.append_history(_tied_entry("completed", "run-1.000003", 14))

    rows = _traverse(store, limit=1)
    assert [(row["kind"], row["checkpoint_id"]) for row in rows] == [
        ("admitted", None),
        ("interrupted", "run-1.000001"),
        ("interrupted", "run-1.000002"),
        ("completed", "run-1.000003"),
    ]
    first = store.list_occurrences("a", limit=1)
    assert first["next_cursor"] is not None
    assert len(str(first["next_cursor"]).split("|")) >= 3


def test_history_pagination_legacy_rows_keep_file_order(tmp_path: Path) -> None:
    """Rows persisted before the entry ordinal order by file position.

    Real persisted data without ``seq`` must still traverse exactly once;
    pre-ordinal two-part cursors stay accepted and resume after the tied
    group exactly as they did before (no duplicates, no crash).
    """
    import json

    store = FileScheduleStore(tmp_path)
    store.create_schedule(_schedule("a"))
    history_path = tmp_path / "schedules" / "a" / "history.json"
    history_path.parent.mkdir(parents=True, exist_ok=True)
    legacy = [
        _tied_entry("admitted", None, 0).model_dump(mode="json"),
        _tied_entry("interrupted", "run-1.000001", 5).model_dump(mode="json"),
    ]
    for item in legacy:
        del item["seq"]
    history_path.write_text(json.dumps(legacy), encoding="utf-8")

    rows = _traverse(store, limit=1)
    assert [row["kind"] for row in rows] == ["admitted", "interrupted"]

    legacy_cursor = "2026-09-08T12:00:00+00:00|a|2026-09-08T12:00:00+00:00"
    resumed = store.list_occurrences("a", cursor=legacy_cursor, limit=1)
    assert resumed["occurrences"] == []
    assert resumed["next_cursor"] is None
    with pytest.raises(ValueError):
        store.list_occurrences("a", cursor="a|b|c|d", limit=1)