routes/subscription.py

import stripe
import logging
import json
from datetime import datetime
import pytz
import os
import requests
import asyncio
import jwt
from fastapi import APIRouter, HTTPException, Request, Header
from pydantic import BaseModel

router = APIRouter()

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

# 🔥 Pegando as chaves do ambiente
stripe.api_key = os.getenv("STRIPE_KEY")  # Lendo do ambiente
stripe.api_version = "2023-10-16"

# 🔥 Supabase Configuração com Secrets
SUPABASE_URL = "https://ussxqnifefkgkaumjann.supabase.co"
SUPABASE_KEY = os.getenv("SUPA_KEY")  # Lendo do ambiente
SUPABASE_ROLE_KEY = os.getenv("SUPA_SERVICE_KEY")

if not stripe.api_key or not SUPABASE_KEY or not SUPABASE_ROLE_KEY:
    raise ValueError("❌ STRIPE_KEY, SUPA_KEY ou SUPA_SERVICE_KEY não foram definidos no ambiente!")

SUPABASE_HEADERS = {
    "apikey": SUPABASE_KEY,
    "Authorization": f"Bearer {SUPABASE_KEY}",
    "Content-Type": "application/json"
}

SUPABASE_ROLE_HEADERS = {
    "apikey": SUPABASE_ROLE_KEY,
    "Authorization": f"Bearer {SUPABASE_ROLE_KEY}",
    "Content-Type": "application/json"
}

class EmergencyPaymentRequest(BaseModel):
    id: str  # ID do estilista

class UserIDRequest(BaseModel):
    user_id: str

class CheckSubscriptionRequest(BaseModel):
    stylist_id: str
    user_id: str  # Agora recebemos diretamente o user_id
    
class SubscriptionRequest(BaseModel):
    id: str  # ID do estilista

class CreatePriceRequest(BaseModel):
    amount: int  # Valor em centavos (ex: 2500 para R$25,00)
    emergency_price: int  # Valor de emergência (ex: 500 para R$5,00)
    consultations: int  # Número de consultas (ex: 3)

def verify_token(user_token: str) -> str:
    """
    Valida o token JWT no Supabase e retorna o user_id se for válido.
    """
    if not user_token or len(user_token.split('.')) != 3:
        raise HTTPException(status_code=400, detail="Invalid JWT token format")
    
    # Verificando o JWT
    try:
        jwt.decode(user_token, options={"verify_signature": False})  # Decodifica sem validar a assinatura, apenas para verificar o formato
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token expired")
    except jwt.DecodeError:
        raise HTTPException(status_code=401, detail="Invalid JWT token")
    
    headers = {
        "Authorization": f"Bearer {user_token}",
        "apikey": SUPABASE_KEY,
        "Content-Type": "application/json"
    }

    response = requests.get(f"{SUPABASE_URL}/auth/v1/user", headers=headers)

    if response.status_code == 200:
        user_data = response.json()
        user_id = user_data.get("id")
        if not user_id:
            raise HTTPException(status_code=400, detail="Invalid token: User ID not found")
        return user_id
    else:
        raise HTTPException(status_code=401, detail="Invalid or expired token")

@router.post("/sync_emergency_payments")
async def sync_emergency_payments(request: Request, data: EmergencyPaymentRequest):
    try:
        # Passo 1: Obter o token JWT do header User-key
        user_token = request.headers.get("User-key")
        if not user_token:
            raise HTTPException(status_code=400, detail="Missing User-key header")
        
        # Passo 2: Validar o token e obter o user_id
        user_id = verify_token(user_token)
        logger.info(f"User ID from token: {user_id}")

        # Passo 3: Buscar o stripe_id associado ao user_id no Supabase
        response = requests.get(
            f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}",
            headers=SUPABASE_HEADERS
        )

        # Log para verificar a resposta da consulta ao Supabase
        logger.info(f"Supabase response for user {user_id}: {response.status_code} {response.text}")

        if response.status_code != 200 or not response.json():
            raise HTTPException(status_code=404, detail="User not found in database")
        
        stripe_id = response.json()[0].get("stripe_id")
        if not stripe_id:
            raise HTTPException(status_code=404, detail="Stripe ID not found for user")
        
        logger.info(f"Stripe ID for user {user_id}: {stripe_id}")

        # Passo 4: Buscar pagamentos de emergência associados ao stylist_id
        stylist_id = data.id  # ID do estilista fornecido na requisição
        response_payments = requests.get(
            f"{SUPABASE_URL}/rest/v1/Emergency_sub?client_id=eq.{user_id}&stylist_id=eq.{stylist_id}",
            headers=SUPABASE_HEADERS
        )

        # Log para verificar a resposta da consulta de pagamentos
        logger.info(f"Supabase response for emergency payments: {response_payments.status_code} {response_payments.text}")

        if response_payments.status_code != 200:
            raise HTTPException(status_code=500, detail="Failed to fetch emergency payments")

        existing_payments = response_payments.json()
        logger.info(f"Found {len(existing_payments)} emergency payments for stylist {stylist_id} and customer {user_id}")

        # Passo 5: Buscar pagamentos no Stripe para esse user_id e stylist_id
        stripe_payments = stripe.PaymentIntent.list(
            customer=stripe_id,
            expand=["data.charges"]
        )

        # Passo 6: Verificar os pagamentos e inserir os que faltam
        for stripe_payment in stripe_payments["data"]:
            payment_id = stripe_payment["id"]
            
            # Verificar se o payment_id já existe no Supabase
            existing_payment = next((payment for payment in existing_payments if payment["payment_id"] == payment_id), None)
            
            if existing_payment:
                logger.info(f"Payment {payment_id} already exists in database, skipping.")
                continue  # Pular se já existe

            # Se não existe, adicionar pagamento de emergência ao Supabase
            price = int(stripe_payment["amount_received"])  # Valor em centavos
            subscription_id = stripe_payment["metadata"].get("subscription_id")
            payment_method = stripe_payment.get("payment_method")
            payment_type = "N/A"
            last4 = "N/A"
            if payment_method:
                payment_method_details = stripe.PaymentMethod.retrieve(payment_method)
                payment_type = payment_method_details["type"]
                last4 = payment_method_details[payment_type].get("last4", "N/A")

            emergency_sub_data = {
                "stylist_id": stylist_id,
                "client_id": user_id,
                "payment_id": payment_id,
                "price": price,  # Usando a coluna correta 'price'
                "sub_id": subscription_id,  # Subscription ID
            }

            # Inserir o novo pagamento de emergência no Supabase
            response_insert = requests.post(
                f"{SUPABASE_URL}/rest/v1/Emergency_sub",
                headers=SUPABASE_HEADERS,
                json=emergency_sub_data
            )

            if response_insert.status_code == 201:
                logger.info(f"Payment {payment_id} added successfully")
            else:
                logger.error(f"Failed to add payment {payment_id}: {response_insert.status_code} - {response_insert.text}")

        return {"status": "success", "message": "Emergency payments synchronized successfully"}

    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token has expired")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")
    except stripe.error.StripeError as e:
        logger.error(f"Stripe error: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Stripe error: {str(e)}")
    except Exception as e:
        logger.error(f"Error in syncing emergency payments: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error in syncing emergency payments: {str(e)}")

