"""
Эндпоинты для статусов ремонта СА
"""
import logging
from fastapi import APIRouter, File, UploadFile, HTTPException, status
from fastapi.responses import JSONResponse

from adapters.storage import MinIOStorageAdapter
from adapters.parsers import StatusesRepairCAParser
from core.models import UploadRequest, DataRequest
from core.services import ReportService
from core.async_services import AsyncReportService
from app.schemas import UploadResponse, UploadErrorResponse
from app.schemas.statuses_repair_ca import StatusesRepairCARequest

logger = logging.getLogger(__name__)

# Создаем роутер для статусов ремонта СА
router = APIRouter()


def get_report_service() -> ReportService:
    """Получение экземпляра сервиса отчетов"""
    storage_adapter = MinIOStorageAdapter()
    return ReportService(storage_adapter)


def get_async_report_service() -> AsyncReportService:
    """Получение экземпляра асинхронного сервиса отчетов"""
    from core.services import ReportService
    storage_adapter = MinIOStorageAdapter()
    report_service = ReportService(storage_adapter)
    return AsyncReportService(report_service)


@router.post("/statuses_repair_ca/upload", tags=[StatusesRepairCAParser.name],
          summary="Загрузка файла отчета статусов ремонта СА",
          response_model=UploadResponse,
          responses={
              400: {"model": UploadErrorResponse, "description": "Неверный формат файла"},
              500: {"model": UploadErrorResponse, "description": "Внутренняя ошибка сервера"}
          },)
async def upload_statuses_repair_ca(
    file: UploadFile = File(..., description="Excel файл статусов ремонта СА (.xlsx, .xlsm, .xls)")
):
    """Загрузка и обработка отчета статусов ремонта СА"""
    report_service = get_report_service()

    try:
        if not file.filename.endswith(('.xlsx', '.xlsm', '.xls')):
            return JSONResponse(
                status_code=status.HTTP_400_BAD_REQUEST,
                content=UploadErrorResponse(
                    message="Поддерживаются только Excel файлы (.xlsx, .xlsm, .xls)",
                    error_code="INVALID_FILE_TYPE",
                    details={
                        "expected_formats": [".xlsx", ".xlsm", ".xls"],
                        "received_format": file.filename.split('.')[-1] if '.' in file.filename else "unknown"
                    }
                ).model_dump()
            )

        file_content = await file.read()
        request = UploadRequest(
            report_type='statuses_repair_ca',
            file_content=file_content,
            file_name=file.filename
        )

        result = report_service.upload_report(request)

        if result.success:
            return UploadResponse(
                success=True,
                message=result.message,
                object_id=result.object_id
            )
        else:
            return JSONResponse(
                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                content=UploadErrorResponse(
                    message=result.message,
                    error_code="ERR_UPLOAD"
                ).model_dump(),
            )

    except HTTPException:
        raise
    except Exception as e:
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content=UploadErrorResponse(
                message=f"Внутренняя ошибка сервера: {str(e)}",
                error_code="INTERNAL_SERVER_ERROR"
            ).model_dump()
        )


@router.post("/statuses_repair_ca/get_data", tags=[StatusesRepairCAParser.name],
          summary="Получение данных из отчета статусов ремонта СА")
async def get_statuses_repair_ca_data(
    request_data: StatusesRepairCARequest
):
    """Получение данных из отчета статусов ремонта СА"""
    report_service = get_report_service()

    try:
        request_dict = request_data.model_dump()
        request = DataRequest(
            report_type='statuses_repair_ca',
            get_params=request_dict
        )

        result = report_service.get_data(request)

        if result.success:
            return {
                "success": True,
                "data": result.data
            }
        else:
            raise HTTPException(status_code=404, detail=result.message)

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Внутренняя ошибка сервера: {str(e)}")


@router.post("/async/statuses_repair_ca/upload", tags=[StatusesRepairCAParser.name],
          summary="Асинхронная загрузка файла отчета статусов ремонта СА",
          response_model=UploadResponse,
          include_in_schema=False,
          responses={
              400: {"model": UploadErrorResponse, "description": "Неверный формат файла"},
              500: {"model": UploadErrorResponse, "description": "Внутренняя ошибка сервера"}
          },)
async def async_upload_statuses_repair_ca(
    file: UploadFile = File(..., description="Excel файл статусов ремонта СА (.xlsx, .xlsm, .xls)")
):
    """Асинхронная загрузка и обработка отчета статусов ремонта СА"""
    async_service = get_async_report_service()

    try:
        if not file.filename.endswith(('.xlsx', '.xlsm', '.xls')):
            return JSONResponse(
                status_code=status.HTTP_400_BAD_REQUEST,
                content=UploadErrorResponse(
                    message="Поддерживаются только Excel файлы (.xlsx, .xlsm, .xls)",
                    error_code="INVALID_FILE_TYPE",
                    details={
                        "expected_formats": [".xlsx", ".xlsm", ".xls"],
                        "received_format": file.filename.split('.')[-1] if '.' in file.filename else "unknown"
                    }
                ).model_dump()
            )

        file_content = await file.read()
        request = UploadRequest(
            report_type='statuses_repair_ca',
            file_content=file_content,
            file_name=file.filename
        )

        result = await async_service.upload_report_async(request)

        if result.success:
            return UploadResponse(
                success=True,
                message=result.message,
                object_id=result.object_id
            )
        else:
            return JSONResponse(
                status_code=status.HTTP_400_BAD_REQUEST,
                content=UploadErrorResponse(
                    message=result.message,
                    error_code="UPLOAD_FAILED"
                ).model_dump()
            )

    except Exception as e:
        logger.error(f"Ошибка при асинхронной загрузке статусов ремонта СА: {str(e)}")
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content=UploadErrorResponse(
                message=f"Внутренняя ошибка сервера: {str(e)}",
                error_code="INTERNAL_ERROR"
            ).model_dump()
        )