from __future__ import annotations

import json
from typing import Any

from ..config import Settings
from ..docs_repository import DocsRepository
from ..freshness import build_freshness_report
from ..inventory import InventoryRepository
from ..relationships import build_relationships
from ..validation import validate_repository
from .db import Database
from .db_repositories import PostgresDocsRepository, PostgresInventoryRepository
from .freshness import build_freshness_report_db
from .importer import normalize_scalars
from .validation import validate_database

DEFAULT_QUERIES = ("gnexus", "host", "GitBucket")


def _canonical(value: Any) -> str:
    return json.dumps(normalize_scalars(value), sort_keys=True, ensure_ascii=False, default=str)


def _preview(value: Any, limit: int = 400) -> Any:
    text = _canonical(value)
    if len(text) <= limit:
        return value
    return text[:limit] + "..."


def _difference(kind: str, key: str, file_value: Any, db_value: Any) -> dict[str, Any]:
    return {
        "kind": kind,
        "key": key,
        "file": _preview(file_value),
        "db": _preview(db_value),
    }


def _normalized_report(report: dict[str, Any]) -> dict[str, Any]:
    return {
        "status": report.get("status"),
        "issue_count": report.get("issue_count"),
        "document_count": report.get("document_count"),
        "issues": sorted(
            (
                issue.get("path"),
                issue.get("severity"),
                issue.get("code"),
                issue.get("message"),
            )
            for issue in report.get("issues", [])
        ),
    }


def compare_repositories(
    settings: Settings,
    database: Database,
    queries: list[str] | None = None,
) -> dict[str, Any]:
    file_settings = Settings(repo_root=settings.repo_root, storage_backend="file")
    file_docs = DocsRepository(file_settings)
    db_docs = PostgresDocsRepository(database)
    file_inventory = InventoryRepository(file_settings)
    db_inventory = PostgresInventoryRepository(database)

    differences: list[dict[str, Any]] = []

    file_doc_list = file_docs.list_docs()
    db_doc_list = db_docs.list_docs()
    if _canonical(file_doc_list) != _canonical(db_doc_list):
        differences.append(
            _difference("docs.list", "all", file_doc_list, db_doc_list)
        )

    file_paths = [str(doc["path"]) for doc in file_doc_list]
    db_paths = [str(doc["path"]) for doc in db_doc_list]
    if file_paths != db_paths:
        differences.append(
            _difference("docs.paths", "all", file_paths, db_paths)
        )

    for path in sorted(set(file_paths) & set(db_paths)):
        file_doc = file_docs.read_doc(path)
        db_doc = db_docs.read_doc(path)
        for field in ("path", "frontmatter", "body", "raw"):
            if _canonical(file_doc.get(field)) != _canonical(db_doc.get(field)):
                differences.append(
                    _difference(f"docs.read.{field}", path, file_doc.get(field), db_doc.get(field))
                )

    for query in queries or list(DEFAULT_QUERIES):
        file_results = file_docs.search(query)
        db_results = db_docs.search(query)
        if _canonical(file_results) != _canonical(db_results):
            differences.append(
                _difference("docs.search", query, file_results, db_results)
            )

    file_types = file_inventory.list_types()
    db_types = db_inventory.list_types()
    if file_types != db_types:
        differences.append(
            _difference("inventory.types", "all", file_types, db_types)
        )

    for type_name in sorted(set(file_types) & set(db_types)):
        file_parsed = normalize_scalars(file_inventory.read_parsed(type_name))
        db_parsed = normalize_scalars(db_inventory.read_parsed(type_name))
        if _canonical(file_parsed) != _canonical(db_parsed):
            differences.append(
                _difference("inventory.parsed", type_name, file_parsed, db_parsed)
            )

        for item in file_parsed if isinstance(file_parsed, list) else []:
            if not isinstance(item, dict):
                continue
            item_id = item.get("id")
            if not isinstance(item_id, str) or not item_id:
                continue
            file_item = file_inventory.read_item(type_name, item_id)
            db_item = db_inventory.read_item(type_name, item_id)
            if _canonical(file_item) != _canonical(db_item):
                differences.append(
                    _difference(
                        "inventory.item",
                        f"{type_name}/{item_id}",
                        file_item,
                        db_item,
                    )
                )

    file_validation = _normalized_report(validate_repository(file_settings))
    db_validation = _normalized_report(validate_database(database))
    if _canonical(file_validation) != _canonical(db_validation):
        differences.append(
            _difference("validation", "all", file_validation, db_validation)
        )

    file_freshness = _normalized_report(build_freshness_report(file_settings))
    db_freshness = _normalized_report(build_freshness_report_db(database))
    if _canonical(file_freshness) != _canonical(db_freshness):
        differences.append(
            _difference("freshness", "all", file_freshness, db_freshness)
        )

    file_relationships = build_relationships(file_inventory)
    db_relationships = build_relationships(db_inventory)
    if _canonical(file_relationships) != _canonical(db_relationships):
        differences.append(
            _difference(
                "relationships", "all", file_relationships, db_relationships
            )
        )

    return {
        "ok": not differences,
        "queries": list(queries or DEFAULT_QUERIES),
        "difference_count": len(differences),
        "validation": {
            "file": file_validation["status"],
            "database": db_validation["status"],
        },
        "freshness": {
            "file": file_freshness["status"],
            "database": db_freshness["status"],
        },
        "differences": differences,
    }
