Update app.py

app.py

@@ -1,3 +1,6 @@
+# --------------------
+# IMPORTS & SETUP
+# --------------------
 import re
 import os
 import time
@@ -5,256 +8,198 @@ import requests
 import base64
 import asyncio
 from datetime import datetime, timedelta
-from bs4 import BeautifulSoup
-from sqlalchemy import select
-
+from typing import Dict, List, Optional
 from fastapi import FastAPI, Request, HTTPException, BackgroundTasks, UploadFile, File, Form
 from fastapi.responses import JSONResponse, StreamingResponse, RedirectResponse
-
-import openai
-
-# For sentiment analysis using TextBlob
-from textblob import TextBlob
-
-# SQLAlchemy Imports (Async)
+from sqlalchemy import select, update
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 from sqlalchemy.orm import sessionmaker, declarative_base
-from sqlalchemy import Column, Integer, String, DateTime, Text, Float
-
-# --- Environment Variables and API Keys ---
-SPOONACULAR_API_KEY = os.getenv("SPOONACULAR_API_KEY", "default_fallback_value")
-PAYSTACK_SECRET_KEY = os.getenv("PAYSTACK_SECRET_KEY", "default_fallback_value")
-DATABASE_URL = os.getenv("DATABASE_URL", "default_fallback_value")  # Example using SQLite
-NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "default_fallback_value")
-openai.api_key = os.getenv("OPENAI_API_KEY", "default_fallback_value")
+from sqlalchemy import Column, Integer, String, DateTime, Text, Float, Boolean
 
-# WhatsApp Business API credentials (Cloud API)
-WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_value")
-WHATSAPP_ACCESS_TOKEN = os.getenv("WHATSAPP_ACCESS_TOKEN", "default_value")
-MANAGEMENT_WHATSAPP_NUMBER = os.getenv("MANAGEMENT_WHATSAPP_NUMBER", "default_value")
-
-# --- Database Setup ---
+# --------------------
+# DATABASE MODELS
+# --------------------
 Base = declarative_base()
 
-class ChatHistory(Base):
-    __tablename__ = "chat_history"
-    id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(String, index=True)
-    timestamp = Column(DateTime, default=datetime.utcnow)
-    direction = Column(String)  # 'inbound' or 'outbound'
-    message = Column(Text)
-
-class Order(Base):
-    __tablename__ = "orders"
-    id = Column(Integer, primary_key=True, index=True)
-    order_id = Column(String, unique=True, index=True)
-    user_id = Column(String, index=True)
-    dish = Column(String)
-    quantity = Column(String)
-    price = Column(String, default="0")
-    status = Column(String, default="Pending Payment")
-    payment_reference = Column(String, nullable=True)
-    delivery_address = Column(String, default="")  # New field for address
-    timestamp = Column(DateTime, default=datetime.utcnow)
-
 class UserProfile(Base):
     __tablename__ = "user_profiles"
     id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(String, unique=True, index=True)
