Update utility.py

utility.py

@@ -1,348 +1,765 @@
+# utility.py
 import json
 import os
 import logging
 from datetime import datetime
-from typing import List, Dict, Union, Optional
+from typing import List, Dict, Union, Optional, Any
 from google.cloud import firestore
 import pandas as pd
+# Remove pandasai if not strictly needed or causing issues, replace with direct Firestore queries
+# from pandasai import SmartDatalake
 from langchain_google_genai import ChatGoogleGenerativeAI
 import google.generativeai as genai
+import re # For currency check
 
 logger = logging.getLogger(__name__)
 
 db = firestore.Client.from_service_account_json("firestore-key.json")
 
-llm = ChatGoogleGenerativeAI(
-    model="gemini-2.0-flash-thinking-exp",
-    max_output_tokens=1024,
-    temperature=0.01,
-    top_k=1,
-    top_p=0.01,
-)
-
-def generateResponse(prompt: str) -> str:
-    """Generate structured response from user input"""
-    system_prompt = """You MUST format responses EXACTLY as follows:
-
-*Intent*: [create/read/update/delete]
-*Transaction Type*: [purchase/sale/inventory/etc]
-*Details*:
-- Field1: Value1
-- Field2: Value2
-- Field3: Value3
-
-For multiple transactions, repeat this pattern for each transaction."""
-    
-    genai.configure(api_key=os.environ.get("GOOGLE_API_KEY"))
+# Configure Google Generative AI (Consider making model configurable)
+try:
+    genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
+    GENERATIVE_MODEL_NAME = "gemini-2.0-flash" # Or another suitable model like gemini-pro
     model = genai.GenerativeModel(
-        'gemini-2.0-flash-thinking-exp',
+        GENERATIVE_MODEL_NAME,
         generation_config={
-            "temperature": 0.1,
-            "top_p": 0.01,
-            "top_k": 1,
-            "max_output_tokens": 1024,
+            "temperature": 0.1, # Slightly higher temp might allow more flexibility if needed
+            "top_p": 0.9,       # Adjust Top P and K for desired creativity/determinism
+            "top_k": 10,        # Example adjustment
+            "max_output_tokens": 2048, # Increased token limit
+            "response_mime_type": "application/json", # Explicitly request JSON
         }
     )
-    
+    # Also configure LangChain LLM if used elsewhere (e.g., potentially for pandasai if kept)
+    llm = ChatGoogleGenerativeAI(
+        model=GENERATIVE_MODEL_NAME,
+        temperature=0.1,
+        # Add other relevant LangChain config if needed
+        convert_system_message_to_human=True # Often helpful for Gemini
+    )
+    logger.info(f"Using Generative Model: {GENERATIVE_MODEL_NAME}")
+
+except KeyError:
+    logger.error("GOOGLE_API_KEY environment variable not set!")
+    # Handle this case gracefully, maybe disable LLM features
+    model = None
+    llm = None
+except Exception as e:
+    logger.error(f"Error configuring Generative AI: {e}")
+    model = None
+    llm = None
+
+
+def generateResponse(prompt: str) -> str:
+    """Generate structured JSON response from user input using Generative AI."""
+    if not model:
+        logger.error("Generative AI model not configured. Cannot generate response.")
+        return '{"error": "Model not available"}' # Return JSON error
+
+    # Refined System Prompt requesting JSON
+    system_prompt = """
+    Analyze the user's request for business transaction management (like sales, purchases, inventory checks).
+    Your goal is to extract structured information about one or more transactions.
+    You MUST output your response as a valid JSON list containing one or more transaction objects.
+    Each transaction object MUST have the following keys:
+    - "intent": A string representing the user's goal (e.g., "create", "read", "update", "delete").
+    - "transaction_type": A string categorizing the transaction (e.g., "sale", "purchase", "inventory", "query", "other").
+    - "details": An object containing key-value pairs extracted from the request. Keys should be lowercase strings (e.g., "item", "quantity", "price", "customer", "date", "description"). Values should be strings or numbers as appropriate. Include a "currency" key (e.g., "$", "£", "€", "ZAR") if a monetary value is present. If no specific type is clear, use "query" or "other".
+
+    Example Input: "Record a sale of 5 apples at $2 each to John Doe"
+    Example Output:
+    [
+      {
+        "intent": "create",
+        "transaction_type": "sale",
+        "details": {
+          "item": "apples",
+          "quantity": 5,
+          "price": 2,
+          "currency": "$",
+          "customer": "John Doe"
+        }
+      }
+    ]
+
+    Example Input: "Add 10 bananas to stock and how many apples do I have?"
+    Example Output:
+    [
+      {
+        "intent": "create",
+        "transaction_type": "inventory",
+        "details": {
+          "item": "bananas",
+          "quantity": 10
+        }
+      },
+      {
+        "intent": "read",
+        "transaction_type": "query",
+        "details": {
+          "item": "apples",
+          "query": "check stock"
+        }
+      }
+    ]
+
+    If the request is unclear or doesn't seem like a transaction, try to interpret it as a "query" intent or respond with an appropriate JSON structure indicating ambiguity.
+    Do NOT add any text before or after the JSON list. Just output the JSON.
+    """
+
     try:
