"""
FastAPI REST API for timing-systemet.
"""

import asyncio
import logging
import uuid
from contextlib import asynccontextmanager
from datetime import datetime, timezone
from pathlib import Path

import aiosqlite
from fastapi import Depends, FastAPI, File, HTTPException, UploadFile
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse
from pydantic import BaseModel
from typing import Optional

from ingest import watch_depot, process_existing
from passage_log import delete_passage, get_passage_images, get_passages, log_passage, resolve_passage
from profile_db import (
    clear_startlist,
    delete_athlete,
    get_db,
    get_or_create_athlete,
    import_startlist_csv,
    list_athletes,
)
from race_db import (
    create_race, delete_race, get_active_race, get_race, get_station,
    list_races, list_stations, set_active_race, update_race, upsert_station, delete_station,
)
from results import get_results

logger = logging.getLogger(__name__)


@asynccontextmanager
async def lifespan(app: FastAPI):
    await process_existing()
    asyncio.create_task(watch_depot())
    yield


app = FastAPI(title="Timing API", version="0.1.0", lifespan=lifespan)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)


async def get_connection():
    db = await get_db()
    try:
        yield db
    finally:
        await db.close()


# =====================
# Løp (races)
# =====================

class RaceRequest(BaseModel):
    name: str
    date: Optional[str] = None
    description: Optional[str] = None
    bib_filter_enabled: bool = False


@app.get("/api/races")
async def list_races_endpoint(db=Depends(get_connection)):
    return await list_races(db)


@app.get("/api/races/active")
async def active_race(db=Depends(get_connection)):
    race = await get_active_race(db)
    return race or {}


@app.post("/api/races")
async def create_race_endpoint(body: RaceRequest, db=Depends(get_connection)):
    return await create_race(db, body.name, body.date, body.description, body.bib_filter_enabled)


@app.put("/api/races/{race_id}")
async def update_race_endpoint(race_id: str, body: RaceRequest, db=Depends(get_connection)):
    ok = await update_race(db, race_id, body.name, body.date, body.description, body.bib_filter_enabled)
    if not ok:
        raise HTTPException(404, "Løp ikke funnet")
    return await get_race(db, race_id)


@app.post("/api/races/{race_id}/activate")
async def activate_race(race_id: str, db=Depends(get_connection)):
    ok = await set_active_race(db, race_id)
    if not ok:
        raise HTTPException(404, "Løp ikke funnet")
    return {"ok": True}


@app.delete("/api/races/{race_id}")
async def delete_race_endpoint(race_id: str, db=Depends(get_connection)):
    ok = await delete_race(db, race_id)
    if not ok:
        raise HTTPException(404, "Løp ikke funnet")
    return {"ok": True}


# =====================
# Stasjoner
# =====================

class StationRequest(BaseModel):
    name: str
    display_name: str
    station_order: int
    gps_lat: Optional[float] = None
    gps_lon: Optional[float] = None
    gps_alt: Optional[float] = None


@app.get("/api/races/{race_id}/stations")
async def list_stations_endpoint(race_id: str, db=Depends(get_connection)):
    return await list_stations(db, race_id)


@app.post("/api/races/{race_id}/stations")
async def create_station_endpoint(race_id: str, body: StationRequest, db=Depends(get_connection)):
    return await upsert_station(
        db, race_id, body.name, body.display_name, body.station_order,
        body.gps_lat, body.gps_lon, body.gps_alt,
    )


@app.put("/api/races/{race_id}/stations/{station_id}")
async def update_station_endpoint(
    race_id: str, station_id: str, body: StationRequest, db=Depends(get_connection)
):
    return await upsert_station(
        db, race_id, body.name, body.display_name, body.station_order,
        body.gps_lat, body.gps_lon, body.gps_alt, station_id=station_id,
    )


@app.delete("/api/races/{race_id}/stations/{station_id}")
async def delete_station_endpoint(race_id: str, station_id: str, db=Depends(get_connection)):
    ok = await delete_station(db, station_id)
    if not ok:
        raise HTTPException(400, "Kan ikke slette start eller mål")
    return {"ok": True}


# =====================
# Startliste
# =====================

@app.get("/api/athletes")
async def list_athletes_endpoint(db=Depends(get_connection)):
    return await list_athletes(db)


