Update app.py

app.py

@@ -64,21 +64,22 @@ class Patient(db.Model):
 # Create database tables if they don't exist
 @app.before_request
 def create_tables():
-    # Ensure this runs only once per request or use a flag
-    # Simple approach for development: check if tables exist
-    if not app.config.get('_tables_created', False):
+    # Ensure this runs only once per application start
+    # Use a flag to prevent repeated checks/creations on every request
+    if not getattr(app, '_tables_created', False):
         with app.app_context():
-            # Check if at least one table exists (e.g., the Patient table)
-            # This check is basic and might not be sufficient for complex setups
             inspector = db.inspect(db.engine)
-            if not inspector.has_table("patient"):
+            if not inspector.has_table("patient"): # Check for at least one table
                 logger.info("Creating database tables.")
                 db.create_all()
-                app.config['_tables_created'] = True # Set flag
+                app._tables_created = True # Set flag
+            else:
+                 logger.info("Database tables already exist.")
+                 app._tables_created = True # Set flag even if they exist
 
 
-upload_base = os.getenv('UPLOAD_DIR', '/tmp/uploads')
-upload_folder = os.path.join(upload_base, 'pdfs')
+upload_base = os.getenv('UPLOAD_DIR', '/tmp') # Changed base to /tmp, safer default
+upload_folder = os.path.join(upload_base, 'uploads', 'pdfs') # Added 'uploads' subdirectory
 
 app.config['UPLOAD_FOLDER'] = upload_folder
 
@@ -92,6 +93,9 @@ AUTH_TOKEN = os.getenv('TWILIO_AUTH_TOKEN')
 TWILIO_FROM = os.getenv('TWILIO_FROM_NUMBER')
 TWILIO_TO = os.getenv('TWILIO_TO_NUMBER') # Hardcoded number as requested, consider making this configurable per patient
 
+# Define WhatsApp message length limit (slightly below the official 4096 for safety)
+WHATSAPP_MAX_CHARS = 4000
+
 twilio_client = None
 if ACCOUNT_SID and AUTH_TOKEN and TWILIO_FROM and TWILIO_TO:
     try:
@@ -150,23 +154,18 @@ def extract_text_from_pdf(pdf_file):
         text = ""
         if pdf_reader.is_encrypted:
              try:
-                 # Attempt decryption - PyPDF2 v3+ might not need password for simple cases
-                 # or might fail differently. Explicitly try common/empty passwords.
-                 # Note: Robust decryption requires knowing the password, which is not handled here.
-                 # This attempt is basic.
+                 # Attempt decryption with common/empty passwords - very basic
                  try:
                      pdf_reader.decrypt('') # Try with empty password
+                     logger.warning("PDF is encrypted but decrypted successfully with empty password.")
                  except PyPDF2.errors.PasswordError:
-                     # If empty password fails, and it's truly password protected
                      logger.warning("PDF is encrypted and requires a password.")
                      return "[PDF Content Unavailable: File is encrypted and requires a password]"
                  except Exception as dec_e:
-                     # Handle other potential decryption errors
                      logger.error(f"Error during PDF decryption attempt: {dec_e}")
                      return "[PDF Content Unavailable: Error decrypting file]"
 
-
-             except Exception: # Catch any other unexpected error during decryption check
+             except Exception: # Catch any other unexpected error
                  logger.error("Unexpected error during PDF decryption check.")
                  return "[PDF Content Unavailable: Unexpected error with encrypted file]"
 
@@ -179,9 +178,15 @@ def extract_text_from_pdf(pdf_file):
                     text += page_text + "\n"
             except Exception as page_e:
                  logger.error(f"Error extracting text from page {page_num + 1}: {page_e}")
-                 text += f"[Error extracting page {page_num + 1}]\n" # Add placeholder for failed pages
+                 text += f"[Error extracting page {page_num + 1}]\n" # Add placeholder
+
+
+        extracted = text.strip()
+        if not extracted:
+             logger.info("PDF text extraction resulted in empty string.")
+             return "[No readable text found in PDF]"
+        return extracted
 
-        return text.strip() or "[No readable text found in PDF]"
     except Exception as e:
         logger.error(f"Error extracting PDF text: {e}", exc_info=True)
         return f"[Error extracting PDF text: {e}]"
@@ -189,44 +194,34 @@ def extract_text_from_pdf(pdf_file):
 
 def extract_care_plan_format(pdf_text):
     """Extract a general format template from PDF text by identifying common section headers."""
-    if not pdf_text or "[No readable text found" in pdf_text or "[Error extracting PDF text" in pdf_text or "[PDF Content Unavailable" in pdf_text:
+    # Define unreadable indicators
+    unreadable_indicators = ["[No readable text found", "[Error extracting PDF text", "[PDF Content Unavailable"]
+
+    if not pdf_text or any(indicator in pdf_text for indicator in unreadable_indicators):
         logger.info("No valid PDF text available to extract format.")
         return None
 
