#!/usr/bin/env python3
"""Tests for leaderboard watcher — first_seen tracking."""

import json
import sys
import tempfile
import unittest
from datetime import datetime, timezone
from pathlib import Path
from unittest.mock import patch

# Make watch.py importable without executing main()
sys.path.insert(0, str(Path(__file__).parent))
import watch

NOW = datetime(2026, 4, 30, 12, 0, 0, tzinfo=timezone.utc)
NOW_ISO = "2026-04-30T12:00:00+00:00"


class TestMigrateSeen(unittest.TestCase):
    def test_list_migrates_to_dict_with_none_timestamps(self):
        old = ["modelA", "modelB"]
        result = watch.migrate_seen(old)
        self.assertEqual(result, {"modelA": None, "modelB": None})

    def test_dict_is_returned_unchanged(self):
        existing = {"modelA": "2026-01-01T00:00:00+00:00", "modelB": None}
        result = watch.migrate_seen(existing)
        self.assertEqual(result, existing)

    def test_empty_list_migrates_to_empty_dict(self):
        self.assertEqual(watch.migrate_seen([]), {})

    def test_empty_dict_returned_unchanged(self):
        self.assertEqual(watch.migrate_seen({}), {})


class TestDiffModels(unittest.TestCase):
    def test_new_models_get_current_timestamp(self):
        seen = {"old-model": "2026-01-01T00:00:00+00:00"}
        current = ["old-model", "new-model"]
        new_ids, updated_seen = watch.diff_models(seen, current, NOW)
        self.assertEqual(new_ids, ["new-model"])
        self.assertEqual(updated_seen["new-model"], NOW_ISO)

    def test_existing_models_keep_their_timestamp(self):
        original_ts = "2026-01-01T00:00:00+00:00"
        seen = {"old-model": original_ts}
        current = ["old-model"]
        _, updated_seen = watch.diff_models(seen, current, NOW)
        self.assertEqual(updated_seen["old-model"], original_ts)

    def test_existing_model_with_none_timestamp_stays_none(self):
        seen = {"old-model": None}
        current = ["old-model"]
        _, updated_seen = watch.diff_models(seen, current, NOW)
        self.assertIsNone(updated_seen["old-model"])

    def test_no_new_models_returns_empty_list(self):
        seen = {"a": NOW_ISO, "b": NOW_ISO}
        current = ["a", "b"]
        new_ids, _ = watch.diff_models(seen, current, NOW)
        self.assertEqual(new_ids, [])

    def test_all_models_new_when_seen_is_empty(self):
        current = ["x", "y"]
        new_ids, updated_seen = watch.diff_models({}, current, NOW)
        self.assertEqual(sorted(new_ids), ["x", "y"])
        self.assertEqual(updated_seen["x"], NOW_ISO)
        self.assertEqual(updated_seen["y"], NOW_ISO)

    def test_models_removed_from_leaderboard_are_retained_in_seen(self):
        seen = {"gone": "2026-01-01T00:00:00+00:00", "still-here": "2026-01-01T00:00:00+00:00"}
        current = ["still-here"]
        _, updated_seen = watch.diff_models(seen, current, NOW)
        self.assertIn("gone", updated_seen)
        self.assertIn("still-here", updated_seen)


class TestStateRoundtrip(unittest.TestCase):
    def test_state_saved_and_loaded_preserves_first_seen(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = Path(tmp) / "state.json"
            data = {
                "some/dataset": {
                    "seen": {"modelA": NOW_ISO, "modelB": None},
                    "last_checked": NOW_ISO,
                    "count": 2,
                }
            }
            watch.save_json(path, data)
            loaded = watch.load_json(path, {})
            self.assertEqual(loaded["some/dataset"]["seen"]["modelA"], NOW_ISO)
            self.assertIsNone(loaded["some/dataset"]["seen"]["modelB"])

    def test_old_state_with_list_seen_is_migrated_on_load(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = Path(tmp) / "state.json"
            old_state = {
                "some/dataset": {
                    "seen": ["modelA", "modelB"],
                    "last_checked": "2026-04-29T00:00:00+00:00",
                    "count": 2,
                }
            }
            path.write_text(json.dumps(old_state))
            loaded = watch.load_json(path, {})
            # Migration happens in run_once, not load_json — test the migration utility
            ds_state = loaded["some/dataset"]
            migrated = watch.migrate_seen(ds_state["seen"])
            self.assertIsInstance(migrated, dict)
            self.assertIsNone(migrated["modelA"])
            self.assertIsNone(migrated["modelB"])


if __name__ == "__main__":
    unittest.main()