"""
Utility module to audit PDF Jinja2 template field coverage against SQLModel classes.
"""
import os
import ast
import re
from typing import Dict, List, Set, Tuple

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
MODELS_DIR = os.path.join(BASE_DIR, "models")
TEMPLATES_DIR = os.path.join(BASE_DIR, "templates")
ROUTES_DIR = os.path.join(BASE_DIR, "routes")


def _is_sqlmodel_class(node: ast.ClassDef) -> bool:
    """Check if an AST class definition inherits from SQLModel."""
    for base in node.bases:
        if isinstance(base, ast.Name) and base.id == "SQLModel":
            return True
        if isinstance(base, ast.Attribute) and base.attr == "SQLModel":
            return True
    return False


def _extract_fields_from_class(node: ast.ClassDef) -> List[str]:
    """Extract annotated variable field names from a class definition."""
    fields = []
    for item in node.body:
        if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
            fields.append(item.target.id)
    return fields


def extract_model_fields() -> Dict[str, List[str]]:
    """Extract model field names by parsing AST of Python files in models directory."""
    models = {}
    if not os.path.exists(MODELS_DIR):
        return models

    for filename in os.listdir(MODELS_DIR):
        if not filename.endswith(".py") or filename.startswith("__"):
            continue
        filepath = os.path.join(MODELS_DIR, filename)
        with open(filepath, "r", encoding="utf-8") as f:
            tree = ast.parse(f.read(), filename=filename)

        for node in ast.walk(tree):
            if isinstance(node, ast.ClassDef) and _is_sqlmodel_class(node):
                models[node.name] = _extract_fields_from_class(node)

    return models


def extract_template_variables(template_name: str) -> Set[str]:
    """Extract Jinja2 template variables from an HTML template file."""
    filepath = os.path.join(TEMPLATES_DIR, template_name)
    if not os.path.exists(filepath):
        return set()

    with open(filepath, "r", encoding="utf-8") as f:
        content = f.read()

    # Find all {{ variable.field }} or {{ field }} references
    vars_found = set(re.findall(r"\{\{\s*([a-zA-Z0-9_\.]+)\s*\}\}", content))
    fields = set()
    for v in vars_found:
        parts = v.split(".")
        fields.add(parts[-1])
    return fields


def audit_pdf_templates() -> List[Dict[str, str]]:
    """Audit HTML templates against extracted model fields."""
    models = extract_model_fields()
    report = []

    for template_name in os.listdir(TEMPLATES_DIR):
        if not template_name.endswith(".html"):
            continue

        used_fields = extract_template_variables(template_name)
        report.append({
            "template": template_name,
            "used_fields_count": str(len(used_fields)),
            "model_count": str(len(models))
        })

    return report


if __name__ == "__main__":
    results = audit_pdf_templates()
    print(f"Audited {len(results)} templates successfully.")