-    # Look for lines that seem like headers followed by a colon, possibly with content below
-    # Pattern: Start of line, followed by one or more uppercase letters or spaces, ending with a colon.
-    # Use word boundaries \b to avoid matching things like "MEDICATION:" within a sentence.
-    # Refined pattern: Allow optional space before colon, and optional space/newline after colon before content starts.
-    # It also accounts for the possibility that a header is the last thing in the text.
-    potential_headers = re.findall(r'^\b([A-Z][A-Z\s]*)\b[ \t]*:(?:[\s\r\n]|$)', pdf_text, re.MULTILINE)
+    # Pattern to find potential headers: Start of line, contains uppercase letters/spaces, ends with colon or period,
+    # possibly followed by whitespace only.
+    # \b ensures we match whole words at boundaries
+    # [:.] accounts for headers ending in colon or period
+    # (?:[\s\r\n]|$) accounts for whitespace or end of string after colon/period
+    potential_headers = re.findall(r'^\s*([A-Z][A-Z\s]*)\b[ \t]*[:.]?[\s\r\n]*$', pdf_text, re.MULTILINE)
 
     if not potential_headers:
          # Fallback: Look for lines that start with a capital letter and seem like standalone headers
-         # (e.g., "Patient Information", "Assessment.")
-         # Ensure it doesn't look like a sentence.
-         # Add more constraints: must end with colon or period, or be followed by a newline and indented text?
-         # Simple fallback: Starts with Capital, contains mostly letters/spaces, ends with colon or period.
-         fallback_headers_strict = re.findall(r'^[A-Z][A-Za-z\s]*[:.][ \t]*$', pdf_text, re.MULTILINE)
-
-         if fallback_headers_strict:
-             logger.info(f"Extracted potential headers (fallback - strict): {list(set(fallback_headers_strict))}")
-             # Remove ending colon/period and strip whitespace
-             unique_headers = sorted(list(set([re.sub(r'[:.\s]*$', '', h).strip() for h in fallback_headers_strict if re.sub(r'[:.\s]*$', '', h).strip()])))
-             format_template = "\n".join([f"{header.strip()}:" for header in unique_headers if header.strip()]) # Sort for consistency
-             return format_template if format_template.strip() else None
-
-         # Less strict fallback: Starts with Capital, seems like a short phrase line
-         fallback_headers_loose = re.findall(r'^[A-Z][A-Za-z\s]{3,}[ \t]*$', pdf_text, re.MULTILINE)
+         # Ensure it doesn't look like a sentence (e.g., short phrase, starts with Cap, ends maybe with space or newline).
+         # Simple heuristic: Starts with Capital, followed by 3+ letters/spaces, ends before another capital or end of line.
+         # This is less reliable than the colon/period method.
+         fallback_headers_loose = re.findall(r'^[A-Z][A-Za-z\s]{3,}(?=\s[A-Z]|\s*$)', pdf_text, re.MULTILINE)
          fallback_headers_loose = [h.strip() for h in fallback_headers_loose if h.strip()]
          if fallback_headers_loose:
-              # Further filter to remove things that look like sentence beginnings
-              # Check if the line is followed by a line starting with a bullet or indentation? Too complex.
-              # Simple filter: check length and word count.
-              fallback_headers_loose = [h for h in fallback_headers_loose if len(h) > 5 and len(h.split()) < 6] # Example filter
+              # Filter out potential sentences - check length, word count, maybe look for typical header words
+              fallback_headers_loose = [h for h in fallback_headers_loose if len(h) > 5 and len(h.split()) < 7 and not h.endswith('.')] # Example filter
               if fallback_headers_loose:
                  logger.info(f"Extracted potential headers (fallback - loose): {list(set(fallback_headers_loose))}")
                  unique_headers = sorted(list(set([h.strip() for h in fallback_headers_loose if h.strip()])))
-                 format_template = "\n".join([f"{header.strip()}:" for header in unique_headers if header.strip()]) # Sort for consistency
+                 format_template = "\n".join([f"{header.strip()}:" for header in unique_headers if header.strip()])
                  return format_template if format_template.strip() else None
 
 
@@ -234,7 +229,8 @@ def extract_care_plan_format(pdf_text):
          return None
 
     # Use a set to get unique headers and sort them for consistency
-    unique_headers = sorted(list(set([h.strip() for h in potential_headers if h.strip()])))
+    # Clean up headers: remove trailing colons/periods and strip
+    unique_headers = sorted(list(set([re.sub(r'[:.\s]*$', '', h).strip() for h in potential_headers if h.strip()])))
 
     if not unique_headers:
          logger.info("Extracted headers are empty after cleaning.")
@@ -247,10 +243,9 @@ def extract_care_plan_format(pdf_text):
     return format_template if format_template.strip() else None
 
 