-    phone_number = Column(String, unique=True, index=True, nullable=True)
-    name = Column(String, default="Valued Customer")
-    email = Column(String, default="[email protected]")
-    preferences = Column(Text, default="")
-    last_interaction = Column(DateTime, default=datetime.utcnow)
-    loyalty_points = Column(Integer, default=0)  # New field for loyalty points
-    preferred_language = Column(String, default="English")  # New field for language preference
-
-class SentimentLog(Base):
-    __tablename__ = "sentiment_logs"
-    id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(String, index=True)
-    timestamp = Column(DateTime, default=datetime.utcnow)
-    sentiment_score = Column(Float)
-    message = Column(Text)
-
-class OrderTracking(Base):
-    __tablename__ = "order_tracking"
-    id = Column(Integer, primary_key=True, index=True)
-    order_id = Column(String, index=True)
-    status = Column(String)  # e.g., "Order Placed", "Payment Confirmed", etc.
-    message = Column(Text, nullable=True)  # Optional additional details
-    timestamp = Column(DateTime, default=datetime.utcnow)
-
-class Feedback(Base):
-    __tablename__ = "feedback"
-    id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(String, index=True)
-    rating = Column(Integer)
-    comment = Column(Text, nullable=True)
-    timestamp = Column(DateTime, default=datetime.utcnow)
-
-# --- Create Engine and Session ---
-engine = create_async_engine(DATABASE_URL, echo=True)
-async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
-
-async def init_db():
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-
-# --- Global In-Memory Stores ---
-user_state = {}       # e.g., { user_id: ConversationState }
-conversation_context = {}  # { user_id: [ { "timestamp": ..., "role": "user"/"bot", "message": ... }, ... ] }
-proactive_timer = {}
-
-# --- Utility Functions ---
-async def log_chat_to_db(user_id: str, direction: str, message: str):
+    user_id = Column(String(36), unique=True, index=True)
+    # ... [keep previous fields] ...
+    ux_mode = Column(String(20), default="default")
+    accessibility_prefs = Column(Text, default="{}")
+
+class UXPreferences(Base):
+    __tablename__ = "ux_preferences"
+    user_id = Column(String(36), primary_key=True)
+    interaction_speed = Column(String(20), default="normal")
+    color_scheme = Column(String(20), default="light")
+    input_preference = Column(String(20), default="buttons")
+
+# --------------------
+# STATE MANAGEMENT
+# --------------------
+class ConversationState:
+    def __init__(self):
+        self.flow: Optional[str] = None
+        self.step: int = 0
+        self.data: Dict = {}
+        self.context: List[Dict] = []
+        self.last_active: datetime = datetime.utcnow()
+    
+    def update_last_active(self):
+        self.last_active = datetime.utcnow()
+    
+    def add_context(self, role: str, message: str):
+        self.context.append({
+            "timestamp": datetime.utcnow(),
+            "role": role,
+            "message": message
+        })
+        # Keep only last 5 messages
+        if len(self.context) > 5:
+            self.context = self.context[-5:]
+
+# --------------------
+# CORE UTILITIES
+# --------------------
+async def update_user_last_interaction(user_id: str):
     async with async_session() as session:
-        entry = ChatHistory(user_id=user_id, direction=direction, message=message)
-        session.add(entry)
+        await session.execute(
+            update(UserProfile)
+            .where(UserProfile.user_id == user_id)
+            .values(last_interaction=datetime.utcnow())
+        )
         await session.commit()
 
-async def log_sentiment(user_id: str, message: str, score: float):
+async def get_or_create_user_profile(user_id: str, phone: str = None) -> UserProfile:
     async with async_session() as session:
-        entry = SentimentLog(user_id=user_id, sentiment_score=score, message=message)
-        session.add(entry)
-        await session.commit()
-
-def analyze_sentiment(text: str) -> float:
-    blob = TextBlob(text)
-    return blob.sentiment.polarity
+        result = await session.execute(
+            select(UserProfile).where(UserProfile.user_id == user_id)
+        )
+        profile = result.scalar_one_or_none()
+        
+        if not profile:
+            profile = UserProfile(
+                user_id=user_id,
+                phone_number=phone,
+                last_interaction=datetime.utcnow()
+            )
+            session.add(profile)
+            await session.commit()
+            await session.refresh(profile)
+        
+        return profile
+
+# --------------------
+# ENHANCED UX FEATURES
+# --------------------
+class DeliveryUXManager:
+    @staticmethod
+    async def generate_response_template(user_id: str) -> Dict:
+        """Generate personalized response structure"""
+        profile = await get_or_create_user_profile(user_id)
+        return {
+            "meta": {
+                "ux_mode": profile.ux_mode,
+                "color_scheme": "light",
+                "interaction_mode": "text"
+            },
+            "content": {
+                "text": "",
+                "quick_replies": [],
+                "carousel": None,
+                "status_overlay": None
+            }
+        }
 
