import logging

from core.database import get_sqlserver_db
from sqlalchemy.ext.asyncio import AsyncSession
from schemas.auth import UserLogin
from services.auth import AuthService
from fastapi import APIRouter, Depends, Header, HTTPException, status
from core.api_responses import build_success_payload, SuccessResponse, ErrorResponse
from typing import Optional

logger = logging.getLogger(__name__)

router = APIRouter(
    prefix="/auth",
    tags=["Autenticação"],
)

@router.post(
    "/login",
    summary="Realizar login",
    description="""
Realiza autenticação do usuário e retorna o token do cliente associado.

**Fluxo:**
1. Valida email e senha do usuário na tabela `dbo.Usuario` (SQL Server)
2. Busca o cliente associado ao usuário na tabela `dbo.Cliente` (SQL Server)
3. Retorna o token do cliente como `access_token`

**Tabelas consultadas:**
- `dbo.Usuario` (SQL Server) - validação de credenciais
- `dbo.Cliente` (SQL Server) - busca do token do cliente

**Exemplo de uso:**
```bash
curl -X POST 'http://localhost:8000/auth/login' \\
  -H 'Content-Type: application/json' \\
  -d '{"email": "usuario@example.com", "senha": "senha123"}'
```

**Resposta de sucesso:**
```json
{
  "access_token": "token_do_cliente",
  "token_type": "bearer"
}
```
""",
    response_model=SuccessResponse,
    responses={
        200: {"description": "Login realizado com sucesso"},
        401: {"description": "Credenciais inválidas", "model": ErrorResponse},
        500: {"description": "Erro interno", "model": ErrorResponse},
    },
    openapi_extra={
        "responses": {
            "200": {
                "content": {
                    "application/json": {
                        "example": {
                            "message": "Login realizado com sucesso",
                            "data": {
                                "access_token": "token_do_cliente",
                                "token_type": "bearer"
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            }
        },
        "requestBody": {
            "content": {
                "application/json": {
                    "example": {
                        "email": "usuario@example.com",
                        "senha": "senha123"
                    }
                }
            }
        }
    }
)
async def login(
    data: UserLogin,
    db: AsyncSession = Depends(get_sqlserver_db),
):
    logger.info(f"Iniciando processo de login para email: {data.email}")
    
    try:
        token_data = await AuthService.login(
            db=db,
            email=data.email,
            senha=data.senha,
        )
        
        logger.info(f"Login realizado com sucesso para email: {data.email}")
        return build_success_payload(
            data=token_data,
            message="Login realizado com sucesso"
        )
    
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Erro ao processar login: {e}", exc_info=True)
        raise

@router.get(
    "/me",
    summary="Obter informações do cliente autenticado",
    description="""
Retorna informações do cliente autenticado baseado no token fornecido.

**Autenticação:**
- Header: `Authorization: Bearer <token>`
- O token deve ser o token do cliente retornado no login

**Tabela consultada:**
- `dbo.Cliente` (SQL Server) - busca informações do cliente pelo token

**Exemplo de uso:**
```bash
curl -X GET 'http://localhost:8000/auth/me' \\
  -H 'Authorization: Bearer <token>'
```

**Resposta de sucesso:**
```json
{
  "message": "Informações do cliente obtidas com sucesso",
  "data": {
    "nome": "Nome Fantasia ou Razão Social",
    "telefone": "1234567890",
    "celular": "9876543210",
    "email": "email@example.com"
  },
  "timestamp": "2025-01-01T12:00:00Z"
}
```
""",
    response_model=SuccessResponse,
    responses={
        200: {"description": "Informações do cliente"},
        401: {"description": "Token inválido ou ausente", "model": ErrorResponse},
        500: {"description": "Erro interno", "model": ErrorResponse},
    },
    openapi_extra={
        "responses": {
            "200": {
                "content": {
                    "application/json": {
                        "example": {
                            "message": "Informações do cliente obtidas com sucesso",
                            "data": {
                                "nome": "Nome Fantasia ou Razão Social",
                                "telefone": "1234567890",
                                "celular": "9876543210",
                                "email": "email@example.com"
                            },
                            "timestamp": "2025-01-01T12:00:00Z"
                        }
                    }
                }
            }
        }
    }
)
async def me(
    Authorization: Optional[str] = Header(None),
    db: AsyncSession = Depends(get_sqlserver_db),
):
    logger.info("Buscando informações do cliente autenticado")
    
    if Authorization is None:
        logger.warning("Token não enviado")
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Token não enviado"
        )
    
    try:
        token = Authorization.replace("Bearer ", "").strip()
    except Exception as e:
        logger.warning(f"Erro ao extrair token: {e}")
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Formato de token inválido"
        )
    
    try:
        cliente_dict = await AuthService.get_current_cliente(db=db, token=token)
        
        nome = cliente_dict.get("NomeFantasia") or cliente_dict.get("RazaoSocial")
        data = {
            "nome": nome,
            "telefone": cliente_dict.get("Telefone"),
            "celular": cliente_dict.get("Celular"),
            "email": cliente_dict.get("EmailOperacional"),
        }
        
        logger.info("Informações do cliente obtidas com sucesso")
        return build_success_payload(
            data=data,
            message="Informações do cliente obtidas com sucesso"
        )
    
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Erro ao obter informações do cliente: {e}", exc_info=True)
        raise