Update app.py

app.py

@@ -66,19 +66,21 @@ class Patient(db.Model):
 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):
+    # Use a flag to prevent running 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"):
                 logger.info("Creating database tables.")
                 db.create_all()
-                app.config['_tables_created'] = True # Set flag
+            else:
+                logger.info("Database tables already exist.")
+            app._tables_created = True # Set flag
 
 
-upload_base = os.getenv('UPLOAD_DIR', '/tmp/uploads')
-upload_folder = os.path.join(upload_base, 'pdfs')
+upload_base = os.getenv('UPLOAD_DIR', '/tmp')
+upload_folder = os.path.join(upload_base, 'uploads', 'pdfs') # Use a sub-directory like 'uploads'
 
 app.config['UPLOAD_FOLDER'] = upload_folder
 
@@ -113,23 +115,17 @@ if GENAI_API_KEY:
         logger.info("Gemini API configured successfully.")
 
         generation_config = {
-            "temperature": 0.8,
+            "temperature": 0.7, # Slightly lower temp for potentially more stable output
             "top_p": 0.9,
             "top_k": 30,
-            "max_output_tokens": 4096,
+            "max_output_tokens": 4096, # Ensure enough tokens, but AI should be concise
         }
 
+        # Use a model suitable for instructions and structured output
         model = genai.GenerativeModel(
-            model_name="gemini-1.5-flash-latest",
+            model_name="gemini-1.5-flash-latest", # Or gemini-1.0-pro
             generation_config=generation_config,
-            # Optionally add safety settings
-            # safety_settings=[
-            #     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
-            #     {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-            #     {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-            #     {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
-            #     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"}, # Duplicate, remove
-            # ]
+            # safety_settings can be added here if needed, but ensure they don't block valid medical info
         )
         logger.info(f"Using Gemini model: {model.model_name}")
 
@@ -150,22 +146,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 - Note: Robust decryption requires knowing the password.
+                 # This is a basic attempt and may fail.
+                 # In production, you might need to handle encrypted PDFs differently.
                  try:
-                     pdf_reader.decrypt('') # Try with empty password
+                     pdf_reader.decrypt('') # Try with empty password first
                  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
                  logger.error("Unexpected error during PDF decryption check.")
                  return "[PDF Content Unavailable: Unexpected error with encrypted file]"
@@ -193,58 +185,40 @@ def extract_care_plan_format(pdf_text):
         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)
+    # Look for lines that seem like headers followed by a colon, period, or are just standalone capitalized lines
+    # Refined Pattern: Start of line, followed by one or more uppercase letters or spaces/words, ending with colon/period or followed by newline/indentation.
+    # Let's stick to the colon/period heuristic first as it's more reliable for structured docs.
+    # Pattern: Start of line ^, followed by one or more word characters (\w+) or spaces (\s), potentially including lowercase letters now `[A-Za-z\s]`, ending with a colon `:` or period `.` and then potentially space or end of line `$`.
+    # Add lookahead for newlines/spaces to handle headers that are the last line or followed by blank space.
+    potential_headers = re.findall(r'^[A-Z][A-Za-z\s]*[:.]?(?:\s|$)', pdf_text, re.MULTILINE)
+    # Further filter to exclude things that are likely sentence fragments or short lines
+    potential_headers = [h.strip() for h in potential_headers if h.strip() and len(h.strip().split()) > 1 and len(h.strip()) > 5] # Filter short/single word lines
 
     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)
