from __future__ import annotations

import logging
from typing import Any

from fastapi import APIRouter, Depends, HTTPException

from app.modules.auth.presentation.auth import get_current_user, require_role
from app.core.postgres.erp_client import ErpDatabaseClient
from app.models.schemas import (
    AIBudgetSummaryResponse,
    DHSMissionRequest,
    DHSMissionResponse,
    DHSSampleMissionItem,
)
from app.modules.agents.application.agent_scheduler_service import AgentSchedulerService
from app.modules.agents.application.deepseek_harness_service import DeepSeekHarnessService

logger = logging.getLogger("dscons.api.knowledge_agents.dhs")
router = APIRouter()
dhs_service = DeepSeekHarnessService()
scheduler_service = AgentSchedulerService()


@router.get(
    "/v1/agents/harness/sample-missions", response_model=list[DHSSampleMissionItem]
)
def get_dhs_sample_missions(
    current_user: dict[str, Any] = Depends(
        require_role(
            ["superadmin", "director", "admin", "pm", "qs", "engineer"]
        )
    ),
) -> list[DHSSampleMissionItem]:
    """Lấy danh mục các kịch bản nhiệm vụ mẫu 4 Trụ cột của DSCons."""
    try:
        samples = dhs_service.get_sample_missions()
        return [DHSSampleMissionItem(**s) for s in samples]
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi lấy danh mục nhiệm vụ mẫu: {exc!s}"
        ) from exc


@router.post("/v1/agents/harness/execute", response_model=DHSMissionResponse)
async def execute_dhs_mission(
    payload: DHSMissionRequest,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "qs"])
    ),
) -> DHSMissionResponse:
    """Kích hoạt điều phối nhiệm vụ Multi-Agent tự trị bằng DeepSeek Harness (DHS)."""
    try:
        result = await dhs_service.execute_mission(
            mission_title=payload.mission_title,
            mission_prompt=payload.mission_prompt,
            target_project_id=payload.target_project_id,
            pillar=payload.pillar,
            deep_reasoning_enabled=payload.deep_reasoning_enabled,
        )
        return DHSMissionResponse(**result)
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi thực thi nhiệm vụ DeepSeek Harness: {exc!s}"
        ) from exc


@router.get("/v1/agents/harness/history")
def get_dhs_mission_history(
    limit: int = 10,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "qs"])
    ),
) -> dict[str, Any]:
    """Truy xuất lịch sử các nhiệm vụ đã thực thi bởi DeepSeek Harness."""
    try:
        logs = dhs_service.get_mission_history(limit=limit)
        return {
            "total": len(logs),
            "history": logs,
        }
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi truy xuất lịch sử DHS: {exc!s}"
        ) from exc


@router.get("/v1/agents/schedule/daily")
def get_daily_agent_schedule(
    current_user: dict[str, Any] = Depends(
        require_role(
            ["superadmin", "director", "admin", "pm", "qs", "engineer"]
        )
    ),
) -> dict[str, Any]:
    """Lấy bảng phân ca làm việc so le thông minh trong ngày của 9 Nhân sự AI."""
    try:
        schedule = scheduler_service.get_daily_schedule()
        return {
            "total_shifts": len(schedule),
            "shifts": schedule,
        }
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi lấy lịch làm việc AI: {exc!s}"
        ) from exc


@router.get("/v1/agents/schedule/anti-spam-status")
def get_anti_spam_status(
    current_user: dict[str, Any] = Depends(
        require_role(
            ["superadmin", "director", "admin", "pm", "qs", "engineer"]
        )
    ),
) -> dict[str, Any]:
    """Lấy trạng thái bộ đệm bảo vệ chống Rate Limit & Spam Detection (OpenRouter & Local failover)."""
    try:
        return scheduler_service.get_anti_spam_shield_status()
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi kiểm tra bộ đệm chống spam: {exc!s}"
        ) from exc


@router.get("/v1/agents/budget-summary", response_model=AIBudgetSummaryResponse)
def get_ai_agents_budget_summary(
    agent_code: str | None = None,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "accountant"])
    ),
) -> AIBudgetSummaryResponse:
    """Truy xuất tổng hợp ngân sách tiêu thụ theo ngày, tuần, tháng, năm của nhân viên AI."""
    client = ErpDatabaseClient()
    try:
        data = client.get_ai_agent_budget_summary(agent_code=agent_code)
        return AIBudgetSummaryResponse(**data)
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi truy xuất ngân sách AI: {exc!s}"
        ) from exc

from fastapi.responses import StreamingResponse

@router.post("/v1/agents/harness/execute_stream")
async def execute_dhs_mission_stream(
    payload: DHSMissionRequest,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "qs"])
    ),
):
    """Kích hoạt điều phối nhiệm vụ Multi-Agent tự trị bằng DeepSeek Harness (DHS) qua SSE."""
    async def event_generator():
        try:
            async for event in dhs_service.execute_mission_stream(
                mission_title=payload.mission_title,
                mission_prompt=payload.mission_prompt,
                target_project_id=payload.target_project_id,
                pillar=payload.pillar,
                deep_reasoning_enabled=payload.deep_reasoning_enabled,
            ):
                yield f"data: {event}\n\n"
        except Exception as exc:
            import json
            yield f"data: {json.dumps({'type': 'ERROR', 'message': str(exc)})}\n\n"

    return StreamingResponse(event_generator(), media_type="text/event-stream")

import os
from fastapi.responses import FileResponse

@router.get("/v1/agents/reports")
def list_executive_reports(
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "qs"])
    ),
) -> dict[str, Any]:
    """Danh sách các file Báo cáo điều hành tự động đã lưu."""
    report_dir = "storage/secure_vault/reports"
    if not os.path.exists(report_dir):
        return {"reports": []}
    
    reports = []
    for filename in os.listdir(report_dir):
        if filename.endswith(".md"):
            filepath = os.path.join(report_dir, filename)
            stat = os.stat(filepath)
            reports.append({
                "filename": filename,
                "size_bytes": stat.st_size,
                "created_at": stat.st_mtime
            })
    
    # Sort by newest first
    reports.sort(key=lambda x: x["created_at"], reverse=True)
    return {"reports": reports}

@router.get("/v1/agents/reports/{filename}")
def download_executive_report(
    filename: str,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "qs"])
    ),
):
    """Tải xuống file Báo cáo điều hành (bảo mật nghiêm ngặt chống Local File Inclusion)."""
    # 1. Chống thư mục giả mạo (Directory Traversal)
    safe_filename = os.path.basename(filename)
    if safe_filename != filename:
        raise HTTPException(status_code=403, detail="Tên file không hợp lệ (Phát hiện Directory Traversal).")
    
    # 2. Chỉ cho phép định dạng .md
    if not safe_filename.endswith(".md"):
        raise HTTPException(status_code=403, detail="Chỉ cho phép truy xuất định dạng .md.")

    report_dir = os.path.abspath("storage/secure_vault/reports")
    file_path = os.path.abspath(os.path.join(report_dir, safe_filename))

    # 3. Double check đường dẫn tuyệt đối phải nằm trong thư mục reports
    if not file_path.startswith(report_dir):
        raise HTTPException(status_code=403, detail="Cố gắng truy cập ngoài thư mục cho phép.")

    if not os.path.exists(file_path):
        raise HTTPException(status_code=404, detail="Không tìm thấy file báo cáo.")

    return FileResponse(
        file_path, 
        media_type="text/markdown", 
        filename=safe_filename
    )