@router.post("/subscription_details")
async def subscription_details(data: SubscriptionRequest):
    try:
        subscription_id = data.id

        # Buscar detalhes da assinatura no Stripe
        subscription = await async_stripe_request(
            stripe.Subscription.retrieve,
            id=subscription_id,
            expand=["items.data.price", "default_payment_method", "customer"]
        ) 

        if not subscription:
            raise HTTPException(status_code=404, detail="Subscription not found")

        # Determinar status da assinatura
        status = subscription["status"]
        if status == "active":
            subscription_status = "active"
        elif status == "canceled" and subscription["current_period_end"] > datetime.utcnow().timestamp():
            subscription_status = "canceled"
        elif status == "canceled" and subscription["current_period_end"] <= datetime.utcnow().timestamp():
            subscription_status = "canceled"
        else:
            subscription_status = "terminated"

        # Pegando os detalhes do preço atual
        current_price = subscription["items"]["data"][0]["price"]["unit_amount"] / 100
        currency = subscription["items"]["data"][0]["price"]["currency"].upper()

        # Data da próxima cobrança
        try:
            upcoming_invoice = await async_stripe_request(
                stripe.Invoice.upcoming,
                subscription=subscription_id
            )
            next_invoice_amount = upcoming_invoice["amount_due"] / 100 if upcoming_invoice else None
        except stripe.error.StripeError:
            next_invoice_amount = None

        if next_invoice_amount is None:
            next_invoice_amount = "N/A"

        # Método de pagamento utilizado
        payment_method = subscription.get("default_payment_method")
        if payment_method:
            payment_method_details = await async_stripe_request(
                stripe.PaymentMethod.retrieve,
                id=payment_method
            )
            payment_type = payment_method_details["type"]
            last4 = payment_method_details[payment_type].get("last4", "N/A")
            payment_info = f"{payment_type.upper()} ending in {last4}"
        else:
            payment_info = "No default payment method found"

        # Pegando o stylist_id dos metadados
        stylist_id = subscription["metadata"].get("stylist_id", "N/A")

        # Buscar avatar e nome do stylist no Supabase
        stylist_avatar = None
        stylist_name = None
        if stylist_id != "N/A":
            response = requests.get(
                f"{SUPABASE_URL}/rest/v1/User?id=eq.{stylist_id}&select=avatar,name",
                headers=SUPABASE_HEADERS
            )
            if response.status_code == 200:
                data = response.json()
                if data:
                    stylist_avatar = data[0].get("avatar")
                    stylist_name = data[0].get("name")

        # Buscar emergency_subscriptions no Supabase
        emergency_subscriptions = []
        response = requests.get(
            f"{SUPABASE_URL}/rest/v1/Emergency_sub?sub_id=eq.{subscription_id}",
            headers=SUPABASE_HEADERS
        )
        if response.status_code == 200:
            emergency_subscriptions = response.json()

        # Obter o email do assinante
        customer_email = "N/A"
        customer_id = subscription.get("customer")
        
        # Se o customer_id for um objeto, extrair o ID corretamente
        if isinstance(customer_id, dict):  
            customer_id = customer_id.get("id")
        
        if customer_id and isinstance(customer_id, str):  # Garante que é uma string
            customer_details = await async_stripe_request(
                stripe.Customer.retrieve,
                id=customer_id
            )
            customer_email = customer_details.get("email", "N/A")

        return {
            "status": subscription_status,
            "subscription_id": subscription_id,
            "current_price": f"{current_price} {currency}",
            "next_invoice_amount": f"{next_invoice_amount} {currency}" if next_invoice_amount != "N/A" else "N/A",
            "next_billing_date": datetime.utcfromtimestamp(subscription["current_period_end"]).isoformat(),
            "payment_method": payment_info,
            "stylist_id": stylist_id,
            "stylist_avatar": stylist_avatar,
            "stylist_name": stylist_name,
            "emergency_subscriptions": emergency_subscriptions,
            "customer_email": customer_email
        }

    except stripe.error.StripeError as e:
        logger.error(f"Stripe error: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Stripe error: {str(e)}")
    except Exception as e:
        logger.error(f"Error retrieving subscription details: {str(e)}")
        raise HTTPException(status_code=500, detail="Error retrieving subscription details.")
        
