"""Operational data routes for DSCons."""

from __future__ import annotations

import asyncio
from typing import Any

from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi.responses import JSONResponse, StreamingResponse

from app.modules.auth.presentation.auth import get_current_user, require_role
from app.models.schemas import (
    CompanyOperationalStateResponse,
    EmployeeLogsResponse,
    OperationsActionsResponse,
    OperationsBlockersResponse,
    OperationsCasesResponse,
    ProjectManagementResponse,
    RemediationBuildRequest,
    RemediationBuildResponse,
    RemediationGapsResponse,
    RemediationListResponse,
)
from app.modules.operations.application.company_operational_state_service import (
    CompanyOperationalStateService,
)
from app.modules.core.application.employee_logs_service import EmployeeLogsService
from app.modules.operations.application.operations_case_management_service import (
    OperationsCaseManagementService,
)
from app.modules.projects.application.project_management_service import ProjectManagementService
from app.modules.core.application.remediation_planning_service import RemediationPlanningService

router = APIRouter()


@router.get("/v1/employees/logs", response_model=EmployeeLogsResponse)
def employee_logs(
    current_user: dict[str, Any] = Depends(get_current_user),
) -> EmployeeLogsResponse:
    """Return employee log data with source metadata and safe fallback behavior."""
    return EmployeeLogsService().get_employee_logs()


@router.get("/v1/projects/management", response_model=ProjectManagementResponse)
def project_management_data(
    current_user: dict[str, Any] = Depends(get_current_user),
) -> ProjectManagementResponse:
    """Return project management data with source metadata and safe fallback behavior."""
    return ProjectManagementService().get_project_management_data()


@router.get(
    "/v1/company/operational-state", response_model=CompanyOperationalStateResponse
)
def company_operational_state(
    current_user: dict[str, Any] = Depends(get_current_user),
) -> CompanyOperationalStateResponse:
    """Return aggregated company operational state for the digital twin view."""
    return CompanyOperationalStateService().get_company_operational_state()


@router.get("/v1/operations/cases", response_model=OperationsCasesResponse)
def operations_cases(
    project_code: str | None = Query(default=None),
    status: str | None = Query(default=None),
    current_user: dict[str, Any] = Depends(get_current_user),
) -> OperationsCasesResponse:
    """Return Phase 1 operations cases derived from dossier review workflow data."""
    return OperationsCaseManagementService().list_cases(
        project_code=project_code,
        status=status,
    )


@router.get("/v1/operations/actions", response_model=OperationsActionsResponse)
def operations_actions(
    project_code: str | None = Query(default=None),
    status: str | None = Query(default=None),
    current_user: dict[str, Any] = Depends(get_current_user),
) -> OperationsActionsResponse:
    """Return Phase 1 operations action queue derived from dossier review workflow data."""
    return OperationsCaseManagementService().list_actions(
        project_code=project_code,
        status=status,
    )


@router.get("/v1/operations/blockers", response_model=OperationsBlockersResponse)
def operations_blockers(
    project_code: str | None = Query(default=None),
    current_user: dict[str, Any] = Depends(get_current_user),
) -> OperationsBlockersResponse:
    """Return Phase 1 operations blocker queue derived from dossier review workflow data."""
    return OperationsCaseManagementService().list_blockers(project_code=project_code)


@router.get("/v1/remediation/plans", response_model=RemediationListResponse)
def list_remediation_plans(
    project_code: str | None = Query(default=None),
    review_id: str | None = Query(default=None),
    finding_code: str | None = Query(default=None),
    current_user: dict[str, Any] = Depends(get_current_user),
) -> RemediationListResponse:
    """Return remediation plans inferred from open dossier findings."""
    return RemediationPlanningService().list_plans(
        project_code=project_code,
        review_id=review_id,
        finding_code=finding_code,
    )


@router.post("/v1/remediation/plans/build", response_model=RemediationBuildResponse)
def build_remediation_plan(
    payload: RemediationBuildRequest,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "pm", "site_engineer"])
    ),
) -> RemediationBuildResponse:
    """Build one remediation plan from an explicit selector payload."""
    return RemediationPlanningService().build_plan(payload)


@router.get("/v1/remediation/gaps", response_model=RemediationGapsResponse)
def list_remediation_gaps(
    project_code: str | None = Query(default=None),
    review_id: str | None = Query(default=None),
    current_user: dict[str, Any] = Depends(get_current_user),
) -> RemediationGapsResponse:
    """Return normalized remediation gaps inferred from open dossier findings."""
    return RemediationPlanningService().list_gaps(
        project_code=project_code,
        review_id=review_id,
    )


@router.get("/v1/company/operational-state/stream")
async def company_operational_state_stream() -> StreamingResponse:
    """Stream aggregated company operational state updates over SSE."""

    async def event_generator():
        # Tạo payload định kỳ để dashboard luôn cập nhật.
        from starlette.concurrency import run_in_threadpool
        service = CompanyOperationalStateService()
        while True:
            state = await run_in_threadpool(service.get_company_operational_state)
            payload = state.model_dump()
            yield f"event: operational_state\ndata: {JSONResponse(content=payload).body.decode('utf-8')}\n\n"
            await asyncio.sleep(5)

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

# NOTE: dossier_coverage endpoint removed — canonical route is in
# app.modules.dossier.presentation.dossier_modules.dossier_readiness_routes