-        response = model.generate_content([system_prompt, prompt])
-        return response.text
+        # Using the newer API structure if applicable, might need adjustment based on library version
+        full_prompt = [system_prompt, prompt] # Or construct as per specific library requirements
+        response = model.generate_content(full_prompt)
+
+        # Accessing the response text might differ slightly based on the exact genai version
+        response_text = response.text
+        logger.info(f"LLM Raw Response: {response_text}") # Log the raw response for debugging
+
+        # Basic validation: Check if it looks like JSON
+        if response_text.strip().startswith('[') and response_text.strip().endswith(']'):
+             return response_text
+        else:
+             logger.warning(f"LLM response does not look like a JSON list: {response_text}")
+             # Attempt to wrap it if it's a single object, otherwise return error
+             if response_text.strip().startswith('{') and response_text.strip().endswith('}'):
+                 return f"[{response_text.strip()}]"
+             return '{"error": "Invalid format from LLM"}'
+
     except Exception as e:
-        logger.error(f"Response generation failed: {e}")
-        return "Sorry, I couldn't process that request."
+        logger.error(f"LLM Response generation failed: {e}", exc_info=True)
+        # Return a JSON formatted error message
+        return '{"error": "Failed to process request with LLM"}'
+
 
 def parse_multiple_transactions(response_text: str) -> List[Dict]:
-    """Parse response into structured transactions"""
+    """Parse JSON response from LLM into structured transactions."""
     transactions = []
-    current_trans = {}
-    
     try:
-        parsed = json.loads(response_text)
-        if isinstance(parsed, dict):
-            return [add_timestamp(parsed)]
-        return [add_timestamp(t) for t in parsed]
-    except json.JSONDecodeError:
-        pass
-
-    lines = [line.strip() for line in response_text.split('\n') if line.strip()]
-    
-    for line in lines:
-        if line.startswith('*Intent*:'):
-            if current_trans:
-                transactions.append(add_timestamp(current_trans))
-                current_trans = {}
-            current_trans['intent'] = line.split(':', 1)[1].strip().lower()
-        elif line.startswith('*Transaction Type*:'):
-            current_trans['transaction_type'] = line.split(':', 1)[1].strip().lower()
-        elif line.startswith('*Details*:'):
-            current_trans['details'] = {}
-        elif line.startswith('-') and 'details' in current_trans:
-            key_value = line[1:].strip().split(':', 1)
-            if len(key_value) == 2:
-                key = key_value[0].strip().lower()
-                value = key_value[1].strip()
-                current_trans['details'][key] = value
-    
-    if current_trans:
-        transactions.append(add_timestamp(current_trans))
-    
-    return transactions if transactions else []
+        # Prioritize JSON parsing
+        parsed_data = json.loads(response_text)
+
+        if isinstance(parsed_data, list):
+            # Ensure each item in the list is a dictionary and add timestamp
+            for item in parsed_data:
+                if isinstance(item, dict):
+                    transactions.append(add_timestamp(item))
+                else:
+                    logger.warning(f"Skipping non-dictionary item in JSON list: {item}")
+            if transactions: # Return only if we successfully parsed some transactions
+                 return transactions
+        elif isinstance(parsed_data, dict) and 'error' in parsed_data:
+             logger.error(f"LLM returned an error: {parsed_data['error']}")
+             return [] # Return empty list on error
+        else:
+            logger.warning(f"Parsed JSON is not a list: {parsed_data}")
+            # Handle case where LLM might return a single object instead of a list
+            if isinstance(parsed_data, dict):
+                 return [add_timestamp(parsed_data)]
+
+
+    except json.JSONDecodeError as json_err:
+        logger.error(f"JSONDecodeError: {json_err} - Response text: {response_text}")
+        # Fallback: Try simple text parsing (less reliable) ONLY if JSON fails completely
+        # This part is kept as a last resort but should ideally not be needed with JSON output
+        logger.info("Falling back to text parsing (less reliable).")
+        lines = [line.strip() for line in response_text.split('\n') if line.strip()]
+        current_trans = {}
+        in_details_section = False
+
+        for line in lines:
+            line_lower = line.lower()
+            if line_lower.startswith('*intent*:'):
+                if current_trans: transactions.append(add_timestamp(current_trans))
+                current_trans = {'details': {}} # Reset with details object
+                current_trans['intent'] = line.split(':', 1)[1].strip().lower()
+                in_details_section = False
+            elif line_lower.startswith('*transaction type*:'):
+                current_trans['transaction_type'] = line.split(':', 1)[1].strip().lower()
+                in_details_section = False
+            elif line_lower.startswith('*details*:'):
+                in_details_section = True
+            elif line.startswith('-') and in_details_section and 'details' in current_trans:
+                key_value = line[1:].strip().split(':', 1)
+                if len(key_value) == 2:
+                    key = key_value[0].strip().lower().replace(" ", "_") # Normalize key
+                    value = key_value[1].strip()
+                    current_trans['details'][key] = value
+
+        if current_trans: # Add the last transaction
+            transactions.append(add_timestamp(current_trans))
+
+        if not transactions: # If fallback also failed
+             logger.error("Failed to parse LLM response using both JSON and text methods.")
+             return []
+
+    except Exception as e:
+         logger.error(f"Unexpected error during parsing: {e}", exc_info=True)
+         return [] # Return empty on unexpected error
+
+    # Final check for essential keys before returning
+    valid_transactions = []
+    for t in transactions:
+        if isinstance(t, dict) and 'intent' in t and 'transaction_type' in t and 'details' in t:
+            valid_transactions.append(t)
+        else:
+            logger.warning(f"Skipping invalid transaction structure after parsing: {t}")
+
+    return valid_transactions
+
 
 def add_timestamp(transaction: Dict) -> Dict:
-    """Add timestamp to transaction"""
-    transaction['created_at'] = datetime.now().isoformat()
+    """Add created_at timestamp to transaction if not present."""
+    if 'created_at' not in transaction:
+        transaction['created_at'] = datetime.now().isoformat()
     return transaction
 
+# --- Firestore CRUD Operations (Largely unchanged, minor logging improvements) ---
+
 def create_inventory(user_phone: str, transaction_data: List[Dict]) -> bool:
-    """Create/update inventory items"""
+    """Create/update inventory items in Firestore."""
     batch = db.batch()
     inventory_ref = db.collection("users").document(user_phone).collection("inventory")
-    
+    success = True
+
     for transaction in transaction_data:
-        item_name = transaction['details'].get('item')
+        details = transaction.get('details', {})
+        item_name = details.get('item')
         if not item_name:
+            logger.warning(f"Skipping inventory update: 'item' missing in details. Data: {transaction}")
+            success = False # Mark as partial failure if any item is skipped
             continue
-            
-        quantity = int(transaction['details'].get('quantity', 0))
-        doc_ref = inventory_ref.document(item_name)
-        
-        batch.set(doc_ref, {
-            'intent': 'create',
-            'transaction_type': 'inventory',
+
+        try:
+            # Attempt to convert quantity to int, default to 0 if missing/invalid
+            quantity = int(details.get('quantity', 0))
+        except (ValueError, TypeError):
+            logger.warning(f"Invalid quantity for item '{item_name}'. Defaulting to 0. Data: {details.get('quantity')}")
+            quantity = 0
+
+        doc_ref = inventory_ref.document(item_name) # Use item name as document ID
+
+        # Prepare data, ensuring quantity is handled as an increment
+        item_data = {
+            'intent': transaction.get('intent', 'create'),
+            'transaction_type': transaction.get('transaction_type', 'inventory'),
             'details': {
-                'item': item_name,
-                'quantity': firestore.Increment(quantity),
-                **{k:v for k,v in transaction['details'].items() 
-                   if k not in ['item', 'quantity']}
+                # Merge existing details, ensuring item name is present
+                **{k: v for k, v in details.items() if k != 'quantity'}, # Keep other details
+                'item': item_name, # Ensure item name is stored
+                'quantity': firestore.Increment(quantity), # Use Increment for atomic adds
             },
-            'last_updated': datetime.now().isoformat()
-        }, merge=True)
-    
+            'last_updated': datetime.now().isoformat(),
+            'created_at': transaction.get('created_at', datetime.now().isoformat()) # Store creation time
+        }
+
+        # Use set with merge=True to create or update the document
+        # We merge the 'details' field specifically if needed, but Increment handles quantity well.
+        # Let's refine the merge logic: update specific fields, especially quantity.
+        # Using set with merge=True might overwrite details if not careful.
+        # Let's use update for existing, set for new, or carefully manage merge.
+
+        # Simpler approach: Set with merge=True, but ensure Increment works.
+        # Firestore's Increment needs to be applied to an existing numeric field or it initializes to the increment value.
+        # This requires checking if the doc exists first for perfect merging, or rely on set(merge=True)
+        # which is generally fine if the structure is consistent.
+
+        batch.set(doc_ref, item_data, merge=True) # merge=True helps preserve other fields if doc exists
+        logger.info(f"Batched inventory update for item: {item_name}, quantity change: {quantity}")
+
     try:
         batch.commit()
-        return True
+        logger.info(f"Inventory batch committed successfully for user {user_phone}.")
+        return success # Return True if all items processed, False if any were skipped
     except Exception as e:
-        logger.error(f"Inventory update failed: {e}")
+        logger.error(f"Inventory batch commit failed for user {user_phone}: {e}", exc_info=True)
         return False
 
-def create_sale(user_phone: str, transaction_data: List[Dict]) -> bool:
-    """Process sales with inventory validation"""
-    batch = db.batch()
+
+def create_sale(user_phone: str, transaction_data: List[Dict]) -> tuple[bool, str]:
+    """Process sales, validate inventory, update stock, and record sale."""
     inventory_ref = db.collection("users").document(user_phone).collection("inventory")
     sales_ref = db.collection("users").document(user_phone).collection("sales")