@router.post("/generate_dashboard_link")
async def generate_dashboard_link(data: UserIDRequest):
    try:
        user_id = data.user_id  # O ID do estilista ou cliente

        # Verifica se é um estilista (conta conectada)
        if user_id.startswith("acct_"):
            try:
                # Cria o login link para o painel do estilista (Stripe Express)
                login_link = stripe.Account.create_login_link(user_id)
                
                return {
                    "status": "success",
                    "dashboard_link": login_link.url  # Retorna o link gerado para o painel do estilista
                }
            except stripe.error.StripeError as e:
                logger.error(f"Error creating login link for stylist account: {str(e)}")
                raise HTTPException(status_code=500, detail="Error creating login link for stylist account.")
        
        # Caso seja um cliente, criamos uma sessão do portal de cobrança
        elif user_id.startswith("cus_"):
            try:
                # Cria uma sessão do portal de cobrança para o cliente
                session = stripe.billing_portal.Session.create(
                    customer=user_id,
                    return_url="https://your-website.com/account"  # URL para onde o cliente será redirecionado após sair do portal
                )
                
                return {
                    "status": "success",
                    "dashboard_link": session.url  # Retorna o link para o painel do cliente
                }

            except stripe.error.StripeError as e:
                logger.error(f"Error creating billing portal session for customer: {str(e)}")
                raise HTTPException(status_code=500, detail="Error creating billing portal session for customer.")
        
        else:
            raise HTTPException(status_code=400, detail="Invalid user ID format. Must start with 'acct_' for stylist or 'cus_' for customer.")

    except Exception as e:
        logger.error(f"Error generating dashboard link: {str(e)}")
        raise HTTPException(status_code=500, detail="Error generating dashboard link.")
        
