from typing import Optional
from src.services.app_updates import VersaoService
from src.core.auth import require_enterprise_or_front
from fastapi import APIRouter, Depends, HTTPException, Query, status
from src.schemas.app_updates import (
    VersaoResponse
)
from src.core.api_responses import (
    build_success_payload,
    SuccessResponse,
    ErrorResponse
)

router = APIRouter(
    prefix="/versoes",
    tags=["Versões"],
)

versao_service = VersaoService()


@router.get(
    "/check",
    summary="Verificar atualizações",
    description="Verifica se há atualizações disponíveis.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
    responses={
        200: {"description": "Verificação realizada com sucesso"},
        500: {"description": "Erro interno", "model": ErrorResponse},
    },
)
async def check_updates(
    current_version: Optional[str] = Query(
        None, description="Versão atual instalada (ex: 1.0.0)"
    ),
    current_build: Optional[int] = Query(
        None, description="Build atual instalado"
    ),
) -> SuccessResponse:
    """Verifica se há atualizações disponíveis."""
    try:
        result = await versao_service.check_for_updates(
            current_version=current_version,
            current_build=current_build
        )
        return build_success_payload(
            data=result,
            message="Verificação de atualização concluída",
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Erro ao verificar atualizações: {str(e)}",
        )


@router.get(
    "/download/{versao_id}",
    summary="Obter URL de download da versão",
    description="Retorna a URL para download de uma versão específica.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
)
async def download_versao(
    versao_id: int,
) -> SuccessResponse:
    """Obter URL de download da versão."""
    versao = await versao_service.get_versao(versao_id)
    if not versao:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Versão com ID {versao_id} não encontrada",
        )

    return build_success_payload(
        data={"download_url": versao.caminhoArquivo},
        message="URL de download obtida com sucesso",
    )


@router.get(
    "/bucket-ls",
    summary="Listar conteúdo do bucket",
    description="Lista o conteúdo do bucket pomind como o comando b2 ls, "
    "mostrando diretórios e arquivos recursivos.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
    responses={
        200: {"description": "Conteúdo listado com sucesso"},
        500: {"description": "Erro interno", "model": ErrorResponse},
    },
)
async def list_bucket(
    enterprise_id: str = Depends(require_enterprise_or_front),
) -> SuccessResponse:
    """Listar conteúdo do bucket."""
    try:
        result = versao_service.list_bucket_contents()
        return build_success_payload(
            data={"output": result},
            message="Conteúdo do bucket listado com sucesso",
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Erro ao listar bucket: {str(e)}",
        )


@router.get(
    "/",
    summary="Listar versões",
    description="Lista todas as versões com filtros opcionais.",
    status_code=status.HTTP_200_OK,
    response_model=SuccessResponse,
    responses={
        200: {
            "description": "Lista de versões retornada com sucesso"},
        401: {
            "description": "Credenciais inválidas ou ausentes",
            "model": ErrorResponse},
        500: {
            "description": "Erro interno",
            "model": ErrorResponse},
    },
)
async def list_versoes(
    ativo: Optional[bool] = Query(
        None, description="Filtrar por status ativo"
    ),
    limit: int = Query(
        100, description="Limite de resultados", ge=1, le=500
    ),
        enterprise_id: str = Depends(require_enterprise_or_front),
) -> SuccessResponse:
    """Listar todas as versões."""
    try:
        versoes = await versao_service.list_versoes(
            ativo=ativo,
            limit=limit
        )
        versoes_response = [VersaoResponse.model_validate(v) for v in versoes]
        return build_success_payload(
            data=versoes_response,
            message=f"{len(versoes_response)} versão(ões) encontrada(s)",
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Erro ao listar versões: {str(e)}",
        )