"""CIS Enhanced - FastAPI app."""
import json
import os
import time
from datetime import datetime, timedelta
from pathlib import Path

from dotenv import load_dotenv
from fastapi import FastAPI, File, Form, Query, Request, UploadFile
from fastapi.responses import HTMLResponse, JSONResponse, Response
from fastapi.templating import Jinja2Templates

load_dotenv(Path(__file__).resolve().parent.parent / ".env")
for _var in ("CIS_USER", "CIS_PASSWORD"):
    if not os.environ.get(_var) or "HIER_" in os.environ[_var]:
        raise RuntimeError(
            f"Umweltvariable {_var} fehlt. .env ausfüllen (siehe .env.example) "
            f"bzw. beim Docker-Start über --env-file / env_file übergeben.")

from fastapi.staticfiles import StaticFiles  # noqa: E402

import numpy as np  # noqa: E402

from .cis import CISClient, SLOTS  # noqa: E402
from .face import engine  # noqa: E402
from .util import (current_semester, decode_matrikel, events_to_json, fmt_range,  # noqa: E402
                    lv_color, week_label, week_start)

BASE = os.environ["CIS_BASE_URL"].rstrip("/")
client = CISClient(os.environ["CIS_USER"], os.environ["CIS_PASSWORD"], BASE)
OWN_UID = os.environ.get("OWN_UID", os.environ["CIS_USER"])

app = FastAPI(title="CIS Enhanced")
app.mount("/static", StaticFiles(directory=str(Path(__file__).parent / "static")), name="static")
templates = Jinja2Templates(directory=str(Path(__file__).parent / "templates"))
templates.env.globals["lv_color"] = lv_color
templates.env.globals["decode_matrikel"] = decode_matrikel
templates.env.globals["fmt_range"] = fmt_range
templates.env.globals["week_label"] = week_label
templates.env.globals["slots"] = SLOTS


def _meta():
    return client.meta()


@app.get("/", response_class=HTMLResponse)
def home(request: Request):
    meta = _meta()
    return templates.TemplateResponse(request, "home.html", {
        "own_uid": OWN_UID,
        "stgs": meta["stgs"],
        "semesters": meta["semesters"],
        "current_sem": current_semester(meta["semesters"]),
    })


def _plan_common(request, kind, uid, kz, sem, ver, grp, semester, week="", tab="week"):
    meta = _meta()
    semester = semester or current_semester(meta["semesters"])
    s = next((x for x in meta["semesters"] if x["label"] == semester), meta["semesters"][0])
    person = None
    if kind == "student":
        uid = uid or OWN_UID
        person = client.person(uid)
        events = client.student_events(uid, s["begin"], s["ende"])
    else:
        kz = kz or "640"
        sem = sem or "1"
        ver = ver or "V"
        events = client.stg_events(kz, sem, ver, grp, s["begin"], s["ende"])
    # initial week: explicit param, today if inside semester, else first event week
    init_week = None
    try:
        if week:
            init_week = week_start(datetime.strptime(week, "%Y-%m-%d").date())
    except ValueError:
        pass
    if init_week is None:
        now = datetime.now()
        if s["begin"] <= now.timestamp() <= s["ende"]:
            first_day = now.date()
        elif events:
            first_day = events[0].start.date()
        else:
            first_day = datetime.fromtimestamp(s["begin"]).date()
        init_week = week_start(first_day)
    stg = next((x for x in meta["stgs"] if x["kz"] == kz), None)
    verbands = client.verbands_for(kz, sem) if kind == "stg" and kz and sem else meta["verbands"]
    return {
        "request": request,
        "kind": kind,
        "uid": uid or "",
        "kz": kz or "",
        "sem": sem or "",
        "ver": ver or "",
        "grp": grp or "",
        "stg": stg,
        "verbands": verbands,
        "person": person,
        "events": events,
        "events_json": events_to_json(events),
        "meta": meta,
        "semester": semester,
        "sem_range": (datetime.fromtimestamp(s["begin"]), datetime.fromtimestamp(s["ende"])),
        "init_week": init_week,
        "tab": tab if tab in ("week", "sem") else "week",
    }


@app.get("/plan", response_class=HTMLResponse)
def plan(request: Request,
         uid: str = Query("", description="Matrikelnummer"),
         semester: str = Query(""),
         week: str = Query("", description="Woche als YYYY-MM-DD (Monatag)"),
         tab: str = Query("week", description="week|sem")):
    return templates.TemplateResponse(request, "plan.html", _plan_common(
        request, "student", uid, "", "", "", "", semester, week, tab))