@router.post("/webhook")
async def stripe_webhook(request: Request):
    try:
        payload = await request.json()
        event_type = payload.get("type")

        if event_type == "invoice.payment_succeeded":
            invoice = payload.get("data", {}).get("object", {})

            amount_paid = invoice.get("amount_paid", 0)
            currency = invoice.get("currency", "usd")
            
            # 🔹 Extraindo metadados corretamente
            metadata = invoice.get("metadata", {})
            subscription_metadata = invoice.get("subscription_details", {}).get("metadata", {})
            line_items = invoice.get("lines", {}).get("data", [])
            line_item_metadata = line_items[0].get("metadata", {}) if line_items else {}

            stylist_id = metadata.get("stylist_id") or subscription_metadata.get("stylist_id") or line_item_metadata.get("stylist_id")
            user_id = metadata.get("user_id") or subscription_metadata.get("user_id") or line_item_metadata.get("user_id")
            price_id = metadata.get("price_id") or subscription_metadata.get("price_id") or line_item_metadata.get("price_id")
            subscription_id = invoice.get("subscription")

            # 🔹 Pegando corretamente o número de consultas
            consultations = (
                int(metadata.get("consultations", 0)) or
                int(subscription_metadata.get("consultations", 0)) or
                int(line_item_metadata.get("consultations", 0))
            )

            stylist_amount = int(amount_paid * 0.8)
            platform_amount = int(amount_paid * 0.2)

            logger.info(f"✅ Pagamento bem-sucedido! Valor total: R$ {amount_paid / 100:.2f}")
            logger.info(f"👤 Stylist ID: {stylist_id}")
            logger.info(f"👥 User ID: {user_id}")
            logger.info(f"📌 Número de consultas: {consultations}")

            # 🔹 Atualiza a tabela Subscriptions no Supabase
            subscription_data = {
                "stylist_id": stylist_id,
                "customer_id": user_id,
                "active": True,
                "sub_id": subscription_id,
                "price_id": price_id,
                "consultations": consultations  # Certifique-se de que a coluna existe no Supabase
            }

            logger.info(f"📝 Enviando dados da assinatura ao Supabase: {subscription_data}")

            response_subscription = requests.post(
                f"{SUPABASE_URL}/rest/v1/Subscriptions",
                headers=SUPABASE_HEADERS,
                json=subscription_data
            )

            if response_subscription.status_code == 201:
                logger.info(f"✅ Subscription adicionada com sucesso para o usuário {user_id}")
            else:
                logger.error(f"❌ Falha ao adicionar subscription: {response_subscription.status_code} - {response_subscription.text}")

            # 🔹 Criar ou verificar chat existente
            check_chat_url = f"{SUPABASE_URL}/rest/v1/chats?stylist_id=eq.{stylist_id}&client_id=eq.{user_id}"
            response_check_chat = requests.get(
                check_chat_url,
                headers=SUPABASE_ROLE_HEADERS
            )

            chat_id = None
            if response_check_chat.status_code == 200:
                existing_chats = response_check_chat.json()
                if existing_chats:
                    chat_id = existing_chats[0]['id']
                    logger.info(f"ℹ️ Chat já existe para stylist {stylist_id} e cliente {user_id}")
                else:
                    chat_data = {"stylist_id": stylist_id, "client_id": user_id}
                    create_chat_headers = SUPABASE_ROLE_HEADERS.copy()
                    create_chat_headers["Prefer"] = "return=representation"
                    response_chat = requests.post(
                        f"{SUPABASE_URL}/rest/v1/chats",
                        headers=create_chat_headers,
                        json=chat_data
                    )
                    if response_chat.status_code == 201:
                        new_chat_data = response_chat.json()
                        chat_id = new_chat_data[0]['id'] if isinstance(new_chat_data, list) else new_chat_data.get('id')
                        logger.info(f"✅ Chat criado para stylist {stylist_id} e cliente {user_id}")
                    else:
                        logger.error(f"❌ Falha ao criar chat: {response_chat.status_code} - {response_chat.text}")

            # 🔹 Enviar mensagem no chat
            if chat_id:
                user_response = requests.get(
                    f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}&select=name",
                    headers=SUPABASE_ROLE_HEADERS
                )

                formatted_name = "User"
                if user_response.status_code == 200:
                    user_data = user_response.json()
                    if user_data:
                        full_name = user_data[0].get('name', '').strip()
                        name_parts = full_name.split()
                        formatted_name = f"{name_parts[0]} {name_parts[1][0]}" if len(name_parts) > 1 else name_parts[0]

                message_data = {
                    "chat_id": chat_id,
                    "sender_id": user_id,
                    "content": f"{formatted_name} subscribed for 1 month",
                    "type": "warning"
                }

                create_message_headers = SUPABASE_ROLE_HEADERS.copy()
                create_message_headers["Prefer"] = "return=representation"
                response_message = requests.post(
                    f"{SUPABASE_URL}/rest/v1/messages",
                    headers=create_message_headers,
                    json=message_data
                )

                if response_message.status_code == 201:
                    logger.info(f"✅ Mensagem inicial criada para chat {chat_id}")
                else:
                    logger.error(f"❌ Falha ao criar mensagem inicial: {response_message.status_code} - {response_message.text}")

            return {
                "status": "success",
                "total_paid": amount_paid / 100,
                "stylist_id": stylist_id,
                "user_id": user_id,
                "stylist_amount": stylist_amount / 100,
                "platform_amount": platform_amount / 100
            }
            
        elif event_type == "customer.subscription.deleted":
            subscription = payload.get("data", {}).get("object", {})
            subscription_id = subscription.get("id")

            if not subscription_id:
                logger.error("❌ Subscription ID not found in event payload.")
                return {"status": "error", "message": "Subscription ID missing."}

            logger.info(f"🔹 Subscription {subscription_id} canceled. Updating database...")

            # 🔹 Atualizar active = False no Supabase
            update_url = f"{SUPABASE_URL}/rest/v1/Subscriptions?sub_id=eq.{subscription_id}"
            update_data = {"active": False}

            supabase_headers = {
                "Authorization": f"Bearer {SUPABASE_KEY}",
                "apikey": SUPABASE_KEY,
                "Content-Type": "application/json"
            }

            response_update = requests.patch(update_url, headers=supabase_headers, json=update_data)

            if response_update.status_code in [200, 204]:
                logger.info(f"✅ Subscription {subscription_id} marked as inactive in Supabase.")
                return {"status": "success", "message": "Subscription canceled and updated."}
            else:
                logger.error(f"❌ Failed to update subscription: {response_update.status_code} - {response_update.text}")
                return {"status": "error", "message": "Failed to update subscription."}

        elif event_type == "customer.subscription.updated":
            subscription = payload.get("data", {}).get("object", {})
            subscription_id = subscription.get("id")
            canceled_at = subscription.get("canceled_at")  # Timestamp do cancelamento
            cancel_status = subscription.get("cancel_at_period_end", False)
        
            # 🔹 Definir os cabeçalhos do Supabase antes de qualquer uso
            supabase_headers = {
                "Authorization": f"Bearer {SUPABASE_KEY}",
                "apikey": SUPABASE_KEY,
                "Content-Type": "application/json"
            }
        
            # Verifica se a assinatura foi cancelada
            if canceled_at:
                # Convertendo timestamp para data e horário de Nova York
                ny_tz = pytz.timezone("America/New_York")
                canceled_date = datetime.fromtimestamp(canceled_at, ny_tz).isoformat()
        
                logger.info(f"🔹 Subscription {subscription_id} canceled at {canceled_date} (New York Time).")
        
                # Atualizando no Supabase a assinatura como cancelada
                update_url = f"{SUPABASE_URL}/rest/v1/Subscriptions?sub_id=eq.{subscription_id}"
                update_data = {
                    "canceled": True,
                    "canceled_date": canceled_date
                }
        
                response_update = requests.patch(update_url, headers=supabase_headers, json=update_data)
        
                if response_update.status_code in [200, 204]:
                    logger.info(f"✅ Subscription {subscription_id} updated with canceled date.")
                    return {"status": "success", "message": "Subscription updated with cancellation date."}
                else:
                    logger.error(f"❌ Failed to update subscription: {response_update.status_code} - {response_update.text}")
                    return {"status": "error", "message": "Failed to update subscription."}
        
            # Caso a assinatura tenha sido reativada (cancel_at_period_end=False)
            elif not cancel_status:
                logger.info(f"🔹 Subscription {subscription_id} reactivated.")
        
                # Atualizando o status no Supabase para reativado
                update_url = f"{SUPABASE_URL}/rest/v1/Subscriptions?sub_id=eq.{subscription_id}"
                update_data = {
                    "canceled": False,
                    "canceled_date": None  # Remove a data de cancelamento
                }
        
                response_update = requests.patch(update_url, headers=supabase_headers, json=update_data)
        
                if response_update.status_code in [200, 204]:
                    logger.info(f"✅ Subscription {subscription_id} reactivated and canceled data removed.")
                    return {"status": "success", "message": "Subscription reactivated and canceled date removed."}
                else:
                    logger.error(f"❌ Failed to update subscription: {response_update.status_code} - {response_update.text}")
                    return {"status": "error", "message": "Failed to update subscription."}
        
            else:
                logger.info(f"🔹 Subscription {subscription_id} updated, but not canceled or reactivated.")
                return {"status": "success", "message": "Subscription updated but not canceled or reactivated."}
        
        elif event_type == "payment_intent.succeeded":
            payment_intent = payload.get("data", {}).get("object", {})
        
            # 🔹 Pegando os valores do metadado - CORRIGIDO
            stylist_id = payment_intent.get("metadata", {}).get("stylist_id")
            client_id = payment_intent.get("metadata", {}).get("user_id")  # Alterado de client_id para user_id
            invoice_id = payment_intent.get("invoice")  # Obtendo o ID da fatura
            payment_id = payment_intent.get("id")  # Payment ID
            amount_received = payment_intent.get("amount_received", 0)  # Valor recebido (em centavos)
            stylist_stripe_id = payment_intent.get("metadata", {}).get("stylist_stripe_id")
        
            if not all([stylist_id, client_id, payment_id]):
                logger.error("❌ Faltando dados essenciais no metadado do Payment Intent.")
                return {"status": "error", "message": "Missing essential metadata."}
                
            # Obter subscription_id da fatura
            subscription_id = None
            if invoice_id:
                try:
                    invoice = stripe.Invoice.retrieve(invoice_id)
                    subscription_id = invoice.get("subscription")
                except Exception as e:
                    logger.error(f"❌ Erro ao obter subscription_id da fatura: {str(e)}")
        
            logger.info(f"🔹 Payment Intent succeeded for subscription {subscription_id}")
            logger.info(f"👤 Client ID: {client_id}")
            logger.info(f"👗 Stylist ID: {stylist_id}")
            logger.info(f"💰 Price: R$ {amount_received / 100:.2f}")
            logger.info(f"💳 Payment ID: {payment_id}")
            
            # Criar transferência para a conta conectada do estilista
            if stylist_stripe_id and amount_received > 0:
                try:
                    # Calcular valor do estilista (80%)
                    stylist_amount = int(amount_received * 0.8)
                    
                    # Criar transferência
                    transfer = stripe.Transfer.create(
                        amount=stylist_amount,
                        currency="brl",
                        destination=stylist_stripe_id,
                        source_transaction=payment_intent.get("latest_charge"),
                        description=f"Pagamento de assinatura para {stylist_id}",
                        metadata={
                            "stylist_id": stylist_id,
                            "client_id": client_id,
                            "payment_intent_id": payment_id,
                            "subscription_id": subscription_id
                        }
                    )
                    logger.info(f"✅ Transferência criada com sucesso: {transfer.id} - Valor: R$ {stylist_amount / 100:.2f}")
                except Exception as e:
                    logger.error(f"❌ Erro ao criar transferência: {str(e)}")
        
            # 🔹 Definindo os cabeçalhos do Supabase
            supabase_headers = {
                "Authorization": f"Bearer {SUPABASE_KEY}",
                "apikey": SUPABASE_KEY,
                "Content-Type": "application/json"
            }
        
            # 🔹 Verificar se o payment_id já existe na tabela Emergency_sub
            check_url = f"{SUPABASE_URL}/rest/v1/Emergency_sub?payment_id=eq.{payment_id}"
            response_check = requests.get(check_url, headers=supabase_headers)
        
            if response_check.status_code == 200 and len(response_check.json()) > 0:
                logger.info(f"❌ Payment ID {payment_id} já existe. Nenhuma nova linha será inserida.")
                return {"status": "error", "message": "Payment ID already exists."}
        
            # 🔹 Inserir dados na tabela Emergency_sub no Supabase
            emergency_sub_data = {
                "sub_id": subscription_id,  # Subscription ID
                "stylist_id": stylist_id,    # Stylist ID
                "client_id": client_id,      # Client ID
                "price": amount_received,    # Price in cents
                "payment_id": payment_id    # Payment ID
            }
        
            emergency_sub_url = f"{SUPABASE_URL}/rest/v1/Emergency_sub"
            response_emergency_sub = requests.post(
                emergency_sub_url,
                headers=supabase_headers,
                json=emergency_sub_data
            )
        
            if response_emergency_sub.status_code == 201:
                logger.info(f"✅ Emergency subscription data added successfully for client {client_id}")
            else:
                logger.error(f"❌ Failed to add emergency subscription: {response_emergency_sub.status_code} - {response_emergency_sub.text}")
        
            return {
                "status": "success",
                "message": "Emergency subscription added successfully"
            }

    except Exception as e:
        logger.error(f"❌ Erro no webhook: {str(e)}")
        return {"status": "error", "message": str(e)}
        
