import json
import secrets
import asyncio
import time
from pathlib import Path

from fastapi import APIRouter, HTTPException, Depends, Request
from fastapi.responses import FileResponse, StreamingResponse
from sqlalchemy.ext.asyncio import AsyncSession
from pydantic import BaseModel, Field
from typing import Optional
from database import get_db
from routes.auth import require_auth
from services.stream_service import StreamService
from services.media_service import media_service
from services.load_balancer import lb
from config import settings

router = APIRouter(prefix="/api/streams", tags=["streams"])


class StreamCreate(BaseModel):
    title: str
    description: Optional[str] = None
    cover_url: Optional[str] = None
    scheduled_at: Optional[str] = None
    replay_file: Optional[str] = None
    chapters: list[dict] = Field(default_factory=list)
    transcode_profile: str = "standard"
    homepage_visible: bool = True
    remote_control_enabled: bool = False


class StreamUpdate(BaseModel):
    title: Optional[str] = None
    description: Optional[str] = None
    cover_url: Optional[str] = None
    scheduled_at: Optional[str] = None
    replay_file: Optional[str] = None
    chapters: Optional[list[dict]] = None
    transcode_profile: Optional[str] = None
    homepage_visible: Optional[bool] = None
    remote_control_enabled: Optional[bool] = None


class RemoteSessionCreate(BaseModel):
    expires_in: int = 300


class RemoteCommand(BaseModel):
    token: str
    action: str
    value: float | None = None


_remote_sessions: dict[str, dict] = {}
_remote_commands: dict[int, list[dict]] = {}


def _media_path(filename: str | None) -> Path | None:
    if not filename:
        return None
    root = Path(settings.replay_media_dir).resolve()
    supplied = Path(filename)
    if supplied.is_absolute() or supplied.drive or ".." in supplied.parts:
        raise HTTPException(status_code=422, detail="回放文件不在允许的媒体目录中")
    candidate = (root / supplied).resolve()
    if candidate != root and root not in candidate.parents:
        raise HTTPException(status_code=422, detail="回放文件不在允许的媒体目录中")
    if not candidate.is_file():
        raise HTTPException(status_code=422, detail="回放文件不在允许的媒体目录中")
    return candidate


def _status_payload(stream) -> dict:
    return {
        "stream_id": stream.id,
        "status": stream.status.value,
        "replay_url": f"/api/streams/{stream.id}/replay" if stream.replay_file else None,
        "chapters": json.loads(stream.chapters_json or "[]"),
    }


def _normalize_chapters(chapters: list[dict]) -> list:
    normalized = []
    for chapter in chapters:
        title = str(chapter.get("title", "")).strip()
        try:
            chapter_time = float(chapter.get("time", 0))
        except (TypeError, ValueError) as exc:
            raise HTTPException(status_code=422, detail="章节时间必须是非负数字") from exc
        if not title or chapter_time < 0:
            raise HTTPException(status_code=422, detail="章节标题不能为空，时间必须是非负数字")
        normalized.append({"title": title, "time": chapter_time})
    return sorted(normalized, key=lambda chapter: chapter["time"])


def _serialize(s, include_private: bool = True):
    data = {
        "id": s.id, "title": s.title, "description": s.description,
        "cover_url": s.cover_url, "status": s.status.value,
        "scheduled_at": str(s.scheduled_at) if s.scheduled_at else None,
        "started_at": str(s.started_at) if s.started_at else None,
        "ended_at": str(s.ended_at) if s.ended_at else None,
        "multicast_enabled": s.multicast_enabled,
        "replay_file": s.replay_file,
        "chapters": json.loads(s.chapters_json or "[]"),
        "transcode_profile": s.transcode_profile,
        "homepage_visible": s.homepage_visible,
        "remote_control_enabled": s.remote_control_enabled,
        "created_at": str(s.created_at),
    }
    if include_private:
        data["stream_key"] = s.stream_key
    return data


def _get_client_ip(request: Request) -> str | None:
    forwarded = request.headers.get("X-Forwarded-For")
    if forwarded:
        return forwarded.split(",")[0].strip()
    client = request.headers.get("X-Real-IP")
    if client:
        return client
    if request.client:
        return request.client.host
    return None


@router.get("")
async def list_streams(admin: bool = False, db: AsyncSession = Depends(get_db)):
    svc = StreamService(db)
    streams = await svc.get_all_streams() if admin else await svc.get_public_streams()
    return [_serialize(s, include_private=admin) for s in streams]