@app.get("/stg", response_class=HTMLResponse)
def stg_page(request: Request,
             kz: str = Query("640"),
             sem: str = Query("1"),
             ver: str = Query("V"),
             grp: str = Query(""),
             semester: str = Query(""),
             week: str = Query(""),
             tab: str = Query("week", description="week|sem")):
    return templates.TemplateResponse(request, "plan.html", _plan_common(
        request, "stg", "", kz, sem, ver, grp, semester, week, tab))


def verband_label(v: str) -> str:
    return {"V": " (Vollzeit)", "B": " (berufsbegl.)"}.get(v, "")


templates.env.globals["verband_label"] = verband_label


@app.get("/liste", response_class=HTMLResponse)
def liste(request: Request,
          kz: str = Query("640"),
          sem: str = Query("1"),
          ver: str = Query("V")):
    meta = _meta()
    students = client.namensliste(kz, sem, ver)
    stg = next((x for x in meta["stgs"] if x["kz"] == kz), None)
    verbands = client.verbands_for(kz, sem)
    students_json = [{"nachname": s.nachname, "vorname": s.vorname,
                      "geschlecht": s.geschlecht, "matrikel": s.matrikel,
                      "mail": s.mail} for s in students]
    return templates.TemplateResponse(request, "liste.html", {
        "request": request,
        "meta": meta,
        "kz": kz,
        "sem": sem,
        "ver": ver,
        "verbands": verbands,
        "stg": stg,
        "students": students,
        "students_json": students_json,
    })


# ---------- Fotos / Gesichter ----------
DATA_DIR = Path(__file__).resolve().parent.parent / "data"
EMB_CACHE = DATA_DIR / "embeddings.json"
MAX_UPLOAD = 8 * 1024 * 1024


def _emb_cache() -> dict:
    if EMB_CACHE.exists():
        try:
            return json.loads(EMB_CACHE.read_text())
        except Exception:
            pass
    return {}


def _embed_person(pid: str, photo: bytes) -> np.ndarray | None:
    cache = _emb_cache()
    if pid in cache:
        return np.asarray(cache[pid], dtype=np.float32)
    v = engine.embed(photo)
    if v is None:
        return None
    cache[pid] = v.tolist()
    try:
        DATA_DIR.mkdir(parents=True, exist_ok=True)
        EMB_CACHE.write_text(json.dumps(cache))
    except OSError:
        pass
    return v


def _photo_wall(kz: str, sem: str, ver: str) -> list[dict]:
    """Students of a verband with person_id + whether a photo exists (cached check)."""
    students = client.namensliste(kz, sem, ver)
    wall = []
    for s in students:
        pid = client.person_id_for(s.matrikel)
        wall.append({
            "nachname": s.nachname, "vorname": s.vorname,
            "matrikel": s.matrikel, "person_id": pid,
            "has_photo": bool(pid),
        })
    return wall


@app.get("/fotos", response_class=HTMLResponse)
def fotos_page(request: Request,
               kz: str = Query("640"),
               sem: str = Query("1"),
               ver: str = Query("V")):
    meta = _meta()
    stg = next((x for x in meta["stgs"] if x["kz"] == kz), None)
    verbands = client.verbands_for(kz, sem)
    wall = _photo_wall(kz, sem, ver)
    return templates.TemplateResponse(request, "fotos.html", {
        "request": request,
        "meta": meta,
        "kz": kz,
        "sem": sem,
        "ver": ver,
        "verbands": verbands,
        "stg": stg,
        "wall": wall,
        "wall_json": wall,
        "own_uid": OWN_UID,
    })


@app.get("/fotos/img/{person_id}")
def fotos_img(person_id: str):
    if not person_id.isdigit():
        return JSONResponse({"error": "Ungültige ID"}, status_code=400)
    res = client.photo_bytes(person_id)
    if not res:
        return JSONResponse({"error": "Kein Foto vorhanden"}, status_code=404)
    data, ct = res
    return Response(data, media_type=ct)


