"""
System Configuration Routes
Map provider settings and system configuration management
"""
from typing import List, Dict, Any
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.ext.asyncio import AsyncSession

from app.database import get_db
from app.models.user import User
from app.models.system_config import MapProviderType, ConfigCategory
from app.schemas.config import (
    SystemConfigResponse,
    SystemConfigUpdate,
    SystemConfigBulkUpdate,
    MapProviderConfigResponse,
    MapProviderConfigUpdate,
    MapProviderActivate,
    MapProviderTestRequest,
    MapProviderTestResponse,
)
from app.schemas.common import MessageResponse
from app.services.config_service import ConfigService
from app.utils.dependencies import require_admin

router = APIRouter()


# System Configuration

@router.get("/settings", response_model=List[SystemConfigResponse])
async def get_all_settings(
    category: ConfigCategory = None,
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Get all system configuration settings"""
    if category:
        configs = await ConfigService.get_configs_by_category(db, category)
    else:
        from sqlalchemy import select
        from app.models.system_config import SystemConfig
        
        query = select(SystemConfig).where(SystemConfig.is_visible == True)
        result = await db.execute(query)
        configs = result.scalars().all()
    
    return [SystemConfigResponse.model_validate(c) for c in configs]


@router.put("/settings/{key}", response_model=SystemConfigResponse)
async def update_setting(
    key: str,
    data: SystemConfigUpdate,
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Update a single configuration setting"""
    try:
        config = await ConfigService.set_config(db, key, data.value)
        return SystemConfigResponse.model_validate(config)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))


@router.put("/settings", response_model=List[SystemConfigResponse])
async def update_settings_bulk(
    data: SystemConfigBulkUpdate,
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Update multiple configuration settings at once"""
    configs = await ConfigService.set_configs_bulk(db, data.configs)
    return [SystemConfigResponse.model_validate(c) for c in configs]


# Map Provider Configuration

@router.get("/map-providers", response_model=List[MapProviderConfigResponse])
async def get_map_providers(
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Get all map provider configurations"""
    providers = await ConfigService.get_map_providers(db)
    return [MapProviderConfigResponse.model_validate(p) for p in providers]


@router.get("/map-providers/active", response_model=MapProviderConfigResponse)
async def get_active_map_provider(
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Get the currently active map provider"""
    provider = await ConfigService.get_active_map_provider(db)
    
    if not provider:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="No active map provider configured"
        )
    
    return MapProviderConfigResponse.model_validate(provider)


@router.put("/map-providers/{provider_name}", response_model=MapProviderConfigResponse)
async def update_map_provider(
    provider_name: MapProviderType,
    data: MapProviderConfigUpdate,
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Update map provider configuration"""
    provider = await ConfigService.update_map_provider(
        db,
        provider_name,
        api_key=data.api_key,
        api_secret=data.api_secret,
        api_url=data.api_url,
        settings=data.settings,
        is_active=data.is_active,
        priority=data.priority
    )
    
    return MapProviderConfigResponse.model_validate(provider)


@router.post("/map-providers/activate", response_model=MapProviderConfigResponse)
async def activate_map_provider(
    data: MapProviderActivate,
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Activate a specific map provider (deactivates others)"""
    provider = await ConfigService.activate_map_provider(db, data.provider_name)
    return MapProviderConfigResponse.model_validate(provider)


@router.post("/map-providers/test", response_model=MapProviderTestResponse)
async def test_map_provider(
    data: MapProviderTestRequest,
    current_user: User = Depends(require_admin),
    db: AsyncSession = Depends(get_db)
):
    """Test a map provider configuration"""
    result = await ConfigService.test_map_provider(db, data.provider_name, data.test_address)
    
    return MapProviderTestResponse(
        provider_name=data.provider_name,
        success=result["success"],
        response_time_ms=result.get("response_time_ms", 0),
        error_message=result.get("error"),
        test_result=result.get("test_result")
    )