"""
Общие эндпоинты FastAPI
"""
import logging
from typing import Dict, List
from fastapi import APIRouter, HTTPException, status
from fastapi.responses import JSONResponse

from adapters.pconfig import SINGLE_OGS
from core.services import ReportService, PARSERS
from app.schemas import ServerInfoResponse

logger = logging.getLogger(__name__)

# Создаем роутер для общих эндпоинтов
router = APIRouter()


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


@router.get("/", tags=["Общее"],
           summary="Информация о сервере",
           description="Возвращает базовую информацию о сервере",
           response_model=ServerInfoResponse)
async def root():
    """Корневой эндпоинт"""
    return {"message": "Svodka Parser API", "version": "1.0.0"}


@router.get("/parsers", tags=["Общее"],
           summary="Список доступных парсеров",
           description="Возвращает список идентификаторов всех доступных парсеров",
           response_model=Dict[str, List[str]],
           responses={
               200: {
                   "content": {
                       "application/json": {
                           "example": {
                               "parsers": ["monitoring_fuel", "svodka_ca", "svodka_pm"]
                           }
                       }
                   }
               }
           },)
async def get_available_parsers():
    """Получение списка доступных парсеров"""
    parsers = list(PARSERS.keys())
    return {"parsers": parsers}


@router.get("/parsers/{parser_name}/available_ogs", tags=["Общее"],
           summary="Доступные ОГ для парсера",
           description="Возвращает список доступных ОГ для указанного парсера",
           responses={
               200: {
                   "content": {
                       "application/json": {
                           "example": {
                               "parser": "svodka_repair_ca",
                               "available_ogs": ["KNPZ", "ANHK", "SNPZ", "BASH"]
                           }
                       }
                   }
               }
           },)
async def get_available_ogs(parser_name: str):
    """Получение списка доступных ОГ для парсера"""
    if parser_name not in PARSERS:
        raise HTTPException(status_code=404, detail=f"Парсер '{parser_name}' не найден")
    
    parser_class = PARSERS[parser_name]
    
    # Для парсеров с данными в MinIO возвращаем ОГ из загруженных данных
    if parser_name in ["svodka_repair_ca", "oper_spravka_tech_pos"]:
        try:
            # Создаем экземпляр сервиса и загружаем данные из MinIO
            report_service = get_report_service()
            from core.models import DataRequest
            data_request = DataRequest(report_type=parser_name, get_params={})
            loaded_data = report_service.get_data(data_request)
            # Если данные загружены, извлекаем ОГ из них
            if loaded_data is not None and hasattr(loaded_data, 'data') and loaded_data.data is not None:
                # Для svodka_repair_ca данные возвращаются в формате словаря по ОГ
                if parser_name == "svodka_repair_ca":
                    data_value = loaded_data.data.get('value')
                    if isinstance(data_value, dict):
                        available_ogs = list(data_value.keys())
                        return {"parser": parser_name, "available_ogs": available_ogs}
                # Для oper_spravka_tech_pos данные возвращаются в формате списка
                elif parser_name == "oper_spravka_tech_pos":
                    # Данные уже в правильном формате, возвращаем их
                    if isinstance(loaded_data.data, list) and loaded_data.data:
                        # Извлекаем уникальные ОГ из данных
                        available_ogs = []
                        for item in loaded_data.data:
                            if isinstance(item, dict) and 'id' in item:
                                available_ogs.append(item['id'])
                        if available_ogs:
                            return {"parser": parser_name, "available_ogs": available_ogs}
        except Exception as e:
            logger.error(f"⚠️ Ошибка при получении ОГ: {e}")
            import traceback
            traceback.print_exc()
    
    # Для других парсеров или если нет данных возвращаем статический список из pconfig
    return {"parser": parser_name, "available_ogs": SINGLE_OGS}


@router.get("/parsers/{parser_name}/getters", tags=["Общее"],
           summary="Информация о геттерах парсера",
           description="Возвращает информацию о доступных геттерах для указанного парсера",
           responses={
               200: {
                   "content": {
                       "application/json": {
                           "example": {
                               "parser": "svodka_pm",
                               "getters": [
                                   {
                                       "name": "get_single_og",
                                       "description": "Получение данных по одному ОГ",
                                       "parameters": ["id", "codes", "columns", "search"]
                                   }
                               ]
                           }
                       }
                   }
               }
           },)
async def get_parser_getters(parser_name: str):
    """Получение информации о геттерах парсера"""
    if parser_name not in PARSERS:
        raise HTTPException(status_code=404, detail=f"Парсер '{parser_name}' не найден")
    
    parser_class = PARSERS[parser_name]
    parser_instance = parser_class()
    
    # Получаем информацию о геттерах
    getters_info = []
    if hasattr(parser_instance, 'getters'):
        for getter_name, getter_info in parser_instance.getters.items():
            getters_info.append({
                "name": getter_name,
                "description": getter_info.get('description', ''),
                "parameters": list(getter_info.get('schema', {}).get('properties', {}).keys())
            })
    
    return {
        "parser": parser_name,
        "getters": getters_info
    }


@router.get("/server-info", tags=["Общее"],
           summary="Подробная информация о сервере",
           description="Возвращает подробную информацию о сервере, включая версии и конфигурацию",
           response_model=ServerInfoResponse)
async def get_server_info():
    """Получение подробной информации о сервере"""
    import platform
    import sys
    import os
    import psutil
    
    # Получаем информацию о процессе
    process = psutil.Process()
    parent_process = process.parent()
    
    # Получаем информацию о системе
    cpu_cores = psutil.cpu_count()
    memory_info = psutil.virtual_memory()
    memory_mb = memory_info.total / (1024 * 1024)  # Конвертируем в MB
    
    return {
        "message": "Svodka Parser API",
        "version": "1.0.0",
        "process_id": process.pid,
        "parent_id": parent_process.pid if parent_process else None,
        "cpu_cores": cpu_cores,
        "memory_mb": memory_mb,
        "python_version": sys.version,
        "platform": platform.platform(),
        "available_parsers": list(PARSERS.keys())
    }