-# --- New Features Implementation ---
-async def send_main_menu(user_id: str):
-    menu_message = (
-        "Hi there! 👋 Welcome to [Delivery Service Co.]. I’m here to help with your deliveries. "
-        "What would you like to do today?"
-    )
-    quick_replies = [
-        {"title": "Track an Order", "payload": "track_order"},
-        {"title": "Schedule a Delivery", "payload": "schedule_delivery"},
-        {"title": "FAQs & Support", "payload": "faqs"},
-        {"title": "Loyalty Points", "payload": "loyalty_points"},
-        {"title": "Talk to an Agent", "payload": "live_agent"},
-    ]
-    await log_chat_to_db(user_id, "outbound", menu_message)
-    return {"response": menu_message, "quick_replies": quick_replies}
-
-async def track_order(user_id: str, order_id: str):
-    # Simulate fetching real-time tracking data
-    tracking_data = {
-        "status": "On the way",
-        "estimated_time": "30 minutes",
-        "driver_location": "https://maps.google.com/?q=6.5244,3.3792",  # Example location
-    }
-    tracking_message = (
-        f"🚚 Your order ({order_id}) is currently {tracking_data['status']} and is expected to arrive in {tracking_data['estimated_time']}. "
-        f"Tap below to track your package in real-time."
-    )
-    quick_replies = [
-        {"title": "Track on Map", "url": tracking_data["driver_location"]},
-        {"title": "Back to Menu", "payload": "main_menu"},
-    ]
-    await log_chat_to_db(user_id, "outbound", tracking_message)
-    return {"response": tracking_message, "quick_replies": quick_replies}
-
-async def recommend_package(user_id: str, package_description: str):
-    # Simulate AI analysis
-    package_size = "Medium"
-    price = 2500
-    recommendation_message = (
-        f"Based on your description, we recommend a {package_size} package for ₦{price}. "
-        "Does this sound right?"
-    )
-    quick_replies = [
-        {"title": "Yes, proceed", "payload": f"confirm_package:{package_size}:{price}"},
-        {"title": "No, adjust size", "payload": "adjust_package"},
-    ]
-    await log_chat_to_db(user_id, "outbound", recommendation_message)
-    return {"response": recommendation_message, "quick_replies": quick_replies}
-
-async def check_loyalty_points(user_id: str):
-    # Simulate fetching loyalty points
-    points = 200
-    discount = 500
-    loyalty_message = (
-        f"🎉 You’ve earned 50 points for this delivery! You now have {points} points. "
-        f"Redeem them for a ₦{discount} discount on your next order."
-    )
-    quick_replies = [
-        {"title": "Redeem Points", "payload": "redeem_points"},
-        {"title": "Back to Menu", "payload": "main_menu"},
-    ]
-    await log_chat_to_db(user_id, "outbound", loyalty_message)
-    return {"response": loyalty_message, "quick_replies": quick_replies}
-
-async def send_proactive_update(user_id: str, order_id: str, status: str):
-    if status == "picked_up":
-        message = f"🚚 Your order ({order_id}) has been picked up and is on the way!"
-    elif status == "nearby":
-        message = f"🚚 Your driver is 10 minutes away! Please ensure someone is available to receive the package."
-    await log_chat_to_db(user_id, "outbound", message)
-    return {"response": message}
-
-async def set_language(user_id: str, language: str):
-    supported_languages = ["English", "Français", "Español"]
-    if language in supported_languages:
-        user_state[user_id]["language"] = language
-        message = f"Language set to {language}. How can I assist you today?"
-    else:
-        message = "Sorry, that language is not supported. Please choose from: English, Français, Español."
-    quick_replies = [{"title": lang, "payload": f"set_language:{lang}"} for lang in supported_languages]
-    await log_chat_to_db(user_id, "outbound", message)
-    return {"response": message, "quick_replies": quick_replies}
-
-async def request_feedback(user_id: str):
-    feedback_message = "How was your delivery experience? Tap to rate:"
-    quick_replies = [
-        {"title": "⭐️⭐️⭐️⭐️⭐️", "payload": "rate:5"},
-        {"title": "⭐️⭐️⭐️⭐️", "payload": "rate:4"},
-        {"title": "⭐️⭐️⭐️", "payload": "rate:3"},
-        {"title": "⭐️⭐️", "payload": "rate:2"},
-        {"title": "⭐️", "payload": "rate:1"},
-    ]
-    await log_chat_to_db(user_id, "outbound", feedback_message)
-    return {"response": feedback_message, "quick_replies": quick_replies}
-
-async def show_environmental_impact(user_id: str):
-    impact_message = "🌍 Your delivery saved 2kg of CO2 emissions! Thank you for choosing eco-friendly shipping."
-    await log_chat_to_db(user_id, "outbound", impact_message)
-    return {"response": impact_message}
-
-async def start_onboarding(user_id: str):
-    tutorial_message = (
-        "Let me guide you through how to schedule a delivery. Tap ‘Next’ to continue."
-    )
-    quick_replies = [
-        {"title": "Next", "payload": "tutorial_step_1"},
-        {"title": "Skip Tutorial", "payload": "main_menu"},
-    ]
-    await log_chat_to_db(user_id, "outbound", tutorial_message)
-    return {"response": tutorial_message, "quick_replies": quick_replies}
-
-async def suggest_faqs(user_id: str, user_input: str):
-    # Simulate AI-powered FAQ suggestions
-    suggested_faqs = [
-        "How long does delivery take?",
-        "Can I change my delivery time?",
-        "What are your pricing options?",
-    ]
-    faq_message = (
-        f"It looks like you’re asking about delivery times. Here are some related FAQs:"
-    )
-    quick_replies = [{"title": faq, "payload": f"faq:{faq}"} for faq in suggested_faqs]
-    await log_chat_to_db(user_id, "outbound", faq_message)
-    return {"response": faq_message, "quick_replies": quick_replies}
+    @staticmethod
+    async def handle_ux_preferences(user_id: str, preference: str):
+        """Update UX preferences"""
+        async with async_session() as session:
+            prefs = await session.get(UXPreferences, user_id)
+            if not prefs:
+                prefs = UXPreferences(user_id=user_id)
+                session.add(prefs)
+            
+            # Update specific preference
+            if preference.startswith("color_"):
+                prefs.color_scheme = preference.split("_")[1]
+            elif preference.startswith("speed_"):
+                prefs.interaction_speed = preference.split("_")[1]
+            
+            await session.commit()
+
+# --------------------
+# MAIN APPLICATION
+# --------------------
+app = FastAPI(title="Delivery Service Chatbot")
 
