import json
import os
from datetime import datetime, timezone
from typing import Any, AsyncGenerator

from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi.responses import StreamingResponse
from starlette.responses import FileResponse

from app.auth import verify_token
from app.ops_runner import (
    run_ops, run_ops_json, run_ops_host, run_ops_host_json, run_command_host,
    stream_ops_host, stream_command_host, new_op_id, is_cancelled, clear_cancelled,
    _BACKUP_TIMEOUT, OFFSITE_PYTHON,
)

router = APIRouter()


def _sse(payload: dict) -> str:
    return f"data: {json.dumps(payload)}\n\n"


def _now() -> str:
    return datetime.now(timezone.utc).isoformat()


@router.get("/", summary="List local backups")
async def list_backups(
    _: str = Depends(verify_token),
) -> list[dict[str, Any]]:
    """Returns a list of local backup records from `ops backups --json`."""
    result = await run_ops_json(["backups"])
    if not result["success"]:
        raise HTTPException(status_code=500, detail=f"Failed to list backups: {result['error']}")

    data = result["data"]
    if isinstance(data, list):
        return data
    if isinstance(data, dict):
        for key in ("backups", "data", "items"):
            if key in data and isinstance(data[key], list):
                return data[key]
        return [data]
    return []


@router.get("/offsite", summary="List offsite backups")
async def list_offsite_backups(
    _: str = Depends(verify_token),
) -> list[dict[str, Any]]:
    """Returns a list of offsite backup records."""
    # Get project list from registry
    import yaml
    registry_path = "/opt/infrastructure/servers/hetzner-vps/registry.yaml"
    try:
        with open(registry_path) as f:
            registry = yaml.safe_load(f)
        projects = [
            name for name, cfg in registry.get("projects", {}).items()
            if cfg.get("backup_dir") and not cfg.get("infrastructure") and not cfg.get("static")
        ]
    except Exception:
        projects = ["mdf", "seriousletter"]  # Fallback

    all_backups = []
    for project in projects:
        result = await run_ops_host_json(["offsite", "list", project])
        if result["success"] and isinstance(result["data"], list):
            for b in result["data"]:
                b["project"] = project
            all_backups.extend(result["data"])
    return all_backups


@router.post("/{project}/{env}", summary="Create a local backup")
async def create_backup(
    project: str,
    env: str,
    _: str = Depends(verify_token),
) -> dict[str, Any]:
    """
    Runs `ops backup {project} {env}` on the host.

    Runs via nsenter because ops backup delegates to project CLIs
    that use host Python venvs.
    """
    result = await run_ops_host(["backup", project, env], timeout=_BACKUP_TIMEOUT)
    if not result["success"]:
        raise HTTPException(
            status_code=500,
            detail=f"Backup failed: {result['error'] or result['output']}",
        )
    return {
        "success": True,
        "output": result["output"],
        "project": project,
        "env": env,
    }


async def _backup_stream(project: str, env: str) -> AsyncGenerator[str, None]:
    """Stream backup creation progress via SSE."""
    op_id = new_op_id()
    yield _sse({"op_id": op_id})
    yield _sse({"line": f"Creating backup for {project}/{env}...", "timestamp": _now()})

    try:
        success = True
        async for line in stream_ops_host(
            ["backup", project, env], timeout=_BACKUP_TIMEOUT, op_id=op_id
        ):
            yield _sse({"line": line, "timestamp": _now()})
            if line.startswith("[error]") or line.startswith("ERROR"):
                success = False

        if is_cancelled(op_id):
            yield _sse({"done": True, "success": False, "cancelled": True})
        else:
            yield _sse({"done": True, "success": success, "project": project, "env": env})
    finally:
        clear_cancelled(op_id)


@router.get("/stream/{project}/{env}", summary="Create backup with streaming output")
async def create_backup_stream(
    project: str,
    env: str,
    _: str = Depends(verify_token),
) -> StreamingResponse:
    """Create a backup with real-time SSE progress output."""
    return StreamingResponse(
        _backup_stream(project, env),
        media_type="text/event-stream",
        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
    )


@router.post("/offsite/upload/{project}/{env}", summary="Upload backup to offsite")
async def upload_offsite(
    project: str,
    env: str,
    _: str = Depends(verify_token),
) -> dict[str, Any]:
    """Runs `ops offsite upload {project} {env}` on the host."""
    result = await run_ops_host(
        ["offsite", "upload", project, env], timeout=_BACKUP_TIMEOUT
    )
    if not result["success"]:
        raise HTTPException(
            status_code=500,
            detail=f"Offsite upload failed: {result['error'] or result['output']}",
        )
    return {"success": True, "output": result["output"], "project": project, "env": env}


async def _upload_stream(project: str, env: str, name: str | None = None) -> AsyncGenerator[str, None]:
    """Stream offsite upload progress via SSE."""
    op_id = new_op_id()
    yield _sse({"op_id": op_id})
    label = f"{project}/{env}/{name}" if name else f"{project}/{env} (latest)"
    yield _sse({"line": f"Uploading {label} to offsite storage...", "timestamp": _now()})

    cmd = ["offsite", "upload", project, env]
    if name:
        cmd.append(name)

    try:
        success = True
        async for line in stream_ops_host(
            cmd, timeout=_BACKUP_TIMEOUT, op_id=op_id
        ):
            yield _sse({"line": line, "timestamp": _now()})
            if line.startswith("[error]") or line.startswith("ERROR"):
                success = False

        if is_cancelled(op_id):
            yield _sse({"done": True, "success": False, "cancelled": True})
        else:
            yield _sse({"done": True, "success": success, "project": project, "env": env})
    finally:
        clear_cancelled(op_id)


