"""
FastAPI app and routes: gitweb actions as path operations.
Ported from gitweb/gitweb.perl dispatch and action handlers.
"""
from __future__ import annotations

import mimetypes
import os
import subprocess
import tempfile
import zipfile
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Annotated

import pygit2
from fastapi import FastAPI, File, Form, HTTPException, Query, Request, UploadFile
from fastapi.responses import HTMLResponse, PlainTextResponse, RedirectResponse, Response
from fastapi.staticfiles import StaticFiles

from jinja2 import Template, Environment, PackageLoader

from pygitweb import config
from pygitweb.config import (
    DISTGIT_AUTH,
    EXPORT_OK,
    PROJECTROOT,
    PROJECTS_LIST,
    STRICT_EXPORT,
    check_loadavg,
    configure_gitweb_features,
    evaluate_gitweb_config,
    get_snapshot_fmts,
)
from pygitweb.formatting import age_string, esc_html, sanitize, to_utf8
from pygitweb.git_helpers import (
    get_blob_at_ref_path,
    get_commit_history,
    get_tree_at_ref_path,
    git_get_head_hash,
    git_get_project_description,
    parse_commit,
)
from pygitweb.projects import (
    git_get_projects_list,
    git_get_project_list_from_file,
    git_get_project_owner,
    project_in_list,
)
from pygitweb.validation import (
    check_export_ok,
    is_valid_action,
    is_valid_pathname,
    is_valid_project,
    is_valid_ref_format,
)
from urllib.parse import quote

# Allowed actions (from %actions in gitweb.perl)
ACTIONS = {
    "blame",
    "blame_incremental",
    "blame_data",
    "blobdiff",
    "blobdiff_plain",
    "blob",
    "blob_plain",
    "commitdiff",
    "commitdiff_plain",
    "commit",
    "forks",
    "heads",
    "history",
    "log",
    "patch",
    "patches",
    "remotes",
    "rss",
    "atom",
    "search",
    "search_help",
    "shortlog",
    "summary",
    "tag",
    "tags",
    "tree",
    "snapshot",
    "object",
    "opml",
    "project_list",
    "project_index",
}

app = FastAPI(title="pygitweb", description="FastAPI + Pygit2 Repo Browser")

env = Environment(
    loader=PackageLoader("pygitweb", "templates"),
    # autoescape=True,
    trim_blocks=True,
    lstrip_blocks=True,
)
PREAMBLE = env.get_template("preamble.html")
POSTAMBLE = """</div></div></div><script src="https://cdn.jsdelivr.net/npm/@tabler/core@1.0.0-beta17/dist/js/tabler.min.js"></script></body></html>"""

# Todo handle with nginx route
_static_dir = Path(__file__).parent / "static"
if _static_dir.is_dir():
    app.mount("/static", StaticFiles(directory=str(_static_dir)), name="static")


def _project_in_list(project: str) -> bool:
    lst = git_get_projects_list(
        filter_path="",
        paranoid=STRICT_EXPORT,
        export_ok=EXPORT_OK,
    )
    return any(p.get("path") == project for p in lst)


def _get_project_config(project: str, key: str):
    from pygitweb.git_helpers import git_get_project_config
    return git_get_project_config(project, key)


_auth_provider = None


def _get_auth_provider():
    """Return auth provider instance if DISTGIT_AUTH is set; None if auth disabled."""
    global _auth_provider
    if DISTGIT_AUTH == "None":
        return None
    if _auth_provider is not None:
        return _auth_provider
    try:
        mod_name, _, cls_name = DISTGIT_AUTH.rpartition(".")
        mod = __import__(mod_name, fromlist=[cls_name])
        cls = getattr(mod, cls_name)
        # RootAuthProvider accepts admin_user, admin_password, session_timeout from env
        admin_user = DISTGIT_ADMIN_USER.encode("utf-8") or None
        admin_password = DISTGIT_ADMIN_PASSWORD.encode("utf-8") or None
        timeout = DISTGIT_SESSION_TIMEOUT
        _auth_provider = cls(
            admin_user=admin_user,
            admin_password=admin_password,
            session_timeout=timeout,
        )
    except Exception:
        _auth_provider = None
    return _auth_provider


