"""Flows + approvals HTTP API."""

from __future__ import annotations

import json
from collections.abc import AsyncIterator, Iterator
from pathlib import Path
from uuid import UUID

import httpx
from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi.responses import StreamingResponse
from sqlmodel import Session

from app.db import get_engine, get_session
from app.models import User
from app.settings import settings
from app.auth.deps import get_optional_user, resolve_tenant

from . import runner, store
from .deploy import import_from_langflow
from .sync import lfx_id_for, sync_from_directory
from .langflow_client import (
    LangflowClient,
    LangflowError,
    LangflowNotFound,
    LangflowUnavailable,
)
from .lfx_client import (
    LfxClient,
    LfxConflict,
    LfxError,
    LfxInvalidFlow,
    LfxNotFound,
    LfxRunFailed,
    LfxUnavailable,
)
from .schemas import (
    ApprovalCreate,
    ApprovalRead,
    DecisionRead,
    DecisionRequest,
    FlowDefinitionCreate,
    FlowDefinitionRead,
    FlowImportRead,
    FlowImportRequest,
    FlowVersionCreate,
    FlowVersionRead,
    RunRead,
    RunRequest,
    SyncReport,
)

flows_router = APIRouter(prefix="/api/flows", tags=["flows"])
approvals_router = APIRouter(prefix="/api/approvals", tags=["approvals"])


def get_db() -> Iterator[Session]:
    yield from get_session()


def get_lfx() -> LfxClient:
    return LfxClient(settings.lfx_url, api_key=settings.lfx_api_key or None)


def get_langflow() -> LangflowClient:
    return LangflowClient(
        settings.langflow_url, api_key=settings.langflow_api_key or ""
    )


def _read_definition(d) -> FlowDefinitionRead:
    return FlowDefinitionRead(
        id=d.id,
        name=d.name,
        description=d.description,
        status=d.status,
        source_path=d.source_path,
        continuation_flow_id=d.continuation_flow_id,
        created_at=d.created_at,
    )


def _read_version(v) -> FlowVersionRead:
    return FlowVersionRead(
        id=v.id,
        flow_id=v.flow_id,
        version_no=v.version_no,
        langflow_json=v.langflow_json,
        lfx_flow_id=v.lfx_flow_id,
        deployed_at=v.deployed_at,
        author=v.author,
        created_at=v.created_at,
    )


def _read_run(r) -> RunRead:
    return RunRead(
        id=r.id,
        version_id=r.version_id,
        tenant_id=r.tenant_id,
        status=r.status,
        input=r.input,
        output=r.output,
        session_id=r.session_id,
        created_at=r.created_at,
        finished_at=r.finished_at,
    )


def _read_task(t) -> ApprovalRead:
    return ApprovalRead(
        id=t.id,
        run_id=t.run_id,
        version_id=t.version_id,
        tenant_id=t.tenant_id,
        title=t.title,
        payload=t.payload,
        continuation_flow_id=t.continuation_flow_id,
        approver=t.approver,
        status=t.status,
        decision_note=t.decision_note,
        created_at=t.created_at,
        decided_at=t.decided_at,
    )


@flows_router.post("", response_model=FlowDefinitionRead, status_code=201)
def create_flow(data: FlowDefinitionCreate, session: Session = Depends(get_db)):
    try:
        return _read_definition(store.create_definition(session, data))
    except store.ConflictError as exc:
        raise HTTPException(status_code=409, detail=str(exc)) from exc
    except store.InvalidError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc


@flows_router.get("", response_model=list[FlowDefinitionRead])
def list_flows(session: Session = Depends(get_db)):
    return [_read_definition(d) for d in store.list_definitions(session)]


@flows_router.post("/sync", response_model=SyncReport)
async def sync_flows(
    session: Session = Depends(get_db),
    lfx: LfxClient = Depends(get_lfx),
):
    """Reconcile backend/flows/*.json into the DB + LFX (add/update/delete)."""
    try:
        return await sync_from_directory(session, lfx, Path(settings.flows_dir))
    except FileNotFoundError as exc:
        raise HTTPException(status_code=500, detail=str(exc)) from exc


@flows_router.get("/{flow_id}", response_model=FlowDefinitionRead)
def get_flow(flow_id: UUID, session: Session = Depends(get_db)):
    try:
        return _read_definition(store.get_definition(session, flow_id))
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@flows_router.post(
    "/{flow_id}/versions", response_model=FlowVersionRead, status_code=201
)
def create_version(
    flow_id: UUID, data: FlowVersionCreate, session: Session = Depends(get_db)
):
    try:
        return _read_version(store.create_version(session, flow_id, data))
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    except store.InvalidError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc


@flows_router.get("/{flow_id}/versions", response_model=list[FlowVersionRead])
def list_versions(flow_id: UUID, session: Session = Depends(get_db)):
    try:
        return [_read_version(v) for v in store.list_versions(session, flow_id)]
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@flows_router.post(
    "/{flow_id}/versions/{version_no}/deploy", response_model=FlowVersionRead
)
async def deploy_version(
    flow_id: UUID,
    version_no: int,
    session: Session = Depends(get_db),
    lfx: LfxClient = Depends(get_lfx),
):
    try:
        version = store.get_version_by_no(session, flow_id, version_no)
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    try:
        # Deterministic LFX id: same (definition, version) always maps to the
        # same registration, no matter which path deployed it.
        uploaded = await lfx.upload_flow(
            version.langflow_json,
            flow_id=lfx_id_for(flow_id, version_no),
            replace=True,
        )
    except LfxInvalidFlow as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    except LfxConflict as exc:
        raise HTTPException(status_code=409, detail=str(exc)) from exc
    except LfxUnavailable as exc:
        raise HTTPException(status_code=503, detail=str(exc)) from exc
    except LfxError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return _read_version(store.mark_deployed(session, version, uploaded.id))


def _resolve_version(session: Session, flow_id: UUID, version_no: int | None):
    if version_no is not None:
        return store.get_version_by_no(session, flow_id, version_no)
    return store.get_latest_deployed_version(session, flow_id)


@flows_router.post("/{flow_id}/run", response_model=RunRead)
async def run_flow(
    flow_id: UUID,
    data: RunRequest,
    stream: bool = Query(default=False),
    session: Session = Depends(get_db),
    lfx: LfxClient = Depends(get_lfx),
    user: User | None = Depends(get_optional_user),
):
    # Tenant comes from the session; the body param stays as a deprecated
    # fallback for unauthenticated callers.
    data = data.model_copy(update={"tenant_id": resolve_tenant(user, data.tenant_id)})
    try:
        version = _resolve_version(session, flow_id, data.version_no)
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    except store.InvalidError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    if stream:
        return await _run_stream(session, lfx, version, data)
    try:
        run = await runner.execute_run(
            session,
            lfx,
            version,
            payload=data.input,
            tenant_id=data.tenant_id,
            session_id=data.session_id,
            callback_base_url=data.callback_base_url or settings.callback_base_url,
            continuation_flow_id=data.continuation_flow_id,
        )
    except LfxNotFound as exc:
        raise HTTPException(status_code=502, detail=f"LFX drift: {exc}") from exc
    except LfxUnavailable as exc:
        raise HTTPException(status_code=503, detail=str(exc)) from exc
    except LfxError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return _read_run(run)


async def _run_stream(session: Session, lfx: LfxClient, version, data: RunRequest):
    if not version.lfx_flow_id:
        raise HTTPException(
            status_code=422, detail=f"version {version.id} is not deployed to LFX"
        )
    run = store.create_run(
        session,
        version,
        input=data.input,
        tenant_id=data.tenant_id,
        session_id=data.session_id,
    )
    envelope = runner.build_envelope(
        payload=data.input,
        run_id=run.id,
        callback_base_url=data.callback_base_url or settings.callback_base_url,
        continuation_flow_id=data.continuation_flow_id,
    )
    run_id = run.id
    lfx_flow_id = version.lfx_flow_id
    session_id = data.session_id or str(run.id)

    async def event_gen() -> AsyncIterator[str]:
        yield f"event: run\ndata: {json.dumps({'run_id': str(run_id)})}\n\n"
        try:
            async with httpx.AsyncClient(
                base_url=lfx.base_url, timeout=lfx.timeout, headers=lfx._headers()
            ) as client:
                async with client.stream(
                    "POST",
                    f"/flows/{lfx_flow_id}/stream",
                    json={"input_value": envelope, "session_id": session_id},
                ) as response:
                    if response.status_code == 404:
                        raise LfxNotFound(f"flow {lfx_flow_id} unknown to LFX")
                    response.raise_for_status()
                    async for chunk in response.aiter_text():
                        yield chunk
        except (LfxNotFound, httpx.HTTPError) as exc:
            yield f"event: error\ndata: {json.dumps({'error': str(exc)})}\n\n"
        # Finalize from a fresh session: the request session may be closed.
        with Session(get_engine()) as fresh:
            try:
                fresh_run = store.get_run(fresh, run_id)
                status = (
                    "pending_approval"
                    if runner._task_exists(fresh, run_id)
                    else "completed"
                )
                store.set_run_result(fresh, fresh_run, status, {"streamed": True})
            except store.NotFoundError:
                status = "failed"
        yield f"event: run_finished\ndata: {json.dumps({'run_id': str(run_id), 'status': status})}\n\n"

    return StreamingResponse(event_gen(), media_type="text/event-stream")


@flows_router.get("/{flow_id}/runs", response_model=list[RunRead])
def list_runs(
    flow_id: UUID,
    tenant_id: str | None = Query(default=None),
    session: Session = Depends(get_db),
    user: User | None = Depends(get_optional_user),
):
    # Authenticated callers are scoped to their session tenant unless they
    # pass an explicit tenant (deprecated fallback for unauthenticated use).
    if user is not None and tenant_id is None:
        tenant_id = user.tenant_id
    try:
        return [_read_run(r) for r in store.list_runs(session, flow_id, tenant_id)]
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@flows_router.get("/langflow/available")
async def list_langflow_flows(langflow: LangflowClient = Depends(get_langflow)):
    """Browse flows on the Langflow authoring server (admin import source)."""
    try:
        return await langflow.list_flows()
    except LangflowUnavailable as exc:
        raise HTTPException(status_code=503, detail=str(exc)) from exc
    except LangflowError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc


@flows_router.post("/import", response_model=FlowImportRead, status_code=201)
async def import_flow(
    data: FlowImportRequest,
    session: Session = Depends(get_db),
    langflow: LangflowClient = Depends(get_langflow),
    lfx: LfxClient = Depends(get_lfx),
):
    """Import a flow from Langflow: export -> version -> (deploy to LFX)."""
    try:
        definition, version = await import_from_langflow(
            session,
            langflow,
            lfx,
            data.langflow_flow_id,
            name=data.name,
            author=data.author,
            deploy=data.deploy,
        )
    except LangflowNotFound as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    except LangflowUnavailable as exc:
        raise HTTPException(status_code=503, detail=str(exc)) from exc
    except LangflowError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    except store.ConflictError as exc:
        raise HTTPException(status_code=409, detail=str(exc)) from exc
    except store.InvalidError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    except LfxInvalidFlow as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    except LfxConflict as exc:
        raise HTTPException(status_code=409, detail=str(exc)) from exc
    except LfxUnavailable as exc:
        raise HTTPException(status_code=503, detail=str(exc)) from exc
    except LfxError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    return FlowImportRead(
        definition=_read_definition(definition), version=_read_version(version)
    )


@flows_router.get("/runs/{run_id}", response_model=RunRead)
def get_run(
    run_id: UUID,
    tenant_id: str | None = Query(default=None),
    session: Session = Depends(get_db),
    user: User | None = Depends(get_optional_user),
):
    """Read a run. With tenant_id, cross-tenant reads 404 (v1 scoping)."""
    if user is not None and tenant_id is None:
        tenant_id = user.tenant_id
    try:
        run = store.get_run(session, run_id)
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    if tenant_id is not None and run.tenant_id != tenant_id:
        raise HTTPException(status_code=404, detail=f"run {run_id} not found")
    return _read_run(run)


@approvals_router.post("", response_model=ApprovalRead, status_code=201)
def create_approval(data: ApprovalCreate, session: Session = Depends(get_db)):
    """Flow callback contract: report a terminal approval state for a run."""
    try:
        return _read_task(store.create_approval_task(session, data))
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    except store.ConflictError as exc:
        raise HTTPException(status_code=409, detail=str(exc)) from exc
    except store.InvalidError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc


@approvals_router.get("", response_model=list[ApprovalRead])
def list_approvals(
    tenant_id: str | None = Query(default=None),
    session: Session = Depends(get_db),
    user: User | None = Depends(get_optional_user),
):
    if user is not None and tenant_id is None:
        tenant_id = user.tenant_id
    return [_read_task(t) for t in store.list_approval_tasks(session, tenant_id)]


@approvals_router.post("/{task_id}/decision", response_model=DecisionRead)
async def decide_approval(
    task_id: UUID,
    data: DecisionRequest,
    session: Session = Depends(get_db),
    lfx: LfxClient = Depends(get_lfx),
):
    """Decide an open task. Approve starts the continuation flow (if any)."""
    try:
        task = store.get_task(session, task_id)
    except store.NotFoundError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc

    # Resolve the continuation first: bad references fail before any state change.
    continuation_version = None
    if data.decision == "approve" and task.continuation_flow_id is not None:
        try:
            continuation_version = store.get_latest_deployed_version(
                session, task.continuation_flow_id
            )
        except (store.NotFoundError, store.InvalidError) as exc:
            raise HTTPException(status_code=422, detail=str(exc)) from exc
    try:
        task = store.decide_task(
            session,
            task,
            decision="approved" if data.decision == "approve" else "rejected",
            approver=data.approver,
            note=data.note,
        )
    except store.ConflictError as exc:
        raise HTTPException(status_code=409, detail=str(exc)) from exc

    # Note: the decision is committed before the continuation runs. If LFX is
    # down, the task stays decided and the continuation can be started
    # manually from the preserved task payload.
    continuation_run = None
    if continuation_version is not None:
        payload = task.payload
        if isinstance(payload.get("facts"), dict):
            payload = payload["facts"]
        try:
            continuation_run = await runner.execute_run(
                session,
                lfx,
                continuation_version,
                payload=payload,
                tenant_id=task.tenant_id,
                session_id=f"continuation-of-{task.run_id}",
                callback_base_url=data.callback_base_url or settings.callback_base_url,
            )
        except LfxNotFound as exc:
            raise HTTPException(status_code=502, detail=f"LFX drift: {exc}") from exc
        except LfxUnavailable as exc:
            raise HTTPException(status_code=503, detail=str(exc)) from exc
        except LfxError as exc:
            raise HTTPException(status_code=502, detail=str(exc)) from exc
    return DecisionRead(
        task=_read_task(task),
        continuation_run=_read_run(continuation_run) if continuation_run else None,
    )