Update main.py

main.py

@@ -1,4 +1,3 @@
-# main.py
 from flask import Flask, request, make_response, jsonify
 import os
 import logging
@@ -19,7 +18,7 @@ import requests
 import dns.resolver
 import socket
 from datetime import datetime, timedelta
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Tuple
 import json
 import sys
 import threading
@@ -33,10 +32,9 @@ IMGUR_CLIENT_ID = os.getenv("IMGUR_CLIENT_ID")
 URL_IMGUR = "https://api.imgur.com/3/image"
 HEADERS_IMGUR = {"Authorization": f"Client-ID {IMGUR_CLIENT_ID}"} if IMGUR_CLIENT_ID else {}
 
-# Deepgram (TTS) Configuration (ONLY used for audio-input pipeline)
-DEEPGRAM_API = os.getenv("DEEPGRAM_API")  # user specified: Kenya’s DEEPGRAM_API
-DEEPGRAM_TTS_MODEL = os.getenv("DEEPGRAM_TTS_MODEL", "aura-asteria-en")
-DEEPGRAM_TTS_VOICE_PARAMS = os.getenv("DEEPGRAM_TTS_VOICE_PARAMS", "")  # optional querystring extras
+# --- New Feature: TTS Configuration ---
+DEEPGRAM_API_KEY = os.getenv("DEEPGRAM_API_KEY") # Ensure this is in .env
+DEEPGRAM_TTS_URL = "https://api.deepgram.com/v1/speak?model=aura-asteria-en"
 
 # AssemblyAI Configuration
 try:
@@ -50,7 +48,7 @@ except Exception as e:
     logging.error(f"Failed to initialize AssemblyAI: {e}")
 
 import firebase_admin