-    
-    for transaction in transaction_data:
-        item_name = transaction['details'].get('item')
-        if not item_name:
-            continue
-            
-        quantity = int(transaction['details'].get('quantity', 0))
-        item_doc = inventory_ref.document(item_name).get()
-        
-        if not item_doc.exists:
-            logger.error(f"Item {item_name} not found")
-            return False
-            
-        current_stock = int(item_doc.to_dict().get('details', {}).get('quantity', 0))
-        if current_stock < quantity:
-            logger.error(f"Insufficient stock for {item_name}")
-            return False
-            
-        batch.update(inventory_ref.document(item_name), {
-            'details.quantity': firestore.Increment(-quantity),
-            'last_updated': datetime.now().isoformat()
-        })
-        
-        batch.set(sales_ref.document(), {
-            **transaction,
-            'timestamp': datetime.now().isoformat()
-        })
-    
+    feedback_messages = []
+    all_successful = True
+
+    # Use a transaction for read-modify-write operations on inventory
+    @firestore.transactional
+    def process_sale_transaction(transaction, sale_details_list):
+        nonlocal feedback_messages, all_successful
+        sale_batch = db.batch() # Batch for creating sale records (can be outside transaction if preferred)
+
+        for sale_details in sale_details_list:
+            item_name = sale_details.get('item')
+            if not item_name:
+                feedback_messages.append("Sale skipped: Missing item name.")
+                all_successful = False
+                continue
+
+            try:
+                quantity_sold = int(sale_details.get('quantity', 0))
+                if quantity_sold <= 0:
+                    feedback_messages.append(f"Sale skipped for '{item_name}': Invalid quantity ({quantity_sold}).")
+                    all_successful = False
+                    continue
+            except (ValueError, TypeError):
+                feedback_messages.append(f"Sale skipped for '{item_name}': Invalid quantity format.")
+                all_successful = False
+                continue
+
+            item_doc_ref = inventory_ref.document(item_name)
+            item_snapshot = item_doc_ref.get(transaction=transaction)
+
+            if not item_snapshot.exists:
+                feedback_messages.append(f"Sale failed for '{item_name}': Item not found in inventory.")
+                all_successful = False
+                continue
+
+            item_data = item_snapshot.to_dict()
+            current_stock = int(item_data.get('details', {}).get('quantity', 0))
+
+            if current_stock < quantity_sold:
+                feedback_messages.append(f"Sale failed for '{item_name}': Insufficient stock (Have: {current_stock}, Need: {quantity_sold}).")
+                all_successful = False
+                continue
+
+            # Update inventory within the transaction
+            transaction.update(item_doc_ref, {
+                'details.quantity': firestore.Increment(-quantity_sold),
+                'last_updated': datetime.now().isoformat()
+            })
+
+            # Prepare sale record (can be added to a separate batch commit after transaction)
+            sale_record = {
+                **sale_details, # Include original details like price, customer etc.
+                'timestamp': datetime.now().isoformat(), # Record time of sale processing
+                'status': 'completed'
+            }
+            # Add sale record to a batch (commit after transaction succeeds)
+            sale_batch.set(sales_ref.document(), sale_record) # Auto-generate sale ID
+
+            feedback_messages.append(f"Sale processed for {quantity_sold} x '{item_name}'.")
+
+        # Return the batch to be committed outside the transaction function
+        return sale_batch
+
+
+    # Prepare the list of sale details dictionaries
+    sales_to_process = [t.get('details', {}) for t in transaction_data if t.get('transaction_type') == 'sale']
+
+    if not sales_to_process:
+         return False, "No valid sale transactions found."
+
     try:
-        batch.commit()
-        return True
+        # Execute the Firestore transaction
+        db_transaction = db.transaction()
+        sale_record_batch = process_sale_transaction(db_transaction, sales_to_process)
+
+        # If transaction successful, commit the batch of sale records
+        if all_successful and sale_record_batch:
+            sale_record_batch.commit()
+            logger.info(f"Sales records committed successfully for user {user_phone}.")
+        elif not all_successful:
+             logger.warning(f"Partial or full failure in sale processing for user {user_phone}. See feedback.")
+        else:
+             logger.info(f"No sales to record for user {user_phone}.")
+
+
+        return all_successful, "\n".join(feedback_messages)
+
     except Exception as e:
-        logger.error(f"Sales processing failed: {e}")
-        return False
+        logger.error(f"Sales processing failed for user {user_phone}: {e}", exc_info=True)
+        feedback_messages.append("An unexpected error occurred during sale processing.")
+        return False, "\n".join(feedback_messages)
+
 
 def read_datalake(user_phone: str, query: str) -> Union[str, Dict]:
-    """Query user's transaction data"""
-    from pandasai import SmartDatalake
-    
+    """Query user's transaction data from Firestore. (Replaces pandasai for simplicity/reliability)."""
+    # This function now performs direct Firestore queries based on keywords in the query.
+    # It's less "smart" than pandasai but more predictable.
+    # You could enhance this with more sophisticated query parsing if needed.
+
+    query_lower = query.lower()
+    results = []
+    queried_collections = set()
+
     try:
