app.py

import re
import os
import time
import requests
import base64
import asyncio
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from fastapi import FastAPI, Request, HTTPException, BackgroundTasks, UploadFile, File, Form
from fastapi.responses import JSONResponse, StreamingResponse, RedirectResponse
from fastapi.encoders import jsonable_encoder
from sqlalchemy import select, update, func
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, Boolean
import logging
import hmac
import hashlib
import json

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("delivery_service")

# --------------------
# DATABASE SETUP
# --------------------
DATABASE_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./test.db")
engine = create_async_engine(DATABASE_URL, echo=True)
async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

Base = declarative_base()

# --------------------
# DATABASE MODELS
# --------------------
class UserProfile(Base):
    __tablename__ = "user_profiles"
    id = Column(Integer, primary_key=True, index=True)
    user_id = Column(String(36), unique=True, index=True)
    phone_number = Column(String(20), nullable=True)
    name = Column(String(100), nullable=True)
    email = Column(String(100), nullable=True)
    preferences = Column(Text, default="{}")
    last_interaction = Column(DateTime, default=datetime.utcnow)
    ux_mode = Column(String(20), default="default")
    accessibility_prefs = Column(Text, default="{}")
    current_order_status = Column(String(50), default="None")

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")

class ChatHistory(Base):
    __tablename__ = "chat_history"
    id = Column(Integer, primary_key=True, index=True)
    user_id = Column(String(36), index=True)
    message = Column(Text)
    timestamp = Column(DateTime, default=datetime.utcnow)

class Order(Base):
    __tablename__ = "orders"
    order_id = Column(String(36), primary_key=True, index=True)
    user_id = Column(String(36), index=True)
    status = Column(String(20), default="pending")
    payment_reference = Column(String(100), nullable=True)
    last_location = Column(Text, nullable=True)  # Stored as a JSON string

class OrderTracking(Base):
    __tablename__ = "order_tracking"
    id = Column(Integer, primary_key=True, index=True)
    order_id = Column(String(36), index=True)
    status = Column(String(50))
    message = Column(Text)
    timestamp = Column(DateTime, default=datetime.utcnow)
    location = Column(Text, nullable=True)  # Stored as a JSON string

# --------------------
# INITIALIZATION
# --------------------
async def init_db():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    logger.info("Database tables created.")

# --------------------
# 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 the last 5 messages
        if len(self.context) > 5:
            self.context = self.context[-5:]

# Global state dictionary
user_state: Dict[str, ConversationState] = {}

# --------------------
# CORE UTILITIES
# --------------------
async def update_user_last_interaction(user_id: str):
    async with async_session() as session:
        await session.execute(
            update(UserProfile)
            .where(UserProfile.user_id == user_id)
            .values(last_interaction=datetime.utcnow())
        )
        await session.commit()

async def get_or_create_user_profile(user_id: str, phone: str = None) -> UserProfile:
    async with async_session() as session:
        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 a 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
            }
        }

    @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 based on input
            if preference.startswith("color_"):
                prefs.color_scheme = preference.split("_")[1]
            elif preference.startswith("speed_"):
                prefs.interaction_speed = preference.split("_")[1]
            
            await session.commit()

# --------------------
# HELPER FUNCTIONS FOR PAYMENT CALLBACK & TRACKING
# --------------------
async def log_order_tracking(order_id: str, status: str, message: str):
    async with async_session() as session:
        tracking_entry = OrderTracking(
            order_id=order_id,
            status=status,
            message=message
        )
        session.add(tracking_entry)
        await session.commit()

async def send_whatsapp_message(number: str, message: str):
    # Dummy implementation for sending WhatsApp messages
    logger.info(f"Sending WhatsApp message to {number}: {message}")

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()

async def get_order_details(order_id: str) -> Optional[Order]:
    async with async_session() as session:
        result = await session.execute(
            select(Order).where(Order.order_id == order_id)
        )
        return result.scalar_one_or_none()

def calculate_eta(last_location: dict) -> str:
    # Implement actual ETA calculation logic here.
    return "30 minutes"

# --------------------
# MAIN APPLICATION
# --------------------
app = FastAPI(title="Delivery Service Chatbot")

@app.on_event("startup")
async def on_startup():
    await init_db()