-# --- OPTIMIZED determine_patient_status FUNCTION ---
 def determine_patient_status(original_plan, updated_plan, feedback):
     """
-    Determine patient status based on feedback, original plan, and the *final* updated plan text.
+    Determine patient status based on feedback, original plan, and the final updated plan text.
     Prioritizes emergency > deteriorating > improving. Checks feedback/original first,
     then checks updated plan for emergency confirmation. Uses refined keyword matching.
     """
@@ -258,11 +253,10 @@ def determine_patient_status(original_plan, updated_plan, feedback):
 
     feedback_lower = feedback.lower() if feedback else ""
     original_plan_lower = original_plan.lower() if original_plan else ""
-    updated_plan_lower = updated_plan.lower() if updated_plan else "" # Include updated plan lower
+    updated_plan_lower = updated_plan.lower() if updated_plan else ""
 
 
     # Define robust keyword lists
-    # Emergency Keywords: Indicate immediate threat to life or limb, requires urgent medical intervention.
     emergency_keywords = [
         "severe chest pain", "heart attack", "sudden shortness of breath",
         "difficulty breathing severely", "loss of consciousness", "unresponsive",
@@ -276,11 +270,11 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "signs of shock", "severe dehydration symptoms", "acute change in mental status",
         "unstable vitals", "rapidly worsening symptoms", "can't breathe", "chest tight severe",
         "severe difficulty swallowing suddenly", "new onset paralysis", "severe burns",
-        "major trauma", "suspected poisoning", "overdose", "suicidal thoughts active", # Added qualifiers
-        "unstable", "critically ill", "life-threatening", "no pulse", "low oxygen saturation severe"
+        "major trauma", "suspected poisoning", "overdose", "suicidal thoughts active",
+        "unstable", "critically ill", "life-threatening", "no pulse", "low oxygen saturation severe",
+        "uncontrolled high fever", "septic shock", "signs of major infection" # Added a few more
     ]
 
-    # Deteriorating Keywords: Indicate condition is worsening, not improving as expected, or new concerning symptoms. Requires prompt medical review.
     deteriorating_keywords = [
         "worsening", "increased pain", "not improving", "deteriorating",
         "getting worse", "more frequent symptoms", "elevated", "higher",
@@ -293,10 +287,10 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "tired all the time", "much weaker", "feeling noticeably worse", "consistent high blood pressure",
         "uncontrolled blood sugar levels", "increased swelling", "persistent cough getting worse",
         "unexplained weight loss significant", "gradual decline", "unmanaged symptoms",
-        "not resolving", "changes in condition", "difficulty performing daily tasks" # Added more
+        "not resolving", "changes in condition", "difficulty performing daily tasks",
+        "pain getting worse", "more tired", "less active", "increased falls", "poorly controlled" # Added a few more
     ]
 
-    # Improvement Keywords: Indicate condition is getting better, symptoms are resolving, or goals are being met.
     improvement_keywords = [
         "improving", "better today", "reduced pain", "lower", "less frequent",
         "healing well", "recovery on track", "making progress", "stable condition",
@@ -309,49 +303,37 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "more energy", "walking further", "blood pressure normal range",
         "blood sugar stable", "swelling reduced", "easier breathing", "cough improving",
         "weight gain healthy", "feeling like myself again", "in remission", "managing well at home",
-        "tolerating well", "no issues reported", "feeling good", "symptoms gone" # Added more positive
+        "tolerating well", "no issues reported", "feeling good", "symptoms gone",
+        "activity increased", "pain well managed", "sleeping better", "appetite improved" # Added a few more
     ]
 
-    # Helper to check if any keyword is found in the text
+    # Helper to check if any keyword is found in the text (using word boundaries)
     def check_keywords(text, keywords):
-        # Create a regex pattern for whole words, handling potential special characters in keywords
+        if not text: return False
         pattern = r'\b(?:' + '|'.join(re.escape(kw) for kw in keywords) + r')\b'
         return re.search(pattern, text) is not None
 
     # --- Classification Logic ---
 
-    # Combine feedback and original plan text for initial assessment
-    combined_initial_text_lower = feedback_lower + " " + (original_plan_lower if original_plan_lower else "")
-    combined_initial_text_lower = re.sub(r'\s+', ' ', combined_initial_text_lower).strip() # Clean up spaces
+    # 1. Check for EMERGENCY status (Highest Priority)
+    # Check combined initial text (feedback + original plan) AND the final generated plan text
+    combined_text_lower = feedback_lower + " " + (original_plan_lower if original_plan_lower else "") + " " + (updated_plan_lower if updated_plan_lower else "")
+    combined_text_lower = re.sub(r'\s+', ' ', combined_text_lower).strip() # Clean up spaces
+
+    if check_keywords(combined_text_lower, emergency_keywords):
+        logger.info("Status determined: EMERGENCY (keyword found).")
+        return "emergency"
 
     # 2. Check for DETERIORATING status (Second Priority)