@router.get("/media-files")
async def list_media_files(_: bool = Depends(require_auth)):
    root = Path(settings.replay_media_dir)
    root.mkdir(parents=True, exist_ok=True)
    extensions = {".mp4", ".m4v", ".mov", ".webm", ".mkv"}
    return [p.name for p in root.iterdir() if p.is_file() and p.suffix.lower() in extensions]


@router.post("")
async def create_stream(body: StreamCreate, db: AsyncSession = Depends(get_db),
                         _: bool = Depends(require_auth)):
    title = body.title.strip()
    if not title:
        raise HTTPException(status_code=422, detail="节目标题不能为空")
    _media_path(body.replay_file)
    if body.transcode_profile not in settings.transcode_profiles:
        raise HTTPException(status_code=422, detail="转码配置不存在")
    svc = StreamService(db)
    try:
        stream = await svc.create_stream(
            title=title,
            description=body.description,
            cover_url=body.cover_url,
            scheduled_at=body.scheduled_at,
            replay_file=body.replay_file,
            chapters=body.chapters,
            transcode_profile=body.transcode_profile,
            homepage_visible=body.homepage_visible,
            remote_control_enabled=body.remote_control_enabled,
        )
    except ValueError as exc:
        raise HTTPException(status_code=422, detail=str(exc)) from exc
    except Exception as exc:
        await db.rollback()
        raise HTTPException(status_code=500, detail="创建节目失败，请检查日期格式和数据库状态") from exc
    rtmp_url = media_service.get_rtmp_url(stream.stream_key)
    return {
        "id": stream.id,
        "title": stream.title,
        "stream_key": stream.stream_key,
        "rtmp_url": rtmp_url,
        "status": stream.status.value,
    }


@router.get("/{stream_id}")
async def get_stream(stream_id: int, db: AsyncSession = Depends(get_db)):
    svc = StreamService(db)
    s = await svc.get_stream(stream_id)
    if not s:
        raise HTTPException(status_code=404, detail="Stream not found")
    return _serialize(s)


@router.put("/{stream_id}")
async def update_stream(stream_id: int, body: StreamUpdate, db: AsyncSession = Depends(get_db),
                        _: bool = Depends(require_auth)):
    svc = StreamService(db)
    existing = await svc.get_stream(stream_id)
    if not existing:
        raise HTTPException(status_code=404, detail="Stream not found")
    updates = {k: v for k, v in body.model_dump().items() if v is not None}
    if ("replay_file" in updates or "chapters" in updates) and existing.status.value != "ended":
        raise HTTPException(status_code=409, detail="仅已结束的节目可以配置回放和章节")
    if "replay_file" in updates:
        _media_path(updates["replay_file"])
    if "transcode_profile" in updates and updates["transcode_profile"] not in settings.transcode_profiles:
        raise HTTPException(status_code=422, detail="转码配置不存在")
    if "chapters" in updates:
        if not updates.get("replay_file") and not existing.replay_file:
            raise HTTPException(status_code=409, detail="请先选择回放文件再编辑章节")
        chapters = _normalize_chapters(updates.pop("chapters"))
        updates["chapters_json"] = json.dumps(chapters, ensure_ascii=False)
    if updates:
        await svc.update_stream(stream_id, **updates)
    return {"ok": True}


@router.delete("/{stream_id}")
async def delete_stream(stream_id: int, db: AsyncSession = Depends(get_db),
                        _: bool = Depends(require_auth)):
    svc = StreamService(db)
    existing = await svc.get_stream(stream_id)
    if not existing:
        raise HTTPException(status_code=404, detail="Stream not found")
    await svc.delete_stream(stream_id)
    return {"ok": True}


@router.get("/{stream_id}/watch")
async def get_watch_urls(stream_id: int, request: Request, db: AsyncSession = Depends(get_db)):
    svc = StreamService(db)
    stream = await svc.get_stream(stream_id)
    if not stream:
        raise HTTPException(status_code=404, detail="Stream not found")
    client_ip = _get_client_ip(request)
    urls = await svc.get_watch_urls(stream.stream_key, client_ip)
    return {
        "stream_id": stream.id,
        "title": stream.title,
        "status": stream.status.value,
        "multicast_available": urls["multicast_available"],
        "selected_node": urls.get("selected_node"),
        "lines": urls["lines"],
        "qualities": urls["qualities"],
        "description": stream.description,
        "scheduled_at": str(stream.scheduled_at) if stream.scheduled_at else None,
        "replay_url": f"/api/streams/{stream.id}/replay" if stream.replay_file else None,
        "chapters": json.loads(stream.chapters_json or "[]"),
        "remote_control_enabled": stream.remote_control_enabled,
    }