def _request_can_add_project(request: Request) -> bool:
    """True if auth is disabled or request has a valid session (header X-Session-Token or param/cookie session)."""
    if DISTGIT_AUTH == "None":
        return True
    provider = _get_auth_provider()
    if provider is None:
        return False
    token = (
        request.headers.get("X-Session-Token")
        or request.query_params.get("session")
        or request.cookies.get("session")
    )
    if not token:
        return False
    return getattr(provider, "validate_session", lambda _: False)(token)


@app.on_event("startup")
def startup():
    evaluate_gitweb_config()
    configure_gitweb_features(
        get_project_config=_get_project_config,
        git_dir=None,
        is_valid_ref_format=is_valid_ref_format,
    )


@app.middleware("http")
async def loadavg_middleware(request: Request, call_next):
    try:
        check_loadavg()
    except RuntimeError as e:
        msg = str(e)
        if msg.startswith("503:"):
            raise HTTPException(status_code=503, detail=msg[4:])
        raise
    return await call_next(request)


def _validate_project(project: str | None) -> str:
    if not project:
        raise HTTPException(status_code=400, detail="Project needed")
    if not is_valid_project(
        project,
        PROJECTROOT,
        EXPORT_OK,
        STRICT_EXPORT,
        _project_in_list,
    ):
        raise HTTPException(status_code=404, detail="No such project")
    return project


# ---------- Routes (no project) ----------


@app.get("/", response_class=HTMLResponse)
def git_project_list(
    request: Request,
    a: Annotated[str | None, Query(alias="a")] = None,
    pf: Annotated[str | None, Query(alias="pf")] = None,
    o: Annotated[str | None, Query(alias="o")] = None,
):
    """Project list page. Port of git_project_list."""
    if a and a != "project_list":
        raise HTTPException(status_code=400, detail="Unknown action")
    if o and o not in ("none", "project", "descr", "owner", "age"):
        raise HTTPException(status_code=400, detail="Unknown order parameter")
    project_filter = pf or ""
    list_ = git_get_projects_list(
        filter_path=project_filter,
        paranoid=STRICT_EXPORT,
        export_ok=EXPORT_OK,
    )
    if not list_:
        raise HTTPException(status_code=404, detail="No projects found")

    # We need better escaping logic here but can wait until we harden the templates
    table = env.get_template("table.html").render(
        cols=["Project", "Description"],
        rows=[
            [f"<a href='/{pr.get('path', "")}'>{pr.get('path', "")}</a>",
            pr.get('descr') or pr.get('path', "")]
             for pr in list_[:50]]
    )
    pre = PREAMBLE.render(title=f'{esc_html(config.SITE_NAME)} - Projects', theme="dark", site_name=config.SITE_NAME)
    return HTMLResponse(f"{pre}<h1>Project List</h1>{table}{POSTAMBLE}")


@app.get("/index", response_class=PlainTextResponse)
def git_project_index(
    pf: Annotated[str | None, Query(alias="pf")] = None,
):
    """Plain text project index (path owner). Port of git_project_index."""
    from urllib.parse import quote_plus
    projects = git_get_projects_list(
        filter_path=pf or "",
        paranoid=STRICT_EXPORT,
        export_ok=EXPORT_OK,
    )
    if not projects:
        raise HTTPException(status_code=404, detail="No projects found")
    lines = []
    for pr in projects:
        path = pr.get("path", "")
        owner = pr.get("owner") or git_get_project_owner(path) or ""
        path_enc = quote_plus(path, safe="/")
        owner_enc = quote_plus(owner, safe="/")
        lines.append(f"{path_enc} {owner_enc}")
    return PlainTextResponse("\n".join(lines), media_type="text/plain; charset=utf-8")


@app.get("/opml", response_class=PlainTextResponse)
def git_opml():
    """OPML feed list. Port of git_opml (stub)."""
    projects = git_get_projects_list(export_ok=EXPORT_OK)
    # Minimal OPML
    lines = ['<?xml version="1.0"?><opml version="1.0"><head><title>Git</title></head><body>']
    for pr in projects[:100]:
        path = pr.get("path", "")
        lines.append(f'<outline text="{esc_html(path)}" />')
    lines.append("</body></opml>")
    return PlainTextResponse("\n".join(lines), media_type="text/xml; charset=utf-8")


# ---------- Add project ----------


@app.get("/projectnamevalid", response_class=HTMLResponse)
def addproject_namevalid(request: Request):
    """Check if project name is valid."""
    project_name = request.query_params.get("name")
    if not project_name:
        raise HTTPException(status_code=400, detail="Param 'name' required")
    if not is_valid_pathname(project_name):
        raise HTTPException(status_code=400, detail="Invalid project name (no path segments)")
    if _project_in_list(project_name):
        raise HTTPException(status_code=409, detail="Project already exists")
    return HTMLResponse(status_code=200, content=f"Project name '{project_name}' is valid")