-    # Check combined initial text for deteriorating keywords (only if not emergency)
-    is_deteriorating_initial = check_keywords(combined_initial_text_lower, deteriorating_keywords)
-    if is_deteriorating_initial:
-        logger.info("Status determined: DETERIORATING (keyword found in feedback/original).")
+    if check_keywords(combined_text_lower, deteriorating_keywords):
+        logger.info("Status determined: DETERIORATING (keyword found).")
         return "deteriorating"
 
-     # 3. Check for IMPROVING status (Third Priority)
-    # Check combined initial text for improving keywords (only if not emergency or deteriorating)
-    is_improving_initial = check_keywords(combined_initial_text_lower, improvement_keywords)
-    if is_improving_initial:
-        logger.info("Status determined: IMPROVING (keyword found in feedback/original).")
+    # 3. Check for IMPROVING status (Third Priority)
+    if check_keywords(combined_text_lower, improvement_keywords):
+        logger.info("Status determined: IMPROVING (keyword found).")
         return "improving"
 
-    # 1. Check for EMERGENCY status (Highest Priority)
-    # Check combined initial text for emergency keywords
-    is_emergency_initial = check_keywords(combined_initial_text_lower, emergency_keywords)
-
-    # Also, check if the *final generated plan* explicitly contains strong emergency keywords.
-    # This helps catch cases where the AI correctly inferred emergency from subtle cues
-    # or context, even if the patient's feedback wasn't explicitly critical *using the exact keywords*.
-    is_emergency_final_plan = check_keywords(updated_plan_lower, emergency_keywords)
-
-    if is_emergency_initial:
-        logger.info("Status determined: EMERGENCY (keyword found in feedback/original or final plan).")
-        return "emergency"
-
-
     # 4. Default to STABLE if no specific status keywords are found
     logger.info("Status determined: STABLE (no specific status keywords found).")
     return "stable"
@@ -491,16 +473,21 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
 
         # Check for section headers (e.g., "MEDICATIONS:", "ASSESSMENT:")
         # Look for lines starting with one or more uppercase words followed by a colon or period
-        header_match = re.match(r'^([A-Z][A-Z\s]*)\b[ \t]*[:.](\s|$)', stripped_line) # Added period check
+        header_match = re.match(r'^\s*([A-Z][A-Z\s]*)\b[ \t]*[:.]?[\s\r\n]*$', line) # Use original line to preserve leading spaces if intentional?
         if header_match:
             # Remove trailing colon or period for cleaner heading
             header_text = re.sub(r'[:.\s]*$', '', stripped_line).strip()
-            story.append(Spacer(1, 8)) # Add space before a new section
-            story.append(Paragraph(header_text + ":", heading_style)) # Use heading style for sections
-        # Check for list items (starting with -, *, •)
-        elif stripped_line.startswith('-') or stripped_line.startswith('*') or stripped_line.startswith('•'):
-             # Remove the bullet character and any leading space/tab
-             bullet_text = re.sub(r'^[-*•][ \t]*', '', line).strip()
+            if header_text: # Ensure there's actual text before adding a heading
+                story.append(Spacer(1, 8)) # Add space before a new section
+                story.append(Paragraph(header_text + ":", heading_style)) # Use heading style for sections
+            # else: # If line was just ":" or ".", treat as empty and skip or handle as plain text?
+            #     pass # Skipping lines that are just punctuation seems reasonable
+
+        # Check for list items (starting with -, *, •) - only if NOT matched as a header
+        # Use original line to preserve leading spaces/tabs for bullet indent
+        elif line.lstrip().startswith(('-', '*', '•')): # Use lstrip to check for bullet at start ignoring leading space
+             # Remove the bullet character and any leading space/tab after it
+             bullet_text = re.sub(r'^[\s-]*[-*•][ \t]*', '', line).strip() # More robust removal including space/tab before bullet
              if bullet_text:
                  formatted_bullet_text = bullet_text.replace('\n', '<br/>')
                  story.append(Paragraph(f"• {formatted_bullet_text}", bullet_style))
@@ -508,9 +495,11 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
                  # Handle cases with just a bullet point on a line
                  story.append(Paragraph("• ", bullet_style))
         else:
-            # Handle regular paragraph text
-            normal_line_content = line.strip().replace('\n', '<br/>')
-            story.append(Paragraph(normal_line_content, normal_style))
+            # Handle regular paragraph text that wasn't a header or bullet
+            # Only add if the stripped line has content
+            if stripped_line:
+                normal_line_content = line.strip().replace('\n', '<br/>') # Use stripped line for content
+                story.append(Paragraph(normal_line_content, normal_style))
 
 
     story.append(Spacer(1, 20))
@@ -524,29 +513,31 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         return buffer
     except Exception as e:
         logger.error(f"Error building PDF: {e}", exc_info=True)
