Add reply function

app/main.py

@@ -1,15 +1,115 @@
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, status
 from fastapi.responses import JSONResponse
 from fastapi.responses import Response
 from fastapi.exceptions import HTTPException
+from typing import Dict
+from app.services.message import generate_reply, send_reply, process_message_with_retry
+import logging
+from datetime import datetime
+import time
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+# Initialize FastAPI app
 app = FastAPI()
 
-# Webhook to handle incoming messages
+# In-memory cache with timestamp cleanup
+class MessageCache:
+    def __init__(self, max_age_hours: int = 24):
+        self.messages: Dict[str, float] = {}
+        self.max_age_seconds = max_age_hours * 3600
+
+    def add(self, message_id: str) -> None:
+        self.cleanup()
+        self.messages[message_id] = time.time()
+
+    def exists(self, message_id: str) -> bool:
+        self.cleanup()
+        return message_id in self.messages
+
+    def cleanup(self) -> None:
+        current_time = time.time()
+        self.messages = {
+            msg_id: timestamp 
+            for msg_id, timestamp in self.messages.items()
+            if current_time - timestamp < self.max_age_seconds
+        }
+
+message_cache = MessageCache()
+
 @app.post("/webhook")
-async def whatsapp_webhook(request: Request):
-    data = await request.json()
-    print("Webhook received:", data)
+async def webhook(request: Request):
+    request_id = f"req_{int(time.time()*1000)}"
+    logger.info(f"Processing webhook request {request_id}")
+    # Parse incoming request
+    payload = await request.json()
+
+    processed_count = 0
+    error_count = 0
+    results = []
+
+    changes = payload.get("entry", [])[0].get("changes", [])
+    
+    for change in changes:
+        messages = change.get("value", {}).get("messages", [])
+        
+        for message in messages:
+            message_id = message.get("id")
+            timestamp = message.get("timestamp")
+            content = message.get("text", {}).get("body")
+            sender_id = message.get("from")
+            
+            # Check for duplicate message ID
+                # Check for duplicate message
+            if message_cache.exists(message_id):
+                logger.info(f"Duplicate message detected: {message_id}")
+                continue
+            
+            try:
+                    # Process message with retry logic
+                    result = await process_message_with_retry(
+                        sender_id,
+                        content,
+                        timestamp
+                    )
+                    message_cache.add(message_id)
+                    processed_count += 1
+                    results.append(result)
+                    
+            except Exception as e:
+                error_count += 1
+                logger.error(
+                    f"Failed to process message {message_id}: {str(e)}",
+                    exc_info=True
+                )
+                results.append({
+                    "status": "error",
+                    "message_id": message_id,
+                    "error": str(e)
+                })
+
+    # Return detailed response
+    response_data = {
+        "request_id": request_id,
+        "processed": processed_count,
+        "errors": error_count,
+        "results": results
+    }
+    
+    logger.info(
+        f"Webhook processing completed - "
+        f"Processed: {processed_count}, Errors: {error_count}"
+    )
+    
+    return JSONResponse(
+        content=response_data,
+        status_code=status.HTTP_200_OK
+    )
+
 
 
 @app.get("/webhook")

app/services/message.py

@@ -0,0 +1,47 @@
+import os
+import requests
+from fastapi.exceptions import HTTPException
+from dotenv import load_dotenv
+import datetime
+load_dotenv()
+
+# Define the WhatsApp API URL
+WHATSAPP_API_URL = os.environ.get("WHATSAPP_API_URL")
+
+# Access the secret token
+ACCESS_TOKEN = os.environ.get("ACCESS_TOKEN")
+
+
+# Helper function to send a reply
+def send_reply(to: str, body: str):
+    headers = {
+        "Authorization": f"Bearer {ACCESS_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    data = {
+        "messaging_product": "whatsapp",
+        "to": to,
+        "type": "text",
+        "text": {
+            "body": body
+        }
+    }
+    print(f"ACCESS_TOKEN: {ACCESS_TOKEN}")
+    response = requests.post(WHATSAPP_API_URL, json=data, headers=headers)
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail=response.json())
+    return response.json()
+
+async def generate_reply(sender: str, content: str, timestamp: str) -> str:
+    # Example customization logic
+    received_time = datetime.fromtimestamp(int(timestamp))
+    if "hello" in content.lower():
+        return f"Hi {sender}, how can I assist you today?"
+    elif "test" in content.lower():
+        return f"Hi {sender}, this is a reply to your test message."
+    elif received_time.hour < 12:
+        return f"Good morning, {sender}! How can I help you?"
+    else:
+        return f"Hello {sender}, I hope you're having a great day!"
+
+