"""FastAPI app for the search evaluation UI (static frontend + JSON APIs)."""

from __future__ import annotations

from pathlib import Path
from typing import Any, Dict

from fastapi import FastAPI, HTTPException
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles

from .api_models import BatchEvalRequest, SearchEvalRequest
from .constants import DEFAULT_QUERY_FILE
from .datasets import list_registered_datasets, resolve_dataset
from .framework import SearchEvaluationFramework

_STATIC_DIR = Path(__file__).resolve().parent / "static"


def create_web_app(framework: SearchEvaluationFramework, initial_dataset_id: str | None = None) -> FastAPI:
    app = FastAPI(title="Search Evaluation UI", version="1.0.0")
    current_dataset_id = initial_dataset_id or "core_queries"

    app.mount(
        "/static",
        StaticFiles(directory=str(_STATIC_DIR)),
        name="static",
    )

    index_path = _STATIC_DIR / "index.html"

    @app.get("/", response_class=HTMLResponse)
    def home() -> str:
        return index_path.read_text(encoding="utf-8")

    @app.get("/api/datasets")
    def api_datasets() -> Dict[str, Any]:
        stats_by_query = {item["query"]: item for item in framework.store.list_query_label_stats(framework.tenant_id)}
        datasets = []
        for item in list_registered_datasets(enabled_only=True):
            snapshot = resolve_dataset(dataset_id=item.dataset_id, tenant_id=framework.tenant_id)
            labeled_queries = sum(1 for query in snapshot.queries if (stats_by_query.get(query) or {}).get("total", 0) > 0)
            datasets.append(
                {
                    **snapshot.summary(),
                    "coverage_summary": {
                        "labeled_queries": labeled_queries,
                        "coverage_ratio": (labeled_queries / snapshot.query_count) if snapshot.query_count else 0.0,
                    },
                }
            )
        return {"datasets": datasets, "current_dataset_id": current_dataset_id}

    @app.get("/api/datasets/{dataset_id}/queries")
    def api_dataset_queries(dataset_id: str) -> Dict[str, Any]:
        dataset = resolve_dataset(dataset_id=dataset_id, tenant_id=framework.tenant_id, require_enabled=True)
        return {"dataset": dataset.summary(), "queries": list(dataset.queries)}

    @app.get("/api/queries")
    def api_queries(dataset_id: str | None = None) -> Dict[str, Any]:
        dataset = resolve_dataset(dataset_id=dataset_id or current_dataset_id, tenant_id=framework.tenant_id)
        return {"dataset": dataset.summary(), "queries": list(dataset.queries)}

    @app.post("/api/search-eval")
    def api_search_eval(request: SearchEvalRequest) -> Dict[str, Any]:
        dataset = resolve_dataset(
            dataset_id=request.dataset_id or current_dataset_id,
            tenant_id=framework.tenant_id,
            language=request.language,
        )
        return framework.evaluate_live_query(
            query=request.query,
            top_k=request.top_k,
            auto_annotate=request.auto_annotate,
            language=dataset.language,
            dataset=dataset,
        )

    @app.post("/api/batch-eval")
    def api_batch_eval(request: BatchEvalRequest) -> Dict[str, Any]:
        dataset = resolve_dataset(
            dataset_id=request.dataset_id or current_dataset_id,
            tenant_id=framework.tenant_id,
            language=request.language,
        )
        queries = request.queries or list(dataset.queries)
        if not queries:
            raise HTTPException(status_code=400, detail="No queries provided")
        return framework.batch_evaluate(
            queries=queries,
            dataset=dataset,
            top_k=request.top_k,
            auto_annotate=request.auto_annotate,
            language=dataset.language,
            force_refresh_labels=request.force_refresh_labels,
        )

    @app.get("/api/history")
    def api_history(dataset_id: str | None = None, limit: int = 20) -> Dict[str, Any]:
        effective_dataset_id = dataset_id or current_dataset_id
        return {
            "history": framework.store.list_batch_runs(limit=limit, dataset_id=effective_dataset_id),
            "dataset_id": effective_dataset_id,
        }

    @app.get("/api/history/{batch_id}/report")
    def api_history_report(batch_id: str) -> Dict[str, Any]:
        row = framework.store.get_batch_run(batch_id)
        if row is None:
            raise HTTPException(status_code=404, detail="Unknown batch_id")
        report_path = Path(row["report_markdown_path"]).resolve()
        root = framework.artifact_root.resolve()
        try:
            report_path.relative_to(root)
        except ValueError:
            raise HTTPException(status_code=403, detail="Report path is outside artifact root")
        if not report_path.is_file():
            raise HTTPException(status_code=404, detail="Report file not found")
        return {
            "batch_id": row["batch_id"],
            "created_at": row["created_at"],
            "tenant_id": row["tenant_id"],
            "dataset": row["metadata"].get("dataset") or {},
            "report_markdown_path": str(report_path),
            "markdown": report_path.read_text(encoding="utf-8"),
        }

    return app