Update utility.py

utility.py

@@ -16,8 +16,8 @@ import google.generativeai as genai
 import re
 import uuid
 import dataframe_image as dfi
-from PIL import Image # --- ADDED ---
-import io # --- ADDED ---
+from PIL import Image
+import io
 
 
 logger = logging.getLogger(__name__)
@@ -37,7 +37,7 @@ def init_firestore_from_env(env_var: str = "FIREBASE"):
         if firebase_admin._apps:
             return firestore.client()
         sa_json = os.environ[env_var]
-        sa_info = json.loads(sa_json)
+        sa_info = json.loads(sa_info)
         cred = credentials.Certificate(sa_info)
         firebase_admin.initialize_app(cred)
         return firestore.client()
@@ -94,12 +94,11 @@ class FlaskResponse(ResponseParser):
     def format_other(self, result):
         return str(result['value'])
 
-# --- AI Model Configuration (WITH VISION ADDED) ---
+# --- AI Model Configuration ---
 try:
     genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
     GENERATIVE_MODEL_NAME = "gemini-2.0-flash" 
     VISION_MODEL_NAME = "gemini-2.0-flash-thinking-exp"
-
     model = genai.GenerativeModel(
         GENERATIVE_MODEL_NAME,
         generation_config={
@@ -110,7 +109,6 @@ try:
         }
     )
     vision_model = genai.GenerativeModel(VISION_MODEL_NAME)