@app.post("/api/athletes/import", summary="Last opp startliste som CSV")
async def import_csv(file: UploadFile = File(...), db=Depends(get_connection)):
    if not file.filename.endswith(".csv"):
        raise HTTPException(400, "Kun CSV-filer støttes")
    content = (await file.read()).decode("utf-8-sig")
    return await import_startlist_csv(db, content)


@app.delete("/api/athletes/all")
async def clear_all_athletes(db=Depends(get_connection)):
    await clear_startlist(db)
    return {"ok": True}


@app.delete("/api/athletes/{profile_id}")
async def remove_athlete(profile_id: str, db=Depends(get_connection)):
    ok = await delete_athlete(db, profile_id)
    if not ok:
        raise HTTPException(404, "Utøver ikke funnet")
    return {"ok": True}


# =====================
# Passeringer
# =====================

@app.get("/api/passages")
async def list_passages(
    race_id: Optional[str] = None,
    station: Optional[str] = None,
    needs_review: Optional[bool] = None,
    profile_id: Optional[str] = None,
    db=Depends(get_connection),
):
    return await get_passages(db, race_id=race_id, profile_id=profile_id,
                              station=station, needs_review=needs_review)


@app.get("/api/passages/review")
async def review_queue(race_id: Optional[str] = None, db=Depends(get_connection)):
    return await get_passages(db, race_id=race_id, needs_review=True)


class ResolveRequest(BaseModel):
    profile_id: Optional[str] = None
    bib_number: Optional[str] = None
    review_note: Optional[str] = None


@app.post("/api/passages/{passage_id}/resolve")
async def resolve(passage_id: str, body: ResolveRequest, db=Depends(get_connection)):
    profile_id = body.profile_id
    if body.bib_number and not profile_id:
        profile_id = await get_or_create_athlete(db, body.bib_number)
    ok = await resolve_passage(db, passage_id,
                               profile_id=profile_id,
                               bib_number=body.bib_number,
                               review_note=body.review_note)
    if not ok:
        raise HTTPException(404, "Passering ikke funnet")

    # Oppdater EXIF-metadata med bekreftet startnummer
    if body.bib_number:
        from image_tagger import write_bib_tags, read_bib_tags
        async with db.execute(
            "SELECT source_image, station, race_id FROM passages WHERE passage_id = ?",
            (passage_id,),
        ) as cur:
            row = await cur.fetchone()
        if row:
            img_path = Path(row["source_image"])
            if img_path.exists():
                # Behold allerede taggede bibs, legg til bekreftet
                existing = read_bib_tags(img_path)
                all_bibs = list(dict.fromkeys(
                    (existing or {}).get("bibs", []) + [body.bib_number]
                ))
                write_bib_tags(
                    img_path, all_bibs,
                    station=row["station"],
                    race_id=row["race_id"],
                    confirmed=True,
                )

    return {"ok": True}


@app.get("/api/passages/{passage_id}/images")
async def passage_images(passage_id: str, db=Depends(get_connection)):
    return await get_passage_images(db, passage_id)


@app.delete("/api/passages/{passage_id}")
async def remove_passage(passage_id: str, db=Depends(get_connection)):
    ok = await delete_passage(db, passage_id)
    if not ok:
        raise HTTPException(404, "Passering ikke funnet")
    return {"ok": True}


