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

from adapters.storage import MinIOStorageAdapter
from adapters.parsers import MonitoringFuelParser
from core.models import UploadRequest, DataRequest
from core.services import ReportService
from core.async_services import AsyncReportService
from app.schemas import (
    UploadResponse, UploadErrorResponse,
    MonitoringFuelMonthRequest, MonitoringFuelTotalRequest, MonitoringFuelSeriesRequest
)

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("/monitoring_fuel/upload-zip", tags=[MonitoringFuelParser.name],
          summary="Загрузка файлов сводок мониторинга топлива одним ZIP-архивом",
          response_model=UploadResponse,
          responses={
            400: {"model": UploadErrorResponse, "description": "Неверный формат архива или файлов"},
            500: {"model": UploadErrorResponse, "description": "Внутренняя ошибка сервера"}
          },)
async def upload_monitoring_fuel_zip(
        zip_file: UploadFile = File(..., description="ZIP архив с Excel файлами (.zip)")
):
    """Загрузка файлов сводок мониторинга топлива одним ZIP-архивом

    ### Поддерживаемые форматы:
    - **ZIP архивы** с файлами мониторинга топлива

    ### Структура данных:
    - Обрабатывает ZIP архивы с файлами по месяцам (monitoring_SNPZ_01.xlsm - monitoring_SNPZ_12.xlsm)
    - Извлекает данные по установкам (SNPZ_IDS)
    - Возвращает агрегированные данные по месяцам

    ### Пример использования:
    1. Подготовьте ZIP архив с файлами мониторинга топлива
    2. Загрузите архив через этот эндпоинт
    3. Используйте полученный `object_id` для запросов данных
    """
    report_service = get_report_service()

    try:
        # Проверяем тип файла - только ZIP архивы
        if not zip_file.filename.endswith('.zip'):
            return JSONResponse(
                status_code=status.HTTP_400_BAD_REQUEST,
                content=UploadErrorResponse(
                    message="Файл должен быть ZIP архивом",
                    error_code="INVALID_FILE_TYPE",
                    details={
                        "expected_formats": [".zip"],
                        "received_format": zip_file.filename.split('.')[-1] if '.' in zip_file.filename else "unknown"
                    }
                ).model_dump()
            )

        # Читаем содержимое файла
        file_content = await zip_file.read()

        # Создаем запрос
        request = UploadRequest(
            report_type='monitoring_fuel',
            file_content=file_content,
            file_name=zip_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("/monitoring_fuel/get_total_by_columns", tags=[MonitoringFuelParser.name],
          summary="Получение данных по колонкам и расчёт средних значений")
async def get_monitoring_fuel_total_by_columns(
    request_data: MonitoringFuelTotalRequest
):
    """Получение данных из сводок мониторинга топлива по колонкам и расчёт средних значений

    ### Структура параметров:
    - `columns`: **Массив названий** выбираемых столбцов (обязательный)

    ### Пример тела запроса:
    ```json
    {
        "columns": ["total", "normativ"]
    }
    ```
    """
    report_service = get_report_service()

    try:
        # Создаем запрос
        request_dict = request_data.model_dump()
        request_dict['mode'] = 'total_by_columns'
        request = DataRequest(
            report_type='monitoring_fuel',
            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("/monitoring_fuel/get_month_by_code", tags=[MonitoringFuelParser.name],
          summary="Получение данных за месяц")
async def get_monitoring_fuel_month_by_code(
    request_data: MonitoringFuelMonthRequest
):
    """Получение данных из сводок мониторинга топлива за указанный номер месяца

    ### Структура параметров:
    - `month`: **Номер месяца строкой с ведущим 0** (обязательный)

    ### Пример тела запроса:
    ```json
    {
        "month": "02"
    }
    ```
    """
    report_service = get_report_service()

    try:
        # Создаем запрос
        request_dict = request_data.model_dump()
        request_dict['mode'] = 'month_by_code'
        request = DataRequest(
            report_type='monitoring_fuel',
            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("/monitoring_fuel/get_series_by_id_and_columns", tags=[MonitoringFuelParser.name],
          summary="Получение временных рядов по колонкам для всех ID")
async def get_monitoring_fuel_series_by_id_and_columns(
    request_data: MonitoringFuelSeriesRequest
):
    """Получение временных рядов данных из сводок мониторинга топлива по колонкам для всех ID

    ### Структура параметров:
    - `columns`: **Массив названий** выбираемых столбцов (обязательный)

    ### Пример тела запроса:
    ```json
    {
        "columns": ["total", "normativ"]
    }
    ```
    
    ### Возвращаемые данные:
    Временные ряды в формате массивов по месяцам:
    ```json
    {
        "SNPZ.VISB": {
            "total": [23.86, 26.51, 19.66, 25.46, 24.85, 22.38, 21.48, 23.5],
            "normativ": [19.46, 19.45, 18.57, 18.57, 18.56, 18.57, 18.57, 18.57]
        },
        "SNPZ.IZOM": {
            "total": [184.01, 195.17, 203.06, 157.33, 158.30, 168.34, 162.12, 149.44],
            "normativ": [158.02, 158.02, 162.73, 162.73, 162.73, 162.73, 162.73, 162.73]
        }
    }
    ```
    """
    report_service = get_report_service()

    try:
        # Создаем запрос
        request_dict = request_data.model_dump()
        request_dict['mode'] = 'series_by_id_and_columns'
        request = DataRequest(
            report_type='monitoring_fuel',
            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/monitoring_fuel/upload-zip", tags=[MonitoringFuelParser.name],
          summary="Асинхронная загрузка файлов сводок мониторинга топлива одним ZIP-архивом",
          response_model=UploadResponse,
          include_in_schema=False,
          responses={
            400: {"model": UploadErrorResponse, "description": "Неверный формат архива или файлов"},
            500: {"model": UploadErrorResponse, "description": "Внутренняя ошибка сервера"}
          },)
async def async_upload_monitoring_fuel_zip(
        zip_file: UploadFile = File(..., description="ZIP архив с Excel файлами (.zip)")
):
    """Асинхронная загрузка файлов сводок мониторинга топлива одним ZIP-архивом"""
    async_service = get_async_report_service()
    try:
        if not zip_file.filename.endswith('.zip'):
            return JSONResponse(
                status_code=status.HTTP_400_BAD_REQUEST,
                content=UploadErrorResponse(
                    message="Файл должен быть ZIP архивом",
                    error_code="INVALID_FILE_TYPE",
                    details={
                        "expected_formats": [".zip"],
                        "received_format": zip_file.filename.split('.')[-1] if '.' in zip_file.filename else "unknown"
                    }
                ).model_dump()
            )
        file_content = await zip_file.read()
        # Создаем запрос
        request = UploadRequest(
            report_type='monitoring_fuel',
            file_content=file_content,
            file_name=zip_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()
        )