@router.post("/create_price")
async def create_price(
    data: CreatePriceRequest,
    user_token: str = Header(None, alias="User-key")
):
    try:
        if not user_token:
            raise HTTPException(status_code=401, detail="Missing User-key header")

        # 🔹 1. Validar o token e obter user_id
        user_id = verify_token(user_token)
        logger.info(f"🔹 User verified. user_id: {user_id}")

        amount = data.amount
        emergency_price = data.emergency_price
        consultations = data.consultations

        # 🔹 2. Verificar se os valores estão dentro dos limites permitidos
        if not (500 <= amount <= 99900):
            raise HTTPException(status_code=400, detail="Amount must be between $5 and $999")
        if not (500 <= emergency_price <= 99900):
            raise HTTPException(status_code=400, detail="Emergency price must be between $5 and $999")

        # 🔹 3. Consultations precisa ser 0 obrigatoriamente se não for definido
        if consultations is None:
            consultations = 0
        elif consultations < 0:
            raise HTTPException(status_code=400, detail="Consultations must be greater than or equal to 0")

        logger.info(f"🔹 Validated amounts: amount = {amount}, emergency_price = {emergency_price}, consultations = {consultations}")

        # 🔹 4. Buscar price_id, name, avatar e bio do usuário no Supabase
        supabase_url = f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}"
        headers = {
            "Authorization": f"Bearer {user_token}",  # 🔹 Incluindo token correto no header
            **SUPABASE_HEADERS
        }
        response = requests.get(supabase_url, headers=headers)
        logger.info(f"🔹 Supabase GET response: {response.status_code} - {response.text}")

        if response.status_code != 200:
            raise HTTPException(status_code=500, detail=f"Failed to fetch user from Supabase: {response.text}")

        user_data = response.json()
        if not user_data:
            raise HTTPException(status_code=404, detail="User not found in Supabase")

        user = user_data[0]
        existing_price_id = user.get("price_id")
        user_full_name = user.get("name", "Unknown User")  # 🔹 Recuperar o nome do usuário
        user_avatar = user.get("avatar", None)  # 🔹 Recuperar a URL do avatar do usuário, se existir

        # 🔹 Criar nome abreviado do usuário (primeiro nome + inicial do segundo nome)
        name_parts = user_full_name.split()
        if len(name_parts) > 1:
            abbreviated_name = f"{name_parts[0]} {name_parts[1][0]}."
        else:
            abbreviated_name = name_parts[0]
        
        product_name = f"{abbreviated_name} Subscription"
        
        logger.info(f"🔹 Existing price_id: {existing_price_id}, user_name: {abbreviated_name}")

        # 🔹 5. Criar produto no Stripe com nome e imagem baseados no usuário
        product_data = {
            "name": product_name,  # Nome do produto formatado
        }
        
        if user_avatar:  # Verificar se o avatar existe e adicionar a imagem
            product_data["images"] = [user_avatar]

        product = stripe.Product.create(**product_data)
        product_id = product.id
        logger.info(f"✅ New product created: {product_id}")

        # 🔹 6. Criar novo preço no Stripe associado ao produto
        price = stripe.Price.create(
            unit_amount=amount,
            currency="brl",
            recurring={"interval": "month"},
            product=product_id  # Associando o preço ao produto
        )
        new_price_id = price.id
        logger.info(f"✅ New price created: {new_price_id}")

        # 🔹 7. Se já houver um price_id, cancelar assinaturas ativas ao final do período
        if existing_price_id:
            subscriptions = stripe.Subscription.list(status="active")
            for sub in subscriptions.auto_paging_iter():
                if sub["items"]["data"][0]["price"]["id"] == existing_price_id:
                    stripe.Subscription.modify(sub.id, cancel_at_period_end=True)
                    logger.info(f"🔹 Subscription {sub.id} set to cancel at period end.")

        # 🔹 8. Atualizar Supabase com o novo price_id e valores adicionais
        update_data = {
            "price_id": new_price_id,  # Novo price_id
            "price": amount,  # Atualizando o valor de 'price'
            "emergency_price": emergency_price,  # Atualizando o valor de 'emergency_price'
            "consultations": consultations  # Atualizando o valor de 'consultations'
        }
        
        # Aqui estamos incluindo o cabeçalho de autenticação com o token JWT correto
        update_headers = {
            "Authorization": f"Bearer {user_token}",  # Incluindo token correto no header
            "apikey": SUPABASE_KEY,
            "Content-Type": "application/json"
        }
        
        update_response = requests.patch(supabase_url, headers=update_headers, json=update_data)
        
        # Log detalhado para verificar a resposta
        logger.info(f"🔹 Supabase PATCH response: {update_response.status_code} - {update_response.text}")
        
        if update_response.status_code not in [200, 204]:
            raise HTTPException(status_code=500, detail=f"Failed to update Supabase: {update_response.text}")
        
        logger.info(f"✅ Successfully updated user {user_id} with new price_id, price, emergency_price, and consultations")
        return {"message": "Price created and user updated successfully!", "price_id": new_price_id}

    except Exception as e:
        logger.error(f"❌ Error creating price: {e}")
        raise HTTPException(status_code=500, detail=f"Error creating price: {str(e)}")

