import logging
import uuid
from fastapi import FastAPI, HTTPException, Request
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from dotenv import load_dotenv

# Import logging configuration FIRST (before any other app imports)
from app.logging_config import setup_logging

# Import tracing configuration (must be before other app imports)
from app.utils import tracing

from app.db import init_db
from app.llm import chat_with_karishye
from app.utils.puja_session_utils import clean_indian_phone_number

# ---------------------------------------------------------
# Setup
# ---------------------------------------------------------
# Setup colored logging with timestamps
setup_logging(level=logging.INFO, use_colors=True)
logger = logging.getLogger(__name__)

app = FastAPI(title="Karishye AI Chat API") 

# Add CORS middleware to allow requests from the frontend
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Allow all origins for development
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

load_dotenv()
init_db()

# ---------------------------------------------------------
# Request/Response Models
# ---------------------------------------------------------
class ChatRequest(BaseModel):
    user_id: str
    message: str
    session_id: str  # Required: unique session identifier for this conversation

# ---------------------------------------------------------
# Chat Endpoint
# ---------------------------------------------------------
@app.post("/chat")
async def chat(payload: ChatRequest):
    """
    Chat endpoint using karishye_agent with RAG and Puja tools.
    Handles conversation flow, puja bookings, and intent tracking.
    """
    try:
        import time
        start_time = time.time()
        
        # Use the karishye agent with tools, pass session_id
        response = await chat_with_karishye(
            payload.message, 
            payload.user_id,
            payload.session_id
        )
        
        end_time = time.time()
        total_time = end_time - start_time
        
        logger.info(f"[/chat] Response completed in {total_time:.2f}s")
        
        result = {
            "user_id": payload.user_id,
            "session_id": payload.session_id,
            "user_message": payload.message,
            "karishye_agent_response": response,
            "success": True
        }
        
        return result
        
    except Exception as e:
        # Log error without stack trace to avoid exposing sensitive data in logs
        logger.error(f"[/chat] Error: {type(e).__name__}")
        raise HTTPException(
            status_code=500, 
            detail="Something went wrong. Please try again in a moment."
        )


@app.post("/webhook/wati")
async def wati_webhook(request: Request):
    """
    WATI webhook endpoint to receive WhatsApp messages.
    Integrates with karishye_agent for AI-powered responses.
    """
    try:
        # Parse incoming webhook payload
        payload = await request.json()
        
        # Check if payload is None or empty
        if not payload:
            logger.warning("[WATI Webhook] Empty payload")
            return {
                "success": False,
                "ai_message": "Empty payload received"
            }
        
        # Extract message details from WATI webhook structure
        name = payload.get("Name", "")
        phone = payload.get("Phone", "")
        email = payload.get("Email", "")
        message_text = payload.get("Message", "")
        
        # Also try alternative field names for phone
        wa_id = payload.get("waId") or payload.get("wa_id")
        if not phone and wa_id:
            phone = wa_id

        # Use phone number as user_id and session_id for conversation continuity
        user_id = phone if phone and phone != "@phone" else f"whatsapp_{uuid.uuid4().hex[:8]}"
        # Use phone number as session_id to maintain conversation context across messages
        session_id = f"wati_{phone}" if phone and phone != "@phone" else f"wati_{uuid.uuid4().hex}"
        
        # Clean phone number and name for storage
        clean_phone = clean_indian_phone_number(phone) if phone else None
        
        # Clean name (remove placeholder values, trim whitespace)
        clean_name = None
        if name and name != "@name" and name.strip():
            clean_name = name.strip()
        
        # Check if we have a message to process
        if not message_text or message_text == "@message":
            logger.warning("[WATI Webhook] No message text")
            return {
                "success": False,
                "ai_message": "No message text received"
            }
        
        # Process message with karishye_agent
        try:
            import time
            start_time = time.time()
            
            # Use the karishye agent with tools, pass phone and name from WhatsApp
            # Format response for WhatsApp (plain text, not markdown)
            ai_response = await chat_with_karishye(
                message_text, 
                user_id,
                session_id,
                phone_number=clean_phone,  # Pass cleaned phone number from WhatsApp
                user_name=clean_name,  # Pass cleaned name from WhatsApp
                format_for_whatsapp=True  # Format response for WhatsApp
            )
            
            end_time = time.time()
            response_time = end_time - start_time
            
            logger.info(f"[WATI Webhook] Response completed in {response_time:.2f}s")
            
            return {
                "success": True,
                "ai_message": ai_response
            }
            
        except Exception as ai_error:
            # Log error without stack trace to avoid exposing sensitive data in logs
            logger.error(f"[WATI Webhook] AI error: {type(ai_error).__name__}")
            # Never send error messages to user - provide friendly fallback
            fallback_response = "Something went wrong. Please visit https://www.karishye.co/ for assistance."
            return {
                "success": True,
                "ai_message": fallback_response
            }
        
    except Exception as e:
        # Log error without stack trace to avoid exposing sensitive data in logs
        logger.error(f"[WATI Webhook] Error: {type(e).__name__}")
        # Never send error messages to user - provide friendly fallback
        return {
            "success": True,
            "ai_message": "Something went wrong. Please visit https://www.karishye.co/ for assistance."
        }