import logging
import os
import httpx
from datetime import datetime
from typing import Dict, List, Any


logger = logging.getLogger(__name__)


async def load_chat_history(phone_number: str, limit: int = 5) -> List[Dict[str, Any]]:
    """
    Load chat history from WATI API for a specific phone number.
    
    Args:
        phone_number: User's phone number (without country code)
        limit: Number of messages to fetch (default: 5)
        
    Returns:
        List of chat messages in chronological order with format:
        [{"type": "user" or "assistant", "message": "text", "timestamp": "iso_timestamp"}]
    """
    try:
        # Get WATI credentials from environment
        wati_url = os.getenv("WATI_URL")
        tenant_id = os.getenv("WATI_TENANT_ID")
        channel_phone = os.getenv("WATI_CHANNEL_PHONE_NUMBER")
        bearer_token = os.getenv("WATI_BEARER_TOKEN")
        
        if not all([wati_url, tenant_id, channel_phone, bearer_token]):
            logger.warning("WATI credentials not configured. Returning empty history.")
            return []
        
        phone_number = f"91{phone_number}"
        
        # Build API URL
        url = f"{wati_url}/{tenant_id}/api/v1/getMessages/{phone_number}"
        params = {
            "channelPhoneNumber": channel_phone,
            "pageSize": limit
        }
        headers = {
            "Authorization": f"Bearer {bearer_token}"
        }
        
        # Fetch messages from WATI
        async with httpx.AsyncClient(timeout=10.0) as client:
            response = await client.get(url, params=params, headers=headers)
            response.raise_for_status()
            data = response.json()
        
        # Parse WATI response and convert to our format
        # WATI structure: {"result": "success", "messages": {"items": [...]}}
        chat_history = []
        
        # Extract items array from nested structure
        messages_data = data.get("messages", {})
        items = messages_data.get("items", []) if isinstance(messages_data, dict) else []
        
        for msg in items:
            # Skip non-message events
            if msg.get("eventType") != "message":
                continue
            
            # Determine message type:
            # owner=true means bot/assistant sent it
            # owner=false means user sent it
            is_owner = msg.get("owner", False)
            message_text = msg.get("text", "")
            timestamp = msg.get("created", msg.get("timestamp", ""))
            
            # Only add messages with text content
            if message_text:
                chat_history.append({
                    "type": "assistant" if is_owner else "user",
                    "message": message_text,
                    "timestamp": timestamp
                })
        
        # WATI returns newest first, reverse to get chronological order
        chat_history.reverse()
        
        logger.debug(f"Loaded {len(chat_history)} messages from WATI")
        return chat_history
        
    except httpx.HTTPError as e:
        logger.error(f"HTTP error loading chat history from WATI: {type(e).__name__}")
        return []
    except Exception as e:
        logger.error(f"Error loading chat history from WATI: {type(e).__name__}")
        return []


def get_recent_chat_history(phone_number: str, limit: int = 6) -> List[Dict[str, Any]]:
    """
    Get recent chat history for a phone number from WATI.
    This is a synchronous wrapper - use load_chat_history directly in async contexts.
    """
    import asyncio
    try:
        loop = asyncio.get_event_loop()
    except RuntimeError:
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
    
    return loop.run_until_complete(load_chat_history(phone_number, limit))