@router.post("/emergency_checkout_session")
def emergency_checkout_session(
    data: EmergencyPaymentRequest,
    user_token: str = Header(None, alias="User-key")
):
    try:
        if not user_token:
            raise HTTPException(status_code=401, detail="Missing User-key header")

        # 🔹 1. Validate client token and get user_id
        user_id = verify_token(user_token)

        # 🔹 2. Check if user has an active subscription
        response_subscription = requests.get(
            f"{SUPABASE_URL}/rest/v1/Subscriptions?customer_id=eq.{user_id}&stylist_id=eq.{data.id}&active=eq.true",
            headers=SUPABASE_HEADERS
        )
        subscription_data = response_subscription.json()
        if not subscription_data:
            raise HTTPException(status_code=403, detail="User is not eligible for emergency checkout")

        # 🔹 3. Get stylist data from Supabase
        response_stylist = requests.get(
            f"{SUPABASE_URL}/rest/v1/User?id=eq.{data.id}",
            headers=SUPABASE_HEADERS
        )
        stylist_data = response_stylist.json()
        if not stylist_data:
            raise HTTPException(status_code=404, detail="Stylist not found")

        stylist = stylist_data[0]
        stylist_id = stylist.get("id")
        stylist_stripe_id = stylist.get("stripe_id")
        emergency_price = stylist.get("emergency_price")

        if not stylist_stripe_id or emergency_price is None:
            raise HTTPException(status_code=400, detail="Stylist profile is incomplete")

        # 🔹 4. Get client data from Supabase
        response_user = requests.get(
            f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}",
            headers=SUPABASE_HEADERS
        )
        user_data = response_user.json()
        if not user_data:
            raise HTTPException(status_code=404, detail="Client not found")

        user = user_data[0]
        user_stripe_id = user.get("stripe_id")

        if not user_stripe_id:
            raise HTTPException(status_code=400, detail="Client does not have a Stripe Customer ID")

        # 🔹 5. Create a one-time payment intent
        payment_intent = stripe.PaymentIntent.create(
            amount=emergency_price,
            currency="brl",
            customer=user_stripe_id,
            application_fee_amount=int(emergency_price * 0.20),  # 20% para a plataforma
            transfer_data={
                "destination": stylist_stripe_id,
                "amount": int(price_amount * 0.8 * 100)
            },
            metadata={
                "stylist_id": stylist_id,  # Id do estilista
                "client_id": user_id,  # Id do cliente
                "subscription_id": subscription_data[0]["sub_id"]  # Alterado para 'sub_id'
            }
        )

        return {
            "message": "Emergency checkout session created successfully!",
            "clientSecret": payment_intent.client_secret,
            "paymentIntentId": payment_intent.id,
            "price": f"{emergency_price / 100:.2f} USD",
            "stylist_id": stylist_id,
            "client_id": user_id,
            "subscription_id": subscription_data[0]["sub_id"]  # Alterado para 'sub_id'
        }

    except Exception as e:
        logger.error(f"Error creating emergency checkout session: {e}")
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/create_checkout_session")
def create_checkout_session(
    data: SubscriptionRequest,
    user_token: str = Header(None, alias="User-key")
):
    try:
        if not user_token:
            raise HTTPException(status_code=401, detail="Missing User-key header")

        user_id = verify_token(user_token)

        response_stylist = requests.get(
            f"{SUPABASE_URL}/rest/v1/User?id=eq.{data.id}",
            headers=SUPABASE_HEADERS
        )
        stylist_data = response_stylist.json()
        if not stylist_data:
            raise HTTPException(status_code=404, detail="Stylist not found")

        stylist = stylist_data[0]
        stylist_id = stylist.get("id")
        stylist_stripe_id = stylist.get("stripe_id")
        price_id = stylist.get("price_id")
        consultations = stylist.get("consultations", 0)  # Obtendo número de consultas

        if not stylist_stripe_id or not price_id:
            raise HTTPException(status_code=400, detail="Stylist profile is incomplete")

        response_user = requests.get(
            f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}",
            headers=SUPABASE_HEADERS
        )
        user_data = response_user.json()
        if not user_data:
            raise HTTPException(status_code=404, detail="Client not found")

        user = user_data[0]
        user_stripe_id = user.get("stripe_id")

        if not user_stripe_id:
            raise HTTPException(status_code=400, detail="Client does not have a Stripe Customer ID")

        price_data = stripe.Price.retrieve(price_id)
        price_amount = price_data.unit_amount / 100
        currency = price_data.currency.upper()

        subscription = stripe.Subscription.create(
            customer=user_stripe_id,
            items=[{"price": price_id}],
            payment_behavior='default_incomplete',
            expand=['latest_invoice.payment_intent'],
            metadata={
                "stylist_id": stylist_id,
                "stylist_stripe_id": stylist_stripe_id,
                "user_id": user_id,
                "user_stripe_id": user_stripe_id,
                "price_id": price_id,
                "consultations": consultations  # Adicionando número de consultas aos metadados
            }
        )
        
        payment_intent = subscription.latest_invoice.payment_intent
        stripe.PaymentIntent.modify(
            payment_intent.id,
            metadata={
                "stylist_id": stylist_id,
                "stylist_stripe_id": stylist_stripe_id,
                "user_id": user_id,
                "user_stripe_id": user_stripe_id,
                "price_id": price_id,
                "consultations": consultations  # Adicionando número de consultas aos metadados
            }
        )

        return {
            "message": "Subscription session created successfully!",
            "clientSecret": subscription.latest_invoice.payment_intent.client_secret,
            "subscriptionId": subscription.id,
            "price": f"{price_amount:.2f} {currency}"  # Retorna o preço formatado corretamente
        }

    except Exception as e:
        logger.error(f"Error creating subscription session: {e}")
        raise HTTPException(status_code=500, detail=str(e))
        
