main.py

import re
import json
import requests
import traceback
import time
import os
from typing import Dict, Any, List, Optional, Tuple
from datetime import datetime, timedelta

# Updated imports for pydantic
from pydantic import BaseModel, Field

# Updated imports for LangChain
from langchain_core.prompts import PromptTemplate, ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from langchain_ollama import OllamaLLM
from langchain.chains import LLMChain
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain_huggingface.embeddings import HuggingFaceEmbeddings

# Enhanced HuggingFace imports for improved functionality
from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
import numpy as np

# Import endpoints documentation
from endpoints_documentation import endpoints_documentation

# Set environment variables for HuggingFace
# if os.name == 'posix' and os.uname().sysname == 'Darwin':  # Check if running on macOS
#     os.environ["HF_HOME"] = os.path.expanduser("~/Library/Caches/huggingface")
#     os.environ["TRANSFORMERS_CACHE"] = os.path.expanduser("~/Library/Caches/huggingface/transformers")
# else:
os.environ["HF_HOME"] = "/tmp/huggingface"
os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"


class ChatMessage(BaseModel):
    """Data model for chat messages"""
    message_id: str = Field(..., description="Unique identifier for the message")
    user_id: str = Field(..., description="User identifier")
    message: str = Field(..., description="The user's message")
    timestamp: datetime = Field(default_factory=datetime.now, description="When the message was sent")
    language: str = Field(default="english", description="Detected language of the message")


class ChatResponse(BaseModel):
    """Data model for chatbot responses"""
    response_id: str = Field(..., description="Unique identifier for the response")
    response_type: str = Field(..., description="Type of response: 'conversation' or 'api_action'")
    message: str = Field(..., description="The chatbot's response message")
    api_call_made: bool = Field(default=False, description="Whether an API call was made")
    api_data: Optional[Dict[str, Any]] = Field(default=None, description="API response data if applicable")
    language: str = Field(default="english", description="Language of the response")
    timestamp: datetime = Field(default_factory=datetime.now, description="When the response was generated")


class EndpointRequest(BaseModel):
    """Data model for API endpoint requests"""
    endpoint: str = Field(..., description="The API endpoint path to call")
    method: str = Field(..., description="The HTTP method to use (GET or POST)")
    params: Dict[str, Any] = Field(default_factory=dict, description="Parameters for the API call")
    missing_required: List[str] = Field(default_factory=list, description="Any required parameters that are missing")


