from __future__ import annotations

from typing import Any

import yaml
from jsonschema import Draft202012Validator
from jsonschema.exceptions import SchemaError
from sqlalchemy import select
from sqlalchemy.orm import Session

from ..freshness import REQUIRED_FRONTMATTER
from ..validation import (
    PRIVATE_KEY_BLOCK_RE,
    SAFE_SECRET_REFERENCE_RE,
    SECRET_ASSIGNMENT_RE,
)
from .db import Database
from .db_repositories import latest_doc_rows
from .models import InventoryItem, InventoryType, JsonSchema


def _issue(path: str, code: str, message: str) -> dict[str, str]:
    return {
        "path": path,
        "severity": "error",
        "code": code,
        "message": message,
    }


def validate_database(database: Database) -> dict[str, object]:
    with database.session() as session:
        return validate_session(session)


def validate_session(session: Session) -> dict[str, object]:
    issues: list[dict[str, str]] = []
    issues.extend(_validate_schemas(session))
    issues.extend(_validate_documents(session))
    issues.extend(_validate_inventory(session))
    return {
        "status": "ok" if not issues else "issues",
        "issue_count": len(issues),
        "issues": issues,
    }


def _validate_schemas(session: Session) -> list[dict[str, str]]:
    issues: list[dict[str, str]] = []
    for schema in session.scalars(select(JsonSchema)).all():
        try:
            Draft202012Validator.check_schema(schema.body)
        except SchemaError as exc:
            issues.append(
                _issue(f"schemas/{schema.name}", "invalid-json-schema", exc.message)
            )
    return issues


def _validate_documents(session: Session) -> list[dict[str, str]]:
    issues: list[dict[str, str]] = []
    for document, version in session.execute(latest_doc_rows(session)).all():
        slug = document.slug
        if slug == "README.md" or slug.startswith("server/"):
            continue

        frontmatter = version.frontmatter or {}
        if not frontmatter:
            issues.append(
                _issue(slug, "missing-frontmatter", "Markdown document is missing frontmatter")
            )
            continue

        missing = sorted(REQUIRED_FRONTMATTER - set(frontmatter))
        if missing:
            issues.append(
                _issue(
                    slug,
                    "missing-frontmatter-fields",
                    "Missing frontmatter fields: " + ", ".join(missing),
                )
            )

        _scan_text(slug, version.raw, issues)
    return issues


def _validate_inventory(session: Session) -> list[dict[str, str]]:
    issues: list[dict[str, str]] = []
    schemas = {schema.id: schema for schema in session.scalars(select(JsonSchema)).all()}

    for inventory_type in session.scalars(
        select(InventoryType).order_by(InventoryType.name)
    ).all():
        path = f"40-inventory/{inventory_type.name}.yml"
        items = session.scalars(
            select(InventoryItem)
            .where(
                InventoryItem.type == inventory_type.name,
                InventoryItem.deleted_at.is_(None),
            )
            .order_by(InventoryItem.position, InventoryItem.item_id)
        ).all()
        data = [dict(item.data or {}) for item in items]

        schema = schemas.get(inventory_type.schema_id) if inventory_type.schema_id else None
        if schema is not None:
            validator = Draft202012Validator(schema.body)
            for error in sorted(validator.iter_errors(data), key=lambda item: list(item.path)):
                issues.append(
                    _issue(
                        path,
                        "json-schema-validation-error",
                        f"{_format_json_path(error.path)}: {error.message}",
                    )
                )

        for item in items:
            text = yaml.safe_dump(item.data or {}, sort_keys=False, allow_unicode=True)
            _scan_text(path, text, issues)

    return issues


def _scan_text(path: str, text: str, issues: list[dict[str, str]]) -> None:
    if PRIVATE_KEY_BLOCK_RE.search(text):
        issues.append(
            _issue(path, "possible-secret", "File contains a private key block marker")
        )

    for line_number, line in enumerate(text.splitlines(), start=1):
        match = SECRET_ASSIGNMENT_RE.search(line)
        if not match:
            continue
        value = match.group("value").strip().strip("\"'")
        if not value or SAFE_SECRET_REFERENCE_RE.search(value):
            continue
        issues.append(
            _issue(
                path,
                "possible-secret",
                f"Possible raw secret assignment at line {line_number}",
            )
        )


def _format_json_path(path: Any) -> str:
    parts = list(path)
    if not parts:
        return "$"
    formatted = "$"
    for part in parts:
        if isinstance(part, int):
            formatted += f"[{part}]"
        else:
            formatted += f".{part}"
    return formatted
