"""
Routes API pour la gestion des groupes Ansible.
"""

from fastapi import APIRouter, Depends, HTTPException

from app.core.dependencies import verify_api_key
from app.schemas.group import GroupRequest, GroupUpdateRequest, GroupDeleteRequest
from app.services import ansible_service

router = APIRouter()


@router.get("")
async def get_groups(api_key_valid: bool = Depends(verify_api_key)):
    """Récupère la liste de tous les groupes Ansible."""
    groups = ansible_service.get_groups()
    env_groups = ansible_service.get_env_groups()
    role_groups = ansible_service.get_role_groups()
    
    result = []
    for group in groups:
        group_type = "env" if group in env_groups else ("role" if group in role_groups else "other")
        hosts = ansible_service.get_group_hosts(group)
        result.append({
            "name": group,
            "type": group_type,
            "display_name": group.replace("env_", "").replace("role_", "").replace("_", " ").title(),
            "hosts_count": len(hosts),
            "hosts": hosts,
        })
    
    return {
        "groups": result,
        "env_count": len(env_groups),
        "role_count": len(role_groups),
    }


@router.get("/{group_name}")
async def get_group(group_name: str, api_key_valid: bool = Depends(verify_api_key)):
    """Récupère les détails d'un groupe."""
    if not ansible_service.group_exists(group_name):
        raise HTTPException(status_code=404, detail=f"Groupe '{group_name}' non trouvé")
    
    env_groups = ansible_service.get_env_groups()
    role_groups = ansible_service.get_role_groups()
    group_type = "env" if group_name in env_groups else ("role" if group_name in role_groups else "other")
    hosts = ansible_service.get_group_hosts(group_name)
    
    return {
        "name": group_name,
        "type": group_type,
        "display_name": group_name.replace("env_", "").replace("role_", "").replace("_", " ").title(),
        "hosts_count": len(hosts),
        "hosts": hosts,
    }


@router.post("")
async def create_group(request: GroupRequest, api_key_valid: bool = Depends(verify_api_key)):
    """Crée un nouveau groupe."""
    # Valider le préfixe selon le type
    expected_prefix = f"{request.type}_"
    if not request.name.startswith(expected_prefix):
        raise HTTPException(
            status_code=400,
            detail=f"Le nom du groupe de type '{request.type}' doit commencer par '{expected_prefix}'"
        )
    
    # Vérifier si le groupe existe déjà
    if ansible_service.group_exists(request.name):
        raise HTTPException(status_code=400, detail=f"Le groupe '{request.name}' existe déjà")
    
    try:
        ansible_service.add_group(request.name, request.type)
        return {
            "message": f"Groupe '{request.name}' créé avec succès",
            "group": {
                "name": request.name,
                "type": request.type,
                "hosts_count": 0,
            }
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Erreur lors de la création du groupe: {str(e)}")


@router.put("/{group_name}")
async def update_group(
    group_name: str,
    request: GroupUpdateRequest,
    api_key_valid: bool = Depends(verify_api_key)
):
    """Renomme un groupe."""
    if not ansible_service.group_exists(group_name):
        raise HTTPException(status_code=404, detail=f"Groupe '{group_name}' non trouvé")
    
    # Vérifier que le nouveau nom a le même préfixe
    old_prefix = group_name.split("_")[0] + "_" if "_" in group_name else ""
    new_prefix = request.new_name.split("_")[0] + "_" if "_" in request.new_name else ""
    
    if old_prefix and old_prefix != new_prefix:
        raise HTTPException(
            status_code=400,
            detail=f"Le nouveau nom doit conserver le même préfixe '{old_prefix}'"
        )
    
    # Vérifier si le nouveau nom existe déjà
    if ansible_service.group_exists(request.new_name):
        raise HTTPException(status_code=400, detail=f"Le groupe '{request.new_name}' existe déjà")
    
    try:
        ansible_service.rename_group(group_name, request.new_name)
        return {
            "message": f"Groupe renommé de '{group_name}' vers '{request.new_name}'",
            "old_name": group_name,
            "new_name": request.new_name,
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Erreur lors du renommage: {str(e)}")


@router.delete("/{group_name}")
async def delete_group(
    group_name: str,
    move_hosts_to: str = None,
    api_key_valid: bool = Depends(verify_api_key)
):
    """Supprime un groupe."""
    if not ansible_service.group_exists(group_name):
        raise HTTPException(status_code=404, detail=f"Groupe '{group_name}' non trouvé")
    
    # Vérifier le groupe de destination si spécifié
    if move_hosts_to and not ansible_service.group_exists(move_hosts_to):
        raise HTTPException(status_code=400, detail=f"Groupe de destination '{move_hosts_to}' non trouvé")
    
    hosts = ansible_service.get_group_hosts(group_name)
    
    try:
        ansible_service.delete_group(group_name, move_hosts_to)
        return {
            "message": f"Groupe '{group_name}' supprimé",
            "hosts_moved": len(hosts) if move_hosts_to else 0,
            "moved_to": move_hosts_to,
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Erreur lors de la suppression: {str(e)}")