# Advanced Conversational AI Agent Implementation
import openai
import asyncio
from typing import Dict, List, Optional
from datetime import datetime
from dataclasses import dataclass
import json

@dataclass
class ConversationContext:
    user_id: str
    session_id: str
    conversation_history: List[Dict]
    user_preferences: Dict
    business_context: Dict

class ConversationalAgent:
    """Production-ready conversational AI agent"""
    
    def __init__(self, api_key: str, model: str = "gpt-4"):
        self.client = openai.OpenAI(api_key=api_key)
        self.model = model
        self.conversation_memory = {}
        self.knowledge_base = self._load_knowledge_base()
        
    def _load_knowledge_base(self) -> Dict:
        """Load business-specific knowledge base"""
        return {
            "business_hours": "Monday-Friday 9 AM - 6 PM EST",
            "return_policy": "30-day return policy on all items",
            "shipping_info": "Free shipping on orders over $50",
            "support_email": "support@company.com",
            "escalation_triggers": [
                "refund", "complaint", "manager", "cancel order"
            ]
        }
    
    async def process_message(self, 
                             message: str, 
                             context: ConversationContext) -> Dict:
        """Process incoming message and generate response"""
        
        # 1. Extract intent and entities
        intent_analysis = await self._analyze_intent(message, context)
        
        # 2. Check for escalation triggers
        if self._should_escalate(message, intent_analysis):
            return await self._escalate_to_human(context, intent_analysis)
        
        # 3. Generate contextual response
        response = await self._generate_response(message, context, intent_analysis)
        
        # 4. Update conversation history
        self._update_conversation_history(context, message, response)
        
        # 5. Extract follow-up actions
        actions = await self._extract_actions(response, context)
        
        return {
            "response": response,
            "intent": intent_analysis["intent"],
            "confidence": intent_analysis["confidence"],
            "actions": actions,
            "escalation_required": False,
            "sentiment": intent_analysis["sentiment"]
        }
    
    async def _analyze_intent(self, message: str, context: ConversationContext) -> Dict:
        """Analyze message intent and extract entities"""
        
        prompt = f"""
        Analyze this customer message for intent, entities, and sentiment:
        
        Message: "{message}"
        
        Previous conversation: {json.dumps(context.conversation_history[-3:])}
        
        Return JSON with:
        - intent: primary intent (inquiry, complaint, request, etc.)
        - entities: extracted entities (product, date, amount, etc.)
        - sentiment: positive/neutral/negative
        - confidence: 0-1 confidence score
        - urgency: low/medium/high
        """
        
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "system", "content": prompt}],
            temperature=0.1
        )
        
        return json.loads(response.choices[0].message.content)
    
    async def _generate_response(self, 
                               message: str, 
                               context: ConversationContext,
                               intent_analysis: Dict) -> str:
        """Generate contextual response based on intent"""
        
        # Build context-aware prompt
        system_prompt = f"""
        You are a helpful customer service agent for our company.
        
        Business Information:
        {json.dumps(self.knowledge_base, indent=2)}
        
        Customer Context:
        - User: {context.user_id}
        - Previous purchases: {context.user_preferences.get('purchase_history', [])}
        - Tier: {context.user_preferences.get('tier', 'standard')}
        
        Guidelines:
        - Be helpful, professional, and empathetic
        - Use customer's name when available
        - Provide specific, actionable information
        - If you don't know something, say so and offer to find out
        - For technical issues, gather relevant details
        
        Intent: {intent_analysis['intent']}
        Sentiment: {intent_analysis['sentiment']}
        """
        
        conversation_messages = [
            {"role": "system", "content": system_prompt}
        ]
        
        # Add conversation history
        for msg in context.conversation_history[-5:]:
            conversation_messages.append(msg)
        
        conversation_messages.append({
            "role": "user", 
            "content": message
        })
        
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=conversation_messages,
            temperature=0.7,
            max_tokens=300
        )
        
        return response.choices[0].message.content
    
    def _should_escalate(self, message: str, intent_analysis: Dict) -> bool:
        """Determine if conversation should be escalated to human"""
        
        # Check for escalation triggers
        message_lower = message.lower()
        for trigger in self.knowledge_base["escalation_triggers"]:
            if trigger in message_lower:
                return True
        
        # Check confidence and sentiment
        if (intent_analysis["confidence"] < 0.7 or 
            intent_analysis["sentiment"] == "negative" and 
            intent_analysis["urgency"] == "high"):
            return True
        
        return False
    
    async def _escalate_to_human(self, context: ConversationContext, 
                               intent_analysis: Dict) -> Dict:
        """Handle escalation to human agent"""
        
        # Create escalation record
        escalation_data = {
            "user_id": context.user_id,
            "session_id": context.session_id,
            "timestamp": datetime.now().isoformat(),
            "reason": intent_analysis["intent"],
            "sentiment": intent_analysis["sentiment"],
            "conversation_history": context.conversation_history,
            "priority": "high" if intent_analysis["urgency"] == "high" else "medium"
        }
        
        # TODO: Send to human agent queue
        # await self.escalation_service.create_ticket(escalation_data)
        
        return {
            "response": "I understand this is important to you. I'm connecting you with one of our specialists who can better assist you. Please hold for a moment.",
            "escalation_required": True,
            "escalation_data": escalation_data,
            "actions": ["create_ticket", "notify_agent"]
        }
    
    async def _extract_actions(self, response: str, context: ConversationContext) -> List[str]:
        """Extract required actions from response"""
        actions = []
        
        # Common action patterns
        action_patterns = {
            "send_email": ["send you an email", "email you", "follow up via email"],
            "create_ticket": ["create a ticket", "file a report", "escalate"],
            "schedule_callback": ["call you back", "schedule a call", "callback"],
            "update_account": ["update your", "change your", "modify your"],
            "send_link": ["here's the link", "visit this page", "go to"]
        }
        
        response_lower = response.lower()
        for action, patterns in action_patterns.items():
            if any(pattern in response_lower for pattern in patterns):
                actions.append(action)
        
        return actions
    
    def _update_conversation_history(self, context: ConversationContext, 
                                   message: str, response: str):
        """Update conversation history"""
        context.conversation_history.append({
            "role": "user",
            "content": message,
            "timestamp": datetime.now().isoformat()
        })
        
        context.conversation_history.append({
            "role": "assistant",
            "content": response,
            "timestamp": datetime.now().isoformat()
        })
        
        # Keep only last 20 messages
        if len(context.conversation_history) > 20:
            context.conversation_history = context.conversation_history[-20:]

# Example Usage
async def main():
    # Initialize agent
    agent = ConversationalAgent(api_key="your-api-key")
    
    # Create conversation context
    context = ConversationContext(
        user_id="user123",
        session_id="session456",
        conversation_history=[],
        user_preferences={
            "tier": "premium",
            "purchase_history": ["laptop", "mouse", "keyboard"]
        },
        business_context={"channel": "website_chat"}
    )
    
    # Process customer message
    result = await agent.process_message(
        "I'm having trouble with my recent laptop order. It hasn't arrived yet and I need it urgently for work tomorrow.",
        context
    )
    
    print(f"Response: {result['response']}")
    print(f"Intent: {result['intent']}")
    print(f"Actions: {result['actions']}")
    print(f"Escalation needed: {result['escalation_required']}")

# Run the example
asyncio.run(main())