@app.get("/addproject", response_class=HTMLResponse)
def addproject_page(request: Request):
    """Add project form page."""
    pre = PREAMBLE.render(
        title=f"{config.SITE_NAME} - Add Project",
        theme="dark",
        site_name=config.SITE_NAME,
    )
    tpl = env.get_template("addproject.html")
    body = tpl.render(site_name=config.SITE_NAME)
    return HTMLResponse(status_code=200, content=f"{pre}{body}{POSTAMBLE}")


@app.post("/addproject", response_class=HTMLResponse)
async def addproject_submit(
    request: Request,
    project_name: Annotated[str, Form()] = "",
    pull_from_remote: Annotated[str, Form()] = "",
    perform_maintenance: Annotated[str, Form()] = "off",
    create_task_board: Annotated[str, Form()] = "off",
    repo_zip: UploadFile | None = File(default=None),
):
    """
    Create a new project. Allowed only if project name does not exist,
    and valid session in headers / session param (or auth is disabled).
    """
    if not _request_can_add_project(request):
        raise HTTPException(status_code=401, detail="Authentication required to add projects")

    project_name = (project_name or "").strip()
    if not project_name:
        raise HTTPException(status_code=400, detail="Project name is required")
    if not is_valid_pathname(project_name):
        raise HTTPException(status_code=400, detail="Invalid project name")
    if _project_in_list(project_name):
        raise HTTPException(status_code=409, detail="Project already exists")

    remote_url = (pull_from_remote or "").strip()
    do_maintenance = perform_maintenance.lower() in ("on", "1", "true", "yes")
    do_task_board = create_task_board.lower() in ("on", "1", "true", "yes")

    dest_path = os.path.join(PROJECTROOT, project_name)
    os.makedirs(PROJECTROOT, exist_ok=True)

    try:
        if remote_url and remote_url != "":
            pygit2.clone_repository(remote_url, dest_path, bare=True)
        elif repo_zip and repo_zip.filename and repo_zip.filename.lower().endswith(".zip"):
            with tempfile.TemporaryDirectory() as tmpdir:
                zip_path = os.path.join(tmpdir, "repo.zip")
                content = await repo_zip.read()
                with open(zip_path, "wb") as f:
                    f.write(content)
                with zipfile.ZipFile(zip_path, "r") as zf:
                    zf.extractall(tmpdir)
                # Find .git: either at root or inside a single top-level dir
                repo_root = None
                for name in os.listdir(tmpdir):
                    if name == "repo.zip":
                        continue
                    p = os.path.join(tmpdir, name)
                    if os.path.isdir(p):
                        if os.path.isdir(os.path.join(p, ".git")):
                            repo_root = p
                            break
                        if name == ".git":
                            repo_root = tmpdir
                            break
                if repo_root is None:
                    if os.path.isdir(os.path.join(tmpdir, ".git")):
                        repo_root = tmpdir
                    else:
                        # Single subdir that might be the repo
                        subs = [x for x in os.listdir(tmpdir) if x != "repo.zip" and os.path.isdir(os.path.join(tmpdir, x))]
                        if len(subs) == 1:
                            repo_root = os.path.join(tmpdir, subs[0])
                if repo_root is None or not pygit2.discover_repository(repo_root):
                    raise HTTPException(
                        status_code=400,
                        detail="ZIP must contain a git repository (directory with .git)",
                    )
                pygit2.clone_repository(repo_root, dest_path, bare=True)
        else:
            pygit2.init_repository(dest_path, bare=True)

        if do_maintenance:
            try:
                subprocess.run(
                    [config.GIT, "-C", dest_path, "maintenance", "start"],
                    capture_output=True,
                    timeout=60,
                )
            except (subprocess.SubprocessError, FileNotFoundError):
                pass  # best-effort

        if do_task_board:
            pass  # stub
    except pygit2.GitError as e:
        raise HTTPException(status_code=400, detail=f"Git error: {e}")
    except HTTPException:
        raise
    except OSError as e:
        raise HTTPException(status_code=500, detail=str(e))

    return RedirectResponse(url=f"/{project_name}", status_code=303)


# ---------- Routes (project required) ----------