+        # Fallback: create a simple error PDF
         error_buffer = io.BytesIO()
         c = canvas.Canvas(error_buffer, pagesize=letter)
         c.drawString(100, 750, "Error Generating Care Plan PDF")
         c.drawString(100, 735, f"Details: {str(e)}")
+        c.drawString(100, 720, "Please check server logs for more information.")
         c.save()
         error_buffer.seek(0)
         return error_buffer
 
 
 def send_whatsapp_care_plan(patient_info, care_plan_text, status):
-    """Send care plan via WhatsApp using Twilio with improved formatting"""
+    """Send care plan via WhatsApp using Twilio with improved formatting and length check"""
     if not twilio_client:
         logger.warning("Twilio client not configured. Cannot send WhatsApp message.")
-        return False, "Twilio client not configured."
+        return False, "Twilio client not configured. Check server settings."
 
     if not TWILIO_TO or not TWILIO_FROM:
          logger.warning("Twilio TO or FROM number not set.")
-         return False, "Twilio TO or FROM number not configured."
+         return False, "Twilio TO or FROM number not configured. Check server settings."
 
     # Basic check for empty plan text before sending
     if not care_plan_text or not care_plan_text.strip():
          logger.warning("Care plan text is empty. Cannot send WhatsApp message.")
-         return False, "Care plan text is empty."
+         return False, "Care plan text is empty. No plan to send."
 
     try:
         status_emoji = {
@@ -569,12 +560,14 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         for line in formatted_plan.split('\n'):
              stripped_line = line.strip()
              # Check for lines that look like headers (starts with capital, ends with colon/period, possibly followed by whitespace)
-             if re.match(r'^[A-Z][A-Z\s]*\b[ \t]*[:.](\s|$)', stripped_line + '\n'): # Add newline for robust match
-                  # Remove trailing colon/period before bolding
+             # Added ? after [:. ] to handle cases where header doesn't have punctuation
+             header_match = re.match(r'^[A-Z][A-Za-z\s]*\b[ \t]*[:.]?$', stripped_line)
+             if header_match:
+                  # Remove trailing colon or period before bolding
                   header_text = re.sub(r'[:.\s]*$', '', stripped_line).strip()
                   if header_text: # Only bold if there's actual text before the colon/period
-                    formatted_plan_lines.append(f"*{header_text}:*")
-                  else: # Handle cases like just ":" on a line
+                    formatted_plan_lines.append(f"*{header_text}:*") # Add colon back after bolding
+                  else: # Handle cases like just ":" or "." on a line
                      formatted_plan_lines.append(line)
              else:
                   formatted_plan_lines.append(line)
@@ -588,12 +581,20 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         message += f"*Status:* {status_emoji.get(status, 'Unknown')}\n\n"
         # Add feedback if available
         feedback_text = patient_info.get('feedback')
-        if feedback_text and feedback_text.strip(): # Check if feedback is not empty
+        if feedback_text and feedback_text.strip():
              message += f"*Latest Feedback:*\n{feedback_text.strip()}\n\n"
 
         message += f"*Care Plan Details:*\n{formatted_plan}"
 
-        logger.info(f"Attempting to send WhatsApp message to {TWILIO_TO}...")
+        # --- WhatsApp Message Length Check ---
+        if len(message) > WHATSAPP_MAX_CHARS:
+            error_msg = f"WhatsApp message exceeds the maximum length ({WHATSAPP_MAX_CHARS} characters). The full care plan text is too long to send via WhatsApp. Please download the PDF instead."
+            logger.warning(f"WhatsApp message too long for patient {patient_info.get('name', 'N/A')} (ID: {patient_info.get('id', 'N/A')}). Length: {len(message)}. Max: {WHATSAPP_MAX_CHARS}")
+            return False, error_msg
+        # --- End Length Check ---
+
+
+        logger.info(f"Attempting to send WhatsApp message to {TWILIO_TO} (length: {len(message)})...")
         message_sent = twilio_client.messages.create(
             from_=TWILIO_FROM,
             body=message,
@@ -605,16 +606,13 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         logger.error(f"Error sending WhatsApp message: {e}", exc_info=True)
         # Provide more specific Twilio error details if available
         twilio_error_message = str(e)
-        # Attempt to parse Twilio API error response
         if hasattr(e, 'status_code') and hasattr(e, 'text'):
              try:
                   error_details = json.loads(e.text)
                   if 'message' in error_details:
                        twilio_error_message = f"Twilio API error: {error_details['message']} (Code: {error_details.get('code')})"
-             except json.JSONDecodeError:
-                  pass # Fallback to generic error if JSON parsing fails
-             except Exception:
-                 pass # Catch other potential exceptions during parsing/formatting
+             except (json.JSONDecodeError, Exception):
+                  pass
 
         return False, f"Error sending WhatsApp: {twilio_error_message}"
 
@@ -657,6 +655,8 @@ def doctor_dashboard():
 def submit_feedback():
     ai_enabled = bool(model) # Check if model is initialized
     ai_error_message = None # Initialize error message
+    whatsapp_sent = False
+    whatsapp_message = "WhatsApp sending skipped or not attempted yet." # Default message
 
     try:
         name = request.form.get('name', 'Unnamed Patient')
@@ -673,12 +673,12 @@ def submit_feedback():
             try:
                 age = int(age)
                 if age <= 0: raise ValueError("Age must be positive")
-                if age > 150: raise ValueError("Age seems unreasonably high") # More realistic sanity check
+                if age > 150: raise ValueError("Age seems unreasonably high")
             except ValueError:
                  logger.warning(f"Submission failed: Invalid Age provided: {age}")
                  return jsonify({'success': False, 'error': 'Invalid Age provided.'}), 400
         else:
-             age = None # Store as None if not provided
+             age = None
 
         care_plan_text = "" # This will store the extracted text from PDF
         care_plan_format = None # This will store the detected format
@@ -692,10 +692,13 @@ def submit_feedback():
                      return jsonify({'success': False, 'error': 'Invalid file type. Only PDF files are allowed.'}), 400
 
                 logger.info(f"Processing uploaded PDF: {pdf_file.filename}")
+                # Reset the file pointer just in case, although seek(0) is in extract_text_from_pdf
+                # pdf_file.seek(0) # Redundant due to seek(0) in extract_text_from_pdf
                 care_plan_text = extract_text_from_pdf(pdf_file)
 
                 # If extraction resulted in an error message, set format to None
-                if "[Error extracting PDF text" in care_plan_text or "[No readable text found" in care_plan_text or "[PDF Content Unavailable" in care_plan_text:
+                unreadable_indicators = ["[No readable text found", "[Error extracting PDF text", "[PDF Content Unavailable"]
+                if any(indicator in care_plan_text for indicator in unreadable_indicators):
                      care_plan_format = None
                      logger.warning(f"PDF text extraction failed or empty: {care_plan_text}")
                 else:
@@ -706,6 +709,7 @@ def submit_feedback():
 
         # Determine the initial status based on feedback and original plan
         # Pass "" for updated_plan initially, as it hasn't been generated yet for status check
+        # Using care_plan_text for original_plan part of status check
         initial_status = determine_patient_status(care_plan_text, "", feedback)
         logger.info(f"Initial status determined based on feedback/original plan: {initial_status}")
 
@@ -714,7 +718,6 @@ def submit_feedback():
         final_status_to_save = initial_status # Start with initial status
 
         # Only generate AI plan if AI is enabled AND status isn't immediate emergency based on feedback
-        # If feedback triggers "emergency", the generated_plan_text is a fixed emergency plan.
         if final_status_to_save == 'emergency':
             logger.info("Emergency status detected. Generating fixed emergency plan.")
             generated_plan_text = (
@@ -740,8 +743,7 @@ def submit_feedback():
                 "- Inform your primary physician/care team as soon as medically stable.\n"
                 "- A new care plan will be developed after the emergency situation is resolved and evaluated by medical professionals.\n"
             )
-            # For emergency, the generated plan text *is* the final plan to save/send.
-            # Status remains 'emergency', which was already set as final_status_to_save.
+            # For emergency, the status is already 'emergency' and the generated plan is fixed.
 
 
         elif ai_enabled: # AI is enabled and initial status is not emergency
@@ -790,8 +792,8 @@ Age: {age if age is not None else 'N/A'}
 Gender: {gender}
 Patient Feedback/Symptoms Update:
 {feedback}
-Previous Care Plan Details (if available):
-{care_plan_text if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text and "[PDF Content Unavailable" not in care_plan_text else "No previous care plan provided or could not be read."}
+Previous Care Plan Details (if available and readable):
+{care_plan_text if care_plan_text and not any(indicator in care_plan_text for indicator in unreadable_indicators) else "No previous care plan provided or could not be read."}
 Instructions:
 1. Generate the updated care plan strictly using the exact following format template.
 2. Populate each section of the template based on the patient's information, their *latest feedback/symptoms*, and integrate relevant, SAFE, and appropriate elements from the previous plan if they are still applicable and helpful given the feedback.
@@ -803,7 +805,7 @@ Instructions:
 8. If the previous care plan was unavailable or unreadable, create the plan based solely on the patient information and feedback, still following the template.
 9. Ensure the plan is medically sound and reflects standard care principles. If feedback indicates a significant change or potential issue, the ASSESSMENT and subsequent sections should clearly address this and recommend appropriate actions (like contacting their doctor for a re-evaluation, even if it's not an immediate emergency).
 10. If the feedback indicates significant improvement, the plan should reflect this (e.g., adjusting activity levels up, noting successful symptom management) while still including monitoring and red flags.
-11. Review the feedback and previous plan carefully to determine the most likely current STATUS (e.g., Emergency, Deteriorating, Improving, Stable) and ensure the plan content aligns with that status, especially the RED FLAGS section.
+11. Review the feedback and previous plan carefully to determine the most likely current STATUS (e.g., Emergency, Deteriorating, Improving, Stable) and ensure the plan content aligns with that status, especially the RED FLAGS section. The determined status will be saved alongside the plan.
 Care Plan Format Template:
 {care_plan_format}
 """
@@ -811,7 +813,6 @@ Care Plan Format Template:
 
             try:
                 response = model.generate_content(prompt)
-                # Access text attribute
                 generated_plan_text = response.text.strip()
 
                 # Remove markdown code block formatting if present
@@ -838,8 +839,6 @@ Care Plan Format Template:
                 logger.info(f"AI Response received. Length: {len(generated_plan_text)}")
 
                 # Re-determine the final status using the generated plan as well.
-                # This is important because the AI might infer severity the keyword matching missed initially,
-                # or the generated plan text itself might contain explicit strong status indicators.
                 final_status_to_save = determine_patient_status(care_plan_text, generated_plan_text, feedback)
                 logger.info(f"Final status determined after AI generation: {final_status_to_save}")
 
@@ -848,10 +847,11 @@ Care Plan Format Template:
                 logger.error(f"Error generating content from AI: {ai_error}", exc_info=True)
                 # If AI fails, construct an error message plan
                 generated_plan_text = f"[Error generating updated plan from AI: {ai_error}]\n\n"
-                if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text and "[PDF Content Unavailable" not in care_plan_text:
+                unreadable_indicators = ["[No readable text found", "[Error extracting PDF text", "[PDF Content Unavailable"]
+                if care_plan_text and not any(indicator in care_plan_text for indicator in unreadable_indicators):
                      generated_plan_text += "Falling back to original plan if available:\n\n" + care_plan_text
                      # If falling back to original, status should reflect original plan/feedback
-                     final_status_to_save = determine_patient_status(care_plan_text, care_plan_text, feedback) # Use original plan for status check if AI failed
+                     final_status_to_save = determine_patient_status(care_plan_text, care_plan_text, feedback) # Use original plan text for status check if AI failed
                      ai_error_message = f"AI generation failed. Showing original plan if available. Error: {ai_error}"
                 else:
                      generated_plan_text += "No previous plan available."
@@ -864,7 +864,8 @@ Care Plan Format Template:
         else: # AI is not enabled and status is not emergency
              logger.warning("AI generation is disabled.")
              generated_plan_text = f"[AI generation is currently disabled.]\n\n"
-             if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text and "[PDF Content Unavailable" not in care_plan_text:
+             unreadable_indicators = ["[No readable text found", "[Error extracting PDF text", "[PDF Content Unavailable"]
+             if care_plan_text and not any(indicator in care_plan_text for indicator in unreadable_indicators):
                   generated_plan_text += "Showing original plan if available:\n\n" + care_plan_text
                   # Status based on original plan/feedback
                   final_status_to_save = determine_patient_status(care_plan_text, care_plan_text, feedback)
@@ -895,17 +896,16 @@ Care Plan Format Template:
         logger.info(f"Patient {patient_id} added to DB with status: {final_status_to_save}.")
 
         # Generate PDF for downloading using the stored data
-        # Note: We pass the patient object directly to the PDF generator for simplicity
-        # and to include feedback in the PDF
         pdf_buffer = generate_care_plan_pdf(new_patient.to_dict(), new_patient.updated_plan, new_patient.status)
         pdf_buffer.seek(0) # Ensure buffer is at the start before base64 encoding
         pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode('utf-8')
         logger.info("PDF generated and base64 encoded.")
 
         # Send care plan via WhatsApp (using the final saved data)
-        # Note: We pass the patient object directly to the WhatsApp function
+        # This call will now handle the length check internally
         whatsapp_sent, whatsapp_message = send_whatsapp_care_plan(new_patient.to_dict(), new_patient.updated_plan, new_patient.status)
-        logger.info(f"WhatsApp message attempt sent: {whatsapp_sent}, message: {whatsapp_message}")
+        logger.info(f"WhatsApp message attempt finished: {whatsapp_sent}, message: {whatsapp_message}")
+
 
         # Return success response, include relevant data
         return jsonify({
@@ -914,8 +914,8 @@ Care Plan Format Template:
             'pdf_data': pdf_base64,
             'patient_id': patient_id,
             'status': new_patient.status, # Return the final determined status
-            'whatsapp_sent': whatsapp_sent,
-            'whatsapp_message': whatsapp_message,
+            'whatsapp_sent': whatsapp_sent, # Indicates if the message was *attempted* and passed length check
+            'whatsapp_message': whatsapp_message, # Contains success or error message
             'ai_error': not ai_enabled or (ai_error_message is not None) # Indicate if AI was not enabled or failed
         })
 
@@ -946,9 +946,7 @@ def update_care_plan(patient_id):
             logger.warning(f"Update failed for ID {patient_id}: Patient not found.")
             return jsonify({'success': False, 'error': 'Patient not found.'}), 404
 
-        # Re-determine status based on the manually updated plan + existing feedback/original?
-        # Yes, this makes sense. If the doctor edits the plan, it should potentially change the status indication
-        # if their edits include stronger language about severity or improvement.
+        # Re-determine status based on the manually updated plan + existing feedback/original
         patient.status = determine_patient_status(patient.original_plan, updated_plan_text, patient.feedback)
 
         patient.updated_plan = updated_plan_text
@@ -985,6 +983,7 @@ def send_whatsapp_doctor(patient_id):
         care_plan_text_to_send = patient.updated_plan
         status_to_send = patient.status
 
+        # This call now includes the length check
         whatsapp_sent, whatsapp_message = send_whatsapp_care_plan(
             patient_info_for_whatsapp,
             care_plan_text_to_send,
@@ -995,14 +994,15 @@ def send_whatsapp_doctor(patient_id):
             logger.info(f"WhatsApp sent successfully for patient ID: {patient_id}")
             return jsonify({'success': True, 'message': whatsapp_message})
         else:
-            logger.error(f"WhatsApp failed for patient ID: {patient_id} - {whatsapp_message}")
-            # Use 500 for server-side error only if it's a backend issue, otherwise 400 maybe?
-            # Let's stick to 500 for general failure to send via backend service.
-            return jsonify({'success': False, 'error': whatsapp_message}), 500
+            logger.warning(f"WhatsApp failed (likely too long) for patient ID: {patient_id} - {whatsapp_message}")
+            # Return a 400 error specifically for the length issue or other client-side fixable problems
+            # Use a more descriptive error message for the user
+            return jsonify({'success': False, 'error': whatsapp_message}), 400 # Changed status to 400
 
     except Exception as e:
         logger.error(f"Error triggering WhatsApp send for ID {patient_id}: {str(e)}", exc_info=True)
-        return jsonify({'success': False, 'error': f'An error occurred while sending WhatsApp: {str(e)}'}), 500
+        # Use 500 for unexpected server errors
+        return jsonify({'success': False, 'error': f'An unexpected error occurred while sending WhatsApp: {str(e)}'}), 500
 
 
 # --- Existing routes remain below ---
@@ -1025,7 +1025,20 @@ def download_pdf(patient_id):
             patient.status
         )
 
-        pdf_buffer.seek(0)
+        # Check if the buffer contains the error message text (simple check)
+        buffer_content = pdf_buffer.getvalue().decode('latin-1', errors='ignore') # Decode to check content
+        if "Error Generating Care Plan PDF" in buffer_content:
+            logger.error(f"PDF generation failed for ID {patient_id}, returning error PDF.")
+            # Send the error PDF, but indicate it's an error
+            return send_file(
+                io.BytesIO(pdf_buffer.getvalue()), # Need to create a new buffer from the value
+                as_attachment=True,
+                download_name=f"care_plan_{re.sub(r'[^a-zA-Z0-9_\-]', '', patient.name or 'patient').lower()}_error.pdf",
+                mimetype='application/pdf'
+            )
+
+
+        pdf_buffer.seek(0) # Reset buffer position after checking content
 
         safe_name = re.sub(r'[^a-zA-Z0-9_\-]', '', patient.name or 'patient').lower()
         download_name = f"care_plan_{safe_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
@@ -1039,15 +1052,13 @@ def download_pdf(patient_id):
         )
     except Exception as e:
         logger.error(f"PDF Download Error for ID {patient_id}: {str(e)}", exc_info=True)
+        # Fallback error response if even generating the basic error PDF fails
         return f"Error generating PDF for download: {str(e)}", 500
 
 
 @app.route('/get_emergency_notifications')
 def get_emergency_notifications():
     # Only include patients whose status is 'emergency'
-    # Exclude temporary 'emergency' status from new submissions before AI runs,
-    # perhaps only include statuses confirmed by AI or manual save?
-    # For simplicity now, just filter by final status == 'emergency' in DB.
     emergency_patients_query = Patient.query.filter_by(status='emergency').order_by(Patient.timestamp.desc())
 
     # Only return basic info needed for the alert, not full patient details
@@ -1120,8 +1131,11 @@ if __name__ == '__main__':
         if not inspector.has_table("patient"): # Check for at least one model's table
              logger.info("Database tables not found, creating.")
              db.create_all()
+             app._tables_created = True # Set flag after creation
         else:
              logger.info("Database tables already exist.")
+             app._tables_created = True # Set flag if they exist
+
 
     # Use a more robust development server like Waitress or Gunicorn in production
     # For development, debug=True is fine