@router.get("/{stream_id}/events")
async def stream_events(stream_id: int, request: Request, db: AsyncSession = Depends(get_db)):
    if not await StreamService(db).get_stream(stream_id):
        raise HTTPException(status_code=404, detail="Stream not found")

    async def events():
        previous = None
        while not await request.is_disconnected():
            stream = await StreamService(db).get_stream(stream_id)
            if not stream:
                yield "event: deleted\ndata: {}\n\n"
                return
            payload = json.dumps(_status_payload(stream), ensure_ascii=False)
            if payload != previous:
                yield f"event: status\ndata: {payload}\n\n"
                previous = payload
            else:
                yield ": keep-alive\n\n"
            await asyncio.sleep(2)

    return StreamingResponse(events(), media_type="text/event-stream", headers={
        "Cache-Control": "no-cache",
        "X-Accel-Buffering": "no",
    })


@router.get("/{stream_id}/replay")
async def serve_replay(stream_id: int, preview: str | None = None,
                       db: AsyncSession = Depends(get_db)):
    stream = await StreamService(db).get_stream(stream_id)
    if not stream:
        raise HTTPException(status_code=404, detail="Program not found")
    path = _media_path(preview if preview is not None else stream.replay_file)
    if not path:
        raise HTTPException(status_code=404, detail="Replay not available")
    return FileResponse(path)


@router.post("/{stream_id}/remote-session")
async def create_remote_session(stream_id: int, body: RemoteSessionCreate,
                                db: AsyncSession = Depends(get_db),
                                _: bool = Depends(require_auth)):
    stream = await StreamService(db).get_stream(stream_id)
    if not stream or not stream.remote_control_enabled:
        raise HTTPException(status_code=409, detail="节目未启用远程控制")
    token = secrets.token_urlsafe(24)
    _remote_sessions[token] = {
        "stream_id": stream_id,
        "expires_at": time.time() + min(max(body.expires_in, 30), 3600),
    }
    return {"token": token, "expires_in": min(max(body.expires_in, 30), 3600)}


@router.post("/{stream_id}/remote-command")
async def send_remote_command(stream_id: int, body: RemoteCommand,
                              _: bool = Depends(require_auth)):
    session = _remote_sessions.get(body.token)
    if not session or session["stream_id"] != stream_id or session["expires_at"] < time.time():
        raise HTTPException(status_code=403, detail="远程控制会话无效或已过期")
    if body.action not in {"play", "pause", "seek"}:
        raise HTTPException(status_code=422, detail="不支持的远程命令")
    command = {"action": body.action, "value": body.value, "created_at": time.time()}
    _remote_commands.setdefault(stream_id, []).append(command)
    return {"ok": True, "command": command}


@router.get("/{stream_id}/remote-command")
async def poll_remote_command(stream_id: int, token: str):
    session = _remote_sessions.get(token)
    if not session or session["stream_id"] != stream_id or session["expires_at"] < time.time():
        raise HTTPException(status_code=403, detail="远程控制会话无效或已过期")
    commands = _remote_commands.get(stream_id, [])
    return commands[-1] if commands else None


@router.post("/{stream_id}/go-live")
async def stream_go_live(stream_id: int, db: AsyncSession = Depends(get_db),
                         _: bool = Depends(require_auth)):
    svc = StreamService(db)
    stream = await svc.get_stream(stream_id)
    if not stream:
        raise HTTPException(status_code=404, detail="Stream not found")
    await svc.set_stream_live(stream.stream_key)
    return {"ok": True, "status": "live"}


@router.post("/{stream_id}/end")
async def stream_end(stream_id: int, db: AsyncSession = Depends(get_db),
                     _: bool = Depends(require_auth)):
    svc = StreamService(db)
    stream = await svc.get_stream(stream_id)
    if not stream:
        raise HTTPException(status_code=404, detail="Stream not found")
    await svc.set_stream_ended(stream.stream_key)
    return {"ok": True, "status": "ended"}


@router.get("/detail/{stream_key}")
async def get_stream_by_key(stream_key: str, request: Request, db: AsyncSession = Depends(get_db)):
    svc = StreamService(db)
    s = await svc.get_stream_by_key(stream_key)
    if not s:
        raise HTTPException(status_code=404, detail="Stream not found")
    client_ip = _get_client_ip(request)
    urls = await svc.get_watch_urls(stream_key, client_ip)
    return {
        "stream_id": s.id,
        "title": s.title,
        "status": s.status.value,
        "multicast_available": urls["multicast_available"],
        "selected_node": urls.get("selected_node"),
        "lines": urls["lines"],
        "qualities": urls["qualities"],
    }