@app.get("/{project:path}", response_class=HTMLResponse)
def dispatch(
    request: Request,
    project: str,
    a: Annotated[str | None, Query(alias="a")] = None,
    h: Annotated[str | None, Query(alias="h")] = None,
    hb: Annotated[str | None, Query(alias="hb")] = None,
    f: Annotated[str | None, Query(alias="f")] = None,
):
    """
    Dispatch by path: /project -> summary; /project/action/... -> action.
    Port of dispatch + run_request path handling.
    """
    # Normalize project: first path segment that is a valid repo
    segments = [s for s in project.split("/") if s]
    if not segments:
        raise HTTPException(status_code=400, detail="Project needed")
    proj = segments[0]
    _validate_project(proj)
    action = a
    hash_param = h or hb
    file_name = f
    # If no action, infer: hash only -> object type; project only -> summary
    if not action:
        if hash_param and file_name:
            obj_type = _object_type(proj, f"{hash_param}:{file_name}")
            if not obj_type:
                raise HTTPException(status_code=404, detail="File or directory does not exist")
            action = "tree" if obj_type == "tree" else "blob_plain"
        elif hash_param:
            obj_type = _object_type(proj, hash_param)
            if not obj_type:
                raise HTTPException(status_code=404, detail="Object does not exist")
            action = {"commit": "commit", "tree": "tree", "blob": "blob", "tag": "tag"}.get(obj_type, "object")
        else:
            action = "summary"
    if not is_valid_action(action, ACTIONS):
        raise HTTPException(status_code=400, detail="Unknown action")
    if action in ("opml", "project_list", "project_index"):
        raise HTTPException(status_code=400, detail="Project not needed for this action")
    # Route to handler
    if action == "summary":
        return git_summary(proj)
    if action == "forks":
        return git_forks(proj, request)
    if action == "tree":
        return git_tree(proj, hash_param, file_name)
    if action in ("blob", "blob_plain"):
        return git_blob(proj, hash_param, file_name, raw=(action == "blob_plain"))
    if action == "log":
        return git_log(proj, hash_param)
    if action == "shortlog":
        return git_shortlog(proj, hash_param)
    if action == "history":
        return git_history(proj, hash_param, file_name)
    # Stub others with minimal response
    pre = PREAMBLE.render(title=f"{esc_html(action)} - {esc_html(proj)}", theme="dark", site_name=config.SITE_NAME)
    return HTMLResponse(
        f"{pre}<p>Action: {esc_html(action)}</p><p>Project: {esc_html(proj)}</p>{POSTAMBLE}"
    )


def _object_type(project: str, ref: str) -> str | None:
    from pygitweb.git_helpers import git_get_type
    return git_get_type(project, ref)


def git_summary(project: str) -> HTMLResponse:
    """Project summary page. Port of git_summary."""
    descr = git_get_project_description(project) or "none"
    owner = git_get_project_owner(project) or ""
    head = git_get_head_hash(project)
    co = parse_commit(project, head) if head else {}
    head_short = head[:7] if head else ""

    table = env.get_template("table.html").render(
        cols=[],
        rows=[
            ["Description", esc_html(descr)],
            ["Owner", esc_html(owner)],
            [esc_html("HEAD"), f"<a href='/{project}/commit/{head or ''}'>{head_short or 'N/A'}</a>"],
            [esc_html("tree"), f"<a href='/{project}?a=tree&h={head or ''}'>browse</a>"],
        ]
    )
    pre = PREAMBLE.render(title=f"{esc_html(config.SITE_NAME)} - {project}", theme="dark", site_name=config.SITE_NAME)
    return HTMLResponse(f"{pre}<h1>{esc_html(project)}</h1>{table}{POSTAMBLE}")


def _tree_url(project: str, h: str, f: str | None, a: str = "tree") -> str:
    """Build URL for tree or blob: /project?a=a&h=h&f=f with f quoted."""
    q = f"a={a}&h={quote(h, safe='')}"
    if f:
        q += f"&f={quote(f, safe='/')}"
    return f"/{project}?{q}"


