from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import Sequence

from ..config import Settings
from .db import Database, DatabaseError
from .importer import (
    database_counts,
    database_manifest,
    import_file_repository,
    verify_import,
)
from .parity import compare_repositories


def _database_settings(args: argparse.Namespace) -> Settings:
    base = Settings()
    database_url = args.database_url or base.database_url
    if not database_url:
        raise SystemExit(
            "Set GNEXUS_BOOK_DATABASE_URL or pass --database-url "
            "(for example postgresql+psycopg://gmikcon@127.0.0.1:5433/gnexus_book)"
        )
    return Settings(
        repo_root=base.repo_root,
        database_url=database_url,
        storage_backend="db",
    )


def _add_common(parser: argparse.ArgumentParser) -> None:
    parser.add_argument(
        "--database-url",
        default=None,
        help="PostgreSQL URL; defaults to GNEXUS_BOOK_DATABASE_URL",
    )


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="python -m app.storage.cli",
        description="Import and compare the file-backed knowledge base and PostgreSQL.",
    )
    subparsers = parser.add_subparsers(dest="command", required=True)

    import_parser = subparsers.add_parser("import", help="Import the file repository into PostgreSQL")
    _add_common(import_parser)
    import_parser.add_argument("--replace", action="store_true", help="Clear existing data first")
    import_parser.add_argument("--dry-run", action="store_true", help="Count without writing")

    migrate_parser = subparsers.add_parser(
        "migrate",
        help="Import the file repository, validate it and reconcile both backends",
    )
    _add_common(migrate_parser)
    migrate_parser.add_argument(
        "--replace", action="store_true", help="Clear existing data first"
    )
    migrate_parser.add_argument(
        "--manifest",
        default=None,
        help="Write the import, verification and reconciliation report to this path",
    )
    migrate_parser.add_argument(
        "--query",
        action="append",
        default=None,
        help="Search query to compare; repeatable",
    )

    parity_parser = subparsers.add_parser("parity", help="Compare file and database read results")
    _add_common(parity_parser)
    parity_parser.add_argument(
        "--query",
        action="append",
        default=None,
        help="Search query to compare; repeatable",
    )

    counts_parser = subparsers.add_parser("counts", help="Print database row counts")
    _add_common(counts_parser)

    return parser


def main(argv: Sequence[str] | None = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)
    settings = _database_settings(args)
    database = Database.from_settings(settings)

    try:
        if args.command == "import":
            report = import_file_repository(
                settings,
                database,
                replace=args.replace,
                dry_run=args.dry_run,
            )
            print(json.dumps(report.as_dict(), indent=2))
            return 0

        if args.command == "migrate":
            report = import_file_repository(
                settings,
                database,
                replace=args.replace,
            )
            verification = verify_import(settings, database)
            reconciliation = compare_repositories(
                settings, database, queries=args.query
            )
            db_manifest, db_manifest_digest = database_manifest(database)
            payload = {
                "source_revision": verification.get("source_revision"),
                "import": report.as_dict(),
                "verification": verification,
                "reconciliation": reconciliation,
                "database_manifest_digest": db_manifest_digest,
            }
            if args.manifest:
                manifest_path = Path(args.manifest)
                manifest_path.parent.mkdir(parents=True, exist_ok=True)
                manifest_path.write_text(
                    json.dumps(
                        {**payload, "database_manifest": db_manifest},
                        indent=2,
                        ensure_ascii=False,
                    )
                    + "\n",
                    encoding="utf-8",
                )
            print(json.dumps(payload, indent=2, ensure_ascii=False))
            return 0 if verification["ok"] and reconciliation["ok"] else 1

        if args.command == "counts":
            print(json.dumps(database_counts(database), indent=2))
            return 0

        if args.command == "parity":
            result = compare_repositories(settings, database, queries=args.query)
            print(json.dumps(result, indent=2, ensure_ascii=False))
            return 0 if result["ok"] else 1
    except (DatabaseError, ValueError) as exc:
        print(f"error: {exc}")
        return 2

    parser.error(f"unknown command {args.command}")


if __name__ == "__main__":
    raise SystemExit(main())