-         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
-              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
-                 return format_template if format_template.strip() else None
-
-
-         logger.info("No sections or potential headers found in PDF.")
+         logger.info("No potential headers found in 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()])))
+    # Use a set to get unique headers, remove trailing colon/period, strip, and sort
+    unique_headers = sorted(list(set([re.sub(r'[:.\s]*$', '', h).strip() for h in potential_headers if re.sub(r'[:.\s]*$', '', h).strip()])))
 
     if not unique_headers:
          logger.info("Extracted headers are empty after cleaning.")
          return None
 
-    format_template = ""
-    for section_title in unique_headers:
-        format_template += f"{section_title.strip()}:\n- [Details]\n" # Use a simple list format placeholder
-    logger.info(f"Extracted sections: {unique_headers}")
-    return format_template if format_template.strip() else None
+    # Construct a format template string
+    # We don't need to represent the *exact* sub-structure with [Details] anymore,
+    # just the main sections. The AI will be instructed to follow a specific *required* structure.
+    # This extraction is mostly for informing the AI about *potential* sections present in the original.
+    # However, the user wants a *fixed* template structure regardless of the PDF.
+    # Let's *ignore* the extracted format for the AI prompt and rely solely on the hardcoded one.
+    # The extracted text itself is what's important from the PDF, not its format template.
+    # So, we can simplify this function or remove it if the AI strictly uses a hardcoded template.
+
+    # Given the user wants a FIXED template in the AI output, this extraction function's
+    # primary use becomes less critical for *generating* the new plan's format,
+    # but it *does* provide context about the original plan's content organization.
+    # Let's keep it simple, just return the extracted text. The prompt handles the structure.
+    return None # We will rely on the hardcoded structure in the prompt
 
 
 # --- OPTIMIZED determine_patient_status FUNCTION ---
@@ -276,8 +250,9 @@ 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",
+        "actively bleeding heavily" # Added
     ]
 
     # Deteriorating Keywords: Indicate condition is worsening, not improving as expected, or new concerning symptoms. Requires prompt medical review.
@@ -293,7 +268,8 @@ 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",
+        "labored breathing", "pain score increasing", "difficulty managing symptoms", "less responsive" # Added
     ]
 
     # Improvement Keywords: Indicate condition is getting better, symptoms are resolving, or goals are being met.
@@ -309,14 +285,30 @@ 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", "pain score decreasing",
+        "increased mobility", "feeling more independent" # Added
     ]
 
     # Helper to check if any keyword is found in the text
     def check_keywords(text, keywords):
         # Create a regex pattern for whole words, handling potential special characters in keywords
+        # Ensure keywords match whole words or are at word boundaries
         pattern = r'\b(?:' + '|'.join(re.escape(kw) for kw in keywords) + r')\b'
-        return re.search(pattern, text) is not None
+        # Also check for phrases that might not be whole words at the start/end, but contain spaces
+        # e.g., "severe chest pain" might be part of "patient reports severe chest pain"
+        # A simple join with | might miss this if not careful about word boundaries.
+        # Let's rely on the \b boundaries which should work for multi-word phrases too if surrounded by non-word chars or boundaries.
+        # Alternative: simple `in` check might be less precise but catches more variations.
+        # Let's use the regex but ensure it's robust. Adding spaces around keywords in pattern? No, \b is better.
+        # Let's also include a fallback simple 'in' check for keywords with spaces that might be tricky.
+        for kw in keywords:
+            if re.search(r'\b' + re.escape(kw) + r'\b', text):
+                 return True
+        # Fallback check for phrases that might not strictly align with \b everywhere
+        # This is less precise, but can catch things like "patient reports severe chest pain".
+        # Let's stick to the more precise regex for now, as loose matching can lead to false positives.
+        return False
+
 
     # --- Classification Logic ---
 
@@ -324,33 +316,35 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     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
 
-    # 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).")
-        return "deteriorating"
+    # Combine feedback and *updated* plan text for final assessment
+    combined_final_text_lower = feedback_lower + " " + (updated_plan_lower if updated_plan_lower else "")
+    combined_final_text_lower = re.sub(r'\s+', ' ', combined_final_text_lower).strip() # Clean up spaces
 
-     # 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).")
-        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)
+    # Check the final combined text (feedback + updated plan) for emergency keywords.
+    # This ensures if the AI generates text indicating emergency, it's caught.
+    is_emergency = check_keywords(combined_final_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).")
+    if is_emergency:
+        logger.info("Status determined: EMERGENCY (keyword found in feedback/final plan).")
         return "emergency"
 
+    # 2. Check for DETERIORATING status (Second Priority)
+    # Check the final combined text for deteriorating keywords (only if not emergency)
+    is_deteriorating = check_keywords(combined_final_text_lower, deteriorating_keywords)
+    if is_deteriorating:
+        # Add a check to see if improving keywords are also present - prioritize improving if both are there?
+        # Or assume deteriorating overrides improving? Let's assume deteriorating is higher priority.
+        logger.info("Status determined: DETERIORATING (keyword found in feedback/final plan).")
+        return "deteriorating"
+
+    # 3. Check for IMPROVING status (Third Priority)
+    # Check the final combined text for improving keywords (only if not emergency or deteriorating)
+    is_improving = check_keywords(combined_final_text_lower, improvement_keywords)
+    if is_improving:
+        logger.info("Status determined: IMPROVING (keyword found in feedback/final plan).")
+        return "improving"
 
     # 4. Default to STABLE if no specific status keywords are found
     logger.info("Status determined: STABLE (no specific status keywords found).")
