inventory_agent.py

"""
Smart Inventory Watchdog Agent
An intelligent monitoring system that acts as a 24/7 inventory guardian,
automatically tracking stock levels and triggering proactive reorder processes.
"""

import os
import json
from typing import List, Dict, Any, Optional
from datetime import datetime

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

from ormcp_tools import (
    ORMCPClient, 
    QueryTool, 
    GetAggregateTool, 
    UpdateTool, 
    InsertTool,
    GetObjectModelSummaryTool
)
from notification_tool import EmailNotificationTool, create_inventory_alert_email, create_reorder_suggestion_email


class InventoryWatchdogAgent:
    """Smart Inventory Watchdog Agent for monitoring and managing inventory"""
    
    def __init__(self, 
                 openai_api_key: str,
                 ormcp_server_url: str = "http://localhost:8080",
                 model_name: str = "gpt-3.5-turbo",
                 temperature: float = 0.3,
                 admin_emails: Optional[List[str]] = None,
                 default_threshold: int = 50):
        """
        Initialize the Inventory Watchdog Agent
        
        Args:
            openai_api_key: OpenAI API key
            ormcp_server_url: URL of the ORMCP server
            model_name: OpenAI model to use
            temperature: Model temperature
            admin_emails: List of admin email addresses for notifications
            default_threshold: Default stock threshold for alerts
        """
        self.openai_api_key = openai_api_key
        self.ormcp_server_url = ormcp_server_url
        self.model_name = model_name
        self.temperature = temperature
        self.admin_emails = admin_emails or []
        self.default_threshold = default_threshold
        
        # Initialize ORMCP client
        self.ormcp_client = ORMCPClient(base_url=ormcp_server_url)
        
        # Initialize LLM
        self.llm = ChatOpenAI(
            model=model_name,
            temperature=temperature,
            openai_api_key=openai_api_key
        )
        
        # Initialize tools
        self.tools = []
        self._setup_tools()
        
        # Initialize agent
        self.agent_executor = None
        self._setup_agent()
    
    def _setup_tools(self):
        """Set up all available tools"""
        # ORMCP tools
        self.tools.extend([
            QueryTool(self.ormcp_client),
            GetAggregateTool(self.ormcp_client),
            UpdateTool(self.ormcp_client),
            InsertTool(self.ormcp_client),
            GetObjectModelSummaryTool(self.ormcp_client),
        ])
        
        # Notification tool
        email_tool = EmailNotificationTool()
        self.tools.append(email_tool)
    
    def _setup_agent(self):
        """Set up the LangChain agent"""
        # Create agent using LangGraph (ReAct agent)
        # The agent will use the tools and LLM to perform inventory monitoring tasks
        self.agent_graph = create_react_agent(self.llm, self.tools)
        
        # System context for the agent (will be included in messages)
        self.system_context = """You are a Smart Inventory Watchdog Agent, an intelligent monitoring system 
that acts as a 24/7 inventory guardian. Your responsibilities include:

1. **Real-Time Stock Monitoring**: Continuously monitor product inventory via ORMCP queries, 
   tracking items where stockQuantity < threshold

2. **Intelligent Alerting**: Automatically send email notifications to admins/suppliers when 
   stock falls below configurable thresholds

3. **Predictive Reordering**: Analyze historical sales trends to suggest optimal reorder 
   quantities using AI-powered forecasting

4. **Multi-Channel Notifications**: Support Gmail API, SMTP, and custom messaging integrations

5. **Threshold Management**: Configure per-product or per-category thresholds with dynamic 
   adjustment based on sales velocity

**Available Tools:**
- `query_products`: Query products with filters (e.g., find low-stock items)
- `get_aggregate`: Calculate aggregates (COUNT, SUM, AVG, MIN, MAX) for sales analysis
- `update_products`: Update product information (stock levels, reorder flags)
- `insert_objects`: Create reorder requests and inventory alerts
- `send_email_notification`: Send email alerts to stakeholders
- `get_object_model_summary`: Discover database schema and available classes

**Key Classes:**
- `com.acme.ecommerce.model.Product`: Product catalog with stockQuantity, price, category, etc.
- `com.acme.ecommerce.model.CustomerOrder`: Order information
- `com.acme.ecommerce.model.OrderItem`: Order line items for sales analysis

**Workflow:**
1. Query products where stockQuantity < threshold
2. Analyze sales trends using getAggregate on OrderItem
3. Calculate suggested reorder quantities based on sales velocity
4. Update products with reorder flags
5. Create reorder requests
6. Send email notifications to admins/suppliers

**IMPORTANT - Update Product Instructions:**
When updating a product (e.g., changing stockQuantity):
1. FIRST: Query the product using query_products with filter "id = [product_id]" to get its complete current data
2. THEN: Use update_products with the complete product object including the ID and the field(s) to update
3. Example: To set product ID 1's stockQuantity to 39:
   - Step 1: query_products with className "com.acme.ecommerce.model.Product" and filter "id = 1"
   - Step 2: update_products with className "com.acme.ecommerce.model.Product" and jsonObjects containing the product object with id=1 and stockQuantity=39

Always be proactive and provide clear explanations of your actions. Stop after completing the requested task."""
    
    def initialize_ormcp(self):
        """Initialize connection to ORMCP server"""
        try:
            session_id = self.ormcp_client.initialize()
            print(f"✅ Connected to ORMCP server (Session: {session_id})")
            return True
        except Exception as e:
            print(f"❌ Failed to connect to ORMCP server: {e}")
            return False
    
    def monitor_stock_levels(self, threshold: Optional[int] = None) -> Dict[str, Any]:
        """
        Monitor stock levels and identify low-stock items
        
        Args:
            threshold: Stock threshold (defaults to self.default_threshold)
        
        Returns:
            Dictionary with monitoring results
        """
        threshold = threshold or self.default_threshold
        
        query = f"""Monitor inventory and find all products where stockQuantity < {threshold}.
        Return the product details including id, sku, name, stockQuantity, category, and price."""
        
        from langchain_core.messages import HumanMessage, SystemMessage
        messages = [
            SystemMessage(content=self.system_context),
            HumanMessage(content=query)
        ]
        # Configure recursion limit to prevent infinite loops
        config = {"recursion_limit": 50}
        result = self.agent_graph.invoke({"messages": messages}, config=config)
        return {"output": result.get("messages", [])[-1].content if result.get("messages") else str(result)}
    
    def analyze_sales_trends(self, product_id: Optional[int] = None, days: int = 30) -> Dict[str, Any]:
        """
        Analyze sales trends for predictive reordering
        
        Args:
            product_id: Specific product ID (None for all products)
            days: Number of days to analyze
        
        Returns:
            Dictionary with sales analysis
        """
        if product_id:
            query = f"""Analyze sales trends for product ID {product_id} over the last {days} days.
            Calculate average daily sales, total sales, and suggest optimal reorder quantity."""
        else:
            query = f"""Analyze overall sales trends over the last {days} days.
            Calculate average daily sales per product and identify fast-moving items."""
        
        from langchain_core.messages import HumanMessage, SystemMessage
        messages = [
            SystemMessage(content=self.system_context),
            HumanMessage(content=query)
        ]
        # Configure recursion limit to prevent infinite loops
        config = {"recursion_limit": 50}
        result = self.agent_graph.invoke({"messages": messages}, config=config)
        return {"output": result.get("messages", [])[-1].content if result.get("messages") else str(result)}
    
    def check_and_alert(self, threshold: Optional[int] = None) -> Dict[str, Any]:
        """
        Check stock levels and send alerts if needed
        
        Args:
            threshold: Stock threshold
        
        Returns:
            Dictionary with alert results
        """
        threshold = threshold or self.default_threshold
        
        query = f"""Check all products for low stock (stockQuantity < {threshold}).
        For each low-stock product:
        1. Analyze its sales velocity
        2. Calculate suggested reorder quantity
        3. Update the product with a reorder flag
        4. Send email alerts to admins at {', '.join(self.admin_emails) if self.admin_emails else 'configured addresses'}
        
        Provide a summary of all actions taken."""
        
        from langchain_core.messages import HumanMessage, SystemMessage
        messages = [
            SystemMessage(content=self.system_context),
            HumanMessage(content=query)
        ]
        # Configure recursion limit to prevent infinite loops
        config = {"recursion_limit": 50}
        result = self.agent_graph.invoke({"messages": messages}, config=config)
        return {"output": result.get("messages", [])[-1].content if result.get("messages") else str(result)}
    
    def suggest_reorder_quantities(self, product_ids: Optional[List[int]] = None) -> Dict[str, Any]:
        """
        Suggest optimal reorder quantities based on sales analysis
        
        Args:
            product_ids: List of product IDs (None for all low-stock products)
        
        Returns:
            Dictionary with reorder suggestions
        """
        if product_ids:
            ids_str = ', '.join(map(str, product_ids))
            query = f"""For products with IDs {ids_str}, analyze sales trends and suggest optimal reorder quantities.
            Consider average daily sales, lead times, and safety stock levels."""
        else:
            query = """For all products with low stock, analyze sales trends and suggest optimal reorder quantities.
            Consider average daily sales, lead times, and safety stock levels."""
        
        from langchain_core.messages import HumanMessage, SystemMessage
        messages = [
            SystemMessage(content=self.system_context),
            HumanMessage(content=query)
        ]
        # Configure recursion limit to prevent infinite loops
        config = {"recursion_limit": 50}
        result = self.agent_graph.invoke({"messages": messages}, config=config)
        return {"output": result.get("messages", [])[-1].content if result.get("messages") else str(result)}
    
    def run_continuous_monitoring(self, interval_seconds: int = 3600, threshold: Optional[int] = None):
        """
        Run continuous monitoring loop
        
        Args:
            interval_seconds: Time between monitoring cycles (default: 1 hour)
            threshold: Stock threshold
        """
        import time
        print(f"🔄 Starting continuous monitoring (interval: {interval_seconds}s)")
        
        while True:
            try:
                print(f"\n⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} - Running monitoring cycle...")
                result = self.check_and_alert(threshold)
                print(f"✅ Monitoring cycle completed")
                
                time.sleep(interval_seconds)
            except KeyboardInterrupt:
                print("\n🛑 Monitoring stopped by user")
                break
            except Exception as e:
                print(f"❌ Error in monitoring cycle: {e}")
                time.sleep(60)  # Wait 1 minute before retrying
    
    def chat(self, user_input: str) -> str:
        """Interactive chat interface"""
        from langchain_core.messages import HumanMessage, SystemMessage
        messages = [
            SystemMessage(content=self.system_context),
            HumanMessage(content=user_input)
        ]
        # Configure recursion limit to prevent infinite loops
        config = {"recursion_limit": 50}
        result = self.agent_graph.invoke({"messages": messages}, config=config)
        return result.get("messages", [])[-1].content if result.get("messages") else str(result)