def git_blob(project: str, h: str | None, f: str | None, *, raw: bool = False) -> Response:
    """Return blob content when f points to a file. Raw = bytes; else HTML with escaped content."""
    if not f:
        raise HTTPException(status_code=400, detail="File path (f) required")
    if not is_valid_pathname(f):
        raise HTTPException(status_code=400, detail="Invalid path")
    result = get_blob_at_ref_path(project, h, f)
    if not result:
        raise HTTPException(status_code=404, detail="File not found")
    blob, _ = result
    data = blob.data
    if raw:
        media_type, _ = mimetypes.guess_type(f.split("/")[-1])
        if media_type is None:
            try:
                data.decode("utf-8")
                media_type = "text/plain; charset=utf-8"
            except UnicodeDecodeError:
                media_type = "application/octet-stream"
        return Response(content=data, media_type=media_type)
    # HTML view: raw content, escaped for safe display
    text = to_utf8(data) or ""
    body = sanitize(text) or ""
    pre = PREAMBLE.render(title=f"{esc_html(f)} - {esc_html(project)}", theme="dark", site_name=config.SITE_NAME)
    return HTMLResponse(
        f"{pre}<pre class='blob-content'>{body}</pre>{POSTAMBLE}")


def git_tree(project: str, h: str | None, f: str | None) -> HTMLResponse:
    """Tree page: list files and directories; directories link to tree with f=path."""
    if f is not None and not is_valid_pathname(f):
        raise HTTPException(status_code=400, detail="Invalid path")
    result = get_tree_at_ref_path(project, h, f)
    if not result:
        raise HTTPException(status_code=404, detail="Tree or path not found")
    tree, ref_oid = result
    # Breadcrumb: project -> path segments
    base = f"/{project}"
    breadcrumbs = [f'<a href="{base}">{esc_html(project)}</a>']
    if f:
        parts = f.strip("/").split("/")
        for i, seg in enumerate(parts):
            prefix = "/".join(parts[: i + 1])
            breadcrumbs.append(
                f' / <a href="{_tree_url(project, ref_oid, prefix)}">{esc_html(seg)}</a>'
            )
    breadcrumb_html = "".join(breadcrumbs)
    # List entries: dirs first then files, sorted by name
    entries = [(obj.name, obj.type_str, str(obj.id)) for obj in tree]
    dirs = sorted((n, t, o) for n, t, o in entries if t == "tree")
    blobs = sorted((n, t, o) for n, t, o in entries if t == "blob")
    rows = []
    for name, typ, _ in dirs:
        sub_path = f"{f.strip('/')}/{name}".strip("/") if f else name
        link = _tree_url(project, ref_oid, sub_path)
        rows.append(
            [f'<a href="{link}">{esc_html(name)}/</a>', "tree"]
        )
    for name, typ, _ in blobs:
        sub_path = f"{f.strip('/')}/{name}".strip("/") if f else name
        link = _tree_url(project, ref_oid, sub_path, a="blob")
        rows.append(
            [f'<a href="{link}">{esc_html(name)}</a>', "blob"]
        )
    title_path = f" / {f}" if f else ""
    pre = PREAMBLE.render(title=f"{esc_html(project)}{esc_html(title_path)} - Tree", theme="dark", site_name=config.SITE_NAME)
    table = env.get_template("table.html").render(
        cols=["Name", "Type"],
        rows=rows
    )
    return HTMLResponse(
        f"{pre}<p class='breadcrumb'>{breadcrumb_html}</p><h1>Tree{esc_html(title_path)}</h1>{table}{POSTAMBLE}"
    )


def git_forks(project: str, request: Request) -> HTMLResponse:
    """Forks of project. Port of git_forks."""
    filter_path = project.replace(".git", "")
    list_ = git_get_projects_list(filter_path=filter_path, export_ok=EXPORT_OK)
    if not list_:
        raise HTTPException(status_code=404, detail="No forks found")
    list_ = filter_forks_from_projects_list(list_)
    rows = []
    for pr in list_:
        path = pr.get("path", "")
        rows.append(f"<tr><td><a href='/{path}'>{esc_html(path)}</a></td></tr>")
    pre = PREAMBLE.render(title=f"{esc_html(project)} - Forks", theme="dark", site_name=config.SITE_NAME)
    return HTMLResponse(
        f"{pre}<h1>Forks of {esc_html(project)}</h1><table>{"".join(rows)}</table>{POSTAMBLE}"
    )


def _format_date(epoch: int | None, tz_offset: int | None = None) -> str:
    """Format epoch timestamp to readable date string.
    tz_offset is in minutes (as returned by pygit2).
    """
    if epoch is None:
        return ""
    try:
        # Create timezone-aware datetime
        if tz_offset is not None:
            # pygit2 offset is in minutes, convert to seconds for timedelta
            tz = timezone(timedelta(seconds=tz_offset * 60))
        else:
            tz = timezone.utc
        dt = datetime.fromtimestamp(epoch, tz=tz)
        return dt.strftime("%Y-%m-%d %H:%M:%S")
    except (ValueError, OSError):
        return ""