-
     llm = ChatGoogleGenerativeAI(
         model=GENERATIVE_MODEL_NAME,
         temperature=0.1,
@@ -124,166 +122,128 @@ except Exception as e:
     logger.error(f"Error configuring Generative AI: {e}", exc_info=True)
     model = vision_model = llm = None
 
-# --- START: NEW VISION PROCESSING FUNCTIONS ---
+# --- START: VISION PROCESSING FUNCTIONS (REVISED) ---
 
-def _transpile_vision_json_to_query(vision_json: dict, caption: Optional[str]) -> str:
-    """Converts the structured JSON from the Vision AI into a natural language query."""
-    image_type = vision_json.get("image_type")
-    data = vision_json.get("data", {})
-    
-    if image_type == "products":
-        items = data.get("items", [])
-        if not items:
-            return "Error: No products were identified in the image."
+def _transpile_vision_json_to_query(vision_json: List[Dict], caption: Optional[str]) -> str:
+    """Converts the structured JSON list from the Vision AI into a natural language query."""
+    if not vision_json:
+        return "Error: Could not extract any transactions from the image."
+
+    query_parts = []
+    for trans in vision_json:
+        details = trans.get("details", {})
+        trans_type = trans.get("transaction_type", "unknown")
         
-        sale_parts = [f"{item['quantity']} {item['name']}" for item in items]
-        query = f"Sell {', '.join(sale_parts)}"
+        # Build a descriptive string for each transaction
+        part = f"Record a {trans_type}"
         
-        if caption:
-            # Append caption for potential price adjustments, etc.
-            query += f" {caption}"
-        return query.strip()
-
-    elif image_type == "document":
-        if not data:
-            return "Error: Could not extract any data from the document."
-
-        # --- Caption Override Logic ---
-        final_trans_type = data.get("transaction_type", "purchase") # Default to purchase for items
-        caption_lower = caption.lower() if caption else ""
-
-        if "expense" in caption_lower:
-            final_trans_type = "expense"
-        elif "purchase" in caption_lower or "inventory" in caption_lower:
-            final_trans_type = "purchase"
-        elif "asset" in caption_lower:
-            final_trans_type = "asset"
-        elif "liability" in caption_lower or "i owe" in caption_lower:
-            final_trans_type = "liability"
+        item = details.get("item") or details.get("name") or details.get("description")
+        quantity = details.get("quantity")
+        price = details.get("price") or details.get("amount") or details.get("value")
+        currency = details.get("currency", "")
+        vendor = details.get("vendor") or details.get("creditor")
+
+        if quantity and item:
+            part += f" of {quantity} {item}"
+        elif item:
+            part += f" for {item}"
         
-        # --- Comprehensive Query Generation ---
-        query_parts = []
-        total = data.get("total")
-        vendor = data.get("vendor")
-        items = data.get("items", [])
-        currency = data.get("currency", "")
-
-        if final_trans_type == "expense":
-            action = "Record an expense"
-            if total:
-                item_list_str = ", ".join([f"{item.get('quantity', 1)} {item.get('name')}" for item in items])
-                details = f"of {currency}{total}"
-                if vendor:
-                    details += f" from {vendor}"
-                if item_list_str:
-                    details += f" for {item_list_str}"
-                query_parts.append(f"{action} {details}")
-            else: # Handle list of expenses without a total
-                for item in items:
-                    query_parts.append(f"Record an expense for {item.get('name')} of {currency}{item.get('price')}")
-
-        elif final_trans_type == "purchase":
-            action = "Record a purchase"
-            if items:
-                for item in items:
-                    item_details = f"of {item.get('quantity', 1)} {item.get('name')}"
-                    if item.get('price'):
-                        item_details += f" for {currency}{item.get('price')} each"
-                    if vendor:
-                        item_details += f" from {vendor}"
-                    query_parts.append(f"{action} {item_details}")
-            elif total: # If only a total is found
-                query_parts.append(f"{action} of {currency}{total} from {vendor if vendor else 'an unknown vendor'}")
-
-
-        elif final_trans_type == "asset":
-            action = "Record an asset"
-            # Prefer item names for assets
-            if items:
-                for item in items:
-                    asset_name = item.get('name', 'unnamed asset')
-                    value = item.get('price', total)
-                    if value:
-                        query_parts.append(f"{action} named {asset_name} with a value of {currency}{value}")
-            elif total:
-                 query_parts.append(f"{action} with a value of {currency}{total}")
-
-        elif final_trans_type == "liability":
-            action = "Record a liability"
-            creditor = data.get("creditor") or (vendor if vendor else "an unknown creditor")
-            amount = data.get("amount") or total
-            if amount:
-                query_parts.append(f"{action} of {currency}{amount} to {creditor}")
-
-        if not query_parts:
-            return "Error: The document was recognized but no actionable data could be extracted to form a command."
-
-        # Join multiple commands (e.g., for lists of expenses/purchases) with "and"
-        return " and ".join(query_parts).strip()
-
-    else:
-        return "Error: The image was not recognized as products for sale or a financial document."
-
-def _analyze_image_with_vision(image_bytes: bytes) -> dict:
-    """Sends the image to the Gemini Vision model and returns structured JSON."""
-    if not vision_model:
-        return {"error": "Vision model is not available."}
-
-    try:
-        image_pil = Image.open(io.BytesIO(image_bytes))
+        if price:
+            part += f" for {currency}{price}"
         
-        prompt = """
-        You are an expert bookkeeping AI. Your task is to analyze an image and return structured JSON.
+        if vendor:
+            part += f" from {vendor}"
+            
+        query_parts.append(part)
 
-        1.  First, classify the image by setting the `image_type` key to one of two values:
-            *   `"products"`: If the image primarily shows physical items for sale (e.g., fruit on a counter, products on a shelf).
-            *   `"document"`: If the image shows a receipt, invoice, bank statement, or a handwritten note/list related to a financial transaction. You MUST be able to read handwriting.
+    # Join multiple commands together
+    final_query = " and ".join(query_parts)
 
-        2.  Second, based on the `image_type`, populate the `data` object:
+    # Allow caption to provide additional context, like a price for a sale
+    if caption:
+        final_query += f" {caption}"
+        
+    return final_query.strip()
 
-        **If `image_type` is "products":**
-        The `data` object must contain one key: `"items"`.
-        -   `"items"`: An array of objects, where each object has `"name"` (string) and `"quantity"` (integer). Count each distinct item.
 
-        **If `image_type` is "document":**
-        The `data` object should contain as many of the following keys as you can find.
-        -   `"transaction_type"`: Infer the type. Use "purchase" for invoices/supplier bills, "liability" for IOUs or loans, "asset" for items of value being logged, and "expense" for general receipts.
-        -   `"total"`: The final total amount (float).
-        -   `"currency"`: The currency symbol or code (e.g., "$", "R").
-        -   `"vendor"`: The name of the store or supplier.
-        -   `"creditor"`: The name of the person or entity owed if it is a liability.
-        -   `"items"`: An array of objects, each with `"name"` (string), `"quantity"` (integer), and `"price"` (float) if available.
-        -   `"date"`: The transaction date (YYYY-MM-DD format).
+def _analyze_image_with_vision(image_bytes: bytes) -> List[Dict]:
+    """Sends the image to the Gemini Vision model and returns a structured JSON list of transactions."""
+    if not vision_model:
+        return [{"error": "Vision model is not available."}]
 
-        **Your final output must be ONLY the raw JSON object, starting with `{` and ending with `}`.**
+    try:
+        image_pil = Image.open(io.BytesIO(image_bytes))
+        
+        # This prompt is now aligned with the text-based `generateResponse` prompt
+        prompt = """
+        You are an expert bookkeeping AI. Your task is to analyze an image (which could be a receipt, invoice, or handwritten note) and extract all financial transactions.
+
+        **1. Output Format:**
+        You MUST output your response as a valid JSON list `[]` containing one or more transaction objects `{}`.
+
+        **2. Transaction Object Structure:**
+        For each distinct transaction you identify, create a JSON object with the following keys:
+        - `"intent"`: The user's goal. For images, this should always be "create".
+        - `"transaction_type"`: The category of the transaction. Infer this from keywords.
+        - `"details"`: An object containing key-value pairs extracted from the image.
+
+        **3. Inference Rules & Keywords:**
+        - **`"purchase"`**: Use this for keywords like "bought", "buy", "purchase", or for inventory items on a receipt.
+        - **`"sale"`**: Use this for keywords like "sold", "sell", or "sale".
+        - **`"expense"`**: Use this for payments for services or non-inventory goods (e.g., 'Tella Football Club', 'fuel', 'lunch', 'tickets'). If you are unsure, default to 'expense'.
+        - **Handwriting**: You MUST be able to read handwriting. Analyze each line of a handwritten note as a potential separate transaction.
+
+        **4. `details` Object Structure:**
+        - For `purchase`/`sale`: Use `"item"` and `"quantity"`.
+        - For `expense`: Use `"description"`, `"amount"`, and `"currency"`. If a vendor is clear, add `"vendor"`.
+
+        **5. Examples:**
+
+        **Example 1: Handwritten Note**
+        - **Image Content:** A note that says "bought 10 Oranges", "sold 5 oranges", "bought 5 lemons".
+        - **Output:**
+          [
+            {"intent": "create", "transaction_type": "purchase", "details": {"item": "Oranges", "quantity": 10}},
+            {"intent": "create", "transaction_type": "sale", "details": {"item": "oranges", "quantity": 5}},
+            {"intent": "create", "transaction_type": "purchase", "details": {"item": "lemons", "quantity": 5}}
+          ]
+
+        **Example 2: Expense Receipt**
+        - **Image Content:** A receipt from "TELLA FOOTBALL CLUB" for "R900.00".
+        - **Output:**
+          [
+            {"intent": "create", "transaction_type": "expense", "details": {"description": "TELLA FOOTBALL CLUB", "amount": 900.00, "currency": "R", "vendor": "TELLA FOOTBALL CLUB"}}
+          ]
+
+        Analyze the provided image and return only the JSON list.
         """
         
         response = vision_model.generate_content([prompt, image_pil])
         response_text = response.text
         
-        json_str = re.search(r'\{.*\}', response_text, re.DOTALL)
+        json_str = re.search(r'\[.*\]', response_text, re.DOTALL)
         if json_str:
             return json.loads(json_str.group(0))
         else:
-            logger.error(f"Vision AI did not return valid JSON. Raw response: {response_text}")
-            return {"error": "Failed to parse vision response."}
+            logger.error(f"Vision AI did not return a valid JSON list. Raw response: {response_text}")
+            return []
 
     except Exception as e:
         logger.error(f"Error in Vision AI processing: {e}", exc_info=True)
-        return {"error": "An unexpected error occurred during image analysis."}
+        return []
 
 def process_image_and_generate_query(image_bytes: bytes, caption: Optional[str]) -> str:
     """Master function to process an image and generate a natural language query."""
     logger.info("Starting image analysis with Vision AI.")
-    vision_json = _analyze_image_with_vision(image_bytes)
+    vision_json_list = _analyze_image_with_vision(image_bytes)
     
-    if "error" in vision_json:
-        return f"Error: {vision_json['error']}"
+    if not vision_json_list:
+        return "Error: I couldn't find any actionable transactions in the image."
         
-    logger.info(f"Vision AI analysis complete. Result: {vision_json}")
-    return _transpile_vision_json_to_query(vision_json, caption)
+    logger.info(f"Vision AI analysis complete. Result: {vision_json_list}")
+    return _transpile_vision_json_to_query(vision_json_list, caption)
 
-# --- END: NEW VISION PROCESSING FUNCTIONS ---
+# --- END: VISION PROCESSING FUNCTIONS ---
 
 class ReportEngine:
     def __init__(self, dfs_with_names: List[Tuple[str, pd.DataFrame]], query: str):
@@ -295,7 +255,6 @@ class ReportEngine:
     def _get_time_filter(self, target_df: pd.DataFrame) -> Optional[pd.Series]:
         if 'timestamp' not in target_df.columns:
             return None
-
         today = self.now.date()
         if "last month" in self.query:
             first_day_current_month = self.now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
@@ -311,82 +270,126 @@ class ReportEngine:
             return target_df['timestamp'].dt.date >= start_of_week
         if "today" in self.query:
             return target_df['timestamp'].dt.date == today
-        return None
+        return pd.Series(True, index=target_df.index)
 
-    def generate_report(self) -> str:
+    def generate_report(self, subject_item: Optional[str] = None) -> str:
         subject = "sales"
-        if "expense" in self.query:
-            subject = "expenses"
-        
-        target_df_name = 'sales' if subject == 'sales' else 'expenses'
-        target_df = self.dfs.get(target_df_name)
+        if "profit" in self.query: subject = "profit"
+        elif any(k in self.query for k in ["best day", "busiest day", "sales by day"]): subject = "day_of_week"
+        elif "expense" in self.query: subject = "expenses"
+        if subject_item: subject = "item_report"
+
+        if subject == "profit":
+            sales_df = self.dfs.get('sales', pd.DataFrame())
+            expenses_df = self.dfs.get('expenses', pd.DataFrame())
+            
+            time_filter_sales = self._get_time_filter(sales_df) if not sales_df.empty else None
+            time_filter_expenses = self._get_time_filter(expenses_df) if not expenses_df.empty else None
 
-        if target_df is None or target_df.empty:
-            return json.dumps({"error": f"I couldn't find any data for {subject} to generate a report."})
+            filtered_sales = sales_df[time_filter_sales] if time_filter_sales is not None else sales_df
+            filtered_expenses = expenses_df[time_filter_expenses] if time_filter_expenses is not None else expenses_df
             
-        time_filter = self._get_time_filter(target_df)
-        if time_filter is not None:
-            target_df = target_df[time_filter]
+            total_revenue = filtered_sales['sale_total'].sum() if not filtered_sales.empty else 0
+            total_cogs = filtered_sales['cogs'].sum() if not filtered_sales.empty and 'cogs' in filtered_sales.columns else 0
+            total_expenses = filtered_expenses['amount'].sum() if not filtered_expenses.empty else 0
+            
+            gross_profit = total_revenue - total_cogs
+            net_profit = gross_profit - total_expenses
+            
+            num_sales = len(filtered_sales)
+            total_items_sold = filtered_sales['quantity'].sum() if not filtered_sales.empty else 0
+            atv = total_revenue / num_sales if num_sales > 0 else 0
+            ipt = total_items_sold / num_sales if num_sales > 0 else 0
+            expense_ratio = (total_expenses / total_revenue) * 100 if total_revenue > 0 else 0
+            
+            most_profitable_item = "N/A"
+            if not filtered_sales.empty and 'cogs' in filtered_sales.columns:
+                filtered_sales['item_profit'] = filtered_sales['sale_total'] - filtered_sales['cogs']
+                item_profitability = filtered_sales.groupby('item')['item_profit'].sum()
+                if not item_profitability.empty:
+                    most_profitable_item = item_profitability.idxmax()
 
-        if target_df.empty:
-            return json.dumps({"error": f"No {subject} data found for the specified period."})
+            self.results = {
+                "report_subject": "Profitability",
+                "total_revenue": f"${total_revenue:.2f}", "total_cogs": f"${total_cogs:.2f}",
+                "gross_profit": f"${gross_profit:.2f}", "total_expenses": f"${total_expenses:.2f}",
+                "net_profit": f"${net_profit:.2f}", "average_transaction_value": f"${atv:.2f}",
+                "items_per_transaction": f"{ipt:.2f}", "expense_to_revenue_ratio": f"{expense_ratio:.2f}%",
+                "most_profitable_item": most_profitable_item
+            }
+        
+        elif subject == "item_report":
+            sales_df = self.dfs.get('sales', pd.DataFrame())
+            if sales_df.empty: return json.dumps({"error": f"No sales data found for '{subject_item}'."})
+            
+            item_df = sales_df[sales_df['item'].str.contains(subject_item, case=False, na=False)]
+            if item_df.empty: return json.dumps({"error": f"I couldn't find any sales for '{subject_item}'."})
+            
+            time_filter = self._get_time_filter(item_df)
+            filtered_df = item_df[time_filter] if time_filter is not None else item_df
+            if filtered_df.empty: return json.dumps({"error": f"No data for '{subject_item}' in this period."})
+
+            units_sold = filtered_df['quantity'].sum()
+            total_revenue = filtered_df['sale_total'].sum()
+            total_cogs = filtered_df['cogs'].sum() if 'cogs' in filtered_df.columns else 0
+            gross_profit = total_revenue - total_cogs
+            profit_margin = (gross_profit / total_revenue) * 100 if total_revenue > 0 else 0
+            avg_price = total_revenue / units_sold if units_sold > 0 else 0
 
-        if subject == "sales":
+            self.results = {
+                "report_subject": "Item Report", "item_name": subject_item,
+                "units_sold": int(units_sold), "total_revenue": f"${total_revenue:.2f}",
+                "total_cogs": f"${total_cogs:.2f}", "gross_profit": f"${gross_profit:.2f}",
+                "profit_margin": f"{profit_margin:.2f}%", "average_selling_price": f"${avg_price:.2f}"
+            }
+
+        elif subject == "day_of_week":
+            sales_df = self.dfs.get('sales', pd.DataFrame())
+            if sales_df.empty or 'day_of_week' not in sales_df.columns: return json.dumps({"error": "No data to analyze by day."})
+            time_filter = self._get_time_filter(sales_df)
+            filtered_df = sales_df[time_filter] if time_filter is not None else sales_df
+            if filtered_df.empty: return json.dumps({"error": "No sales data in this period."})
+
+            daily_sales = filtered_df.groupby('day_of_week')['sale_total'].sum()
+            best_day = daily_sales.idxmax()
+            day_order = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+            daily_sales = daily_sales.reindex(day_order).fillna(0)
+
+            self.results = {
+                "report_subject": "Day of Week Analysis",
+                "best_day": best_day,
+                "daily_sales_breakdown": {day: f"${amount:.2f}" for day, amount in daily_sales.to_dict().items()}
+            }
+
+        elif subject == "sales":
+            target_df = self.dfs.get('sales', pd.DataFrame())
+            if target_df.empty: return json.dumps({"error": "No sales data."})
+            time_filter = self._get_time_filter(target_df)
+            target_df = target_df[time_filter] if time_filter is not None else target_df
+            if target_df.empty: return json.dumps({"error": "No sales data in this period."})
+            
             total_revenue = target_df['sale_total'].sum()
             num_transactions = len(target_df)
             item_summary = target_df.groupby('item')['quantity'].sum()
             best_selling_item = item_summary.idxmax() if not item_summary.empty else "N/A"
             worst_selling_item = item_summary.idxmin() if not item_summary.empty else "N/A"
-            self.results = {
-                "report_subject": "Sales",
-                "total_revenue": f"${total_revenue:.2f}",
-                "number_of_sales": num_transactions,
-                "best_selling_item": best_selling_item,
-                "worst_selling_item": worst_selling_item
-            }
+            self.results = {"report_subject": "Sales", "total_revenue": f"${total_revenue:.2f}", "number_of_sales": num_transactions, "best_selling_item": best_selling_item, "worst_selling_item": worst_selling_item}
+        
         else: # expenses
+            target_df = self.dfs.get('expenses', pd.DataFrame())
+            if target_df.empty: return json.dumps({"error": "No expense data."})
+            time_filter = self._get_time_filter(target_df)
+            target_df = target_df[time_filter] if time_filter is not None else target_df
+            if target_df.empty: return json.dumps({"error": "No expense data in this period."})
+
             total_expenses = target_df['amount'].sum()
             num_transactions = len(target_df)
             category_summary = target_df.groupby('description')['amount'].sum()
             highest_expense_category = category_summary.idxmax() if not category_summary.empty else "N/A"
-            self.results = {
-                "report_subject": "Expenses",
-                "total_expenses": f"${total_expenses:.2f}",
-                "number_of_expenses": num_transactions,
-                "highest_expense_category": highest_expense_category
-            }
+            self.results = {"report_subject": "Expenses", "total_expenses": f"${total_expenses:.2f}", "number_of_expenses": num_transactions, "highest_expense_category": highest_expense_category}
         
         return json.dumps(self.results, indent=2)
 
-    def generate_forecast_data(self) -> str:
-        sales_df = self.dfs.get('sales')
-        if sales_df is None or sales_df.empty:
-            return json.dumps({"error": "Not enough sales data to generate a forecast."})
-        
-        sales_df_copy = sales_df.copy()
-        sales_df_copy.set_index('timestamp', inplace=True)
-        weekly_sales = sales_df_copy['sale_total'].resample('W').sum()
-        
-        if len(weekly_sales) < 2:
-            return json.dumps({"error": "I need at least two weeks of sales data to make a forecast."})
-            
-        last_week_sales = weekly_sales.iloc[-1]
-        previous_week_sales = weekly_sales.iloc[-2] if len(weekly_sales) > 1 else 0
-        
-        growth_rate = 0
-        if previous_week_sales > 0:
-            growth_rate = ((last_week_sales - previous_week_sales) / previous_week_sales) * 100
-            
-        historical_avg = weekly_sales.head(-1).mean()
-
-        self.results = {
-            "last_period_sales": f"${last_week_sales:.2f}",
-            "previous_period_sales": f"${previous_week_sales:.2f}",
-            "period_over_period_growth": f"{growth_rate:.2f}%",
-            "historical_average": f"${historical_avg:.2f}"
-        }
-        return json.dumps(self.results, indent=2)
-
 def generateResponse(prompt: str) -> str:
     """Generate structured JSON response from user input using Generative AI."""
     if not model:
@@ -746,214 +749,6 @@ def _validate_dataframe(df: pd.DataFrame) -> pd.DataFrame:
         df[col] = df[col].fillna('Unknown')
     return df
 
-def _fetch_all_collections_as_dfs(user_phone: str) -> List[Tuple[str, pd.DataFrame]]:
-    """Fetches all user data, splits/validates DataFrames, and engineers features."""
-    all_dfs_with_names = []
-    inv_serv_docs = db.collection("users").document(user_phone).collection('inventory_and_services').stream()
-    inventory_data, services_data = [], []
-    for doc in inv_serv_docs:
-        doc_data = doc.to_dict()
-        flat_data = {**doc_data, **doc_data.get('details', {})}
-        if 'details' in flat_data: del flat_data['details']
-        if doc_data.get('type') == 'service': services_data.append(flat_data)
-        else: inventory_data.append(flat_data)
-    if inventory_data: all_dfs_with_names.append(("inventory", _validate_dataframe(pd.DataFrame(inventory_data))))
-    if services_data: all_dfs_with_names.append(("services", _validate_dataframe(pd.DataFrame(services_data))))
-    collections_to_fetch = {'sales': 'sales', 'expenses': 'expenses', 'assets': 'assets', 'liabilities': 'liabilities'}
-    for df_name, coll_name in collections_to_fetch.items():
-        docs = db.collection("users").document(user_phone).collection(coll_name).stream()
-        data = [doc.to_dict() for doc in docs]
-        if data:
-            flat_data_list = []
-            for item in data:
-                flat_item = {**item, **item.get('details', {})}
-                if 'details' in flat_item: del flat_item['details']
-                flat_data_list.append(flat_item)
-            df = pd.DataFrame(flat_data_list)
-            validated_df = _validate_dataframe(df)
-            if df_name == 'sales' and 'price' in validated_df.columns and 'quantity' in validated_df.columns:
-                validated_df['sale_total'] = validated_df['price'] * validated_df['quantity']
-            all_dfs_with_names.append((df_name, validated_df))
-    return all_dfs_with_names
-
-def _get_relative_date_context() -> str:
-    """
-    Generates a string of pre-calculated dates to inject into the PandasAI prompt
-    for improved temporal awareness.
-    """
-    today = datetime.now(timezone.utc)
-    
-    # Helper to format dates
-    def fmt(d):
-        return d.strftime('%Y-%m-%d')
-
-    # Basic dates
-    yesterday = today - timedelta(days=1)
-    
-    # Week calculations
-    start_of_this_week = today - timedelta(days=today.weekday())
-    end_of_this_week = start_of_this_week + timedelta(days=6)
-    start_of_last_week = start_of_this_week - timedelta(days=7)
-    end_of_last_week = start_of_last_week + timedelta(days=6)
-    
-    # Last weekday calculations
-    last_monday = start_of_this_week if today.weekday() != 0 else start_of_last_week
-    if last_monday >= today:
-        last_monday -= timedelta(days=7)
-    last_tuesday = last_monday + timedelta(days=1)
-    last_wednesday = last_monday + timedelta(days=2)
-    last_thursday = last_monday + timedelta(days=3)
-    last_friday = last_monday + timedelta(days=4)
-    last_saturday = last_monday + timedelta(days=5)
-    last_sunday = last_monday + timedelta(days=6)
-
-    context = [
-        f"Here are some pre-calculated dates to help you understand the user's request:",
-        f"- Today is: {fmt(today)}",
-        f"- Yesterday was: {fmt(yesterday)}",
-        f"- The start of this week was: {fmt(start_of_this_week)}",
-        f"- The end of this week is: {fmt(end_of_this_week)}",
-        f"- The start of last week was: {fmt(start_of_last_week)}",
-        f"- The end of last week was: {fmt(end_of_last_week)}",
-        f"- Last Monday was on: {fmt(last_monday)}",
-        f"- Last Tuesday was on: {fmt(last_tuesday)}",
-        f"- Last Wednesday was on: {fmt(last_wednesday)}",
-        f"- Last Thursday was on: {fmt(last_thursday)}",
-        f"- Last Friday was on: {fmt(last_friday)}",
-        f"- Last Saturday was on: {fmt(last_saturday)}",
-        f"- Last Sunday was on: {fmt(last_sunday)}"
-    ]
-    
-    return "\n".join(context)
-
-
-def read_datalake(user_phone: str, query: str) -> str:
-    """
-    Implements the final Unified Strategy for robust, intelligent data analysis.
-    """
-    try:
-        all_dfs_with_names = _fetch_all_collections_as_dfs(user_phone)
-        if not all_dfs_with_names:
-            return "You have no data recorded yet. Please add some transactions first."
-
-        query_lower = query.lower()
-        engine = ReportEngine(all_dfs_with_names, query)
-
-        # --- Tier 0: Simple Direct Lookups (NEW) ---
-        simple_lookup_map = {
-            "inventory": ["stock", "inventory", "in stock", "what do i have"],
-            "assets": ["asset", "assets", "my assets"],
-            "liabilities": ["liabilities", "i owe", "creditor", "my debts"],
-            "sales": ["show my sales", "list sales"],
-            "expenses": ["show my expenses", "list expenses"]
-        }
-
-        for df_name, keywords in simple_lookup_map.items():
-            if any(keyword in query_lower for keyword in keywords):
-                logger.info(f"Handling '{query}' with Simple Lookup Path for '{df_name}'.")
-                # Find the corresponding dataframe
-                target_df_tuple = next((item for item in all_dfs_with_names if item[0] == df_name), None)
-                if target_df_tuple is not None:
-                    target_df = target_df_tuple[1]
-                    if not target_df.empty:
-                        # Return the dataframe rendered as an image
-                        return render_df_as_image(target_df)
-                    else:
-                         return f"You don't have any {df_name} recorded yet."
-                else:
-                    return f"I couldn't find any data for {df_name}."
-
-        # --- Tier 1: Intelligent Router (Existing) ---
-        predictive_keywords = ["expect", "forecast", "predict", "next month", "next week"]
-        historical_report_keywords = ["report", "summary", "performance", "how did i do", "overview", "month", "year", "week", "today"]
-        
-        if any(keyword in query_lower for keyword in predictive_keywords):
-            # --- Path A: Forecasting ---
-            logger.info(f"Handling '{query}' with the Forecasting Path.")
-            forecast_json = engine.generate_forecast_data()
-            forecast_data = json.loads(forecast_json)
-            if "error" in forecast_data: return forecast_data["error"]
-            
-            synthesis_prompt = f"""
-            You are a business analyst making a simple projection. Based on the following data, provide a friendly sales forecast.
-            Acknowledge this is an estimate based on past performance. Format your response for WhatsApp (*bold*, _italic_).
-
-            Data:
-            {forecast_json}
-            """
-            response = llm.invoke(synthesis_prompt)
-            return response.content
-
-        elif any(keyword in query_lower for keyword in historical_report_keywords):
-            # --- Path B: Historical Reporting with Creative Insights ---
-            logger.info(f"Handling '{query}' with the Reporting Path.")
-            report_json = engine.generate_report()
-            report_data = json.loads(report_json)
-            if "error" in report_data: return report_data["error"]
-
-            synthesis_prompt = f"""
-            You are a helpful business assistant. Based on the following JSON data summary, synthesize a concise, friendly report for the user.
-            The user's original request was: '{query}'. Format your response using WhatsApp-compatible markdown (*bold*, _italic_).
-            
-            Your most important task is to provide a creative and actionable "Insight" at the end. Use the product data provided to give specific advice.
-            - For the best-selling item, suggest a complementary product or a "double-down" strategy. (e.g., "Bananas are a hit! Consider adding banana bread.")
-            - For the worst-selling item, suggest a promotion or bundle deal. (e.g., "To boost Apple sales, try a 'Fruit Duo' bundle with your best-selling Bananas.")
-
-            Here is the data summary:
-            {report_json}
-            """
-            response = llm.invoke(synthesis_prompt)
-            return response.content
-
-        else:
-            # --- Path C: Fortified PandasAI for Q&A and Plotting ---
-            logger.info(f"Handling '{query}' with the Fortified PandasAI Path.")
-            
-            schema_description = "You have been provided with these Pandas DataFrames:\n"
-            for name, df in all_dfs_with_names:
-                schema_description += f"*   **{name}**: Contains columns like {', '.join(df.columns.to_list())}.\n"
-
-            # NEW: Injecting temporal context
-            date_context = _get_relative_date_context()
-            today_str = datetime.now(timezone.utc).strftime('%Y-%m-%d')
-
-            pandasai_prompt = (
-                f"{schema_description}\n"
-                f"For context, today's date is {today_str}.\n"
-                f"{date_context}\n\n" # Injecting the new context here
-                f"IMPORTANT:\n"
-                f"1. For any time-based queries, you MUST use timezone-aware pandas Timestamps for comparison. Example: `pd.Timestamp('{today_str}', tz='UTC')`.\n"
-                f"2. When a plot or chart is requested, you MUST save it as a file. The final line of your code must be `result = {{'type': 'plot', 'value': 'filename.png'}}`.\n"
-                f"3. Your code MUST end by declaring a `result` dictionary.\n\n"
-                f"Based on this, please write Python code to answer the following specific user query: '{query}'"
-            )
-
-            datalake_dfs = [df for _, df in all_dfs_with_names]
-            lake = SmartDatalake(
-                datalake_dfs,
-                config={
-                    "llm": llm,
-                    "response_parser": FlaskResponse,
-                    "save_charts_path": user_defined_path,
-                    "enable_cache": False,
-                    "conversational": False, # Set to False for single-turn queries
-                    "custom_whitelisted_dependencies": [
-                        "os", "io", "sys", "glob", "collections", "matplotlib", "seaborn",
-                        "numpy", "scipy", "statsmodels", "sklearn"
-                    ],
-                    "security": "none"
-                }
-            )
-            response = lake.chat(pandasai_prompt)
-            return str(response)
-
-    except (NoCodeFoundError, MaliciousQueryError) as e:
-        logger.error(f"PandasAI failed for query '{query}': {e}")
-        return f"Unfortunately, I was not able to answer your question, because of the following error:\n\n{e}"
-    except Exception as e:
-        logger.error(f"Data query failed for user {user_phone}, query '{query}': {e}", exc_info=True)
-        return "Sorry, I encountered an error while analyzing your data."
-
 def _find_document_by_details(user_phone: str, collection_name: str, details: Dict) -> Optional[Any]:
     col_ref = db.collection("users").document(user_phone).collection(collection_name)
     if 'transaction_id' in details and details['transaction_id']:
@@ -1060,8 +855,6 @@ def persist_temporary_transaction(transactions: List[Dict], mobile: str) -> bool
         logger.error(f"Failed to persist temporary transaction for user {mobile}: {e}", exc_info=True)
         return False
 
-CURRENCY_SYMBOL_REGEX = re.compile(r"^\s*[\$\£\€\¥\₹R]")
-
 def format_transaction_response(transactions: Union[List[Dict], Dict, None]) -> str:
     if not transactions: return "No transaction data to display."
     if isinstance(transactions, dict): transactions = [transactions]
@@ -1073,11 +866,7 @@ def format_transaction_response(transactions: Union[List[Dict], Dict, None]) ->
         title = f"{trans_type}"
         if len(transactions) > 1: output_lines.append(f"--- {title} {idx + 1} ---")
         else: output_lines.append(f"--- {title} ---")
-        key_order = [
-            'transaction_id', 'item', 'service_name', 'name', 'creditor', 'category',
-            'quantity', 'units_available', 'hours', 'price', 'rate', 'amount', 'cost', 'value',
-            'customer', 'vendor', 'client', 'date', 'acquisition_date', 'due_date', 'description', 'type'
-        ]
+        key_order = ['transaction_id', 'item', 'service_name', 'name', 'creditor', 'category', 'quantity', 'units_available', 'hours', 'price', 'rate', 'amount', 'cost', 'value', 'customer', 'vendor', 'client', 'date', 'acquisition_date', 'due_date', 'description', 'type']
         displayed_keys = set()
         if 'transaction_id' in trans:
             output_lines.append(f"• Transaction ID: {trans['transaction_id']}")