def main():
    """Main entry point"""
    import argparse
    
    parser = argparse.ArgumentParser(description="Smart Inventory Watchdog Agent")
    parser.add_argument("--openai-api-key", required=True, help="OpenAI API key")
    parser.add_argument("--ormcp-url", default="http://localhost:8080", help="ORMCP server URL")
    parser.add_argument("--model", default="gpt-3.5-turbo", help="OpenAI model name")
    parser.add_argument("--threshold", type=int, default=50, help="Default stock threshold")
    parser.add_argument("--admin-emails", nargs="+", help="Admin email addresses for alerts")
    parser.add_argument("--monitor", action="store_true", help="Run continuous monitoring")
    parser.add_argument("--interval", type=int, default=3600, help="Monitoring interval in seconds")
    parser.add_argument("--interactive", action="store_true", help="Run in interactive chat mode")
    
    args = parser.parse_args()
    
    # Create agent
    agent = InventoryWatchdogAgent(
        openai_api_key=args.openai_api_key,
        ormcp_server_url=args.ormcp_url,
        model_name=args.model,
        admin_emails=args.admin_emails,
        default_threshold=args.threshold
    )
    
    # Initialize ORMCP connection
    agent.initialize_ormcp()
    
    if args.monitor:
        # Run continuous monitoring
        agent.run_continuous_monitoring(
            interval_seconds=args.interval,
            threshold=args.threshold
        )
    elif args.interactive:
        # Interactive chat mode
        print("💬 Interactive Chat Mode - Type 'exit' to quit")
        while True:
            user_input = input("\nYou: ")
            if user_input.lower() in ['exit', 'quit']:
                break
            response = agent.chat(user_input)
            print(f"\nAgent: {response}")
    else:
        # Single monitoring check
        print("🔍 Running single inventory check...")
        result = agent.check_and_alert(args.threshold)
        print(f"\n✅ Check completed: {result.get('output', 'No output')}")


if __name__ == "__main__":
    main()