-        inventory = [doc.to_dict() for doc in 
-                   db.collection("users").document(user_phone).collection("inventory").stream()]
-        sales = [doc.to_dict() for doc in 
-                db.collection("users").document(user_phone).collection("sales").stream()]
-        
-        if not inventory and not sales:
-            return "No transaction data found"
-        
-        inventory_df = pd.DataFrame(inventory)
-        sales_df = pd.DataFrame(sales)
-        
-        lake = SmartDatalake(
-            [inventory_df, sales_df],
-            config={
-                "llm": llm,
-                "enable_cache": False,
-                "save_logs": False
-            }
-        )
-        
-        response = lake.chat(query)
-        return str(response)
-        
+        # Simple keyword matching for now
+        if "inventory" in query_lower or "stock" in query_lower or "how many" in query_lower or "what do i have" in query_lower:
+            queried_collections.add("inventory")
+            inventory_ref = db.collection("users").document(user_phone).collection("inventory")
+            docs = inventory_ref.stream()
+            inventory_data = [doc.to_dict() for doc in docs]
+            if inventory_data:
+                results.append({"collection": "Inventory", "data": inventory_data})
+            else:
+                 results.append({"collection": "Inventory", "message": "No inventory data found."})
+
+
+        if "sale" in query_lower or "sold" in query_lower or "revenue" in query_lower or "customer" in query_lower:
+             queried_collections.add("sales")
+             sales_ref = db.collection("users").document(user_phone).collection("sales")
+             # Add ordering or filtering based on query if needed (e.g., by date, item)
+             docs = sales_ref.order_by("timestamp", direction=firestore.Query.DESCENDING).limit(20).stream() # Example: Get recent sales
+             sales_data = [doc.to_dict() for doc in docs]
+             if sales_data:
+                 results.append({"collection": "Sales", "data": sales_data})
+             else:
+                 results.append({"collection": "Sales", "message": "No sales data found."})
+
+        # If no specific collection keywords, maybe return summary or ask for clarification
+        if not queried_collections:
+             # Could try fetching both, or just return a message
+             return "Please specify if you want to query 'inventory' or 'sales' data."
+
+
+        # Format the results for display
+        if not results:
+            return "No data found matching your query."
+
+        # Use format_transaction_response to display the results
+        formatted_output = f"Query Results for '{query}':\n\n"
+        for res_block in results:
+            formatted_output += f"--- {res_block.get('collection', 'Data')} ---\n"
+            if "data" in res_block:
+                 # Pass the list of dictionaries to the formatter
+                 formatted_output += format_transaction_response(res_block["data"]) + "\n"
+            elif "message" in res_block:
+                 formatted_output += res_block["message"] + "\n"
+            formatted_output += "\n"
+
+        return formatted_output.strip()
+
+
     except Exception as e:
-        logger.error(f"Data query failed: {e}")
-        return "Sorry, I couldn't retrieve that data."
-
-def update_transaction(user_phone: str, transaction_id: str, 
-                     updates: Dict, collection: str = "inventory") -> bool:
-    """Update existing transaction"""
-    doc_ref = db.collection("users").document(user_phone).collection(collection).document(transaction_id)
-    
-    if not doc_ref.get().exists:
-        return False
-        
-    update_data = {
-        f"details.{k}": v for k,v in updates.items()
-    }
-    update_data['last_updated'] = datetime.now().isoformat()
-    
+        logger.error(f"Data query failed for user {user_phone}, query '{query}': {e}", exc_info=True)
+        return "Sorry, I encountered an error while retrieving your data."
+
+
+def update_transaction(user_phone: str, transaction_data: List[Dict]) -> tuple[bool, str]:
+    """Update existing transaction(s) based on provided data."""
+    # This needs refinement. How do we identify *which* transaction to update?
+    # Assuming for now the primary identifier is 'item' within the 'details'.
+    # And we update based on the first transaction in the list if multiple are provided for update.
+    if not transaction_data:
+        return False, "No update data provided."
+
+    update_info = transaction_data[0] # Process the first update instruction
+    details = update_info.get('details', {})
+    item_name = details.get('item')
+    trans_type = update_info.get('transaction_type', 'inventory').lower() # Default to inventory
+
+    if not item_name:
+        return False, "Cannot update: 'item' name not specified in details."
+
+    collection_map = {'purchase': 'inventory', 'sale': 'sales', 'inventory': 'inventory'}
+    collection_name = collection_map.get(trans_type, 'inventory')
+    doc_ref = db.collection("users").document(user_phone).collection(collection_name).document(item_name)
+
     try:
-        doc_ref.update(update_data)
-        return True
+        doc_snapshot = doc_ref.get()
+        if not doc_snapshot.exists:
+            return False, f"Cannot update: Item '{item_name}' not found in {collection_name}."
+
+        # Prepare updates, excluding the item identifier itself
+        updates = {f"details.{k}": v for k, v in details.items() if k != 'item'}
+        if not updates:
+             return False, "No update fields provided (only item name was given)."
+
+        updates['last_updated'] = datetime.now().isoformat()
+
+        doc_ref.update(updates)
+        logger.info(f"Successfully updated item '{item_name}' in {collection_name} for user {user_phone}.")
+        # Format the *intended* update for confirmation message
+        formatted_update = format_transaction_response([update_info])
+        return True, f"Successfully updated '{item_name}'.\n\n{formatted_update}"
+
     except Exception as e:
-        logger.error(f"Update failed: {e}")
-        return False
+        logger.error(f"Update failed for item '{item_name}' in {collection_name}, user {user_phone}: {e}", exc_info=True)
+        return False, f"Failed to update '{item_name}'. An error occurred."
+
 
-def delete_transaction(user_phone: str, transaction_data: List[Dict]) -> bool:
-    """Delete specified transactions"""
+def delete_transaction(user_phone: str, transaction_data: List[Dict]) -> tuple[bool, str]:
+    """Delete specified transactions (identified by item name)."""
     batch = db.batch()
-    collection_map = {
-        'purchase': 'inventory',
-        'sale': 'sales',
-        'inventory': 'inventory'
-    }
-    
+    collection_map = {'purchase': 'inventory', 'sale': 'sales', 'inventory': 'inventory'}
+    deleted_items = []
+    errors = []
+    processed = False
+
     for transaction in transaction_data:
-        item_name = transaction['details'].get('item')
+        details = transaction.get('details', {})
+        item_name = details.get('item')
+        trans_type = transaction.get('transaction_type', '').lower() # Get type if specified
+
         if not item_name:
+            errors.append("Skipped delete: 'item' name missing.")
             continue
-            
-        trans_type = transaction.get('transaction_type', 'inventory').lower()
-        collection = collection_map.get(trans_type, 'inventory')
-        
-        doc_ref = db.collection("users").document(user_phone).collection(collection).document(item_name)
+
+        # Determine collection: Use specified type, default to inventory if ambiguous/missing
+        collection_name = collection_map.get(trans_type, 'inventory')
+        # If type is 'sale', we might need a different identifier than item_name (e.g., sale ID)
+        # For simplicity now, we assume deleting from inventory or sales based on item name if type is sale
+        # This might need adjustment based on how sales are uniquely identified.
+        # If deleting sales, you likely need a sale ID, not just item name.
+        # Let's assume for now delete primarily targets inventory items by name.
+        if trans_type == 'sale':
+             errors.append(f"Deletion of specific sales by item name ('{item_name}') is not fully supported. Please specify a Sale ID or delete from inventory.")
+             continue # Skip deletion of sales by item name for now
+
+
+        doc_ref = db.collection("users").document(user_phone).collection(collection_name).document(item_name)
+        # Check if doc exists before adding delete to batch (optional but good practice)
+        # doc_snapshot = doc_ref.get()
+        # if doc_snapshot.exists:
         batch.delete(doc_ref)
-    
+        deleted_items.append(f"'{item_name}' from {collection_name}")
+        processed = True
+        # else:
+        #     errors.append(f"Item '{item_name}' not found in {collection_name}, cannot delete.")
+
+
+    if not processed and not errors:
+         return False, "No valid items found to delete."
+
     try:
-        batch.commit()
-        return True
+        if processed: # Only commit if there are items to delete
+            batch.commit()
+            logger.info(f"Deletion batch committed for user {user_phone}. Items: {deleted_items}")
+
+        final_message = ""
+        if deleted_items:
+            final_message += f"Successfully deleted: {', '.join(deleted_items)}."
+        if errors:
+            final_message += f"\nErrors/Skipped: {'; '.join(errors)}"
+
+        return processed, final_message.strip() # Return True if at least one delete was attempted
+
     except Exception as e:
-        logger.error(f"Deletion failed: {e}")
-        return False
+        logger.error(f"Deletion batch commit failed for user {user_phone}: {e}", exc_info=True)
+        errors.append("An error occurred during the delete operation.")
+        return False, "\n".join(errors)
+
 
 def persist_temporary_transaction(transactions: List[Dict], mobile: str) -> bool:
-    """Store transactions temporarily before confirmation"""
+    """Store transactions temporarily in Firestore before confirmation."""
+    if not transactions:
+        logger.warning(f"Attempted to persist empty transaction list for {mobile}")
+        return False
     try:
         doc_ref = db.collection("users").document(mobile).collection("temp_transactions").document("pending")
         doc_ref.set({
-            "transactions": transactions,
+            "transactions": transactions, # Store the list of transactions
             "timestamp": datetime.now().isoformat(),
             "status": "pending_confirmation"
         })
+        logger.info(f"Temporary transaction persisted for user {mobile}.")
         return True
     except Exception as e:
-        logger.error(f"Temp storage failed: {e}")
+        logger.error(f"Failed to persist temporary transaction for user {mobile}: {e}", exc_info=True)
         return False
 
-def format_transaction_response(transactions: Union[List[Dict], Dict]) -> str:
-    """Format transaction data for user display"""
+# Regex to check for common currency symbols at the start of a string
+CURRENCY_SYMBOL_REGEX = re.compile(r"^\s*[\$\£\€\¥\₹]") # Add more symbols as needed (e.g., ZAR R)
+
+def format_transaction_response(transactions: Union[List[Dict], Dict, None]) -> str:
+    """Format transaction data for user display, fixing double currency symbols."""
     if not transactions:
-        return "No transaction data"
-    
+        return "No transaction data to display."
+
     if isinstance(transactions, dict):
-        transactions = [transactions]
-    
-    output = []
-    for idx, trans in enumerate(transactions, 1):
-        output.append(f"Transaction {idx}:" if len(transactions) > 1 else "Transaction Details:")
-        output.append(f"• Intent: {trans.get('intent', 'unknown').title()}")
-        output.append(f"• Type: {trans.get('transaction_type', 'unknown').title()}")
-        
-        if 'details' in trans:
-            output.append("• Details:")
-            for k, v in trans['details'].items():
-                if k == 'currency':
-                    continue
-                if 'price' in k or 'amount' in k or 'cost' in k:
-                    currency = trans['details'].get('currency', '$')
-                    output.append(f"  - {k.title()}: {currency}{v}")
-                else:
-                    output.append(f"  - {k.title()}: {v}")
-        output.append("")
-    
-    return "\n".join(output)
+        transactions = [transactions] # Wrap single dict in a list
+
+    if not isinstance(transactions, list) or not transactions:
+         return "Invalid transaction data format."
+
+    output_lines = []
+    for idx, trans in enumerate(transactions):
+        if not isinstance(trans, dict):
+             logger.warning(f"Skipping non-dictionary item in format_transaction_response: {trans}")
+             continue
+
+        # Use a more descriptive title if possible
+        trans_desc = trans.get('transaction_type', 'Unknown Type').replace("_", " ").title()
+        intent_desc = trans.get('intent', 'Unknown Intent').title()
+        title = f"{intent_desc}: {trans_desc}"
+        if len(transactions) > 1:
+            output_lines.append(f"--- Transaction {idx + 1}: {title} ---")
+        else:
+            output_lines.append(f"--- {title} ---")
+
+        details = trans.get('details')
+        if isinstance(details, dict):
+            # Try to display key info first: item, quantity, price/amount
+            order = ['item', 'quantity', 'price', 'amount', 'cost', 'customer', 'date']
+            displayed_keys = set()
+
+            for key in order:
+                if key in details:
+                    value = details[key]
+                    key_title = key.replace("_", " ").title()
+                    currency = details.get('currency', '$') # Default currency
+                    value_str = str(value)
 