-async def schedule_offline(user_id: str):
-    offline_message = (
-        "You’re offline. Your delivery has been scheduled and will be confirmed once you’re back online."
+@app.post("/chatbot")
+async def enhanced_chatbot_handler(request: Request, bg: BackgroundTasks):
+    data = await request.json()
+    user_id = data["user_id"]
+    message = data.get("message", "")
+    
+    # Initialize state
+    if user_id not in user_state:
+        user_state[user_id] = ConversationState()
+    
+    state = user_state[user_id]
+    state.update_last_active()
+    
+    # Process message
+    response = await DeliveryUXManager.generate_response_template(user_id)
+    
+    # [Add conversation handling logic here]
+    
+    return JSONResponse(response)
+
+@app.post("/ux/preferences")
+async def update_ux_preferences(request: Request):
+    data = await request.json()
+    await DeliveryUXManager.handle_ux_preferences(
+        data["user_id"], 
+        data["preference"]
     )
-    await log_chat_to_db(user_id, "outbound", offline_message)
-    return {"response": offline_message}
+    return {"status": "preferences updated"}
+
+# --------------------
+# PROACTIVE FEATURES
+# --------------------
+async def send_proactive_update(user_id: str, update_type: str):
+    """Send unsolicited updates to users"""
+    state = user_state.get(user_id)
+    if not state:
+        return  # User not active
+    
+    response = await DeliveryUXManager.generate_response_template(user_id)
+    
+    if update_type == "delivery_eta":
+        response["content"]["text"] = "📦 Your package is arriving in 15 minutes!"
+        response["content"]["quick_replies"] = [
+            {"title": "Track Live", "action": "track_live"},
+            {"title": "Delay Delivery", "action": "delay_delivery"}
+        ]
+    
+    return response
+
+# --------------------
+# ERROR HANDLING
+# --------------------
+@app.exception_handler(HTTPException)
+async def ux_error_handler(request: Request, exc: HTTPException):
+    return JSONResponse({
+        "meta": {"error": True},
+        "content": {
+            "text": f"⚠️ Error: {exc.detail}",
+            "quick_replies": [{"title": "Main Menu", "action": "reset"}]
+        }
+    }, status_code=exc.status_code)
 
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
 # --- FastAPI Setup & Endpoints ---
 app = FastAPI()
 
@@ -262,164 +207,6 @@ app = FastAPI()
 async def on_startup():
     await init_db()
 
-@app.post("/chatbot")
-async def chatbot_response(request: Request, background_tasks: BackgroundTasks):
-    data = await request.json()
-    user_id = data.get("user_id")
-    phone_number = data.get("phone_number")
-    user_message = data.get("message", "").strip()
-    is_image = data.get("is_image", False)
-    image_b64 = data.get("image_base64", None)
-
-    if not user_id:
-        raise HTTPException(status_code=400, detail="Missing user_id in payload.")
-
-    # Initialize conversation context for the user if not present.
-    if user_id not in conversation_context:
-        conversation_context[user_id] = []
-    # Append the inbound message to the conversation context.
-    conversation_context[user_id].append({
-        "timestamp": datetime.utcnow().isoformat(),
-        "role": "user",
-        "message": user_message
-    })
-
-    background_tasks.add_task(log_chat_to_db, user_id, "inbound", user_message)
-    await update_user_last_interaction(user_id)
-    await get_or_create_user_profile(user_id, phone_number)
-
-    # Handle image queries
-    if is_image and image_b64:
-        if len(image_b64) >= 180_000:
-            raise HTTPException(status_code=400, detail="Image too large.")
-        return StreamingResponse(stream_image_completion(image_b64), media_type="text/plain")
-
-    sentiment_score = analyze_sentiment(user_message)
-    background_tasks.add_task(log_sentiment, user_id, user_message, sentiment_score)
-    sentiment_modifier = ""
-    if sentiment_score < -0.3:
-        sentiment_modifier = "I'm sorry if you're having a tough time. "
-    elif sentiment_score > 0.3:
-        sentiment_modifier = "Great to hear from you! "
-
-    # --- Order Tracking Handling ---
-    order_id_match = re.search(r"ord-\d+", user_message.lower())
-    if order_id_match:
-        order_id = order_id_match.group(0)
-        try:
-            # Call the /track_order endpoint
-            tracking_response = await track_order(order_id)
-            return JSONResponse(content={"response": tracking_response})
-        except HTTPException as e:
-            return JSONResponse(content={"response": f"⚠️ {e.detail}"})
-
-    # --- Order Flow Handling ---
-    order_response = process_order_flow(user_id, user_message)
-    if order_response:
-        background_tasks.add_task(log_chat_to_db, user_id, "outbound", order_response)
-        conversation_context[user_id].append({
-            "timestamp": datetime.utcnow().isoformat(),
-            "role": "bot",
-            "message": order_response
-        })
-        return JSONResponse(content={"response": sentiment_modifier + order_response})
-
-    # --- Menu Display ---
-    if "menu" in user_message.lower():
-        if user_id in user_state:
-            del user_state[user_id]
-        menu_with_images = []
-        for index, item in enumerate(menu_items, start=1):
-            image_url = google_image_scrape(item["name"])
-            menu_with_images.append({
-                "number": index,
-                "name": item["name"],
-                "description": item["description"],
-                "price": item["price"],
-                "image_url": image_url
-            })
-        response_payload = {
-            "response": sentiment_modifier + "Here’s our delicious menu:",
-            "menu": menu_with_images,
-            "follow_up": (
-                "To order, type the *number* or *name* of the dish you'd like. "
-                "For example, type '1' or 'Jollof Rice' to order Jollof Rice.\n\n"
-                "You can also ask for nutritional facts by typing, for example, 'Nutritional facts for Jollof Rice'."
-            )
-        }
-        background_tasks.add_task(log_chat_to_db, user_id, "outbound", str(response_payload))
-        conversation_context[user_id].append({
-            "timestamp": datetime.utcnow().isoformat(),
-            "role": "bot",
-            "message": response_payload["response"]
-        })
-        return JSONResponse(content=response_payload)
-
-    # --- Dish Selection via Menu ---
-    if any(item["name"].lower() in user_message.lower() for item in menu_items) or \
-       any(str(index) == user_message.strip() for index, item in enumerate(menu_items, start=1)):
-        selected_dish = None
-        if user_message.strip().isdigit():
-            dish_number = int(user_message.strip())
-            if 1 <= dish_number <= len(menu_items):
-                selected_dish = menu_items[dish_number - 1]["name"]
-        else:
-            for item in menu_items:
-                if item["name"].lower() in user_message.lower():
-                    selected_dish = item["name"]
-                    break
-        if selected_dish:
-            state = ConversationState()
-            state.flow = "order"
-            # Set step to 2 since the dish is already selected
-            state.step = 2  
-            state.data["dish"] = selected_dish
-            state.update_last_active()
-            user_state[user_id] = state
-            response_text = f"You selected {selected_dish}. How many servings would you like?"
-            background_tasks.add_task(log_chat_to_db, user_id, "outbound", response_text)
-            conversation_context[user_id].append({
-                "timestamp": datetime.utcnow().isoformat(),
-                "role": "bot",
-                "message": response_text
-            })
-            return JSONResponse(content={"response": sentiment_modifier + response_text})
-        else:
-            response_text = "Sorry, I couldn't find that dish in the menu. Please try again."
-            background_tasks.add_task(log_chat_to_db, user_id, "outbound", response_text)
-            conversation_context[user_id].append({
-                "timestamp": datetime.utcnow().isoformat(),
-                "role": "bot",
-                "message": response_text
-            })
-            return JSONResponse(content={"response": sentiment_modifier + response_text})
-
-    # --- Nutritional Facts ---
-    if "nutritional facts for" in user_message.lower():
-        dish_name = user_message.lower().replace("nutritional facts for", "").strip().title()
-        dish = next((item for item in menu_items if item["name"].lower() == dish_name.lower()), None)
-        if dish:
-            response_text = f"Nutritional facts for {dish['name']}:\n{dish['nutrition']}"
-        else:
-            response_text = f"Sorry, I couldn't find nutritional facts for {dish_name}."
-        background_tasks.add_task(log_chat_to_db, user_id, "outbound", response_text)
-        conversation_context[user_id].append({
-            "timestamp": datetime.utcnow().isoformat(),
-            "role": "bot",
-            "message": response_text
-        })
-        return JSONResponse(content={"response": sentiment_modifier + response_text})
-
-    # --- Fallback: LLM Response Streaming with Conversation Context ---
-    recent_context = conversation_context.get(user_id, [])[-5:]
-    context_str = "\n".join([f"{entry['role'].capitalize()}: {entry['message']}" for entry in recent_context])
-    prompt = f"Conversation context:\n{context_str}\nUser query: {user_message}\nGenerate a helpful, personalized response for a restaurant chatbot."
-    def stream_response():
-        for chunk in stream_text_completion(prompt):
-            yield chunk
-    fallback_log = f"LLM fallback response for prompt: {prompt}"
-    background_tasks.add_task(log_chat_to_db, user_id, "outbound", fallback_log)
-    return StreamingResponse(stream_response(), media_type="text/plain")
 
 # --- Other Endpoints (Chat History, Order Details, User Profile, Analytics, Voice, Payment Callback) ---
 @app.get("/chat_history/{user_id}")
@@ -476,82 +263,164 @@ async def process_voice(file: UploadFile = File(...)):
     simulated_text = "Simulated speech-to-text conversion result."
     return {"transcription": simulated_text}
 
-# --- Payment Callback Endpoint with Payment Tracking and Redirection ---
+# Enhanced payment callback with security checks
 @app.api_route("/payment_callback", methods=["GET", "POST"])
 async def payment_callback(request: Request):
-    # GET: User redirection after payment
-    if request.method == "GET":
-        params = request.query_params
-        order_id = params.get("reference")
-        status = params.get("status", "Paid")
+    """Handle payment gateway callbacks with HMAC verification"""
+    try:
+        if request.method == "POST":
+            # Verify Paystack signature
+            signature = request.headers.get("x-paystack-signature")
+            if not signature:
+                raise HTTPException(status_code=403, detail="Missing signature")
+
+            body = await request.body()
+            computed_sha = hmac.new(
+                PAYSTACK_SECRET_KEY.encode(),
+                body,
+                digestmod=hashlib.sha512
+            ).hexdigest()
+
+            if not hmac.compare_digest(computed_sha, signature):
+                raise HTTPException(status_code=403, detail="Invalid signature")
+
+            data = await request.json()
+            event = data.get("event")
+            order_id = data.get("data", {}).get("reference")
+            status = "Paid" if event == "charge.success" else "Failed"
+            
+        elif request.method == "GET":
+            data = request.query_params
+            order_id = data.get("reference")
+            status = data.get("status", "Paid")
+
         if not order_id:
-            raise HTTPException(status_code=400, detail="Missing order reference in callback.")
+            raise HTTPException(status_code=400, detail="Missing order reference")
+
         async with async_session() as session:
+            # Get order with lock to prevent race conditions
             result = await session.execute(
-                Order.__table__.select().where(Order.order_id == order_id)
+                select(Order)
+                .where(Order.order_id == order_id)
+                .with_for_update()
             )
             order = result.scalar_one_or_none()
-            if order:
-                order.status = status
-                await session.commit()
-            else:
-                raise HTTPException(status_code=404, detail="Order not found.")
-        # Record payment confirmation tracking update
-        await log_order_tracking(order_id, "Payment Confirmed", f"Payment status updated to {status}.")
-        # Notify management via WhatsApp about the payment update
-        await asyncio.to_thread(send_whatsapp_message, MANAGEMENT_WHATSAPP_NUMBER,
-            f"Payment Update:\nOrder ID: {order_id} is now {status}."
-        )
-        # Redirect user back to the chat interface (adjust URL as needed)
-        redirect_url = f"https://wa.link/am87s2"
-        return RedirectResponse(url=redirect_url)
-    # POST: Server-to-server callback from Paystack
-    else:
-        data = await request.json()
-        order_id = data.get("reference")
-        new_status = data.get("status", "Paid")
-        if not order_id:
-            raise HTTPException(status_code=400, detail="Missing order reference in callback.")
-        async with async_session() as session:
-            result = await session.execute(
-                Order.__table__.select().where(Order.order_id == order_id)
+
+            if not order:
+                raise HTTPException(status_code=404, detail="Order not found")
+
+            valid_statuses = ["Paid", "Failed", "Pending"]
+            if status not in valid_statuses:
+                raise HTTPException(status_code=400, detail="Invalid status")
+
+            order.status = status
+            order.payment_reference = order_id
+            
+            # Add tracking update
+            tracking_entry = OrderTracking(
+                order_id=order_id,
+                status="Payment Updated",
+                message=f"Payment status changed to {status}"
             )
-            order = result.scalar_one_or_none()
-            if order:
-                order.status = new_status
-                await session.commit()
-                await log_order_tracking(order_id, "Payment Confirmed", f"Payment status updated to {new_status}.")
-                await asyncio.to_thread(send_whatsapp_message, MANAGEMENT_WHATSAPP_NUMBER,
-                    f"Payment Update:\nOrder ID: {order_id} is now {new_status}."
+            session.add(tracking_entry)
+            
+            await session.commit()
+
+            # Send notifications
+            await asyncio.gather(
+                log_order_tracking(order_id, "Payment Updated", status),
+                send_whatsapp_message(
+                    MANAGEMENT_WHATSAPP_NUMBER,
+                    f"Payment Update: Order {order_id} - {status}"
+                ),
+                update_user_order_status(order.user_id, order_id, status)
+            )
+
+            if request.method == "GET":
+                return RedirectResponse(
+                    url=os.getenv("PAYMENT_REDIRECT_URL", "https://default-redirect.com"),
+                    status_code=303
                 )
-                return JSONResponse(content={"message": "Order updated successfully."})
-            else:
-                raise HTTPException(status_code=404, detail="Order not found.")
-                
-@app.get("/track_order/{order_id}")
-async def track_order(order_id: str):
+            return JSONResponse(content={"status": "success", "order_id": order_id})
+
+    except HTTPException as he:
+        raise
+    except Exception as e:
+        logger.error(f"Payment callback error: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Enhanced tracking endpoint with caching
+from fastapi_cache.decorator import cache
+
+@app.get("/track_order/{order_id}", response_model=List[dict])
+@cache(expire=60)  # Cache for 1 minute
+async def get_order_tracking(order_id: str, 
+                            page: int = 1, 
+                            limit: int = 10):
     """
-    Fetch order tracking details for a given order ID.
+    Get order tracking history with pagination
     """
-    async with async_session() as session:
-        result = await session.execute(
-            select(OrderTracking)
-            .where(OrderTracking.order_id == order_id)
-            .order_by(OrderTracking.timestamp)
-        )
-        tracking_updates = result.scalars().all()
-        if tracking_updates:
-            response = []
-            for update in tracking_updates:
-                response.append({
+    try:
+        async with async_session() as session:
+            # Get order first to verify existence
+            order_result = await session.execute(
+                select(Order).where(Order.order_id == order_id)
+            if not order_result.scalar_one_or_none():
+                raise HTTPException(status_code=404, detail="Order not found")
+
+            # Get tracking history
+            tracking_result = await session.execute(
+                select(OrderTracking)
+                .where(OrderTracking.order_id == order_id)
+                .order_by(OrderTracking.timestamp.desc())
+                .offset((page-1)*limit)
+                .limit(limit)
+            )
+            
+            tracking_updates = tracking_result.scalars().all()
+            
+            if not tracking_updates:
+                return JSONResponse(content=[])
+
+            response = [
+                {
                     "status": update.status,
                     "message": update.message,
                     "timestamp": update.timestamp.isoformat(),
-                })
+                    "location": jsonable_encoder(update.location) if update.location else None
+                } 
+                for update in tracking_updates
+            ]
+
+            # Add estimated delivery time
+            order = await get_order_details(order_id)
+            if order.status == "shipped":
+                response[0]["estimated_delivery"] = calculate_eta(order.last_location)
+
             return JSONResponse(content=response)
-        else:
-            raise HTTPException(status_code=404, detail="No tracking information found for this order.")
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    except HTTPException as he:
+        raise
+    except Exception as e:
+        logger.error(f"Tracking error: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+# Helper functions
+async def get_order_details(order_id: str):
+    async with async_session() as session:
+        result = await session.execute(
+            select(Order).where(Order.order_id == order_id)
+        return result.scalar_one_or_none()
+
+async def update_user_order_status(user_id: str, order_id: str, status: str):
+    async with async_session() as session:
+        await session.execute(
+            update(UserProfile)
+            .where(UserProfile.user_id == user_id)
+            .values(current_order_status=status)
+        )
+        await session.commit()
+
+def calculate_eta(last_location: dict) -> str:
+    # Implement actual ETA calculation logic
+    return "30 minutes"