from __future__ import annotations

from biliup_next.app.bootstrap import ensure_initialized
from biliup_next.app.task_control_service import TaskControlService
from biliup_next.app.session_delivery_service import SessionDeliveryService
from biliup_next.app.task_audit import record_task_action


def run_task_action(task_id: str) -> dict[str, object]:
    state = ensure_initialized()
    result = TaskControlService(state).run_task(task_id)
    record_task_action(state["repo"], task_id, "task_run", "ok", "task run invoked", result)
    return result


def retry_step_action(task_id: str, step_name: str) -> dict[str, object]:
    state = ensure_initialized()
    result = TaskControlService(state).retry_step(task_id, step_name)
    record_task_action(state["repo"], task_id, "retry_step", "ok", f"retry step invoked: {step_name}", result)
    return result


def reset_to_step_action(task_id: str, step_name: str) -> dict[str, object]:
    state = ensure_initialized()
    payload = TaskControlService(state).reset_to_step(task_id, step_name)
    record_task_action(state["repo"], task_id, "reset_to_step", "ok", f"reset to step invoked: {step_name}", payload)
    return payload


def bind_full_video_action(task_id: str, full_video_bvid: str) -> dict[str, object]:
    state = ensure_initialized()
    payload = SessionDeliveryService(state).bind_task_full_video(task_id, full_video_bvid)
    if "error" in payload:
        return payload
    record_task_action(
        state["repo"],
        task_id,
        "bind_full_video",
        "ok",
        f"full video bvid bound: {payload['full_video_bvid']}",
        payload,
    )
    return payload


def rebind_session_full_video_action(session_key: str, full_video_bvid: str) -> dict[str, object]:
    state = ensure_initialized()
    payload = SessionDeliveryService(state).rebind_session_full_video(session_key, full_video_bvid)
    if "error" in payload:
        return payload

    for item in payload["tasks"]:
        record_task_action(
            state["repo"],
            item["task_id"],
            "rebind_session_full_video",
            "ok",
            f"session full video bvid rebound: {payload['full_video_bvid']}",
            {
                "session_key": session_key,
                "full_video_bvid": payload["full_video_bvid"],
                "path": item["path"],
            },
        )
    return payload


def merge_session_action(session_key: str, task_ids: list[str]) -> dict[str, object]:
    state = ensure_initialized()
    payload = SessionDeliveryService(state).merge_session(session_key, task_ids)
    if "error" in payload:
        return payload
    for item in payload["tasks"]:
        record_task_action(state["repo"], item["task_id"], "merge_session", "ok", f"task merged into session: {session_key}", item)
    return payload


def receive_full_video_webhook(payload: dict[str, object]) -> dict[str, object]:
    state = ensure_initialized()
    result = SessionDeliveryService(state).receive_full_video_webhook(payload)
    if "error" in result:
        return result

    for item in result["tasks"]:
        record_task_action(
            state["repo"],
            item["task_id"],
            "webhook_full_video_uploaded",
            "ok",
            f"full video bvid received via webhook: {result['full_video_bvid']}",
            {
                "session_key": result["session_key"],
                "source_title": result["source_title"],
                "full_video_bvid": result["full_video_bvid"],
                "path": item["path"],
            },
        )
    return result