@@ -490,18 +484,26 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
             continue
 
         # 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
-        if header_match:
-            # Remove trailing colon or period for cleaner heading
+        # Look for lines starting with one or more uppercase words followed by a colon or period,
+        # or lines that are entirely uppercase words (might be headers without colon).
+        # Pattern: ^ Start of line, ([A-Z][A-Za-z\s]*): Captures words/spaces starting with Capital.
+        # [:. ]? Optional colon/period/space. ($|\n) Followed by end of line or newline (accounts for empty lines after header).
+        # Added check for lines that are ALL CAPS and maybe don't have a colon/period.
+        header_match = re.match(r'^([A-Z][A-Za-z\s]*)\s*[:.]?$', stripped_line) # Looks for headers ending in optional colon/period/space
+        all_caps_match = re.match(r'^[A-Z\s]+$', stripped_line) # Looks for lines that are all caps
+
+        if header_match or (all_caps_match and len(stripped_line.split()) > 1): # Consider all-caps lines with >1 word headers
+            # Clean up header text - remove trailing colon/period/whitespace
             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
+            if header_text: # Only add if header text isn't empty after cleaning
+                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()
+             bullet_text = re.sub(r'^[-*•][ \t]*', '', line).strip() # Use original line to preserve indentation? No, strip is better.
              if bullet_text:
+                 # Replace newline with <br/> for ReportLab within bullet text
                  formatted_bullet_text = bullet_text.replace('\n', '<br/>')
                  story.append(Paragraph(f"• {formatted_bullet_text}", bullet_style))
              else:
@@ -510,7 +512,8 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         else:
             # Handle regular paragraph text
             normal_line_content = line.strip().replace('\n', '<br/>')
-            story.append(Paragraph(normal_line_content, normal_style))
+            if normal_line_content: # Only add if not empty after cleaning
+                story.append(Paragraph(normal_line_content, normal_style))
 
 
     story.append(Spacer(1, 20))
@@ -564,20 +567,38 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         # Replace common list bullet formats with WhatsApp bullet
         formatted_plan = formatted_plan.replace('- ', '• ').replace('* ', '• ')
 
-        # Attempt to bold section headers - look for lines ending with a colon or period, possibly followed by whitespace
+        # Attempt to bold section headers - look for lines ending with a colon or period, potentially followed by whitespace
+        # Use the same pattern as in PDF generation for consistency
         formatted_plan_lines = []
-        for line in formatted_plan.split('\n'):
+        lines = formatted_plan.split('\n')
+        for i, line in enumerate(lines):
              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
+             if not stripped_line:
+                 formatted_plan_lines.append("") # Keep empty lines for spacing
+                 continue
+
+             # Check for lines that look like headers
+             header_match = re.match(r'^([A-Z][A-Za-z\s]*)\s*[:.]?$', stripped_line)
+             all_caps_match = re.match(r'^[A-Z\s]+$', stripped_line)
+
+             if header_match or (all_caps_match and len(stripped_line.split()) > 1):
+                  # Clean up header text - remove trailing colon/period/whitespace
                   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(line)
+                  if header_text:
+                    formatted_plan_lines.append(f"*{header_text.upper()}:*") # Bold and capitalize for clarity
+                  else:
+                     formatted_plan_lines.append(line) # Add original line if cleaning results in empty
+             # Check for bullet points
+             elif stripped_line.startswith('•'):
+                 # Ensure consistent bullet point and formatting
+                 # If the AI uses "-", replace it earlier. Here, just format the text after "•"
+                 bullet_content = re.sub(r'^•[ \t]*', '', line).strip() # Get text after bullet
+                 formatted_plan_lines.append(f"• {bullet_content}") # Add WhatsApp bullet
              else:
-                  formatted_plan_lines.append(line)
+                  # Handle regular paragraph text
+                  formatted_plan_lines.append(line) # Add as is
+
+
         formatted_plan = '\n'.join(formatted_plan_lines)
 
 
@@ -589,10 +610,16 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         # Add feedback if available
         feedback_text = patient_info.get('feedback')
         if feedback_text and feedback_text.strip(): # Check if feedback is not empty
+             # Simple formatting for feedback in WhatsApp
              message += f"*Latest Feedback:*\n{feedback_text.strip()}\n\n"
 
         message += f"*Care Plan Details:*\n{formatted_plan}"
 
+        # Basic check for message length (Twilio has limits, WhatsApp is large but not infinite)
+        if len(message) > 4000: # Arbitrary limit, adjust as needed
+             logger.warning(f"WhatsApp message for ID {patient_info.get('id')} is very long ({len(message)} chars). May be truncated or fail.")
+             # Consider truncating or sending in multiple parts if needed for production
+
         logger.info(f"Attempting to send WhatsApp message to {TWILIO_TO}...")
         message_sent = twilio_client.messages.create(
             from_=TWILIO_FROM,
@@ -621,25 +648,30 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
 
 @app.route('/')
 def index():
-    role = session.get('role', 'patient')
+    # Default role if not set
+    if 'role' not in session:
+        session['role'] = 'patient'
+        logger.info("Session role not set, defaulting to 'patient'.")
+
+    role = session.get('role')
+
     # If doctor role is in session but user visits '/', redirect to doctor dashboard
     if role == 'doctor':
+        logger.info("Role is 'doctor', redirecting to doctor dashboard.")
         return redirect(url_for('doctor_dashboard'))
-    # Otherwise, render patient index
+
+    logger.info("Rendering patient index page.")
     return render_template('index.html')
 
 
 @app.route('/switch_role', methods=['POST'])
 def switch_role():
-    role = request.form.get('role')
+    data = request.get_json()
+    role = data.get('role')
     if role in ['patient', 'doctor']:
         session['role'] = role
         logger.info(f"Role switched to: {role}")
-        # Redirect to the appropriate page after switching
-        if role == 'doctor':
-             return redirect(url_for('doctor_dashboard'))
-        else:
-             return redirect(url_for('index')) # Redirect to patient home
+        return jsonify({'success': True, 'role': role})
     logger.warning(f"Invalid role switch attempted: {role}")
     return jsonify({'success': False, 'error': 'Invalid role'}), 400
 
@@ -649,7 +681,8 @@ def doctor_dashboard():
     # Ensure user is marked as doctor in session when accessing this page directly
     if session.get('role') != 'doctor':
          session['role'] = 'doctor'
-         logger.info("Accessed doctor dashboard, setting role to doctor.")
+         logger.info("Accessed doctor dashboard directly, setting role to doctor.")
+    logger.info("Rendering doctor dashboard page.")
     return render_template('doctor_dashboard.html')
 
 
@@ -681,7 +714,6 @@ def submit_feedback():
              age = None # Store as None if not provided
 
         care_plan_text = "" # This will store the extracted text from PDF
-        care_plan_format = None # This will store the detected format
 
         if 'care_plan_pdf' in request.files:
             pdf_file = request.files['care_plan_pdf']
@@ -694,25 +726,35 @@ def submit_feedback():
                 logger.info(f"Processing uploaded PDF: {pdf_file.filename}")
                 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:
-                     care_plan_format = None
-                     logger.warning(f"PDF text extraction failed or empty: {care_plan_text}")
-                else:
-                    care_plan_format = extract_care_plan_format(care_plan_text)
-                    logger.info(f"Extracted text length: {len(care_plan_text)}. Format found: {care_plan_format is not None}")
+                # If extraction resulted in an error message, the variable will contain it.
+                # This error message will be passed to the AI as "Previous Care Plan Details".
+                logger.info(f"Extracted text length: {len(care_plan_text)}. Begins with: {care_plan_text[:100]}...")
             else:
                  logger.info("No PDF file uploaded or file is empty.")
 
-        # 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
+        # Determine the initial status based on feedback and original plan text
+        # Pass "" for updated_plan initially
         initial_status = determine_patient_status(care_plan_text, "", feedback)
         logger.info(f"Initial status determined based on feedback/original plan: {initial_status}")
 
-
         generated_plan_text = "" # This will store the AI-generated or fallback plan
         final_status_to_save = initial_status # Start with initial status
 
+        # --- Define the NEW, FIXED Care Plan Structure for the AI Output ---
+        # Removed 'Emergency Contacts' and 'Red Flags' sections, added 'PHYSICAL ACTIVITY AND EXERCISE'
+        required_care_plan_structure = """
+PATIENT INFORMATION:
+ASSESSMENT:
+DAILY CARE PLAN:
+Morning:
+Afternoon:
+Night:
+MEDICATIONS:
+DIET AND HYDRATION:
+PHYSICAL ACTIVITY AND EXERCISE:
+SYMPTOM MANAGEMENT:
+"""
+
         # 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':
@@ -725,82 +767,67 @@ def submit_feedback():
                 f"- Gender: {gender}\n\n"
                 "ASSESSMENT:\n"
                 f"- Emergency symptoms reported: {feedback}. Immediate medical attention required.\n\n"
-                "EMERGENCY ACTION PLAN:\n"
-                "- *Call emergency services immediately* at your local emergency number (e.g., 104/108/109/112).\n"
-                "- Do not delay seeking medical help. If possible, have someone stay with the patient.\n"
-                "- If conscious, help the patient into a comfortable position (e.g., upright for breathing difficulties, on back with legs elevated for shock).\n"
-                "- Do not give food or drink until evaluated by medical professionals.\n"
-                "- Prepare relevant medical history, medication list, and previous care plan if available for emergency responders.\n"
-                "- Follow *all* instructions from emergency responders.\n\n"
-                 "RED FLAGS / WHEN TO SEEK HELP:\n"
-                 "- *Any* worsening of reported emergency symptoms requires urgent re-evaluation by medical professionals.\n"
-                 "- Do not attempt to manage severe symptoms at home once emergency signs are present.\n\n"
-                "FOLLOW-UP:\n"
-                "- Immediate hospitalization or urgent medical evaluation is necessary.\n"
-                "- 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"
+                "DAILY CARE PLAN:\n" # Using the new structure headings
+                "Morning:\n"
+                "- Seek immediate medical evaluation.\n"
+                "Afternoon:\n"
+                "- Follow instructions from emergency services.\n"
+                "Night:\n"
+                "- Remain under medical supervision if advised.\n\n"
+                "MEDICATIONS:\n"
+                "- Follow *only* instructions from emergency medical personnel regarding medications.\n\n"
+                "DIET AND HYDRATION:\n"
+                "- Do not consume food or drink unless advised by medical professionals.\n\n"
+                "PHYSICAL ACTIVITY AND EXERCISE:\n"
+                "- Rest completely and avoid any physical activity until evaluated by medical professionals.\n\n"
+                "SYMPTOM MANAGEMENT:\n"
+                "- Focus on seeking professional help. Do not attempt home management of emergency symptoms.\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.
 
-
         elif ai_enabled: # AI is enabled and initial status is not emergency
-            # Define or get the format template
-            if not care_plan_format or not care_plan_format.strip():
-                logger.info("Using default care plan format as extraction failed or returned empty.")
-                care_plan_format = """
-PATIENT INFORMATION:
-- Name: [Patient Name]
-- Age: [Age]
-- Gender: [Gender] (no other parameter other than these three should be there , not even contact number i want only three Name)
-ASSESSMENT:
-- [Summary of patient's current condition based on feedback and previous plan]
-DAILY CARE PLAN:
-Morning:
-- [Morning activities/medications/checks]
-Afternoon:
-- [Afternoon activities/medications/checks]
-Night:
-- [Night activities/medications/sleep instructions/checks]
-MEDICATIONS:
-- [List of medications, dosage, frequency, and time, including PRN (as needed) instructions] {hey please give it by general sense dont response like i am not physician etc , give , if you dont know still appropriate medicates pelase give)}
-- DIET AND HYDRATION 
-- Physical activity and exercise
-SYMPTOM MANAGEMENT:
-- [Short instructions for managing specific symptoms (e.g., pain, nausea, shortness of breath), non-pharmacological interventions]
-                """ # Enhanced default format
+            logger.info("AI is enabled and status is not emergency. Generating plan via AI.")
 
+            # --- MODIFIED AND OPTIMIZED AI PROMPT ---
             prompt = f"""
-You are a helpful and highly structured AI assistant generating updated patient care plans.
-Your task is to create a NEW, comprehensive, and well-structured daily care plan based on the provided patient's personal information, their current symptoms/feedback, and their previous care plan (if available).
-Patient Information:
+You are an expert AI assistant specialized in generating concise, structured patient care plans.
+
+Based on the following Patient Information, Patient Feedback, and Previous Care Plan (if available), generate a NEW care plan.
+
+--- Patient Information ---
 Name: {name}
 Age: {age if age is not None else 'N/A'}
 Gender: {gender}
-Patient Feedback/Symptoms Update:
+
+--- Patient Feedback/Symptoms Update ---
 {feedback}
-Previous Care Plan Details (if available):
+
+--- 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."}
-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.
-3. Prioritize addressing the issues raised in the patient feedback.
-4. Be specific, actionable, and realistic in your recommendations (e.g., specify *what* activities, *when* to take medications and *what" medications and diet to follow).
-5. Ensure the language is clear, empathetic, and easy for a patient or caregiver to understand. Avoid overly technical jargon where possible.
-7. Do NOT include any introductory phrases (like "Here is the updated plan:", "Based on your feedback...") or concluding sentences outside the plan structure. Provide ONLY the structured content that fits within the template.
-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. also give specific medications rexomemndations based on patient symptoms (ex : paracetamol for fever etc)
-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. ensure plan does not exist whatsapp message character limit
-12. kindly, do not produce emergency contact section drop it okay,also in any section dont give like not provided, not known,need to be added like stufff, cosnider youself super intellgient and real physician
-Care Plan Format Template (hey only give in text format do not use tbales okay ,a lso ensure that plan is short and no section great than 4 sentences okay):
-{care_plan_format}
-also ensure that do not give the follwong section :
-Emergency Contacts:
-Primary Caregiver: (Not provided)
-Doctor's Name: (Not provided)
-Hospital Contact: (Not provided) (it is useless abd vague okay and also in any section do not say like doctor or caretaker will provide)
+
+--- Instructions for Generating the New Care Plan ---
+1. Generate the care plan using ONLY the exact section headings and sub-sections listed in the "Required Care Plan Structure" below. Maintain the order.
+2. Fill in the details for each section based on the provided information. Prioritize addressing the latest feedback while incorporating relevant, SAFE, and appropriate details from the previous plan.
+3. Be specific, actionable, and tailored to the patient's situation as described.
+4. Keep the content concise. Aim for a few sentences or bullet points per sub-section (e.g., Morning, Afternoon, Night) and per main section (e.g., ASSESSMENT, MEDICATIONS, DIET, EXERCISE, SYMPTOM MANAGEMENT). Do NOT exceed 4 sentences/points per section/sub-section if possible, but prioritize clarity and necessary instructions.
+5. Regarding MEDICATIONS:
+    - If the previous plan listed specific prescribed medications, include them with dosage and timing if possible.
+    - If specific medications are not available in the previous plan, list the *types* of medications commonly used for the patient's condition (if implied by the feedback/previous plan, e.g., "Blood pressure medication", "Pain relief").
+    - You MAY mention common, over-the-counter examples for specific symptoms if the feedback implies them (e.g., "Paracetamol for fever or mild pain"), but *always* emphasize consulting a doctor for specific prescriptions and dosage. Avoid recommending prescription drugs you are not explicitly told about.
+    - *Crucially, do NOT make up prescription drug names or dosages.*
+    - *Crucially, do NOT use phrases like "Medications to be determined by physician", "Doctor will provide", "Not provided", "(Unknown)", etc.* List what is known or infer likely categories.
+6. For PHYSICAL ACTIVITY AND EXERCISE, provide concrete examples or recommendations suitable for someone with the patient's condition and current status (e.g., "Gentle walking 15 mins daily", "Light stretching exercises", "Avoid strenuous activity"). Tailor this to the patient's feedback (e.g., if deteriorating, recommend rest).
+7. Do NOT include sections like "Red Flags", "Emergency Contacts", "Contact Number", "Doctor's Name", "Hospital Contact", or "Primary Caregiver".
+8. Do NOT use any vague placeholders like "(To be added)", "(Not provided)", or "(Unknown)" anywhere in the plan. If information is truly unavailable and you cannot infer a reasonable default (like suggesting a type of medication), omit the specific detail rather than using a placeholder.
+9. Do NOT include any introductory phrases (e.g., "Here is the plan", "Based on your feedback") or concluding remarks outside the plan structure. Provide ONLY the structured content.
+10. Ensure the plan's tone and content are appropriate for the patient's determined status (Deteriorating, Improving, Stable). For deteriorating status, emphasize caution and monitoring. For improving, suggest gradual progression if appropriate.
+11. Respond ONLY with the text that follows the "Required Care Plan Structure".
+
+--- Required Care Plan Structure (Use ONLY these exact sections and sub-sections in this order) ---
+{required_care_plan_structure}
 """
+            # --- END OF MODIFIED AI PROMPT ---
+
             logger.info("Sending prompt to AI model...")
 
             try:
@@ -809,7 +836,7 @@ Hospital Contact: (Not provided) (it is useless abd vague okay and also in any s
                 generated_plan_text = response.text.strip()
 
                 # Remove markdown code block formatting if present
-                if generated_plan_text.startswith('```') and generated_plan_text.endswith('```'):
+                if generated_plan_text.startswith('```'):
                     # Find the first newline after ``` to potentially strip language name
                     first_newline_after_code = generated_plan_text.find('\n')
                     if first_newline_after_code != -1:
@@ -834,6 +861,7 @@ Hospital Contact: (Not provided) (it is useless abd vague okay and also in any s
                 # 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.
+                # Pass original_plan_text again for context if needed by the status function, but updated_plan_text is key here.
                 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}")
 
@@ -872,6 +900,7 @@ Hospital Contact: (Not provided) (it is useless abd vague okay and also in any s
 
 
         # Create and store patient record in the database
+        # Ensure original_plan is stored even if it contains error messages from PDF extraction
         new_patient = Patient(
             name=name,
             age=age,
@@ -890,14 +919,14 @@ Hospital Contact: (Not provided) (it is useless abd vague okay and also in any s
 
         # 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
+        # and to include feedback in the PDF. PDF generator reads updated_plan from the object.
         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
+        # Note: We pass the patient object directly to the WhatsApp function.
         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}")
 
@@ -910,7 +939,8 @@ Hospital Contact: (Not provided) (it is useless abd vague okay and also in any s
             'status': new_patient.status, # Return the final determined status
             'whatsapp_sent': whatsapp_sent,
             'whatsapp_message': whatsapp_message,
-            'ai_error': not ai_enabled or (ai_error_message is not None) # Indicate if AI was not enabled or failed
+            'ai_error': not ai_enabled or (ai_error_message is not None), # Indicate if AI was not enabled or failed
+            'ai_error_message': ai_error_message # Include the specific error message if applicable
         })
 
     except Exception as e:
@@ -1013,6 +1043,7 @@ def download_pdf(patient_id):
             return "Patient data not found.", 404
 
         # Pass the full patient dict to PDF generator for feedback inclusion
+        # PDF generator reads patient.updated_plan and patient.status
         pdf_buffer = generate_care_plan_pdf(
             patient.to_dict(),
             patient.updated_plan,
@@ -1039,9 +1070,6 @@ def download_pdf(patient_id):
 @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
@@ -1109,13 +1137,15 @@ def delete_patient(patient_id):
 if __name__ == '__main__':
     # Create database tables if they don't exist within the application context
     with app.app_context():
-        # Check if tables exist before creating to avoid errors on subsequent runs
-        inspector = db.inspect(db.engine)
-        if not inspector.has_table("patient"): # Check for at least one model's table
-             logger.info("Database tables not found, creating.")
-             db.create_all()
-        else:
-             logger.info("Database tables already exist.")
+        # Use the flag to avoid re-creating tables on every `run` if hot-reloading
+        if not getattr(app, '_tables_created', False):
+             inspector = db.inspect(db.engine)
+             if not inspector.has_table("patient"): # Check for at least one model's table
+                  logger.info("Database tables not found, creating.")
+                  db.create_all()
+             else:
+                  logger.info("Database tables already exist.")
+             app._tables_created = True # Set flag after creation/check
 
     # Use a more robust development server like Waitress or Gunicorn in production
     # For development, debug=True is fine