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

import os
import subprocess
import tempfile
import zipfile
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
from fastapi.staticfiles import StaticFiles

from pygitweb import config, __meta__
from pygitweb.config import (
    ACTIONS,
    DISTGIT_AUTH,
    DISTGIT_ADMIN_USER,
    DISTGIT_ADMIN_PASSWORD,
    DISTGIT_SESSION_TIMEOUT,
    EXPORT_OK,
    PROJECTROOT,
    STRICT_EXPORT,
    check_loadavg,
    configure_gitweb_features,
    evaluate_gitweb_config,
)
from pygitweb.formatting import esc_html
from pygitweb.git_helpers import git_get_project_config, git_get_type
from pygitweb.projects import git_get_projects_list, git_get_project_owner
from pygitweb.templates_env import PREAMBLE, POSTAMBLE, env
from pygitweb.validation import is_valid_action, is_valid_pathname, is_valid_project, is_valid_ref_format

from pygitweb.actions import (
    git_blob,
    git_blobdiff,
    git_blobpatch,
    git_commit,
    git_commitdiff,
    git_heads,
    git_history,
    git_log,
    git_object,
    git_patch,
    git_patches,
    git_remotes,
    git_shortlog,
    git_summary,
    git_tag,
    git_tags,
    git_tree,
    parse_pagination,
)

app = FastAPI(
    debug=(DISTGIT_AUTH == "None"),
    title="PyGitWeb",
    summary="FastAPI + Pygit2 Repo Browser",
    description=open("pygitweb/README.md", "r", encoding="utf-8").read(),
    version=__meta__.__version__,
)

# 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)


_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=git_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='/project/{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', 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",
        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/{project_name}", status_code=303)


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


@app.get("/project/{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,
    fp: Annotated[str | None, Query(alias="fp")] = None,
    page: Annotated[str | None, Query(alias="page")] = None,
    pagecount: Annotated[str | None, Query(alias="pagecount")] = None,
):
    """
    Dispatch by path: /project/{project} -> summary; /project/{project}/action/... -> action.
    Port of dispatch + run_request path handling.
    """
    if not project or project == "":
        raise HTTPException(status_code=400, detail="Project needed")
    _validate_project(project)
    action = a
    hash_param = h or hb
    file_name = f
    file_parent = fp
    # If no action, infer: hash only -> object type; project only -> summary
    if not action:
        if hash_param and file_name:
            obj_type = git_get_type(project, 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 = git_get_type(project, 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(project)
    if action == "tree":
        return git_tree(project, hash_param, file_name)
    if action in ("blob", "blob_plain"):
        return git_blob(project, hash_param, file_name, raw=(action == "blob_plain"))
    if action == "blobdiff":
        return git_blobdiff(project, h, hb, file_name, file_parent)
    if action == "blobpatch":
        return git_blobpatch(project, h, hb, file_name, file_parent)
    if action == "log":
        p, pc = parse_pagination(page, pagecount)
        return git_log(project, hash_param, request, p, pc)
    if action == "shortlog":
        p, pc = parse_pagination(page, pagecount)
        return git_shortlog(project, hash_param, request, p, pc)
    if action == "history":
        p, pc = parse_pagination(page, pagecount)
        return git_history(project, hash_param, file_name, request, p, pc)
    if action == "heads":
        return git_heads(project)
    if action == "tags":
        p, pc = parse_pagination(page, pagecount)
        return git_tags(project, request, p, pc)
    if action == "tag":
        return git_tag(project, hash_param)
    if action == "commit":
        return git_commit(project, hash_param)
    if action == "patch":
        return git_patch(project, h)
    if action == "patches":
        return git_patches(project, h, hb)
    if action == "commitdiff":
        return git_commitdiff(project, hash_param)
    if action == "remotes":
        return git_remotes(project)
    if action == "object":
        return git_object(project, hash_param)
    # Stub others with minimal response
    pre = PREAMBLE.render(title=f"{esc_html(action)} - {esc_html(project)}", site_name=config.SITE_NAME)
    return HTMLResponse(
        f"{pre}<p>Action: {esc_html(action)}</p><p>Project: {esc_html(project)}</p>{POSTAMBLE}"
    )




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