from sqlalchemy.ext.asyncio import AsyncSession
from src.core.database import get_db
from src.core.auth import require_enterprise_or_front
from src.services.usuarios_times import UsuarioTimeService
from src.schemas.usuarios_times import (
    UsuarioTimeCreate,
    UsuarioTimeUpdate,
    UsuarioTimeResponse,
)
from src.core.api_responses import (
    build_success_payload,
    SuccessResponse,
    ErrorResponse,
)
from fastapi import APIRouter, Depends, HTTPException, status

router = APIRouter(
    prefix="/usuarios-times",
    tags=["Usuarios-Times"]
)

service = UsuarioTimeService()


@router.post(
    "/vincular",
    summary="Vincular usuário a um time",
    description="Adiciona um usuário a um time com função opcional.",
    status_code=status.HTTP_201_CREATED,
    response_model=SuccessResponse,
    responses={
        201: {"description": "Vínculo criado com sucesso"},
        400: {"description": "Dados inválidos", "model": ErrorResponse},
        401: {"description": "Credenciais inválidas", "model": ErrorResponse},
    },
)
async def vincular_usuario_time(
    payload: UsuarioTimeCreate,
    db: AsyncSession = Depends(get_db),
    _auth=Depends(require_enterprise_or_front),
) -> SuccessResponse:
    """Vincular um usuário a um time"""
    try:
        vinculo = await service.vincular_usuario_time(
            db=db,
            usuario_id=payload.usuario_id,
            time_id=payload.time_id,
            funcao=payload.funcao
        )
        return build_success_payload(
            data=UsuarioTimeResponse.model_validate(vinculo),
            message=(
                f"Usuário {payload.usuario_id} "
                f"vinculado ao time {payload.time_id}"
            ),
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Erro ao vincular usuário ao time: {str(e)}"
        )


@router.delete(
    "/desvincular",
    summary="Desvincular usuário de um time",
    description="Remove um usuário de um time.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
    responses={
        200: {"description": "Vínculo removido com sucesso"},
        404: {"description": "Vínculo não encontrado", "model": ErrorResponse},
        401: {"description": "Credenciais inválidas", "model": ErrorResponse},
    },
)
async def desvincular_usuario_time(
    usuario_id: int,
    time_id: int,
    db: AsyncSession = Depends(get_db),
    _auth=Depends(require_enterprise_or_front),
) -> SuccessResponse:
    """Desvincular usuário de um time"""
    success = await service.desvincular_usuario_time(db, usuario_id, time_id)

    if not success:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Vínculo não encontrado"
        )

    return build_success_payload(
        data=None,
        message=f"Usuário {usuario_id} desvinculado do time {time_id}"
    )


@router.put(
    "/atualizar-funcao",
    summary="Atualizar função do usuário no time",
    description="Atualiza a função/cargo do usuário em um time específico.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
    responses={
        200: {"description": "Função atualizada com sucesso"},
        404: {"description": "Vínculo não encontrado", "model": ErrorResponse},
        401: {"description": "Credenciais inválidas", "model": ErrorResponse},
    },
)
async def atualizar_funcao_usuario_time(
    usuario_id: int,
    time_id: int,
    payload: UsuarioTimeUpdate,
    db: AsyncSession = Depends(get_db),
    _auth=Depends(require_enterprise_or_front),
) -> SuccessResponse:
    """Atualizar função do usuário no time"""
    vinculo = await service.atualizar_funcao(
        db=db,
        usuario_id=usuario_id,
        time_id=time_id,
        funcao=payload.funcao
    )

    if not vinculo:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Vínculo não encontrado"
        )

    return build_success_payload(
        data=UsuarioTimeResponse.model_validate(vinculo),
        message="Função atualizada com sucesso",
    )


@router.get(
    "/time/{time_id}/usuarios",
    summary="Listar usuários de um time",
    description="Retorna todos os usuários vinculados a um time.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
    responses={
        200: {"description": "Usuários listados com sucesso"},
        401: {"description": "Credenciais inválidas", "model": ErrorResponse},
    },
)
async def listar_usuarios_do_time(
    time_id: int,
    db: AsyncSession = Depends(get_db),
    _auth=Depends(require_enterprise_or_front),
) -> SuccessResponse:
    """Listar todos os usuários de um time"""
    vinculos = await service.listar_usuarios_do_time(db, time_id)

    return build_success_payload(
        data=[UsuarioTimeResponse.model_validate(v) for v in vinculos],
        message=f"Total de {len(vinculos)} usuário(s) no time",
    )


@router.get(
    "/usuario/{usuario_id}/times",
    summary="Listar times de um usuário",
    description="Retorna todos os times aos quais o usuário está vinculado.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
    responses={
        200: {"description": "Times listados com sucesso"},
        401: {"description": "Credenciais inválidas", "model": ErrorResponse},
    },
)
async def listar_times_do_usuario(
    usuario_id: int,
    db: AsyncSession = Depends(get_db),
    _auth=Depends(require_enterprise_or_front),
) -> SuccessResponse:
    """Listar todos os times de um usuário"""
    vinculos = await service.listar_times_do_usuario(db, usuario_id)

    return build_success_payload(
        data=[UsuarioTimeResponse.model_validate(v) for v in vinculos],
        message=f"Total de {len(vinculos)} time(s) do usuário",
    )