@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 conversation state if it doesn't exist
    if user_id not in user_state:
        user_state[user_id] = ConversationState()
    
    state = user_state[user_id]
    state.update_last_active()
    
    # Dummy conversation handling logic
    response = await DeliveryUXManager.generate_response_template(user_id)
    response["content"]["text"] = f"Received your message: {message}"
    state.add_context("user", message)
    
    # Background task to update user's last interaction in the DB
    bg.add_task(update_user_last_interaction, user_id)
    
    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"]
    )
    return {"status": "preferences updated"}

@app.get("/chat_history/{user_id}")
async def get_chat_history(user_id: str):
    async with async_session() as session:
        result = await session.execute(
            select(ChatHistory).where(ChatHistory.user_id == user_id)
        )
        history = result.scalars().all()
        return [jsonable_encoder({
            "user_id": entry.user_id,
            "message": entry.message,
            "timestamp": entry.timestamp.isoformat()
        }) for entry in history]

@app.get("/order/{order_id}")
async def get_order(order_id: str):
    async with async_session() as session:
        result = await session.execute(
            select(Order).where(Order.order_id == order_id)
        )
        order = result.scalar_one_or_none()
        if order:
            return jsonable_encoder({
                "order_id": order.order_id,
                "user_id": order.user_id,
                "status": order.status,
                "payment_reference": order.payment_reference,
                "last_location": order.last_location
            })
        else:
            raise HTTPException(status_code=404, detail="Order not found.")

@app.get("/user_profile/{user_id}")
async def get_user_profile(user_id: str):
    profile = await get_or_create_user_profile(user_id)
    return {
        "user_id": profile.user_id,
        "phone_number": profile.phone_number,
        "name": profile.name,
        "email": profile.email,
        "preferences": profile.preferences,
        "last_interaction": profile.last_interaction.isoformat(),
        "ux_mode": profile.ux_mode,
        "current_order_status": profile.current_order_status
    }

@app.get("/analytics")
async def get_analytics():
    async with async_session() as session:
        msg_result = await session.execute(
            select(func.count()).select_from(ChatHistory)
        )
        total_messages = msg_result.scalar() or 0
        order_result = await session.execute(
            select(func.count()).select_from(Order)
        )
        total_orders = order_result.scalar() or 0
        # This query assumes a sentiment_logs table exists with a sentiment_score column.
        sentiment_result = await session.execute("SELECT AVG(sentiment_score) FROM sentiment_logs")
        avg_sentiment = sentiment_result.scalar() or 0
    return {
        "total_messages": total_messages,
        "total_orders": total_orders,
        "average_sentiment": avg_sentiment
    }

@app.post("/voice")
async def process_voice(file: UploadFile = File(...)):
    contents = await file.read()
    simulated_text = "Simulated speech-to-text conversion result."
    return {"transcription": simulated_text}

@app.api_route("/payment_callback", methods=["GET", "POST"])
async def payment_callback(request: Request):
    PAYSTACK_SECRET_KEY = os.getenv("PAYSTACK_SECRET_KEY", "dummy_secret")
    MANAGEMENT_WHATSAPP_NUMBER = os.getenv("MANAGEMENT_WHATSAPP_NUMBER", "+1234567890")
    
    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")

        async with async_session() as session:
            result = await session.execute(
                select(Order)
                .where(Order.order_id == order_id)
                .with_for_update()
            )
            order = result.scalar_one_or_none()

            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}"
            )
            session.add(tracking_entry)
            
            await session.commit()

            # Send notifications concurrently
            await asyncio.gather(
                log_order_tracking(order_id, "Payment Updated", f"Payment status changed to {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":
                redirect_url = os.getenv("PAYMENT_REDIRECT_URL", "https://default-redirect.com")
                return RedirectResponse(
                    url=redirect_url,
                    status_code=303
                )
            return JSONResponse(content={"status": "success", "order_id": order_id})

    except HTTPException as he:
        raise he
    except Exception as e:
        logger.error(f"Payment callback error: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")

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):
    """
    Get order tracking history with pagination.
    """
    try:
        async with async_session() as session:
            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")

            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": json.loads(update.location) if update.location else None
                } 
                for update in tracking_updates
            ]

            # Add estimated delivery time if order is shipped
            order = await get_order_details(order_id)
            if order and order.status.lower() == "shipped":
                loc = json.loads(order.last_location) if order.last_location else {}
                response[0]["estimated_delivery"] = calculate_eta(loc)

            return JSONResponse(content=response)

    except HTTPException as he:
        raise he
    except Exception as e:
        logger.error(f"Tracking error: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")

# --------------------
# 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)