def _format_commit_table_row(project: str, commit: dict[str, Any], short: bool = False) -> str:
    """Format a single commit as a table row."""
    oid = commit.get("oid", "")
    oid_short = oid[:7] if oid else ""
    subject = commit.get("subject", "")
    author = commit.get("author", "")
    author_email = commit.get("author_email", "")
    committer_epoch = commit.get("committer_epoch")
    author_epoch = commit.get("author_epoch")
    
    # Format date
    date_str = _format_date(author_epoch, commit.get("author_tz"))
    age_sec = None
    if author_epoch:
        age_sec = datetime.now(timezone.utc).timestamp() - author_epoch
        age_str = age_string(age_sec) if age_sec > 0 else "right now"
    else:
        age_str = ""
    
    commit_link = f"/{project}?a=commit&h={quote(oid, safe='')}"
    author_display = esc_html(author) or "unknown"
    
    if short:
        # Shortlog: simpler format
        return [
            f'<a href="{commit_link}">{esc_html(oid_short)}</a>',
            esc_html(subject),
            author_display,
            esc_html(age_str)
        ]
    else:
        # Full log: more details
        return [
            f'<a href="{commit_link}">{esc_html(oid_short)}</a>',
            esc_html(subject),
            author_display,
            esc_html(date_str),
            esc_html(age_str)
        ]


def git_log(project: str, h: str | None) -> HTMLResponse:
    """Commit log page. Port of git_log."""
    commits = get_commit_history(project, ref=h, max_count=100)
    if not commits:
        raise HTTPException(status_code=404, detail="No commits found")
    
    rows = []
    for commit in commits:
        rows.append(_format_commit_table_row(project, commit, short=False))
    
    ref_display = h[:7] if h else "HEAD"
    title = f"Log - {esc_html(project)} @ {esc_html(ref_display)}"

    pre = PREAMBLE.render(title=title, theme="dark", site_name=config.SITE_NAME)
    table = env.get_template("table.html").render(
        cols=["Commit", "Subject", "Author", "Date", "Age"],
        rows=rows
    )
    return HTMLResponse(
        f"{pre}<h1>{title}</h1>{table}{POSTAMBLE}"
    )


def git_shortlog(project: str, h: str | None) -> HTMLResponse:
    """Shortlog page. Port of git_shortlog."""
    commits = get_commit_history(project, ref=h, max_count=100)
    if not commits:
        raise HTTPException(status_code=404, detail="No commits found")
    
    rows = []
    for commit in commits:
        rows.append(_format_commit_table_row(project, commit, short=True))
    
    ref_display = h[:7] if h else "HEAD"
    title = f"Shortlog - {esc_html(project)} @ {esc_html(ref_display)}"
    
    pre = PREAMBLE.render(title=title, theme="dark", site_name=config.SITE_NAME)
    table = env.get_template("table.html").render(
        cols=["Commit", "Subject", "Author", "Age"],
        rows=rows
    )
    return HTMLResponse(
        f"{pre}<h1>{title}</h1>{table}{POSTAMBLE}"
    )


def git_history(project: str, h: str | None, f: str | None) -> HTMLResponse:
    """History page for a file or directory. Port of git_history."""
    if not f:
        raise HTTPException(status_code=400, detail="File path (f) required for history")
    if not is_valid_pathname(f):
        raise HTTPException(status_code=400, detail="Invalid path")
    
    commits = get_commit_history(project, ref=h, path=f, max_count=100)
    if not commits:
        raise HTTPException(status_code=404, detail="No history found for this path")
    
    rows = []
    for commit in commits:
        rows.append(_format_commit_table_row(project, commit, short=False))

    ref_display = h[:7] if h else "HEAD"    
    title=f"History - {esc_html(f)} - {esc_html(project)} @ {esc_html(ref_display)}"
    pre = PREAMBLE.render(title=title, theme="dark", site_name=config.SITE_NAME)
    table = env.get_template("table.html").render(
        cols=["Commit", "Subject", "Author", "Date", "Age"],
        rows=rows
    )
    return HTMLResponse(
        f"{pre}<h1>{title}</h1><p>Project: <a href='/{project}'>{esc_html(project)}</a></p>{table}{POSTAMBLE}"
    )


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)