"""Project-scoped APIs for operational tasks, evidence and approved actions."""
from __future__ import annotations

from datetime import datetime
from typing import Literal
from uuid import UUID

from fastapi import APIRouter, Depends, Header, HTTPException, Query, status
from psycopg import AsyncConnection
from app.auth.metadata_dependencies import get_metadata_repository

from app.auth.permissions import (
    OPERATIONAL_TASK_EXECUTE,
    OPERATIONAL_TASK_EXTERNAL_SYNC,
    OPERATIONAL_TASK_VIEW,
    OPERATIONAL_TASK_WRITE,
    SCADA_VIEW,
    SIMULATION_VIEW,
    permissions_for_context,
    require_permission,
)
from app.auth.project_dependencies import (
    ProjectContext,
    get_project_context,
    get_project_pg_connection,
    get_project_timescale_connection,
)
from app.domain.domain_errors import DomainError
from app.domain.schemas.workbench_runtime import WorkbenchDateTime
from app.domain.schemas.operational_data import TaskDataQuery, TaskDataSnapshot
from app.domain.schemas.task_question import TaskQuestionCreate, TaskQuestionReply, TaskQuestionRequest
from app.services.task_questions import create_question, answer_question
from app.domain.schemas.operational_task import (
    ActionDecisionCommand,
    ActionExecuteCommand,
    ActionProposalCommand,
    ActionReconcileCommand,
    WorkOrderDraftUpdateCommand,
    WorkOrderConfirmDispatchCommand,
    TaskAccessRequest,
    TaskAccessRequestCreate,
    TaskAccessRequestDecision,
    AgentArtifactsCommand,
    AgentArtifactsResult,
    AgentRunCancelCommand,
    AgentRunCommand,
    AgentRunDispatchFailureCommand,
    AgentRunFailureCommand,
    AgentTaskContext,
    DispatchDueSchedulesCommand,
    DispatchDueSchedulesResult,
    EvidenceRecord,
    ExternalFeedbackCommand,
    ExternalFeedbackResult,
    ExternalSourceWithdrawalCommand,
    HumanApprovalAction,
    HumanEvidenceCommand,
    InvestigationReportPage,
    InvestigationReportRevision,
    NotificationAcknowledgeCommand,
    OperationalTaskCreate,
    OperationalTaskDetail,
    OperationalTaskNotification,
    OperationalTaskNotificationPage,
    OperationalTaskPage,
    OperationalTaskRetryCommand,
    OperationalTaskRun,
    OperationalTaskRunPage,
    OperationalTaskSchedule,
    OperationalTaskScheduleCreate,
    OperationalTaskSchedulePage,
    OperationalTaskScheduleUpdate,
    RecoverExpiredLeasesCommand,
    RecoverExpiredLeasesResult,
    TaskStatus,
    TaskDataQueryResult,
    TaskType,
    TaskPresentationEventCommand,
    TaskPresentationEventResult,
    TaskPresentationCursor,
    TaskPresentationHistoryPage,
)
from app.infra.db.postgresql.operational_tasks import OperationalTaskRepository
from app.infra.integrations.operational_actions import (
    OperationalActionDispatcher,
    get_operational_action_dispatcher,
)
from app.infra.integrations.operational_data import TaskDataError, read_task_data
from app.services.operational_tasks import OperationalTaskService


router = APIRouter()


@router.post("/operational-tasks/recovery/reconcile")
async def reconcile_task_recoveries(
    command: RecoverExpiredLeasesCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
    timescale=Depends(get_project_timescale_connection),
    metadata=Depends(get_metadata_repository),
) -> dict[str, int]:
    from app.domain.schemas.project_settings import ProjectSettings
    from app.services.operational_recovery import reconcile_recoveries

    if SCADA_VIEW not in permissions_for_context(ctx):
        raise HTTPException(403, "恢复监测需要 SCADA 查看权限")
    project = await metadata.get_project_by_id(ctx.project_id)
    if project is None:
        raise HTTPException(404, "当前项目不存在")
    try:
        resumed = await reconcile_recoveries(_service(ctx, conn), timescale,
            ProjectSettings.model_validate(project.settings or {}), limit=command.limit,
            created_from=command.task_created_from)
        return {"resumed": resumed}
    except DomainError as exc:
        _raise_domain(exc)