@app.post("/api/passages/{passage_id}/reanalyze")
async def reanalyze_passage(passage_id: str, db=Depends(get_connection)):
    """
    Kjør OCR på nytt på passeringens kildebilde.
    Oppretter nye passeringer for eventuelle startnumre som ikke allerede er logget fra dette bildet.
    Returnerer alle funne startnumre og eventuelle nye passage_id-er.
    """
    from datetime import timezone as _tz
    from ocr import read_all_bibs
    from ingest import MIN_AUTO_CONFIDENCE
    from profile_db import get_athlete_by_bib

    async with db.execute("SELECT * FROM passages WHERE passage_id = ?", (passage_id,)) as cur:
        row = await cur.fetchone()
    if not row:
        raise HTTPException(404, "Passering ikke funnet")

    passage = dict(row)
    image_path = Path(passage["source_image"])
    if not image_path.exists():
        raise HTTPException(404, "Kildebilde ikke funnet på disk")

    bibs = read_all_bibs(image_path)

    # Finn bib-numre som allerede er logget fra dette bildet
    async with db.execute(
        "SELECT bib_number FROM passages WHERE source_image = ?", (passage["source_image"],)
    ) as cur:
        existing_bibs = {r["bib_number"] for r in await cur.fetchall()}

    new_passages = []
    ts_str = passage["timestamp_utc"]
    ts = datetime.fromisoformat(ts_str)
    if ts.tzinfo is None:
        ts = ts.replace(tzinfo=_tz.utc)

    for ocr in bibs:
        if ocr.digits in existing_bibs:
            continue

        confidence = ocr.confidence
        needs_review = confidence < MIN_AUTO_CONFIDENCE
        id_method = "bib_ocr" if not needs_review else "bib_ocr_uncertain"
        review_note = "low_confidence" if needs_review else None

        profile_id = None
        if ocr.digits and not needs_review:
            athlete = await get_athlete_by_bib(db, ocr.digits)
            if athlete:
                profile_id = athlete["profile_id"]

        new_id = await log_passage(
            db,
            race_id=passage["race_id"],
            profile_id=profile_id,
            bib_number=ocr.digits,
            station=passage["station"],
            timestamp_utc=ts,
            gps_lat=passage["gps_lat"],
            gps_lon=passage["gps_lon"],
            gps_alt=passage["gps_alt"],
            confidence=confidence,
            proximity_score=ocr.proximity_score,
            id_method=id_method,
            source_image=passage["source_image"],
            needs_review=needs_review,
            review_note=review_note,
        )
        new_passages.append({"passage_id": new_id, "bib_number": ocr.digits, "confidence": confidence})

    return {
        "found_bibs": [ocr.digits for ocr in bibs],
        "new_passages": new_passages,
    }


# =====================
# Resultater
# =====================

@app.get("/api/results")
async def get_results_endpoint(race_id: Optional[str] = None, db=Depends(get_connection)):
    return await get_results(db, race_id=race_id)


# =====================
# Bildeopplasting
# =====================

VALID_IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png"}


@app.post("/api/upload")
async def upload_images(
    files: list[UploadFile] = File(...),
    race_id: Optional[str] = None,
    station_id: Optional[str] = None,
    db=Depends(get_connection),
):
    """
    Last opp bilder til depot. Med race_id + station_id behandles bildene
    direkte (ingen EXIF GPS-krav) og passeringen logges umiddelbart.
    """
    # Hent stasjon for å få GPS og stasjonsnavn
    station = None
    if station_id:
        station = await get_station(db, station_id)
        if not station:
            raise HTTPException(404, "Stasjon ikke funnet")

    results = []
    for file in files:
        suffix = Path(file.filename).suffix.lower()
        if suffix not in VALID_IMAGE_SUFFIXES:
            results.append({"filename": file.filename, "ok": False, "error": "Ugyldig filtype"})
            continue

        dest = Path("/depot") / file.filename
        if dest.exists():
            dest = Path("/depot") / f"{uuid.uuid4().hex}_{file.filename}"

        try:
            content = await file.read()
            dest.write_bytes(content)

            if station:
                # Direktebehandling — flytt til processed og logg passering
                from ingest import process_image_with_override
                await process_image_with_override(
                    dest,
                    race_id=race_id,
                    station_name=station["name"],
                    gps_lat=station["gps_lat"],
                    gps_lon=station["gps_lon"],
                    gps_alt=station["gps_alt"],
                    db=db,
                )

            results.append({"filename": file.filename, "ok": True, "saved_as": dest.name})
        except Exception as e:
            logger.exception("Feil ved opplasting av %s", file.filename)
            results.append({"filename": file.filename, "ok": False, "error": str(e)})

    return {"uploaded": sum(1 for r in results if r["ok"]), "results": results}


# =====================
# Bilder
# =====================

@app.get("/api/images/{path:path}")
async def serve_image(path: str):
    full_path = Path("/processed") / path
    if not full_path.exists() or not full_path.is_file():
        raise HTTPException(404, "Bilde ikke funnet")
    try:
        full_path.resolve().relative_to(Path("/processed").resolve())
    except ValueError:
        raise HTTPException(403, "Forbudt")
    return FileResponse(full_path)


# =====================
# Helse
# =====================

@app.get("/api/health")
async def health():
    return {"status": "ok"}