-def fetch_transaction(user_phone: str, 
+                    # Check for currency fields and apply symbol *only if not present*
+                    if 'price' in key or 'amount' in key or 'cost' in key:
+                        if not CURRENCY_SYMBOL_REGEX.match(value_str):
+                             output_lines.append(f"• {key_title}: {currency}{value_str}")
+                        else:
+                             output_lines.append(f"• {key_title}: {value_str}") # Already has symbol
+                    else:
+                        output_lines.append(f"• {key_title}: {value_str}")
+                    displayed_keys.add(key)
+
+            # Display remaining details
+            for key, value in details.items():
+                if key not in displayed_keys and key != 'currency': # Don't display currency key itself
+                    key_title = key.replace("_", " ").title()
+                    output_lines.append(f"• {key_title}: {value}")
+        elif details: # If details is not a dict but exists
+             output_lines.append(f"• Details: {details}")
+
+
+        # Add timestamp if available
+        ts = trans.get('timestamp') or trans.get('created_at') or trans.get('last_updated')
+        if ts:
+            try:
+                # Attempt to parse and format timestamp nicely
+                dt_obj = datetime.fromisoformat(ts)
+                output_lines.append(f"• Recorded: {dt_obj.strftime('%Y-%m-%d %H:%M:%S')}")
+            except ValueError:
+                output_lines.append(f"• Recorded: {ts}") # Fallback to raw string
+
+        output_lines.append("") # Add spacing between transactions
+
+    return "\n".join(output_lines).strip()
+
+
+def fetch_transaction(user_phone: str,
                     item_name: Optional[str] = None,
-                    collection: str = "inventory") -> Union[Dict, List[Dict]]:
-    """Retrieve transaction(s) from Firestore"""
+                    collection: str = "inventory") -> Union[Dict, List[Dict], None]:
+    """Retrieve transaction(s) from Firestore."""
+    # Ensure collection is valid
+    valid_collections = ["inventory", "sales"] # Add others if needed
+    if collection not in valid_collections:
+        logger.warning(f"Invalid collection specified for fetch: {collection}")
+        collection = "inventory" # Default to inventory
+
     col_ref = db.collection("users").document(user_phone).collection(collection)
-    
-    if item_name:
-        doc = col_ref.document(item_name).get()
-        return doc.to_dict() if doc.exists else None
-    else:
-        return [doc.to_dict() for doc in col_ref.stream()]
+
+    try:
+        if item_name:
+            # Fetch a specific document by ID (item_name)
+            doc_ref = col_ref.document(item_name)
+            doc_snapshot = doc_ref.get()
+            if doc_snapshot.exists:
+                return doc_snapshot.to_dict()
+            else:
+                logger.info(f"Item '{item_name}' not found in {collection} for user {user_phone}.")
+                return None
+        else:
+            # Fetch all documents in the collection
+            docs = col_ref.stream()
+            results = [doc.to_dict() for doc in docs]
+            logger.info(f"Fetched {len(results)} items from {collection} for user {user_phone}.")
+            return results if results else [] # Return empty list if collection is empty
+
+    except Exception as e:
+        logger.error(f"Error fetching from Firestore ({collection}, item: {item_name}) for user {user_phone}: {e}", exc_info=True)
+        return None # Return None on error
+
 
 def process_intent(parsed_trans_data: List[Dict], mobile: str) -> str:
-    """Route transactions to appropriate CRUD operation"""
+    """Route transactions to appropriate CRUD operation based on parsed intent."""
     if not parsed_trans_data:
-        return "Error: No transaction data provided"
-    
-    intent = parsed_trans_data[0].get('intent', '').lower()
-    trans_type = parsed_trans_data[0].get('transaction_type', '').lower()
+        logger.warning(f"process_intent called with empty data for user {mobile}")
+        return "I couldn't understand the transaction details. Could you please try again?"
+
+    # Note: This function now handles only ONE intent type per call, determined by the FIRST transaction.
+    # The CRUD functions themselves handle lists if multiple items share the same intent/type.
+    # If the LLM returns mixed intents (e.g., add inventory AND check stock), this needs more complex handling.
+    # For now, we process based on the first transaction's intent.
+
+    first_transaction = parsed_trans_data[0]
+    intent = first_transaction.get('intent', '').lower()
+    trans_type = first_transaction.get('transaction_type', '').lower()
+
+    # Generate a summary of *all* transactions received for context, even if only processing the first intent type.
     transaction_summary = format_transaction_response(parsed_trans_data)
