"""
Webhook handlers for WhatsApp, Telegram, etc.
"""
from fastapi import APIRouter, Request, HTTPException, Query
import httpx
import logging
import json

from app.config import settings
from app.services.ai_service import ai_service

logger = logging.getLogger(__name__)
router = APIRouter()

# WhatsApp conversation store
whatsapp_conversations = {}


@router.get("/whatsapp")
async def verify_whatsapp_webhook(
        hub_mode: str = Query(alias="hub.mode"),
        hub_verify_token: str = Query(alias="hub.verify_token"),
        hub_challenge: str = Query(alias="hub.challenge")
):
    """
    WhatsApp webhook verification endpoint
    Meta sends a GET request to verify the webhook
    """
    if hub_mode == "subscribe" and hub_verify_token == settings.WHATSAPP_VERIFY_TOKEN:
        logger.info("WhatsApp webhook verified successfully")
        return int(hub_challenge)

    raise HTTPException(status_code=403, detail="Verification failed")


@router.post("/whatsapp")
async def handle_whatsapp_message(request: Request):
    """
    Handle incoming WhatsApp messages

    Receives messages from WhatsApp Business API and responds with AI
    """
    try:
        body = await request.json()
        logger.info(f"WhatsApp webhook received: {json.dumps(body)}")

        # Extract message data
        entry = body.get("entry", [{}])[0]
        changes = entry.get("changes", [{}])[0]
        value = changes.get("value", {})
        messages = value.get("messages", [])

        for message in messages:
            if message.get("type") == "text":
                from_number = message.get("from")
                message_text = message.get("text", {}).get("body", "")

                logger.info(f"Message from {from_number}: {message_text}")

                # Get or create conversation
                if from_number not in whatsapp_conversations:
                    whatsapp_conversations[from_number] = []

                # Add user message
                whatsapp_conversations[from_number].append({
                    "role": "user",
                    "content": message_text
                })

                # Get AI response
                messages_for_ai = whatsapp_conversations[from_number][-10:]  # Last 10 messages
                ai_response = await ai_service.get_chat_response(
                    messages=messages_for_ai,
                    system_prompt="You are a helpful WhatsApp assistant. Keep responses concise and mobile-friendly."
                )

                # Add assistant response to conversation
                whatsapp_conversations[from_number].append({
                    "role": "assistant",
                    "content": ai_response["content"]
                })

                # Send response via WhatsApp API
                await send_whatsapp_message(from_number, ai_response["content"])

        return {"status": "ok"}

    except Exception as e:
        logger.error(f"WhatsApp webhook error: {str(e)}")
        return {"status": "error", "message": str(e)}


async def send_whatsapp_message(to: str, message: str):
    """Send message via WhatsApp Business API"""
    if not settings.WHATSAPP_TOKEN or not settings.WHATSAPP_PHONE_NUMBER_ID:
        logger.warning("WhatsApp not configured, skipping send")
        return

    url = f"https://graph.facebook.com/v18.0/{settings.WHATSAPP_PHONE_NUMBER_ID}/messages"

    headers = {
        "Authorization": f"Bearer {settings.WHATSAPP_TOKEN}",
        "Content-Type": "application/json"
    }

    payload = {
        "messaging_product": "whatsapp",
        "to": to,
        "type": "text",
        "text": {"body": message}
    }

    async with httpx.AsyncClient() as client:
        response = await client.post(url, headers=headers, json=payload)
        logger.info(f"WhatsApp send response: {response.status_code}")
        return response.json()


@router.post("/telegram")
async def handle_telegram_message(request: Request):
    """
    Handle incoming Telegram messages (future implementation)
    """
    body = await request.json()
    logger.info(f"Telegram webhook received: {json.dumps(body)}")
    # TODO: Implement Telegram integration
    return {"status": "ok"}


@router.post("/voice/inbound")
async def handle_voice_call(request: Request):
    """
    Handle incoming voice calls (Twilio integration - future)
    """
    form_data = await request.form()
    logger.info(f"Voice call received: {dict(form_data)}")
    # TODO: Implement voice AI integration
    return {"status": "ok"}