### **CANCELAMENTO DE ASSINATURA**
class CancelSubscriptionRequest(BaseModel):
    subscription_id: str

@router.post("/cancel_subscription")
def cancel_subscription(data: CancelSubscriptionRequest):
    try:
        subscription = stripe.Subscription.modify(
            data.subscription_id,
            cancel_at_period_end=True,
        )
        return {"status": "Subscription will be canceled at period end"}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

class ReactivateSubscriptionRequest(BaseModel):
    subscription_id: str
    
@router.post("/reactivate_subscription")
def reactivate_subscription(data: ReactivateSubscriptionRequest):
    try:
        subscription = stripe.Subscription.modify(
            data.subscription_id,
            cancel_at_period_end=False,  # Reativa a assinatura
        )
        return {"status": "Subscription has been reactivated"}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/check_subscription")
async def check_subscription(
    data: CheckSubscriptionRequest  # Agora recebemos user_id diretamente do corpo
):
    try:
        user_id = data.user_id  # Não precisamos mais verificar o token, pois user_id vem na requisição

        # 🔹 Buscar o stripe_id do usuário no Supabase
        response_user = await async_request(
            f"{SUPABASE_URL}/rest/v1/User?id=eq.{user_id}",
            SUPABASE_HEADERS
        )
        user_data = response_user.json()
        if not user_data:
            raise HTTPException(status_code=404, detail="User not found")
        
        user_stripe_id = user_data[0].get("stripe_id")
        if not user_stripe_id:
            raise HTTPException(status_code=404, detail="Stripe customer not found for user")

        # 🔹 Buscar todas as assinaturas do cliente (ativas, canceladas, expiradas, etc.)
        subscriptions = await async_stripe_request(
            stripe.Subscription.list,
            customer=user_stripe_id,
            expand=["data.items"]
        )

        logger.info(f"Stripe response data: {subscriptions}")

        if not subscriptions or not subscriptions["data"]:
            # Se não houver assinaturas para o cliente, desativa as assinaturas associadas ao estilista no banco de dados
            logger.info(f"No active subscription found for user {user_id}. Deactivating all subscriptions for stylist {data.stylist_id}.")

            # 🔹 Buscar todas as assinaturas do estilista no banco de dados para este cliente
            response_subscriptions = await async_request(
                f"{SUPABASE_URL}/rest/v1/Subscriptions?customer_id=eq.{user_id}&stylist_id=eq.{data.stylist_id}",
                SUPABASE_HEADERS
            )
            if response_subscriptions.status_code == 200:
                subscriptions_data = response_subscriptions.json()
                await asyncio.gather(
                    *(update_subscription_status(sub['id'], False) for sub in subscriptions_data)
                )
            else:
                logger.error(f"❌ Failed to fetch subscriptions from Supabase for stylist {data.stylist_id} and user {user_id}.")
            
            return {"status": "inactive", "message": "No active subscription found for stylist."}

        # 🔹 Verifica se existe uma assinatura ativa para o estilista
        stylist_found = False
        for subscription in subscriptions["data"]:
            if subscription["metadata"].get("stylist_id") == data.stylist_id:
                stylist_found = True
                subscription_id = subscription["id"]
                price_id = subscription["items"]["data"][0]["price"]["id"]
                status = subscription.get("status")
                cancel_at_period_end = subscription.get("cancel_at_period_end", False)
                canceled_at = subscription.get("canceled_at")
                current_period_end = subscription.get("current_period_end")

                # 🔹 Converte timestamps para data legível
                nyc_tz = pytz.timezone('America/New_York')
                canceled_at_date = (
                    datetime.utcfromtimestamp(canceled_at).replace(tzinfo=pytz.utc).astimezone(nyc_tz).isoformat()
                    if canceled_at else None
                )
                expiration_date = (
                    datetime.utcfromtimestamp(current_period_end).replace(tzinfo=pytz.utc).astimezone(nyc_tz).isoformat()
                    if current_period_end else None
                )

                # 🔹 Atualiza o banco de dados Supabase com os dados da assinatura
                subscription_data = {
                    "stylist_id": data.stylist_id,
                    "customer_id": user_id,
                    "active": status == "active",
                    "sub_id": subscription_id,
                    "price_id": price_id,
                    "canceled": cancel_at_period_end or (status == "canceled"),
                    "canceled_date": canceled_at_date
                }

                # Verifica se a assinatura no banco de dados já existe e está marcada como inactive
                response_existing_sub = await async_request(
                    f"{SUPABASE_URL}/rest/v1/Subscriptions?customer_id=eq.{user_id}&stylist_id=eq.{data.stylist_id}&sub_id=eq.{subscription_id}",
                    SUPABASE_HEADERS
                )
                if response_existing_sub.status_code == 200 and response_existing_sub.json():
                    db_subscription = response_existing_sub.json()[0]
                    db_active = db_subscription.get("active")

                    # Se o status no banco for False e no Stripe for True, atualiza para True
                    if not db_active and status == "active":
                        await update_subscription_status(db_subscription["id"], True)

                # Se a assinatura não existir no banco, cria uma nova
                if response_existing_sub.status_code != 200 or not response_existing_sub.json():
                    await async_request(
                        f"{SUPABASE_URL}/rest/v1/Subscriptions",
                        SUPABASE_HEADERS,
                        json=subscription_data,
                        method='POST'
                    )

                # Retorna informações sobre a assinatura sincronizada
                return {
                    "status": status,
                    "subscription_id": subscription_id,
                    "consultations_per_month": subscription["metadata"].get("consultations_per_month", None),
                    "cancel_at_period_end": cancel_at_period_end,
                    "canceled_at": canceled_at_date,
                    "expiration_date": expiration_date
                }

        # 🔹 Caso não tenha encontrado assinatura ativa para o estilista
        if not stylist_found:
            logger.info(f"No active subscription found for stylist {data.stylist_id}. Deactivating all subscriptions for this stylist.")

            # 🔹 Buscar todas as assinaturas do estilista no banco de dados
            response_subscriptions = await async_request(
                f"{SUPABASE_URL}/rest/v1/Subscriptions?stylist_id=eq.{data.stylist_id}",
                SUPABASE_HEADERS
            )
            if response_subscriptions.status_code == 200:
                subscriptions_data = response_subscriptions.json()
                await asyncio.gather(
                    *(update_subscription_status(sub['id'], False) for sub in subscriptions_data)
                )
            else:
                logger.error(f"❌ Failed to fetch subscriptions from Supabase for stylist {data.stylist_id}.")
            
            return {"status": "inactive", "message": "No active subscription found for stylist."}

    except stripe.error.StripeError as e:
        logger.error(f"Stripe error: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Stripe error: {str(e)}")
    except Exception as e:
        logger.error(f"Error checking subscription: {str(e)}")
        raise HTTPException(status_code=500, detail="Error checking subscription.")


