import os
from fastapi import FastAPI, Request
import anthropic
import spotipy
from spotipy.oauth2 import SpotifyOAuth

# Inicializa o app e o cliente do Claude
app = FastAPI()
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# --- CONFIGURAÇÕES DO SPOTIFY ---
SPOTIPY_CLIENT_ID = '73162ec026ad4d1ea8493c1bce0900d3'
SPOTIPY_CLIENT_SECRET = '43dca155cb4b4bc0ba51ba8eeec94b5e'
SPOTIPY_REDIRECT_URI = 'https://localhost:8080/callback'

# Escopo necessário para buscar músicas e controlar o player do dispositivo
scope = "user-modify-playback-state user-read-playback-state"

sp = spotipy.Spotify(auth_manager=SpotifyOAuth(
    client_id=SPOTIPY_CLIENT_ID,
    client_secret=SPOTIPY_CLIENT_SECRET,
    redirect_uri=SPOTIPY_REDIRECT_URI,
    scope=scope,
    open_browser=False # Importante por estar rodando em um servidor sem interface gráfica
))

# --- FUNÇÕES AUXILIARES ---

def tocar_musica_no_spotify(nome_musica):
    try:
        resultados = sp.search(q=nome_musica, limit=1, type='track')
        tracks = resultados['tracks']['items']
        
        if not tracks:
            return "Não encontrei essa música no Spotify."
            
        track_uri = tracks[0]['uri']
        nome_encontrado = tracks[0]['name']
        artista = tracks[0]['artists'][0]['name']
        
        # Tenta dar o Play no dispositivo ativo
        sp.start_playback(uris=[track_uri])
        return f"Tocando {nome_encontrado} de {artista} no Spotify."
        
    except Exception as e:
        print(f"Erro no Spotify: {e}")
        return "Não consegui tocar. Verifique se o Spotify está aberto e ativo em algum dos seus aparelhos."

def process_with_claude(text: str) -> str:
    """Envia o texto para a API da Anthropic e retorna a resposta pura"""
    try:
        message = client.messages.create(
            model="claude-3-haiku-20240307",
            max_tokens=150,
            temperature=0.2, # Baixa temperatura para respostas lógicas e estruturadas
            system=(
                "Você é o cérebro de uma skill da Alexa. "
                "Responda de forma extremamente concisa, direta e em texto puro. "
                "Nunca use formatações como Markdown, asteriscos ou emojis. "
                "Se o usuário pedir para tocar uma música, extraia as informações e responda APENAS com o formato: "
                "[PLAY: nome da música e artista]. "
                "Para outras perguntas, responda normalmente."
            ),
            messages=[
                {"role": "user", "content": text}
            ]
        )
        return message.content[0].text
    except Exception as e:
        print(f"Erro na API do Claude: {e}")
        return "Desculpe, o assistente inteligente está fora do ar no momento."

def build_alexa_response(text: str, end_session: bool = True):
    """Constrói o payload JSON exatamente como a Amazon Alexa exige"""
    return {
        "version": "1.0",
        "response": {
            "outputSpeech": {
                "type": "PlainText",
                "text": text
            },
            "shouldEndSession": end_session
        }
    }

# --- ROTA PRINCIPAL DA ALEXA ---

@app.post("/alexa") 
async def alexa_webhook(request: Request):
    payload = await request.json()
    
    # Identifica o tipo de requisição da Alexa
    req_type = payload.get("request", {}).get("type")
    
    # 1. Quando você diz apenas "Alexa, abrir meu assistente"
    if req_type == "LaunchRequest":
        return build_alexa_response("Estou ouvindo. O que você quer tocar ou perguntar?", end_session=False)
        
    # 2. Quando você faz uma pergunta ou dá um comando
    if req_type == "IntentRequest":
        try:
            # Captura o texto do slot (assumindo que o nome do slot na skill é "CatchAllSlot")
            slots = payload.get("request", {}).get("intent", {}).get("slots", {})
            spoken_text = slots.get("CatchAllSlot", {}).get("value", "")
            
            if not spoken_text:
                return build_alexa_response("Não consegui ouvir o comando direito.")

            # Envia para o Claude interpretar
            # claude_reply = process_with_claude(spoken_text)
            claude_reply = "[PLAY: the trooper iron maiden]"

            # --- A MÁGICA ACONTECE AQUI ---
            # Se o Claude retornar a tag, extraímos a música e ativamos o Spotify
            if "[PLAY:" in claude_reply:
                nome_musica = claude_reply.split("[PLAY:")[1].split("]")[0].strip()
                texto_para_alexa = tocar_musica_no_spotify(nome_musica)
            else:
                texto_para_alexa = claude_reply
            
            return build_alexa_response(texto_para_alexa, end_session=True)
            
        except Exception as e:
            print(f"Erro: {e}")
            return build_alexa_response("Houve um erro de comunicação com o servidor.")
            
    # 3. Quando a sessão é encerrada
    if req_type == "SessionEndedRequest":
        return {"version": "1.0", "response": {}}