-from firebase_admin import credentials, firestore
+from firebase_admin import credentials, firestore, storage
 
 def init_firestore_from_env(env_var: str = "FIREBASE"):
     """
@@ -79,7 +77,7 @@ db = init_firestore_from_env()
 
 app = Flask(__name__)
 
-# Logging Configuration (Improved Format)
+# Logging Configuration
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(levelname)s - %(module)s.%(funcName)s - %(message)s",
@@ -91,13 +89,11 @@ logger = logging.getLogger(__name__)
 # --- DNS Workaround ---
 nameserver1 = os.getenv('nameserver1', '8.8.8.8')
 nameserver2 = os.getenv('nameserver2', '8.8.4.4')
-
 def setup_dns():
     try:
         resolver = dns.resolver.Resolver()
         resolver.nameservers = [nameserver1, nameserver2]
         _orig_getaddrinfo = socket.getaddrinfo
-
         def new_getaddrinfo(*args, **kwargs):
             try:
                 if args and isinstance(args[0], str) and 'graph.facebook.com' in args[0]:
@@ -106,16 +102,14 @@ def setup_dns():
                     logger.info(f"DNS Override: Resolved {args[0]} to {ip} using {resolver.nameservers}")
                     return _orig_getaddrinfo(ip, *args[1:], **kwargs)
             except dns.resolver.NoAnswer:
-                logger.warning(f"DNS Override: No A record found for {args[0]} using {resolver.nameservers}")
+                 logger.warning(f"DNS Override: No A record found for {args[0]} using {resolver.nameservers}")
             except Exception as e:
                 logger.error(f"DNS resolution override failed for {args}: {e}")
             return _orig_getaddrinfo(*args, **kwargs)
-
         socket.getaddrinfo = new_getaddrinfo
         logger.info(f"DNS resolver configured with nameservers: {resolver.nameservers}")
     except Exception as e:
         logger.error(f"Failed to setup custom DNS resolver: {e}")
-
 setup_dns()
 # --- End DNS Workaround ---
 
@@ -126,7 +120,6 @@ GREETING_PATTERN = re.compile(r'^\s*(hi|hello|hola|hey|greetings|sawubona)\b.*$'
 PROCESSED_MESSAGES_TTL_HOURS = 24
 
 class MessageDeduplicator:
-    """Thread-safe in-memory cache for message IDs with TTL and Firestore backup."""
     def __init__(self, ttl_hours=24, max_cache_size=10000, db_client=None):
         self.ttl_seconds = ttl_hours * 3600
         self.max_cache_size = max_cache_size
@@ -135,55 +128,45 @@ class MessageDeduplicator:
         self.lock = threading.RLock()
         self._cleanup_thread = threading.Thread(target=self._periodic_cleanup, daemon=True)
         self._cleanup_thread.start()
-
+    
     def is_duplicate(self, message_id):
-        if not message_id:
-            return False
+        if not message_id: return False
         with self.lock:
             if message_id in self.cache:
                 self.cache.move_to_end(message_id)
                 return True
-
             if self.db_client:
                 try:
                     doc_ref = self.db_client.collection("processed_messages").document(message_id)
                     if doc_ref.get().exists:
                         self.cache[message_id] = time()
-                        if len(self.cache) > self.max_cache_size:
-                            self.cache.popitem(last=False)
+                        if len(self.cache) > self.max_cache_size: self.cache.popitem(last=False)
                         return True
                 except Exception as e:
                     logger.error(f"Database error in is_duplicate: {e}", exc_info=True)
-
             self._mark_processed(message_id)
             return False
-
+    
     def _mark_processed(self, message_id):
         current_time = time()
         with self.lock:
             self.cache[message_id] = current_time
-            if len(self.cache) > self.max_cache_size:
-                self.cache.popitem(last=False)
-
+            if len(self.cache) > self.max_cache_size: self.cache.popitem(last=False)
             if self.db_client:
                 try:
-                    expiry = datetime.now() + timedelta(seconds=self.ttl_seconds)
+                    expiry = datetime.now() + timedelta(hours=self.ttl_seconds/3600)
                     doc_ref = self.db_client.collection("processed_messages").document(message_id)
                     doc_ref.set({"processed_at": firestore.SERVER_TIMESTAMP, "expires_at": expiry})
                 except Exception as e:
                     logger.error(f"Database error in _mark_processed: {e}", exc_info=True)
-
+    
     def _periodic_cleanup(self):
         while True:
             try:
                 with self.lock:
                     current_time = time()
-                    expired_ids = [
-                        msg_id for msg_id, timestamp in list(self.cache.items())
-                        if current_time - timestamp > self.ttl_seconds
-                    ]
-                    for msg_id in expired_ids:
-                        self.cache.pop(msg_id, None)
+                    expired_ids = [msg_id for msg_id, timestamp in list(self.cache.items()) if current_time - timestamp > self.ttl_seconds]
+                    for msg_id in expired_ids: self.cache.pop(msg_id, None)
                 threading.Event().wait(3600)
             except Exception as e:
                 logger.error(f"Error in cleanup thread: {e}", exc_info=True)
@@ -192,34 +175,33 @@ class MessageDeduplicator:
 message_deduplicator = MessageDeduplicator(ttl_hours=PROCESSED_MESSAGES_TTL_HOURS, db_client=db)
 
 def check_and_mark_processed(message_id: str) -> bool:
-    """Check if a message has been processed already using the deduplicator."""
     if not message_id:
         logger.warning("Empty message ID provided to check_and_mark_processed")
         return False
     return message_deduplicator.is_duplicate(message_id)
 
-def is_user_approved(mobile: str) -> bool:
-    """Checks if a user's phone number is in the 'users' collection and has status 'approved'."""
+def is_user_approved(mobile: str) -> Tuple[bool, Optional[Dict]]:
+    """Checks approval AND returns user data (for currency preferences)."""
     if not db:
         logger.error("Authorization check failed: Firestore client is not available.")
-        return False
+        return False, None
     try:
         normalized_mobile = mobile if mobile.startswith('+') else f'+{mobile}'
-        logger.info(f"AUTHORIZATION: Checking approval for mobile: '{mobile}', using normalized ID: '{normalized_mobile}'")
+        logger.info(f"AUTHORIZATION: Checking approval for mobile: '{mobile}'")
         user_ref = db.collection("users").document(normalized_mobile)
         user_doc = user_ref.get()
 
         if user_doc.exists:
             user_data = user_doc.to_dict()
-            status = str(user_data.get("status", "N/A")).lower()
-            return status == "approved"
-        return False
+            status = user_data.get("status", "N/A").lower()
+            if status == "approved":
+                return True, user_data
+        return False, None
     except Exception as e:
         logger.error(f"AUTHORIZATION: An exception occurred for {mobile}: {e}", exc_info=True)
-        return False
+        return False, None
 
 def send_confirmation_buttons(mobile: str, message_summary: str) -> None:
-    """Send interactive confirmation buttons using the new client."""
     buttons = [
         {"reply": {"id": "confirm_transaction", "title": "✅ Confirm"}},
         {"reply": {"id": "cancel_transaction", "title": "❌ Cancel"}}
@@ -228,7 +210,6 @@ def send_confirmation_buttons(mobile: str, message_summary: str) -> None:
     wa_client.send_reply_buttons(recipient_id=mobile, body_text=body, button_data=buttons)
 
 def handle_interactive_response(mobile: str, button_id: str) -> None:
-    """Process user's button response (Confirm/Cancel)."""
     if not db:
         wa_client.send_text_message(mobile, "Sorry, cannot process confirmation due to a database issue.")
         return
@@ -242,9 +223,9 @@ def handle_interactive_response(mobile: str, button_id: str) -> None:
 
         pending_transactions = transaction_doc.to_dict().get("transactions", [])
         if not pending_transactions:
-            wa_client.send_text_message(mobile, "There seems to be an issue with the pending transaction data.")
-            doc_ref.delete()
-            return
+             wa_client.send_text_message(mobile, "There seems to be an issue with the pending transaction data.")
+             doc_ref.delete()
+             return
 
         if button_id == "confirm_transaction":
             msg = process_intent(pending_transactions, mobile)
@@ -254,86 +235,45 @@ def handle_interactive_response(mobile: str, button_id: str) -> None:
             doc_ref.delete()
         else:
             msg = "Sorry, I didn't understand that button press."
-
         wa_client.send_text_message(mobile, msg)
     except Exception as e:
         logger.error(f"Error handling interactive response for user {mobile}: {e}", exc_info=True)
         wa_client.send_text_message(mobile, "Sorry, something went wrong while handling your confirmation.")
 
-def _deepgram_tts_to_mp3(text: str) -> Optional[str]:
-    """
-    Generate an MP3 using Deepgram TTS and return local file path.
-    Only used when input originated from STT/audio.
-    """
-    if not DEEPGRAM_API:
-        logger.warning("DEEPGRAM_API not set. Skipping TTS.")
-        return None
-
-    try:
-        safe_text = (text or "").strip()
-        if not safe_text:
-            return None
-
-        # Keep it short-ish to avoid huge audio
-        # (WhatsApp media limits + faster UX)
-        if len(safe_text) > 1800:
-            safe_text = safe_text[:1800] + "..."
-
-        base_url = f"https://api.deepgram.com/v1/speak?model={DEEPGRAM_TTS_MODEL}"
-        if DEEPGRAM_TTS_VOICE_PARAMS:
-            base_url += f"&{DEEPGRAM_TTS_VOICE_PARAMS.lstrip('&')}"
-
-        headers = {
-            "Authorization": f"Token {DEEPGRAM_API}",
-            "Content-Type": "application/json",
-            "Accept": "audio/mpeg"
-        }
-        payload = {"text": safe_text}
-
-        resp = requests.post(base_url, headers=headers, json=payload, timeout=60)
-        resp.raise_for_status()
-
-        temp_dir = "temp_tts"
-        os.makedirs(temp_dir, exist_ok=True)
-        out_path = os.path.join(temp_dir, f"tts_{int(time())}.mp3")
-        with open(out_path, "wb") as f:
-            f.write(resp.content)
-
-        return out_path
-
-    except Exception as e:
-        logger.error(f"Deepgram TTS failed: {e}", exc_info=True)
-        return None
-
-def process_text_message(message_text: str, mobile: str, input_mode: str = "text") -> Optional[str]:
+def process_text_message(message_text: str, mobile: str, user_settings: Optional[Dict] = None) -> Optional[str]:
     """
     Processes incoming text messages.
-    If input_mode == 'speech', returns the final text response string for TTS usage.
-    Otherwise sends responses as before and returns None.
+    Returns the response text string (for TTS pipeline), or None if no direct text response (e.g. image/button).
     """
-    logger.info(f"Processing {input_mode} message from {mobile}: '{message_text}'")
-
+    logger.info(f"Processing text message from {mobile}: '{message_text}'")
+    
     if GREETING_PATTERN.match(message_text):
         msg = "Hi there! I'm Qx-SmartLedger, your business assistant. How can I help?"
         wa_client.send_text_message(mobile, msg)
-        return msg if input_mode == "speech" else None
-
-    llm_response_str = generateResponse(message_text)
+        return msg
+
+    # --- FIX BUG 4: Get User Currency ---
+    user_currency = "R"
+    if user_settings:
+        # Assuming currency might be in 'settings' dict or top level. Check both.
+        user_currency = user_settings.get('currency') or user_settings.get('settings', {}).get('currency', "R")
+    
+    # Inject currency into LLM Prompt
+    llm_response_str = generateResponse(message_text, currency=user_currency)
     parsed_trans_data = parse_multiple_transactions(llm_response_str)
-
+    
     if not parsed_trans_data:
         msg = "Sorry, I couldn't quite understand that. Could you please rephrase?"
         wa_client.send_text_message(mobile, msg)
-        return msg if input_mode == "speech" else None
+        return msg
 
-    primary_intent = (parsed_trans_data[0].get('intent', '') or '').lower()
-    primary_type = (parsed_trans_data[0].get('transaction_type', '') or '').lower()
+    primary_intent = parsed_trans_data[0].get('intent', '').lower()
+    primary_type = parsed_trans_data[0].get('transaction_type', '').lower()
 
-    # Reads / Queries
     if primary_intent == 'read' or primary_type == 'query':
         response_data = process_intent(parsed_trans_data, mobile)
-
-        # If the response is a generated image report path, we send image and stop
+        
+        # Handle Image Response
         if isinstance(response_data, str) and os.path.isfile(response_data) and HEADERS_IMGUR:
             try:
                 with open(response_data, "rb") as f:
@@ -342,41 +282,77 @@ def process_text_message(message_text: str, mobile: str, input_mode: str = "text
                 imgur_data = response_imgur.json()
                 if imgur_data.get("success"):
                     wa_client.send_image_message(recipient_id=mobile, image_url=imgur_data["data"]["link"])
-                    # For speech pipeline: we already delivered an image; don't TTS this
-                    return None
+                    os.remove(response_data)
+                    return None # No text response to TTS
                 else:
-                    wa_client.send_text_message(mobile, f"Couldn't generate the image report, but here's the data:\n{response_data}")
-                    return str(response_data) if input_mode == "speech" else None
+                    msg = f"Couldn't generate the image report, but here's the data:\n{response_data}"
+                    wa_client.send_text_message(mobile, msg)
+                    os.remove(response_data)
+                    return msg
             except Exception as e:
                 logger.error(f"Image report processing/upload failed: {e}", exc_info=True)
-                wa_client.send_text_message(mobile, f"Error generating image report. Here's the text data:\n{response_data}")
-                return str(response_data) if input_mode == "speech" else None
-            finally:
-                try:
-                    os.remove(response_data)
-                except Exception:
-                    pass
+                msg = f"Error generating image report. Here's the text data:\n{response_data}"
+                wa_client.send_text_message(mobile, msg)
+                return msg
         else:
             wa_client.send_text_message(mobile, str(response_data))
-            return str(response_data) if input_mode == "speech" else None
+            return str(response_data)
 
-    # Create/Update/Delete with confirmation flow
-    if primary_intent in ['create', 'update', 'delete']:
+    elif primary_intent in ['create', 'update', 'delete']:
         if persist_temporary_transaction(parsed_trans_data, mobile):
             transaction_summary = format_transaction_response(parsed_trans_data)
             send_confirmation_buttons(mobile, transaction_summary)
-            return None
+            return None # Interactive buttons, no TTS
         else:
             msg = "Sorry, I couldn't save your transaction for confirmation."
             wa_client.send_text_message(mobile, msg)
-            return msg if input_mode == "speech" else None
+            return msg
+    else:
+        msg = f"I'm not sure how to handle the action '{primary_intent}'."
+        wa_client.send_text_message(mobile, msg)
+        return msg
+
+# --- NEW FEATURE: Audio Helpers ---
 
-    msg = f"I'm not sure how to handle the action '{primary_intent}'."
-    wa_client.send_text_message(mobile, msg)
-    return msg if input_mode == "speech" else None
+def _deepgram_tts_to_mp3(text: str) -> Optional[str]:
+    """Generates MP3 from text using DeepGram."""
+    if not DEEPGRAM_API_KEY:
+        logger.warning("DEEPGRAM_API_KEY not found. Skipping TTS.")
+        return None
+    try:
+        headers = {
+            "Authorization": f"Token {DEEPGRAM_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        payload = {"text": text}
+        response = requests.post(DEEPGRAM_TTS_URL, headers=headers, json=payload)
+        response.raise_for_status()
+        
+        filename = f"tts_{uuid.uuid4()}.mp3"
+        filepath = os.path.join(os.getcwd(), filename)
+        with open(filepath, "wb") as f:
+            f.write(response.content)
+        return filepath
+    except Exception as e:
+        logger.error(f"DeepGram TTS failed: {e}", exc_info=True)
+        return None
+
+def _upload_to_firebase_storage(file_path: str) -> Optional[str]:
+    """Uploads file to Firebase Storage and returns signed URL. Tries default bucket."""
+    try:
+        bucket = storage.bucket() # Uses default bucket from init
+        blob = bucket.blob(f"audio_responses/{os.path.basename(file_path)}")
+        blob.upload_from_filename(file_path)
+        
+        # Generate a signed URL valid for 1 hour
+        url = blob.generate_signed_url(expiration=timedelta(hours=1))
+        return url
+    except Exception as e:
+        logger.error(f"Firebase Storage upload failed: {e}. Ensure storage bucket is configured.", exc_info=True)
+        return None
 
-def process_audio_message(audio_id: str, mobile: str) -> None:
-    """Processes incoming audio messages: STT -> normal pipeline -> ALSO TTS back (new feature)."""
+def process_audio_message(audio_id: str, mobile: str, user_settings: Optional[Dict]) -> None:
+    """Processes incoming audio messages: Transcribe -> Process -> TTS -> Send Audio."""
     if not transcriber:
         wa_client.send_text_message(mobile, "Sorry, I cannot process audio messages at the moment.")
         return
@@ -396,47 +372,39 @@ def process_audio_message(audio_id: str, mobile: str) -> None:
 
     try:
         transcript = transcriber.transcribe(downloaded_path)
-
         if transcript.status == aai.TranscriptStatus.error:
             wa_client.send_text_message(mobile, f"Sorry, I couldn't transcribe your audio. Error: {transcript.error}")
-            return
-
-        if not transcript.text:
-            wa_client.send_text_message(mobile, "Sorry, I couldn't understand the audio.")
-            return
-
-        # 1) Send normal text response as before (but we also need the text for TTS)
-        response_text = process_text_message(transcript.text, mobile, input_mode="speech")
-
-        # 2) If we got a textual response, produce TTS and send it as WhatsApp audio
-        #    (We skip if response is None e.g. interactive flow or image report)
-        if response_text:
-            mp3_path = _deepgram_tts_to_mp3(response_text)
-            if mp3_path:
-                try:
-                    wa_client.send_audio_message(recipient_id=mobile, audio_path=mp3_path)
-                except Exception as e:
-                    logger.error(f"Failed to send TTS audio: {e}", exc_info=True)
-                finally:
-                    try:
+        elif not transcript.text:
+             wa_client.send_text_message(mobile, "Sorry, I couldn't understand the audio.")
+        else:
+            # 1. Process as text and get the response string
+            text_response = process_text_message(transcript.text, mobile, user_settings)
+            
+            # 2. TTS Pipeline
+            if text_response:
+                mp3_path = _deepgram_tts_to_mp3(text_response)
+                if mp3_path:
+                    # Try Firebase first (as requested)
+                    audio_url = _upload_to_firebase_storage(mp3_path)
+                    
+                    if audio_url:
+                        # Send via URL
+                        wa_client.send_audio_message(mobile, audio_url=audio_url)
+                    else:
+                        # Fallback: Upload directly to WhatsApp
+                        logger.info("Falling back to direct WhatsApp upload for TTS audio.")
+                        wa_client.send_audio_message(mobile, audio_path=mp3_path)
+                    
+                    # Cleanup TTS file
+                    if os.path.exists(mp3_path):
                         os.remove(mp3_path)
-                    except Exception:
-                        pass
 
     finally:
         if os.path.exists(downloaded_path):
-            try:
-                os.remove(downloaded_path)
-            except Exception:
-                pass
+            os.remove(downloaded_path)
 
-def process_image_message(image_id: str, caption: Optional[str], mobile: str) -> None:
-    """
-    Processes incoming image messages.
-    NOTE:
-    - Product photos (like dresses) with no caption should auto-record as sale (vision prompt already handles this).
-    - Receipts should not become sales unless they truly indicate sales lines (vision prompt already handles this).
-    """
+def process_image_message(image_id: str, caption: Optional[str], mobile: str, user_settings: Optional[Dict]) -> None:
+    """Processes incoming image messages."""
     logger.info(f"Processing image message (ID: {image_id}) from {mobile} with caption: '{caption}'")
     wa_client.send_text_message(mobile, "Analyzing your image, please wait a moment...")
 
@@ -457,7 +425,7 @@ def process_image_message(image_id: str, caption: Optional[str], mobile: str) ->
     try:
         with open(downloaded_path, "rb") as f:
             image_bytes = f.read()
-
+        
         generated_query = process_image_and_generate_query(image_bytes, caption)
 
         if not generated_query or "Error:" in generated_query:
@@ -465,7 +433,8 @@ def process_image_message(image_id: str, caption: Optional[str], mobile: str) ->
             wa_client.send_text_message(mobile, f"I had some trouble understanding that image. {generated_query}")
         else:
             logger.info(f"Vision processing successful. Generated query: '{generated_query}'")
-            process_text_message(generated_query, mobile, input_mode="text")
+            # Process the generated query like a normal text message
+            process_text_message(generated_query, mobile, user_settings)
 
     except Exception as e:
         logger.error(f"Error during vision processing of image {downloaded_path}: {e}", exc_info=True)
@@ -487,10 +456,10 @@ def webhook_handler():
         challenge = request.args.get("hub.challenge")
         if mode == "subscribe" and token == VERIFY_TOKEN:
             return make_response(challenge, 200)
-        return make_response("Verification failed", 403)
+        else:
+            return make_response("Verification failed", 403)
 
     if request.method == "POST":
-        mobile = None
         try:
             data = request.get_json()
             if not data:
@@ -500,32 +469,29 @@ def webhook_handler():
             if not msg_details:
                 return make_response("ok", 200)
 
-            message_id = msg_details.get("id")
-            mobile = msg_details.get("from")
-            message_type = msg_details.get("type")
+            message_id, mobile, message_type = msg_details.get("id"), msg_details.get("from"), msg_details.get("type")
 
             if not message_id or not mobile:
                 return make_response("ok - invalid message", 200)
-
             if check_and_mark_processed(message_id):
                 return make_response("ok - duplicate", 200)
-
-            if not is_user_approved(mobile):
-                wa_client.send_text_message(
-                    mobile,
-                    "Access denied. Please sign up at https://smartqx.co.za or contact your administrator."
-                )
+            
+            # --- AUTH & USER DATA FETCH ---
+            is_approved, user_data = is_user_approved(mobile)
+            
+            if not is_approved:
+                wa_client.send_text_message(mobile, "Access denied. Please sign up at https://smartqx.co.za or contact your administrator.")
                 return make_response("ok", 200)
 
             if message_type == "text":
-                process_text_message(msg_details.get("text"), mobile, input_mode="text")
+                process_text_message(msg_details.get("text"), mobile, user_data)
             elif message_type == "audio":
-                process_audio_message(msg_details.get("audio_id"), mobile)
+                process_audio_message(msg_details.get("audio_id"), mobile, user_data)
             elif message_type == "image":
                 image_id = msg_details.get("image_id")
                 caption = msg_details.get("caption")
                 if image_id:
-                    process_image_message(image_id, caption, mobile)
+                    process_image_message(image_id, caption, mobile, user_data)
                 else:
                     logger.warning(f"Missing image ID for image message: {msg_details}")
             elif message_type == "interactive":
@@ -536,7 +502,7 @@ def webhook_handler():
 
         except Exception as e:
             logger.error(f"Unhandled exception: {e}", exc_info=True)
-            if mobile:
+            if 'mobile' in locals() and mobile:
                 wa_client.send_text_message(mobile, "Sorry, an unexpected error occurred.")
         return make_response("ok", 200)
 
@@ -548,12 +514,12 @@ if __name__ == '__main__':
     logger.info(f"Starting Flask app. Debug mode: {debug_mode}, Port: {port}")
 
     if not db:
-        logger.critical("Firestore client failed to initialize. Application cannot run.")
+         logger.critical("Firestore client failed to initialize. Application cannot run.")
     else:
-        if not debug_mode:
-            from waitress import serve
-            logger.info("Running in production mode using Waitress.")
-            serve(app, host="0.0.0.0", port=port)
-        else:
-            logger.info("Running in debug mode using Flask development server.")
-            app.run(debug=True, host="0.0.0.0", port=port)
+         if not debug_mode:
+              from waitress import serve
+              logger.info("Running in production mode using Waitress.")
+              serve(app, host="0.0.0.0", port=port)
+         else:
+              logger.info("Running in debug mode using Flask development server.")
+              app.run(debug=True, host="0.0.0.0", port=port)