# Função assíncrona para fazer requisições de rede
async def async_request(url, headers, json=None, method='GET'):
    method_func = requests.post if method == 'POST' else requests.get
    response = method_func(url, headers=headers, json=json)
    return response

# Função assíncrona para chamar a Stripe API
async def async_stripe_request(func, **kwargs):
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, lambda: func(**kwargs))
    return response

# Função assíncrona para atualizar o status de uma assinatura
async def update_subscription_status(subscription_id, status):
    update_data = {
        "active": 1 if status else 0  # Usa 1 para True e 0 para False
    }
    subscription_url = f"{SUPABASE_URL}/rest/v1/Subscriptions?id=eq.{subscription_id}"

    logger.info(f"Request to update subscription {subscription_id} with data: {update_data}")

    # Enviar a requisição PATCH
    update_response = await async_request(
        subscription_url,
        SUPABASE_HEADERS,
        json=update_data,
        method='PATCH'
    )

    # Verificar a resposta da requisição
    if update_response.status_code == 200:
        logger.info(f"✅ Subscription {subscription_id} updated to {'active' if status else 'inactive'} successfully.")
        # Confirmar que o dado foi atualizado
        updated_data = update_response.json()
        logger.info(f"Updated subscription data: {updated_data}")
    else:
        logger.error(f"❌ Failed to update subscription {subscription_id}. Response status: {update_response.status_code}. Response: {update_response.text}")