class HealthcareChatbot:
    def __init__(self):
        self.endpoints_documentation = endpoints_documentation
        self.ollama_base_url = "http://localhost:11434"
        self.model_name = "gemma3"
        self.BASE_URL = 'https://d623-105-196-69-205.ngrok-free.app'
        self.headers = {'Content-type': 'application/json'}
        self.user_id = '5c745974-f1e6-4a9d-b93f-0e0aa75c5b09'
        self.max_retries = 3
        self.retry_delay = 2
        
        # Store conversation history
        self.conversation_history = []
        self.max_history_length = 10  # Keep last 10 exchanges
        
        # Initialize components
        self._initialize_language_tools()
        self._initialize_llm()
        self._initialize_parsers_and_chains()
        self._initialize_date_parser()
        
        print("Healthcare Chatbot initialized successfully!")
        self._print_welcome_message()

    def _print_welcome_message(self):
        """Print welcome message in both languages"""
        print("\n" + "="*60)
        print("🏥 HEALTHCARE CHATBOT READY")
        print("="*60)
        print("English: Hello! I'm your healthcare assistant. I can help you with:")
        print("• Booking and managing appointments")
        print("• Finding hospital information")
        print("• Viewing your medical records")
        print("• General healthcare questions")
        print()
        print("Arabic: مرحباً! أنا مساعدك الطبي. يمكنني مساعدتك في:")
        print("• حجز وإدارة المواعيد")
        print("• العثور على معلومات المستشفى")
        print("• عرض سجلاتك الطبية")
        print("• الأسئلة الطبية العامة")
        print("="*60)
        print("Type 'quit' or 'خروج' to exit\n")

    def _initialize_language_tools(self):
        """Initialize language processing tools"""
        try:
            self.embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
            self.language_classifier = pipeline(
                "text-classification", 
                model="papluca/xlm-roberta-base-language-detection",
                top_k=1
            )
            self.sentiment_analyzer = pipeline(
                "sentiment-analysis",
                model="cardiffnlp/twitter-xlm-roberta-base-sentiment"
            )
            print("✓ Language processing models loaded successfully")
        except Exception as e:
            print(f"⚠ Warning: Some language models failed to load: {e}")
            self.language_classifier = None
            self.sentiment_analyzer = None

    def _initialize_date_parser(self):
        """Initialize date parsing model"""
        try:
            self.date_parser = pipeline(
                "token-classification",
                model="Jean-Baptiste/roberta-large-ner-english",
                aggregation_strategy="simple"
            )
        except Exception as e:
            print(f"⚠ Warning: Date parsing model failed to load: {e}")
            self.date_parser = None

    def _initialize_llm(self):
        """Initialize the LLM"""
        callbacks = [StreamingStdOutCallbackHandler()]
        self.llm = OllamaLLM(
            model=self.model_name,
            base_url=self.ollama_base_url,
            callbacks=callbacks,
            temperature=0.7,
            num_ctx=8192,
            top_p=0.9,
            request_timeout=60,
        )

    def _initialize_parsers_and_chains(self):
        """Initialize all prompt templates and chains"""
        self.json_parser = JsonOutputParser(pydantic_object=EndpointRequest)
        
        # Intent classification prompt
        self.intent_classifier_template = PromptTemplate(
            template="""
            You are an intent classifier for a healthcare chatbot. Analyze the user's message and determine if it requires an API call or is conversational.

            === ANALYSIS CONTEXT ===
            User Message: {user_query}
            Language: {detected_language}
            Conversation History: {conversation_history}

            === AVAILABLE API ENDPOINTS ===
            {endpoints_documentation}

            === CLASSIFICATION TASK ===
            Determine if the user's message requires:
            1. API_ACTION: Specific healthcare action (book appointment, view records, etc.)
            2. CONVERSATION: General chat, greeting, questions not requiring backend data

            === RESPONSE FORMAT ===
            Respond with EXACTLY this JSON structure:
            {{
                "intent": "API_ACTION" or "CONVERSATION",
                "confidence": 0.95,
                "reasoning": "Brief explanation of classification decision",
                "requires_backend": true or false
            }}

            === CLASSIFICATION RULES ===
            Choose API_ACTION for:
            - Booking, canceling, or viewing appointments
            - Requesting medical records or test results
            - Hospital information queries (locations, hours, etc.)
            - Medication management requests
            - Specific patient data requests

            Choose CONVERSATION for:
            - Greetings and pleasantries
            - General health advice (not patient-specific)
            - Explanations of medical terms
            - Small talk or casual questions
            - Questions about the chatbot itself

            Classify the intent:""",
            input_variables=["user_query", "detected_language", "conversation_history", "endpoints_documentation"]
        )

        # API routing prompt (reuse existing router_prompt_template)
        self.router_prompt_template = PromptTemplate(
            template="""
            You are a precise API routing assistant. Your job is to analyze user queries and select the correct API endpoint with proper parameters.

                === ENDPOINT DOCUMENTATION ===
                {endpoints_documentation}

                === USER REQUEST ANALYSIS ===
                User Query: {user_query}
                Language: {detected_language}
                Keywords: {extracted_keywords}
                Sentiment: {sentiment_analysis}

                === ROUTING PROCESS ===
                Follow these steps in order:

                STEP 1: INTENT ANALYSIS
                - What is the user trying to accomplish?
                - What type of operation are they requesting? (create, read, update, delete, search, etc.)
                - What entity/resource are they working with?

                STEP 2: ENDPOINT MATCHING
                - Review each endpoint in the documentation
                - Match the user's intent to the endpoint's PURPOSE/DESCRIPTION
                - Consider the HTTP method (GET for retrieval, POST for creation, etc.)
                - Verify the endpoint can handle the user's specific request

                STEP 3: PARAMETER EXTRACTION
                - Identify ALL required parameters from the endpoint documentation
                - Extract parameter values from the user query
                - Convert data types as needed (dates to ISO 8601, numbers to integers, etc.)
                - Set appropriate defaults for optional parameters if beneficial

                STEP 4: VALIDATION
                - Ensure ALL required parameters are provided or identified as missing
                - Verify parameter formats match documentation requirements
                - Check that the selected endpoint actually solves the user's problem

                === RESPONSE FORMAT ===
                Provide your analysis and decision in this exact JSON structure:

                {{
                    "reasoning": {{
                        "user_intent": "Brief description of what the user wants to accomplish",
                        "selected_endpoint": "Why this endpoint was chosen over others",
                        "parameter_mapping": "How user query maps to endpoint parameters"
                    }},
                    "endpoint": "/exact_endpoint_path_from_documentation",
                    "method": "HTTP_METHOD",
                    "params": {{
                        "required_param_1": "extracted_or_converted_value",
                        "required_param_2": "extracted_or_converted_value",
                        "optional_param": "value_if_applicable"
                    }},
                    "missing_required": ["list", "of", "missing", "required", "parameters"],
                    "confidence": 0.95
                }}

                === CRITICAL RULES ===
                1. ONLY select endpoints that exist in the provided documentation
                2. NEVER fabricate or assume endpoint parameters not in documentation
                3. ALL required parameters MUST be included or listed as missing
                4. Convert dates/times to ISO 8601 format (YYYY-MM-DDTHH:MM:SS)
                5. If patient_id is required and not provided, add it to missing_required
                6. Match endpoints by PURPOSE, not just keywords in the path
                7. If multiple endpoints could work, choose the most specific one
                8. If no endpoint matches, set endpoint to null and explain in reasoning

                === EXAMPLES OF GOOD MATCHING ===
                - User wants "patient records" → Use patient retrieval endpoint, not general search
                - User wants to "schedule appointment" → Use appointment creation endpoint
                - User asks "what appointments today" → Use appointment listing with date filter
                - User wants to "update medication" → Use medication update endpoint with patient_id

                Think step by step and be precise with your endpoint selection and parameter extraction.:""",
            input_variables=["endpoints_documentation", "user_query", "detected_language", 
                            "extracted_keywords", "sentiment_analysis", "conversation_history"]
        )

        # Conversational response prompt
        self.conversation_template = PromptTemplate(
            template="""
            You are a friendly and professional healthcare chatbot assistant.

            === RESPONSE GUIDELINES ===
            - Respond ONLY in {detected_language}
            - Be helpful, empathetic, and professional
            - Keep responses concise but informative
            - Use appropriate medical terminology when needed
            - Maintain a caring and supportive tone

            === CONTEXT ===
            User Message: {user_query}
            Language: {detected_language}
            Sentiment: {sentiment_analysis}
            Conversation History: {conversation_history}

            === LANGUAGE-SPECIFIC INSTRUCTIONS ===
            
            FOR ARABIC RESPONSES:
            - Use Modern Standard Arabic (الفصحى)
            - Be respectful and formal as appropriate in Arabic culture
            - Use proper Arabic medical terminology
            - Keep sentences clear and grammatically correct

            FOR ENGLISH RESPONSES:
            - Use clear, professional English
            - Be warm and approachable
            - Use appropriate medical terminology

            === RESPONSE RULES ===
            1. Address the user's question or comment directly
            2. Provide helpful information when possible
            3. If you cannot help with something specific, explain what you CAN help with
            4. Never provide specific medical advice - always recommend consulting healthcare professionals
            5. Be encouraging and supportive
            6. Do NOT mix languages in your response
            7. End responses naturally without asking multiple questions

            Generate a helpful conversational response:""",
            input_variables=["user_query", "detected_language", "sentiment_analysis", "conversation_history"]
        )

        # API response formatting prompt (reuse existing user_response_template)
        self.user_response_template = PromptTemplate(
            template="""
            You are a professional healthcare assistant. Generate clear, accurate responses using EXACT data from the system.

            === STRICT REQUIREMENTS ===
            - Respond ONLY in {detected_language}
            - Use EXACT information from api_response - NO modifications
            - Keep responses SHORT, SIMPLE, and DIRECT
            - Use professional healthcare tone
            - NEVER mix languages or make up information

            === ORIGINAL REQUEST ===
            User Query: {user_query}
            User Sentiment: {sentiment_analysis}

            === SYSTEM DATA ===
            {api_response}

            === LANGUAGE-SPECIFIC FORMATTING ===

            FOR ARABIC RESPONSES:
            - Use Modern Standard Arabic (الفصحى)
            - Use Arabic numerals: ١، ٢، ٣، ٤، ٥، ٦، ٧، ٨، ٩، ١٠
            - Time format: "من الساعة ٨:٠٠ صباحاً إلى ٥:٠٠ مساءً"
            - Date format: "١٥ مايو ٢٠٢٥"
            - Use proper Arabic medical terminology
            - Keep sentences short and grammatically correct
            - Example format for hospitals:
            "مستشفى [الاسم] - العنوان: [العنوان الكامل] - أوقات العمل: من [الوقت] إلى [الوقت]"

            FOR ENGLISH RESPONSES:
            - Use clear, professional language
            - Time format: "8:00 AM to 5:00 PM"
            - Date format: "May 15, 2025"
            - Keep sentences concise and direct
            - Example format for hospitals:
            "[Hospital Name] - Address: [Full Address] - Hours: [Opening Time] to [Closing Time]"

            === RESPONSE STRUCTURE ===
            1. Direct answer to the user's question
            2. Essential details only (names, addresses, hours, contact info)
            3. Brief helpful note if needed
            4. No unnecessary introductions or conclusions

            === CRITICAL RULES ===
            - Extract information EXACTLY as provided in api_response
            - Do NOT include technical URLs, IDs, or system codes in the response
            - Do NOT show raw links or booking URLs to users
            - Present information in natural, conversational language
            - Do NOT use bullet points or technical formatting
            - Write as if you're speaking to the patient directly
            - If data is missing, state "المعلومات غير متوفرة" (Arabic) or "Information not available" (English)
            - Convert technical data into human-readable format
            - NEVER add translations or explanations in other languages
            - NEVER include "Translated response" or similar phrases
            - END your response immediately after providing the requested information
            - Do NOT add any English translation when responding in Arabic
            - Do NOT add any Arabic translation when responding in English

            === HUMAN-LIKE FORMATTING RULES ===
            FOR ARABIC:
            - Instead of "رابط الحجز: [URL]" → say "تم حجز موعدك بنجاح"
            - Instead of "الأزمة: غير متوفرة" → omit or say "بدون أعراض محددة"
            - Use natural sentences like "موعدك مع الدكتور [Name] يوم [Date] في تمام الساعة [Time]"
            - Avoid technical terms and system language

            FOR ENGLISH:
            - Instead of "Booking URL: [link]" → say "Your appointment has been scheduled"
            - Use natural sentences like "You have an appointment with Dr. [Name] on [Date] at [Time]"
            - Avoid showing raw URLs, IDs, or technical data

            === QUALITY CHECKS ===
            Before responding, verify:
            ✓ Response sounds natural and conversational
            ✓ No technical URLs, IDs, or system codes are shown
            ✓ Information is presented in human-friendly language
            ✓ Grammar is correct in the target language
            ✓ Response directly answers the user's question
            ✓ No bullet points or technical formatting
            ✓ Sounds like a helpful human assistant, not a system

            Generate a response that is accurate, helpful, and professionally formatted.

            === FINAL INSTRUCTION ===
            Respond ONLY in the requested language. Do NOT provide translations, explanations, or additional text in any other language. Stop immediately after answering the user's question.
            """,
            input_variables=["user_query", "api_response", "detected_language", "conversation_history"]
        )

        # Create chains
        self.intent_chain = LLMChain(llm=self.llm, prompt=self.intent_classifier_template)
        self.router_chain = LLMChain(llm=self.llm, prompt=self.router_prompt_template)
        self.conversation_chain = LLMChain(llm=self.llm, prompt=self.conversation_template)
        self.api_response_chain = LLMChain(llm=self.llm, prompt=self.user_response_template)

    def detect_language(self, text):
        """Detect language of the input text"""
        if self.language_classifier and len(text.strip()) > 3:
            try:
                result = self.language_classifier(text)
                detected_lang = result[0][0]['label']
                confidence = result[0][0]['score']
                
                if detected_lang in ['ar', 'arabic']:
                    return "arabic"
                elif detected_lang in ['en', 'english']:
                    return "english"
                elif confidence > 0.8:
                    return "english"  # Default to English for unsupported languages
            except:
                pass
        
        # Fallback: Basic Arabic detection
        arabic_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]+')
        if arabic_pattern.search(text):
            return "arabic"
        
        return "english"

    def analyze_sentiment(self, text):
        """Analyze sentiment of the text"""
        if self.sentiment_analyzer and len(text.strip()) > 3:
            try:
                result = self.sentiment_analyzer(text)
                return {
                    "sentiment": result[0]['label'],
                    "score": result[0]['score']
                }
            except:
                pass
        
        return {"sentiment": "NEUTRAL", "score": 0.5}

    def extract_keywords(self, text):
        """Extract keywords from text"""
        # Simple keyword extraction
        words = re.findall(r'\b\w+\b', text.lower())
        # Filter out common words and keep meaningful ones
        stopwords = {'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were'}
        keywords = [w for w in words if len(w) > 3 and w not in stopwords]
        return list(set(keywords))[:5]  # Return top 5 unique keywords

    def get_conversation_context(self):
        """Get recent conversation history as context"""
        if not self.conversation_history:
            return "No previous conversation"
        
        context = []
        for item in self.conversation_history[-3:]:  # Last 3 exchanges
            context.append(f"User: {item['user_message']}")
            context.append(f"Bot: {item['bot_response'][:100]}...")  # Truncate long responses
        
        return " | ".join(context)

    def add_to_history(self, user_message, bot_response, response_type):
        """Add exchange to conversation history"""
        self.conversation_history.append({
            'timestamp': datetime.now(),
            'user_message': user_message,
            'bot_response': bot_response,
            'response_type': response_type
        })
        
        # Keep only recent history
        if len(self.conversation_history) > self.max_history_length:
            self.conversation_history = self.conversation_history[-self.max_history_length:]

    def classify_intent(self, user_query, detected_language):
        """Classify if the user query requires API action or is conversational"""
        try:
            result = self.intent_chain.invoke({
                "user_query": user_query,
                "detected_language": detected_language,
                "conversation_history": self.get_conversation_context(),
                "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2)
            })
            
            # Parse the JSON response
            intent_text = result["text"]
            # Clean and parse JSON
            cleaned_response = re.sub(r'//.*?$', '', intent_text, flags=re.MULTILINE)
            cleaned_response = re.sub(r'/\*.*?\*/', '', cleaned_response, flags=re.DOTALL)
            cleaned_response = re.sub(r',(\s*[}\]])', r'\1', cleaned_response)
            
            try:
                intent_data = json.loads(cleaned_response)
                return intent_data
            except json.JSONDecodeError:
                # Try to extract JSON from the response
                json_match = re.search(r'\{.*?\}', cleaned_response, re.DOTALL)
                if json_match:
                    intent_data = json.loads(json_match.group(0))
                    return intent_data
                else:
                    # Default classification if parsing fails
                    return {
                        "intent": "CONVERSATION",
                        "confidence": 0.5,
                        "reasoning": "Failed to parse LLM response",
                        "requires_backend": False
                    }
        except Exception as e:
            print(f"Error in intent classification: {e}")
            return {
                "intent": "CONVERSATION",
                "confidence": 0.5,
                "reasoning": f"Error in classification: {str(e)}",
                "requires_backend": False
            }

    def handle_conversation(self, user_query, detected_language, sentiment_result):
        """Handle conversational responses"""
        try:
            result = self.conversation_chain.invoke({
                "user_query": user_query,
                "detected_language": detected_language,
                "sentiment_analysis": json.dumps(sentiment_result),
                "conversation_history": self.get_conversation_context()
            })
            
            return result["text"].strip()
            
        except Exception as e:
            # Fallback response
            if detected_language == "arabic":
                return "أعتذر، واجهت مشكلة في المعالجة. كيف يمكنني مساعدتك؟"
            else:
                return "I apologize, I encountered a processing issue. How can I help you?"

    def backend_call(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Make API call to backend with retry logic"""
        endpoint_url = data.get('endpoint')
        endpoint_method = data.get('method')
        endpoint_params = data.get('params', {}).copy()

        print('Sending the api request')
        print(f"🔗 Making API call to {endpoint_method} {self.BASE_URL + endpoint_url} with params: {endpoint_params}")
        
        # Inject patient_id if needed
        if 'patient_id' in endpoint_params:
            endpoint_params['patient_id'] = self.user_id
        
        retries = 0
        while retries < self.max_retries:
            try:
                if endpoint_method.upper() == 'GET':
                    response = requests.get(
                        self.BASE_URL + endpoint_url,
                        params=endpoint_params,
                        headers=self.headers,
                        timeout=10
                    )
                elif endpoint_method.upper() in ['POST', 'PUT', 'DELETE']:
                    response = requests.request(
                        endpoint_method.upper(),
                        self.BASE_URL + endpoint_url,
                        json=endpoint_params,
                        headers=self.headers,
                        timeout=10
                    )
                
                response.raise_for_status()
                return response.json()
                
            except requests.exceptions.RequestException as e:
                retries += 1
                if retries >= self.max_retries:
                    return {
                        "error": "Backend API call failed after multiple retries",
                        "details": str(e),
                        "status_code": getattr(e.response, 'status_code', None) if hasattr(e, 'response') else None
                    }
                
                time.sleep(self.retry_delay)

    def handle_api_action(self, user_query, detected_language, sentiment_result, keywords):
        """Handle API-based actions"""
        try:
            # Route the query to determine API endpoint
            router_result = self.router_chain.invoke({
                "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2),
                "user_query": user_query,
                "detected_language": detected_language,
                "extracted_keywords": ", ".join(keywords),
                "sentiment_analysis": json.dumps(sentiment_result),
                "conversation_history": self.get_conversation_context()
            })
            
            # Parse router response
            route_text = router_result["text"]
            cleaned_response = re.sub(r'//.*?$', '', route_text, flags=re.MULTILINE)
            cleaned_response = re.sub(r'/\*.*?\*/', '', cleaned_response, flags=re.DOTALL)
            cleaned_response = re.sub(r',(\s*[}\]])', r'\1', cleaned_response)
            
            try:
                parsed_route = json.loads(cleaned_response)
            except json.JSONDecodeError:
                json_match = re.search(r'\{.*?\}', cleaned_response, re.DOTALL)
                if json_match:
                    parsed_route = json.loads(json_match.group(0))
                else:
                    raise ValueError("Could not parse routing response")
            
            print(f"🔍 Parsed route: {parsed_route}")
            # Make backend API call
            api_response = self.backend_call(parsed_route)
            
            # Generate user-friendly response
            user_response_result = self.api_response_chain.invoke({
                "user_query": user_query,
                "api_response": json.dumps(api_response, indent=2),
                "detected_language": detected_language,
                "conversation_history": self.get_conversation_context()
            })
            
            return {
                "response": user_response_result["text"].strip(),
                "api_data": api_response,
                "routing_info": parsed_route
            }
            
        except Exception as e:
            # Fallback error response
            if detected_language == "arabic":
                error_msg = "أعتذر، لم أتمكن من معالجة طلبك. يرجى المحاولة مرة أخرى أو صياغة السؤال بطريقة مختلفة."
            else:
                error_msg = "I apologize, I couldn't process your request. Please try again or rephrase your question."
            
            return {
                "response": error_msg,
                "api_data": {"error": str(e)},
                "routing_info": None
            }

    def chat(self, user_message: str) -> ChatResponse:
        """Main chat method that handles user messages"""
        start_time = time.time()
        
        # Check for exit commands
        exit_commands = ['quit', 'exit', 'bye', 'خروج', 'وداعا', 'مع السلامة']
        if user_message.lower().strip() in exit_commands:
            return ChatResponse(
                response_id=f"resp_{int(time.time())}",
                response_type="conversation",
                message="Goodbye! Take care of your health! / وداعاً! اعتن بصحتك!",
                language="bilingual"
            )
        
        try:
            # Language detection and analysis
            detected_language = self.detect_language(user_message)
            sentiment_result = self.analyze_sentiment(user_message)
            keywords = self.extract_keywords(user_message)
            
            print(f"🔍 Language: {detected_language} | Sentiment: {sentiment_result['sentiment']} | Keywords: {keywords}")
            
            # Classify intent
            intent_data = self.classify_intent(user_message, detected_language)
            print(f"🎯 Intent: {intent_data['intent']} (confidence: {intent_data.get('confidence', 'N/A')})")
            
            # Handle based on intent
            if intent_data["intent"] == "API_ACTION" and intent_data.get("requires_backend", False):
                # Handle API-based actions
                print("🔗 Processing API action...")
                action_result = self.handle_api_action(user_message, detected_language, sentiment_result, keywords)
                
                response = ChatResponse(
                    response_id=f"resp_{int(time.time())}",
                    response_type="api_action",
                    message=action_result["response"],
                    api_call_made=True,
                    api_data=action_result["api_data"],
                    language=detected_language
                )
                
            else:
                # Handle conversational responses
                print("💬 Processing conversational response...")
                conv_response = self.handle_conversation(user_message, detected_language, sentiment_result)
                
                response = ChatResponse(
                    response_id=f"resp_{int(time.time())}",
                    response_type="conversation",
                    message=conv_response,
                    api_call_made=False,
                    language=detected_language
                )
            
            # Add to conversation history
            self.add_to_history(user_message, response.message, response.response_type)
            
            print(f"⏱️ Processing time: {time.time() - start_time:.2f}s")
            return response
            
        except Exception as e:
            print(f"❌ Error in chat processing: {e}")
            error_msg = "I apologize for the technical issue. Please try again. / أعتذر عن المشكلة التقنية. يرجى المحاولة مرة أخرى."
            
            return ChatResponse(
                response_id=f"resp_{int(time.time())}",
                response_type="conversation",
                message=error_msg,
                api_call_made=False,
                language="bilingual"
            )

    def start_interactive_chat(self):
        """Start an interactive chat session"""
        print("🚀 Starting interactive chat session...")
        
        while True:
            try:
                # Get user input
                user_input = input("\n👤 You: ").strip()
                
                if not user_input:
                    continue
                
                # Process the message
                print("🤖 Processing...")
                response = self.chat(user_input)
                
                # Display response
                print(f"\n🏥 Healthcare Bot: {response.message}")
                
                # Show additional info if API call was made
                if response.api_call_made and response.api_data:
                    if "error" not in response.api_data:
                        print("✅ Successfully retrieved information from healthcare system")
                    else:
                        print("⚠️ There was an issue accessing the healthcare system")
                
                # Check for exit
                if "Goodbye" in response.message or "وداعاً" in response.message:
                    break
                    
            except KeyboardInterrupt:
                print("\n\n👋 Chat session ended. Goodbye!")
                break
            except Exception as e:
                print(f"\n❌ Unexpected error: {e}")
                print("The chat session will continue...")


# Create a simple function to start the chatbot
# def start_healthcare_chatbot():
#     """Initialize and start the healthcare chatbot"""
#     try:
#         chatbot = HealthcareChatbot()
#         chatbot.start_interactive_chat()
#     except Exception as e:
#         print(f"Failed to start chatbot: {e}")
#         print("Please check your Ollama installation and endpoint documentation.")


# Test the chatbot
# if __name__ == "__main__":
    # You can test individual messages like this:
    # chatbot = HealthcareChatbot()
    
    # Test conversational message
    # print("\n=== TESTING CONVERSATIONAL MESSAGE ===")
    # conv_response = chatbot.chat("Hello, how are you today?")
    # print(f"Response: {conv_response.message}")
    # print(f"Type: {conv_response.response_type}")
    
    # Test API action message
    # print("\n=== TESTING API ACTION MESSAGE ===")
    # api_response = chatbot.chat("I want to book an appointment tomorrow at 2 PM")
    # print(f"Response: {api_response.message}")
    # print(f"Type: {api_response.response_type}")
    # print(f"API Called: {api_response.api_call_made}")
    
    # Start interactive session (uncomment to run)
    # start_healthcare_chatbot()

# Fast api section 
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Dict, Any, Optional


app = FastAPI(
    title="Healthcare AI Assistant",
    description="An AI-powered healthcare assistant that handles appointment booking and queries",
    version="1.0.0"
)

# Initialize the AI agent
agent = HealthcareChatbot()

class QueryRequest(BaseModel):
    query: str

class QueryResponse(BaseModel):
    routing_info: Dict[str, Any]
    api_response: Dict[str, Any]
    user_friendly_response: str
    detected_language: str
    sentiment: Dict[str, Any]

@app.post("/query")
async def process_query(request: QueryRequest):
    """
    Process a user query and return a response
    """
    try:
        response = agent.chat(request.query)
        return response
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    """
    Health check endpoint
    """
    return {"status": "healthy", "service": "healthcare-ai-assistant"}

@app.get("/")
async def root():
    return {"message": "Hello World"}

# if __name__ == "__main__":
#     import uvicorn
#     uvicorn.run(app, host="0.0.0.0", port=8000)