"""Online persistence and startup recovery, on either AnyIO/database backend."""

import argparse
import json
from datetime import UTC, datetime
from pathlib import Path
from tempfile import TemporaryDirectory

import anyio

from rpkiparrot import Client
from rpkiparrot.config import (
    ClientConfig,
    FreshnessPolicy,
    JsonFileSourceConfig,
    PersistenceConfig,
    SourceGroupConfig,
)
from rpkiparrot.models import PayloadKind
from rpkiparrot.validation import validate_origin


async def main(database: str) -> None:
    with TemporaryDirectory() as folder:
        root = Path(folder)
        path = root / "payload.json"
        path.write_text(
            json.dumps(
                {
                    "metadata": {"generated": int(datetime.now(UTC).timestamp())},
                    "roas": [{"asn": "AS64496", "prefix": "192.0.2.0/24", "maxLength": 24}],
                    "aspas": [],
                }
            )
        )
        configuration = ClientConfig(
            groups=(
                SourceGroupConfig(
                    id="cache",
                    priority=0,
                    sources=(
                        JsonFileSourceConfig(
                            id="file",
                            path=path,
                            format="routinator-json",
                            freshness=FreshnessPolicy(max_age=300),
                        ),
                    ),
                ),
            ),
            persistence=PersistenceConfig(
                backend="sqlite" if database == "sqlite" else "duckdb",
                path=root / "cache.db",
            ),
        )
        async with anyio.create_task_group() as tasks, Client(configuration) as client:
            await tasks.start(client.run)
            snapshot = await client.wait_ready(required=frozenset({PayloadKind.VRP}))
            receipt = await client.flush()
            assert receipt.snapshot_id == snapshot.id
        path.unlink()
        async with Client(configuration) as recovered:
            current = await recovered.get_snapshot()
            assert recovered.get_status().recovered_from == receipt.snapshot_id
            assert current.sources["file"].expires_at == snapshot.sources["file"].expires_at
            assert validate_origin(current, "192.0.2.0/24", 64496).status.value == "valid"
            print("Recovered original valid data before starting source tasks")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--backend", choices=("asyncio", "trio"), default="asyncio")
    parser.add_argument("--database", choices=("sqlite", "duckdb"), default="sqlite")
    options = parser.parse_args()
    anyio.run(main, options.database, backend=options.backend)