+    logger.info(f"Processing intent '{intent}' for type '{trans_type}' for user {mobile}")
+
+    response_message = ""
+    success = False
+
+    try:
+        if intent == 'create':
+            if trans_type in ('purchase', 'inventory'):
+                # Pass all transactions that are inventory creation
+                inventory_creates = [t for t in parsed_trans_data if t.get('intent','').lower() == 'create' and t.get('transaction_type','').lower() in ('purchase', 'inventory')]
+                if inventory_creates:
+                    success = create_inventory(mobile, inventory_creates)
+                    response_message = "Inventory updated!" if success else "Failed to update inventory."
+                else:
+                    response_message = "No valid inventory creation details found."
+
+            elif trans_type == 'sale':
+                 # Pass all transactions that are sales
+                 sales_creates = [t for t in parsed_trans_data if t.get('intent','').lower() == 'create' and t.get('transaction_type','').lower() == 'sale']
+                 if sales_creates:
+                     success, feedback = create_sale(mobile, sales_creates)
+                     response_message = f"Sale processing results:\n{feedback}" # Use detailed feedback
+                 else:
+                     response_message = "No valid sale creation details found."
+            else:
+                response_message = f"Sorry, I can't 'create' transactions of type: {trans_type}"
+
+        elif intent == 'read' or trans_type == 'query':
+            # Use the original user query text if possible, otherwise generate a query string
+            # For simplicity, let's just use the formatted details as a pseudo-query
+            query_details = first_transaction.get('details', {})
+            query_str = " ".join([f"{k}:{v}" for k,v in query_details.items()]) if query_details else "Show summary" # Simple query string
+            logger.info(f"Performing read/query for user {mobile}: {query_str}")
+            # Call the simplified read_datalake
+            read_result = read_datalake(mobile, query_str) # Pass the generated query string
+            # Check if read_result is an image path (if you re-introduce image reports)
+            # For now, assume it returns text
+            response_message = str(read_result)
+            # No separate summary needed as the result is the response
+            return response_message # Return directly, don't add summary again
+
+        elif intent == 'update':
+            # Pass all update transactions (assuming they target different items or update sequentially)
+            updates = [t for t in parsed_trans_data if t.get('intent','').lower() == 'update']
+            if updates:
+                 # Update logic currently processes one item at a time, needs enhancement for batch updates
+                 # For now, process the first update instruction found
+                 success, feedback = update_transaction(mobile, updates) # Pass the list, function handles first
+                 response_message = feedback # Use feedback from function
+            else:
+                 response_message = "No valid update details found."
+
+
+        elif intent == 'delete':
+             # Pass all delete transactions
+             deletes = [t for t in parsed_trans_data if t.get('intent','').lower() == 'delete']
+             if deletes:
+                 success, feedback = delete_transaction(mobile, deletes)
+                 response_message = feedback # Use feedback from function
+             else:
+                 response_message = "No valid deletion details found."
 
-    if intent == 'create':
-        if trans_type in ('purchase', 'inventory'):
-            success = create_inventory(mobile, parsed_trans_data)
-            return ("Inventory updated successfully!\n\n" + transaction_summary) if success else \
-                   ("Failed to update inventory!\n\n" + transaction_summary)
-        elif trans_type == 'sale':
-            success = create_sale(mobile, parsed_trans_data)
-            return ("Sale recorded successfully!\n\n" + transaction_summary) if success else \
-                   ("Failed to record sale! Check inventory.\n\n" + transaction_summary)
         else:
-            return f"Unsupported transaction type: {trans_type}\n\n{transaction_summary}"
-                
-    elif intent == 'read':
-        if 'item' in parsed_trans_data[0].get('details', {}):
-            item = parsed_trans_data[0]['details']['item']
-            result = fetch_transaction(mobile, item)
-            return f"Item details:\n\n{format_transaction_response(result)}" if result else f"Item '{item}' not found"
+            response_message = f"Sorry, I don't know how to handle the intent: '{intent}'"
+
+        # Combine the action result message with the summary of what was processed
+        # Avoid adding summary if the response message already contains it (like read_datalake)
+        if intent != 'read' and trans_type != 'query':
+             full_response = f"{response_message}\n\nSummary of processed data:\n{transaction_summary}"
         else:
-            results = fetch_transaction(mobile)
-            return f"All items:\n\n{format_transaction_response(results)}" if results else "No items found"
-                
-    elif intent == 'update':
-        item = parsed_trans_data[0]['details'].get('item')
-        if not item:
-            return "Error: No item specified for update"
-                
-        updates = {k:v for k,v in parsed_trans_data[0]['details'].items() if k != 'item'}
-        success = update_transaction(mobile, item, updates, trans_type if trans_type else 'inventory')
-        return (f"Updated {item} successfully!\n\n{transaction_summary}") if success else \
-               (f"Failed to update {item}!\n\n{transaction_summary}")
-                   
-    elif intent == 'delete':
-        item = parsed_trans_data[0]['details'].get('item', 'item')
-        success = delete_transaction(mobile, parsed_trans_data)
-        return (f"Deleted {item} successfully!") if success else \
-               (f"Failed to delete {item}!")
-                   
-    else:
-        return f"Unsupported intent: {intent}\n\n{transaction_summary}"
+             full_response = response_message # Read intent already formatted output
+
+        return full_response.strip()
+
+    except Exception as e:
+        logger.error(f"Error processing intent '{intent}' for user {mobile}: {e}", exc_info=True)
+        return f"Sorry, an error occurred while processing your request for '{intent}'.\n\nDetails received:\n{transaction_summary}"