@router.get("/offsite/stream/{project}/{env}", summary="Upload to offsite with streaming output")
async def upload_offsite_stream(
    project: str,
    env: str,
    name: str | None = Query(None),
    _: str = Depends(verify_token),
) -> StreamingResponse:
    """Upload backup to offsite with real-time SSE progress output."""
    return StreamingResponse(
        _upload_stream(project, env, name),
        media_type="text/event-stream",
        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
    )


async def _download_stream(project: str, env: str, name: str) -> AsyncGenerator[str, None]:
    """Stream offsite-to-local download progress via SSE."""
    op_id = new_op_id()
    yield _sse({"op_id": op_id})
    yield _sse({"line": f"Downloading {name} from offsite to local storage...", "timestamp": _now()})

    # Download to the local backup directory so it appears in the backup list
    local_path = f"/opt/data/backups/{project}/{env}/{name}"
    cmd = [
        OFFSITE_PYTHON, "-c",
        f"import sys; sys.stdout.reconfigure(line_buffering=True); "
        f"sys.path.insert(0, '/opt/data/scripts'); "
        f"from offsite import download; from pathlib import Path; "
        f"import os; os.makedirs('/opt/data/backups/{project}/{env}', exist_ok=True); "
        f"ok = download('{name}', Path('{local_path}'), '{project}', '{env}'); "
        f"sys.exit(0 if ok else 1)"
    ]

    try:
        success = True
        async for line in stream_command_host(cmd, timeout=_BACKUP_TIMEOUT, op_id=op_id):
            yield _sse({"line": line, "timestamp": _now()})
            if line.startswith("[error]") or line.startswith("ERROR") or "failed" in line.lower():
                success = False

        if is_cancelled(op_id):
            yield _sse({"done": True, "success": False, "cancelled": True})
        else:
            yield _sse({"done": True, "success": success, "project": project, "env": env, "name": name})
    finally:
        clear_cancelled(op_id)


@router.get("/offsite/download/stream/{project}/{env}", summary="Download offsite backup to local storage with streaming output")
async def download_offsite_stream(
    project: str,
    env: str,
    name: str = Query(...),
    _: str = Depends(verify_token),
) -> StreamingResponse:
    """Download an offsite backup to local storage with real-time SSE progress output."""
    if "/" in name or "\\" in name or ".." in name:
        raise HTTPException(status_code=400, detail="Invalid backup name")
    return StreamingResponse(
        _download_stream(project, env, name),
        media_type="text/event-stream",
        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
    )


@router.post("/offsite/retention", summary="Apply offsite retention policy")
async def apply_retention(
    _: str = Depends(verify_token),
) -> dict[str, Any]:
    """Runs `ops offsite retention` on the host."""
    result = await run_ops_host(["offsite", "retention"], timeout=_BACKUP_TIMEOUT)
    if not result["success"]:
        raise HTTPException(
            status_code=500,
            detail=f"Retention policy failed: {result['error'] or result['output']}",
        )
    return {"success": True, "output": result["output"]}


@router.delete("/{project}/{env}/{name}", summary="Delete a backup")
async def delete_backup(
    project: str,
    env: str,
    name: str,
    target: str = Query("local", regex="^(local|offsite|both)$"),
    _: str = Depends(verify_token),
) -> dict[str, Any]:
    """
    Delete a backup from local storage, offsite, or both.

    Query param `target`: local | offsite | both (default: local).
    """
    if "/" in name or "\\" in name or ".." in name:
        raise HTTPException(status_code=400, detail="Invalid backup name")

    results = {"local": None, "offsite": None}

    # Delete local
    if target in ("local", "both"):
        backup_path = f"/opt/data/backups/{project}/{env}/{name}"
        check = await run_command_host(["test", "-f", backup_path])
        if check["success"]:
            result = await run_command_host(["rm", backup_path])
            results["local"] = "ok" if result["success"] else "failed"
        else:
            results["local"] = "not_found"

    # Delete offsite
    if target in ("offsite", "both"):
        result = await run_command_host([
            "/opt/data/\u03c0/bin/python3", "-c",
            f"import sys; sys.path.insert(0, '/opt/data/scripts'); "
            f"from offsite import delete; "
            f"ok = delete('{name}', '{project}', '{env}', quiet=True); "
            f"sys.exit(0 if ok else 1)"
        ])
        results["offsite"] = "ok" if result["success"] else "failed"

    # Check if anything succeeded
    any_ok = "ok" in results.values()
    if not any_ok:
        raise HTTPException(status_code=500, detail=f"Delete failed: {results}")

    return {"success": True, "project": project, "env": env, "name": name, "results": results}


@router.get("/download/{project}/{env}/{name}", summary="Download a backup to browser")
async def download_backup(
    project: str,
    env: str,
    name: str,
    _: str = Depends(verify_token),
) -> FileResponse:
    """Serve a local backup file as a browser download."""
    for param in (project, env, name):
        if "/" in param or "\\" in param or ".." in param:
            raise HTTPException(status_code=400, detail="Invalid path parameter")

    backup_path = f"/opt/data/backups/{project}/{env}/{name}"
    if not os.path.isfile(backup_path):
        raise HTTPException(status_code=404, detail="Backup file not found")

    media_type = "application/gzip" if name.endswith(".gz") else "application/octet-stream"
    return FileResponse(
        path=backup_path,
        media_type=media_type,
        filename=name,
    )