def _service(ctx: ProjectContext, conn: AsyncConnection) -> OperationalTaskService:
    return OperationalTaskService(
        OperationalTaskRepository(conn, ctx.project_id),
        ctx,
        _task_permissions(ctx),
    )


def _task_permissions(ctx: ProjectContext) -> set[str]:
    # Investigations use preconfigured project access, including service accounts.
    # Do not force an already-authorized reader through legacy per-task delegation.
    return set(permissions_for_context(ctx))


def _raise_domain(exc: DomainError):
    raise HTTPException(status_code=exc.status, detail=exc.payload()) from exc


@router.get("/operational-tasks/{task_id}/reports", response_model=InvestigationReportPage)
async def list_investigation_reports(
    task_id: UUID,
    limit: int = Query(default=20, ge=1, le=100),
    offset: int = Query(default=0, ge=0),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        items, next_offset = await _service(ctx, conn).list_reports(task_id, limit, offset)
        return InvestigationReportPage(items=items, next_offset=next_offset)
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-tasks/{task_id}/reports/{revision}", response_model=InvestigationReportRevision)
async def get_investigation_report(
    task_id: UUID,
    revision: int,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).report(task_id, revision)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks",
    response_model=OperationalTaskDetail,
    status_code=status.HTTP_201_CREATED,
)
async def create_operational_task(
    command: OperationalTaskCreate,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).create(command)
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-tasks", response_model=OperationalTaskPage)
async def list_operational_tasks(
    task_type: TaskType | None = None,
    task_status: TaskStatus | None = Query(default=None, alias="status"),
    limit: int = Query(default=50, ge=1, le=100),
    offset: int = Query(default=0, ge=0),
    peripheral_work_order_id: UUID | None = Query(
        default=None, description="Only tasks sourced from or linked to this peripheral work order",
    ),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        items, next_offset = await _service(ctx, conn).list(
            task_type=task_type, status=task_status, limit=limit, offset=offset,
            **({"peripheral_work_order_id": peripheral_work_order_id}
               if peripheral_work_order_id is not None else {}),
        )
        return OperationalTaskPage(
            items=items, limit=limit, offset=offset, next_offset=next_offset
        )
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-task-runs", response_model=OperationalTaskRunPage)
async def list_operational_task_runs(
    run_status: Literal[
        "queued", "claimed", "running", "succeeded", "failed", "timed_out", "cancelled"
    ] | None = Query(default=None, alias="status"),
    task_type: TaskType | None = None,
    task_created_from: WorkbenchDateTime | None = None,
    limit: int = Query(default=50, ge=1, le=100),
    cursor: str | None = None,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    cursor_created_at = None
    cursor_run_id = None
    if cursor:
        try:
            timestamp, run_id = cursor.rsplit("|", 1)
            cursor_created_at = datetime.fromisoformat(timestamp)
            cursor_run_id = UUID(run_id)
        except (ValueError, TypeError) as exc:
            raise HTTPException(status_code=400, detail="Invalid run cursor") from exc
    try:
        items, next_cursor = await _service(ctx, conn).list_runs(
            status=run_status,
            task_type=task_type,
            task_created_from=task_created_from,
            limit=limit,
            cursor_created_at=cursor_created_at,
            cursor_run_id=cursor_run_id,
        )
        return OperationalTaskRunPage(items=items, next_cursor=next_cursor)
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-tasks/{task_id}/runs", response_model=OperationalTaskRunPage)
async def list_task_run_history(
    task_id: UUID,
    limit: int = Query(default=20, ge=1, le=100),
    offset: int = Query(default=0, ge=0),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return OperationalTaskRunPage(items=await _service(ctx, conn).task_runs(task_id, limit, offset))
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-tasks/{task_id}/runs/{run_id}", response_model=OperationalTaskRun)
async def get_task_run(
    task_id: UUID, run_id: UUID,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).task_run(task_id, run_id)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/schedules",
    response_model=OperationalTaskSchedule,
    status_code=status.HTTP_201_CREATED,
)
async def create_operational_schedule(
    command: OperationalTaskScheduleCreate,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).create_schedule(command)
    except DomainError as exc:
        _raise_domain(exc)


@router.get(
    "/operational-tasks/schedules", response_model=OperationalTaskSchedulePage
)
async def list_operational_schedules(
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return OperationalTaskSchedulePage(items=await _service(ctx, conn).list_schedules())
    except DomainError as exc:
        _raise_domain(exc)


@router.patch(
    "/operational-tasks/schedules/{schedule_id}",
    response_model=OperationalTaskSchedule,
)
async def update_operational_schedule(
    schedule_id: UUID,
    command: OperationalTaskScheduleUpdate,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).update_schedule(schedule_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/schedules/dispatch-due",
    response_model=DispatchDueSchedulesResult,
)
async def dispatch_due_operational_schedules(
    command: DispatchDueSchedulesCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).dispatch_due_schedules(command.limit)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/leases/recover",
    response_model=RecoverExpiredLeasesResult,
)
async def recover_operational_task_leases(
    command: RecoverExpiredLeasesCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).recover_expired_leases(
            command.limit, task_type=command.task_type,
            task_created_from=command.task_created_from,
        )
    except DomainError as exc:
        _raise_domain(exc)


@router.get(
    "/operational-task-notifications",
    response_model=OperationalTaskNotificationPage,
)
async def list_operational_task_notifications(
    unread_only: bool = False,
    limit: int = Query(default=50, ge=1, le=100),
    offset: int = Query(default=0, ge=0),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        items, next_offset = await _service(ctx, conn).list_notifications(
            unread_only=unread_only, limit=limit, offset=offset
        )
        return OperationalTaskNotificationPage(
            items=items, limit=limit, offset=offset, next_offset=next_offset
        )
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-task-notifications/{notification_id}/acknowledge",
    response_model=OperationalTaskNotification,
)
async def acknowledge_operational_task_notification(
    notification_id: UUID,
    command: NotificationAcknowledgeCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).acknowledge_notification(notification_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-tasks/{task_id}", response_model=OperationalTaskDetail)
async def get_operational_task(
    task_id: UUID,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).detail(task_id)
    except DomainError as exc:
        _raise_domain(exc)


@router.post("/operational-tasks/{task_id}/retry", response_model=OperationalTaskDetail)
async def retry_operational_task(
    task_id: UUID,
    command: OperationalTaskRetryCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).retry_task(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/runs/{run_id}/claim",
    response_model=OperationalTaskRun,
)
async def claim_operational_task_run(
    task_id: UUID,
    run_id: UUID,
    command: AgentRunCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).claim_run(task_id, run_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/runs/{run_id}/heartbeat",
    response_model=OperationalTaskRun,
)
async def heartbeat_operational_task_run(
    task_id: UUID,
    run_id: UUID,
    command: AgentRunCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).heartbeat_run(task_id, run_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/runs/{run_id}/complete",
    response_model=OperationalTaskDetail,
)
async def complete_operational_task_run(
    task_id: UUID,
    run_id: UUID,
    command: AgentRunCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).complete_run(task_id, run_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/runs/{run_id}/fail",
    response_model=OperationalTaskDetail,
)
async def fail_operational_task_run(
    task_id: UUID,
    run_id: UUID,
    command: AgentRunFailureCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).fail_run(task_id, run_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/runs/{run_id}/cancel",
    response_model=OperationalTaskDetail,
)
async def cancel_operational_task_run(
    task_id: UUID,
    run_id: UUID,
    command: AgentRunCancelCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).cancel_run(task_id, run_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/runs/{run_id}/dispatch-failure",
    response_model=OperationalTaskRun,
)
async def record_operational_task_run_dispatch_failure(
    task_id: UUID,
    run_id: UUID,
    command: AgentRunDispatchFailureCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).record_dispatch_failure(task_id, run_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.get(
    "/operational-tasks/{task_id}/agent-context", response_model=AgentTaskContext
)
async def get_operational_task_agent_context(
    task_id: UUID,
    report_revision: int | None = Query(default=None, ge=1),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).agent_context(task_id, report_revision)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/agent-artifacts",
    response_model=AgentArtifactsResult,
)
async def publish_operational_task_artifacts(
    task_id: UUID,
    command: AgentArtifactsCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).publish_artifacts(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-tasks/{task_id}/presentation-cursor", response_model=TaskPresentationCursor)
async def get_operational_task_presentation_cursor(
    task_id: UUID,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).presentation_cursor(task_id)
    except DomainError as exc:
        _raise_domain(exc)


@router.get("/operational-tasks/{task_id}/presentation-events", response_model=TaskPresentationHistoryPage)
async def get_operational_task_presentation_history(
    task_id: UUID,
    after: int = Query(default=0, ge=0),
    through: int | None = Query(default=None, ge=0),
    limit: int = Query(default=100, ge=1, le=200),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).presentation_history(task_id, after=after, through=through, limit=limit)
    except DomainError as exc:
        _raise_domain(exc)


@router.post("/operational-tasks/{task_id}/presentation-events", response_model=TaskPresentationEventResult)
async def publish_operational_task_presentation_event(
    task_id: UUID,
    command: TaskPresentationEventCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).publish_presentation_event(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/data-query", response_model=TaskDataQueryResult
)
async def query_operational_task_data(
    task_id: UUID,
    query: TaskDataQuery,
    authorization: str | None = Header(default=None, alias="Authorization"),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    service = _service(ctx, conn)
    try:
        if not await service.can_read_source(task_id, query.source):
            raise DomainError("PERMISSION_DENIED", "Task has no approved access to this data source", status=403)
        source_permission = SCADA_VIEW if query.source.startswith("scada_") else SIMULATION_VIEW
        from app.services.scada_replay_queries import replay_snapshot_rows
        replay_context = await service.replay_context(task_id)
        if replay_context:
            if query.source != "scada_readings":
                raise HTTPException(403, "回放调查数据接口仅开放本轮 SCADA 快照，请通过 MCP 查询设备目录")
            rows = await replay_snapshot_rows(conn, ctx.project_id, replay_context, query.device_ids,
                                              query.start, query.end, 1001)
            from app.services.content_digest import digest
            from datetime import datetime, timezone
            snapshot = TaskDataSnapshot(
                source="scada_readings", source_ref=f"scada_replay:{replay_context['replay_id']}:{digest(rows)}",
                queried_at=datetime.now(timezone.utc), origin="synthetic", data=rows[:1000], truncated=len(rows) > 1000,
            )
        else:
            snapshot = await read_task_data(
                context=ctx, query=query, credential=authorization,
                delegated=source_permission not in _task_permissions(ctx),
            )
        evidence, stored_snapshot = await service.record_data_snapshot(task_id, snapshot)
        return TaskDataQueryResult(evidence=evidence, snapshot=stored_snapshot)
    except TaskDataError as exc:
        raise HTTPException(status_code=exc.status, detail=exc.detail) from exc
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/access-requests",
    response_model=TaskAccessRequest,
    status_code=status.HTTP_201_CREATED,
)
async def request_operational_task_access(
    task_id: UUID,
    command: TaskAccessRequestCreate,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).request_access(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/access-requests/{access_request_id}/decision",
    response_model=TaskAccessRequest,
)
async def decide_operational_task_access(
    task_id: UUID,
    access_request_id: UUID,
    command: TaskAccessRequestDecision,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).decide_access(task_id, access_request_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/human-evidence",
    response_model=OperationalTaskDetail,
)
async def add_operational_task_human_evidence(
    task_id: UUID,
    command: HumanEvidenceCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).add_human_evidence(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.get(
    "/operational-tasks/{task_id}/evidence/{evidence_id}/snapshot",
    response_model=TaskDataSnapshot,
)
async def get_operational_task_data_snapshot(
    task_id: UUID,
    evidence_id: str,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).data_snapshot(task_id, evidence_id)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/actions",
    response_model=HumanApprovalAction,
    status_code=status.HTTP_201_CREATED,
)
async def propose_operational_task_action(
    task_id: UUID,
    command: ActionProposalCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).propose_action(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/actions/{action_id}/decision",
    response_model=HumanApprovalAction,
)
async def decide_operational_task_action(
    task_id: UUID,
    action_id: UUID,
    command: ActionDecisionCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).decide_action(task_id, action_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.patch(
    "/operational-tasks/{task_id}/actions/{action_id}/draft",
    response_model=HumanApprovalAction,
)
async def update_operational_work_order_draft(
    task_id: UUID,
    action_id: UUID,
    command: WorkOrderDraftUpdateCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).update_work_order_draft(task_id, action_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/actions/{action_id}/confirm-dispatch",
    response_model=HumanApprovalAction,
)
async def confirm_operational_work_order_dispatch(
    task_id: UUID,
    action_id: UUID,
    command: WorkOrderConfirmDispatchCommand,
    authorization: str | None = Header(default=None, alias="Authorization"),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
    dispatcher: OperationalActionDispatcher = Depends(get_operational_action_dispatcher),
):
    try:
        return await _service(ctx, conn).confirm_work_order_dispatch(
            task_id, action_id, command, dispatcher, authorization
        )
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/actions/{action_id}/execute",
    response_model=HumanApprovalAction,
)
async def execute_operational_task_action(
    task_id: UUID,
    action_id: UUID,
    command: ActionExecuteCommand,
    authorization: str | None = Header(default=None, alias="Authorization"),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
    dispatcher: OperationalActionDispatcher = Depends(get_operational_action_dispatcher),
):
    try:
        return await _service(ctx, conn).submit_action(
            task_id, action_id, command, dispatcher, authorization
        )
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/actions/{action_id}/reconcile",
    response_model=HumanApprovalAction,
)
async def reconcile_operational_task_action(
    task_id: UUID,
    action_id: UUID,
    command: ActionReconcileCommand,
    authorization: str | None = Header(default=None, alias="Authorization"),
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_VIEW)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
    dispatcher: OperationalActionDispatcher = Depends(get_operational_action_dispatcher),
):
    try:
        return await _service(ctx, conn).reconcile_action(
            task_id, action_id, command, dispatcher, authorization
        )
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/external-feedback",
    response_model=ExternalFeedbackResult,
)
async def synchronize_operational_task_feedback(
    task_id: UUID,
    command: ExternalFeedbackCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXTERNAL_SYNC)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).external_feedback(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post(
    "/operational-tasks/{task_id}/withdraw-external-source",
    response_model=OperationalTaskDetail,
)
async def withdraw_operational_task_external_source(
    task_id: UUID,
    command: ExternalSourceWithdrawalCommand,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXTERNAL_SYNC)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await _service(ctx, conn).withdraw_external_source(task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post("/operational-tasks/{task_id}/questions", response_model=TaskQuestionRequest)
async def create_operational_task_question(
    task_id: UUID, command: TaskQuestionCreate,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_EXECUTE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await create_question(_service(ctx, conn), task_id, command)
    except DomainError as exc:
        _raise_domain(exc)


@router.post("/operational-tasks/{task_id}/questions/{question_id}/answer", response_model=OperationalTaskDetail)
async def answer_operational_task_question(
    task_id: UUID, question_id: UUID, command: TaskQuestionReply,
    ctx: ProjectContext = Depends(require_permission(OPERATIONAL_TASK_WRITE)),
    conn: AsyncConnection = Depends(get_project_pg_connection),
):
    try:
        return await answer_question(_service(ctx, conn), task_id, question_id, command)
    except DomainError as exc:
        _raise_domain(exc)