@app.post("/fotos/suche", response_class=HTMLResponse)
def fotos_suche(request: Request,
                kz: str = Form("640"),
                sem: str = Form("1"),
                ver: str = Form("V"),
                file: UploadFile = File(...)):
    data = file.file.read()
    if not data:
        return templates.TemplateResponse(request, "fotos_result.html", {
            "request": request, "error": "Leere Datei hochgeladen.",
            "kz": kz, "sem": sem, "ver": ver, "results": [], "meta": _meta(),
            "stg": next((x for x in _meta()["stgs"] if x["kz"] == kz), None),
            "verbands": client.verbands_for(kz, sem),
            "own_uid": OWN_UID,
        }, status_code=400)
    if len(data) > MAX_UPLOAD:
        return templates.TemplateResponse(request, "fotos_result.html", {
            "request": request, "error": "Datei zu groß (max. 8 MB).",
            "kz": kz, "sem": sem, "ver": ver, "results": [], "meta": _meta(),
            "stg": next((x for x in _meta()["stgs"] if x["kz"] == kz), None),
            "verbands": client.verbands_for(kz, sem),
            "own_uid": OWN_UID,
        }, status_code=400)
    emb = engine.embed(data)
    if emb is None:
        return templates.TemplateResponse(request, "fotos_result.html", {
            "request": request, "error": "Kein Gesicht im hochgeladenen Bild gefunden.",
            "kz": kz, "sem": sem, "ver": ver, "results": [], "meta": _meta(),
            "stg": next((x for x in _meta()["stgs"] if x["kz"] == kz), None),
            "verbands": client.verbands_for(kz, sem),
            "own_uid": OWN_UID,
        }, status_code=422)
    wall = _photo_wall(kz, sem, ver)
    results = []
    t0 = time.time()
    for p in wall:
        pid = p["person_id"]
        if not pid:
            continue
        res = client.photo_bytes(pid)
        if not res:
            continue
        e = _embed_person(pid, res[0])
        if e is None:
            continue
        sim = engine.similarity(emb, e)
        results.append({**p, "sim": round(sim, 4),
                        "img": f"/fotos/img/{pid}"})
    results.sort(key=lambda r: r["sim"], reverse=True)
    meta = _meta()
    return templates.TemplateResponse(request, "fotos_result.html", {
        "request": request,
        "error": None,
        "took": round(time.time() - t0, 1),
        "query": {"kz": kz, "sem": sem, "ver": ver},
        "kz": kz, "sem": sem, "ver": ver,
        "results": results[:30],
        "meta": meta,
        "stg": next((x for x in meta["stgs"] if x["kz"] == kz), None),
        "verbands": client.verbands_for(kz, sem),
        "own_uid": OWN_UID,
    })


@app.get("/api/person_id")
def api_person_id(uid: str = Query(...)):
    return {"uid": uid, "person_id": client.person_id_for(uid)}


@app.get("/api/meta")
def api_meta():
    return _meta()


@app.get("/api/semesters_for_stg")
def api_semesters_for_stg(kz: str = Query(...)):
    """Study semesters that exist for a StG (from CIS autocomplete endpoint)."""
    try:
        r = client.s.post(f"{BASE}/private/lvplan/lvplan_autocomplete.php",
                          data={"autocomplete": "getSemester", "stg_kz": kz}, timeout=30)
        return JSONResponse(r.json())
    except Exception:
        return JSONResponse([])


@app.get("/api/verbands")
def api_verbands(kz: str = Query(...), sem: str = Query("")):
    return client.verbands_for(kz, sem)


@app.get("/api/detail")
def api_detail(kind: str = "student", datum: str = "", stunde: int = 0,
               uid: str = "", kz: str = "", sem: str = "", ver: str = "",
               grp: str = "", ort: str = ""):
    if kind == "student" and not (kz and sem and ver):
        p = client.person(uid)
        if p:
            if not kz:
                code = p.stg.split(" - ")[0].strip()
                stg = next((x for x in _meta()["stgs"] if x["code"] == code), None)
                kz = stg["kz"] if stg else ""
            sem = sem or p.semester
            ver = ver or p.verband
            grp = grp or p.gruppe
    try:
        rows = client.detail(kind, datum, stunde, uid, kz, sem, ver, grp, ort)
        return {"rows": rows}
    except Exception as e:
        return JSONResponse({"error": str(e)}, status_code=502)


@app.get("/export/ical")
def export_ical(kind: str = "student",
                uid: str = Query(""), kz: str = Query(""),
                sem: str = Query(""), ver: str = Query(""), grp: str = Query(""),
                semester: str = Query("")):
    meta = _meta()
    s = next((x for x in meta["semesters"] if x["label"] == semester),
             next((x for x in meta["semesters"]
                   if x["begin"] <= datetime.now().timestamp() <= x["ende"]),
                  meta["semesters"][0]))
    if kind == "student":
        ical = client.ical_raw("student", uid=uid or OWN_UID, begin=s["begin"], ende=s["ende"])
        fname = f"lvplan_{uid or OWN_UID}_{s['label']}.ics"
    else:
        ical = client.ical_raw("stg", kz=kz, sem=sem, ver=ver, grp=grp,
                               begin=s["begin"], ende=s["ende"])
        fname = f"lvplan_{kz}_{sem}_{ver}_{s['label']}.ics"
    return Response(ical, media_type="text/calendar",
                    headers={"Content-Disposition": f'attachment; filename="{fname}"'})


@app.get("/health")
def health():
    return {"ok": True}