Update app.py

app.py

@@ -15,6 +15,7 @@ from reportlab.pdfgen import canvas
 from reportlab.lib import colors
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY
 
 app = Flask(__name__, instance_path='/tmp') # Explicitly set instance_path to a writable location
 
@@ -73,9 +74,9 @@ os.makedirs(upload_folder, exist_ok=True)
 
 # Twilio Configuration
 # IMPORTANT: Use environment variables for sensitive information like SID and Auth Token
-ACCOUNT_SID = os.getenv('TWILIO_ACCOUNT_SID', 'AC490e071f8d01bf0df2f03d086c788d87')
-AUTH_TOKEN = os.getenv('TWILIO_AUTH_TOKEN', '224b23b950ad5a4052aba15893fdf083')
-TWILIO_FROM = os.getenv('TWILIO_FROM_NUMBER', 'whatsapp:+14155238886')
+ACCOUNT_SID = os.getenv('TWILIO_ACCOUNT_SID', 'AC490e071f8d01bf0df2f03d086c788d87') # Replace with your SID
+AUTH_TOKEN = os.getenv('TWILIO_AUTH_TOKEN', '224b23b950ad5a4052aba15893fdf083') # Replace with your Auth Token
+TWILIO_FROM = os.getenv('TWILIO_FROM_NUMBER', 'whatsapp:+14155238886') # Replace with your Twilio Sandbox or purchased number
 TWILIO_TO = os.getenv('TWILIO_TO_NUMBER', 'whatsapp:+917559355282') # Hardcoded number as requested
 
 # Initialize Twilio client
@@ -93,7 +94,7 @@ else:
 
 # Gemini API Configuration
 # IMPORTANT: Use environment variables for sensitive information like API keys
-GENAI_API_KEY = os.getenv('GENAI_API_KEY', "AIzaSyD54ejbjVIVa-F3aD_Urnp8m1EFLUGR__I") # CHANGE THIS KEY
+GENAI_API_KEY = os.getenv('GENAI_API_KEY', "AIzaSyD54ejbjVIVa-F3aD_Urnp8m1EFLUGR__I") # Replace with your actual API Key
 model = None
 if GENAI_API_KEY:
     try:
@@ -108,7 +109,7 @@ if GENAI_API_KEY:
         }
 
         model = genai.GenerativeModel(
-            model_name="gemini-1.5-flash-latest",
+            model_name="gemini-1.5-flash-latest", # Consider gemini-1.5-pro-latest for potentially better quality
             generation_config=generation_config,
         )
         print(f"Using Gemini model: {model.model_name}")
@@ -128,10 +129,12 @@ def extract_text_from_pdf(pdf_file):
         text = ""
         if pdf_reader.is_encrypted:
              try:
+                 # Attempt decryption with a blank password first
                  pdf_reader.decrypt('')
-             except Exception as e:
-                  print(f"PDF is encrypted and cannot be decrypted: {e}")
-                  return "[PDF Content Unavailable: File is encrypted]"
+             except Exception:
+                 # If blank password fails, the PDF is likely password protected
+                 print("PDF is encrypted and requires a password.")
+                 return "[PDF Content Unavailable: File is encrypted and requires a password]"
 
         for page in pdf_reader.pages:
             page_text = page.extract_text()
@@ -145,28 +148,38 @@ 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:
+    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:
         return None
 
-    sections = re.findall(
-        r'^([A-Z][A-Z\s]*):(?:\s*\n)?((?:(?!\n[A-Z][A-Z\s]*:).*\n?)*)',
-        pdf_text,
-        re.MULTILINE | re.DOTALL
-    )
-
-    if not sections:
-         potential_headers = re.findall(r'^[A-Z][A-Za-z\s,]*[.:]?$', pdf_text, re.MULTILINE)
-         if potential_headers:
-             format_template = "\n".join([f"{header.strip()}:" for header in set(potential_headers) if header.strip()]) + "\n"
-             print(f"Extracted potential headers (fallback): {list(set(potential_headers))}")
+    # 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.
+    # Non-capturing group `(?:...)` ensures we match the pattern but don't store the content part separately.
+    # Use word boundaries \b to avoid matching things like "MEDICATION:" within a sentence.
+    potential_headers = re.findall(r'^\b([A-Z][A-Z\s]*)\b[ \t]*:', 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.")
+         fallback_headers = re.findall(r'^[A-Z][A-Za-z\s,]*[.:]?$', pdf_text, re.MULTILINE)
+         if fallback_headers:
+             print(f"Extracted potential headers (fallback): {list(set(fallback_headers))}")
+             format_template = "\n".join([f"{header.strip()}:" for header in sorted(list(set(fallback_headers))) if header.strip()]) # Sort for consistency
              return format_template if format_template.strip() else None
+
          print("No sections or potential headers found in PDF.")
          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()])))
+
+    if not unique_headers:
+         print("Extracted headers are empty after cleaning.")
+         return None
+
     format_template = ""
-    for section_title, _ in sections:
-        format_template += f"{section_title.strip()}:\n- [Details]\n"
-    print(f"Extracted sections: {[s[0].strip() for s in sections]}")
+    for section_title in unique_headers:
+        format_template += f"{section_title.strip()}:\n- [Details]\n" # Use a simple list format placeholder
+    print(f"Extracted sections: {unique_headers}")
     return format_template if format_template.strip() else None
 
 
@@ -175,7 +188,7 @@ def determine_patient_status(original_plan, updated_plan, feedback):
 
     feedback_lower = feedback.lower()
     original_plan_lower = original_plan.lower() if original_plan else ""
-    updated_plan_lower = updated_plan.lower()
+    updated_plan_lower = updated_plan.lower() if updated_plan else "" # Ensure it's not None
 
     emergency_keywords = [
         "severe chest pain", "heart attack", "sudden shortness of breath",
@@ -187,7 +200,9 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "collapsed", "unconscious", "unresponsive", "stroke", "seizure", "convulsion",
         "suffocating", "not breathing", "blue lips", "blue face", "cardiac arrest",
         "high fever", "signs of shock", "severe dehydration", "acute change",
-        "unstable vitals", "rapidly worsening", "can't breathe", "chest tight"
+        "unstable vitals", "rapidly worsening", "can't breathe", "chest tight",
+        "severe difficulty swallowing", "new onset paralysis", "severe burns",
+        "major trauma", "poisoning", "overdose", "suicidal thoughts" # Added some more critical terms
     ]
 
     deteriorating_keywords = [
@@ -199,7 +214,9 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "increased symptoms", "more severe", "progressing", "progressive", "complicated",
         "adverse change", "unstable", "needs attention", "spike in", "significant increase",
         "new symptoms", "trouble with", "reduced appetite", "difficulty sleeping",
-        "tired all the time", "much weaker", "feeling worse"
+        "tired all the time", "much weaker", "feeling worse", "consistent high blood pressure",
+        "uncontrolled blood sugar", "increased swelling", "difficulty walking",
+        "persistent cough", "unexplained weight loss" # Added more worsening signs
     ]
 
     improvement_keywords = [
@@ -210,9 +227,12 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "normalized", "normal range", "responding well", "responding positively",
         "effective treatment", "successful treatment", "managed well", "under control",
         "symptoms decreased", "feeling stronger", "better sleep", "increased appetite",
-        "pain decreased", "more energy", "walking further"
+        "pain decreased", "more energy", "walking further", "blood pressure normal",
+        "blood sugar stable", "swelling reduced", "easier breathing", "cough improving",
+        "weight gain", "feeling like myself again" # Added more positive signs
     ]
 
+    # Check feedback first as it's the most direct update from the patient
     if any(keyword in feedback_lower for keyword in emergency_keywords):
         return "emergency"
     if any(keyword in feedback_lower for keyword in deteriorating_keywords):
@@ -220,14 +240,29 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     if any(keyword in feedback_lower for keyword in improvement_keywords):
         return "improving"
 
-    if updated_plan_lower != original_plan_lower:
+    # If feedback wasn't definitive, look at the *change* in plan
+    # Compare original plan (if available) vs updated plan keywords
+    # This part is tricky with AI generation; sometimes the plan *describes* worsening symptoms
+    # while still being a 'stable' plan on *how to manage* it.
+    # Let's prioritize keywords in the feedback. Only if feedback is neutral,
+    # or if the *updated plan itself strongly mandates* a status change (e.g., it says "Monitor closely due to worsening..."),
+    # we might infer status from the updated plan *content* keywords.
+    # However, for this version, sticking primarily to feedback-driven status is safer.
+    # The AI *should* generate content reflecting the feedback anyway.
+    # We'll keep the check on the updated plan as a secondary indicator if feedback is neutral.
+
+    if updated_plan_lower and updated_plan_lower != original_plan_lower:
          if any(keyword in updated_plan_lower for keyword in emergency_keywords):
-             return "emergency"
+             # This is less likely to be a *status* derived from the plan itself
+             # unless the plan is *instructing* emergency actions based on the feedback
+             return "emergency" # Re-confirm based on AI output if needed
          if any(keyword in updated_plan_lower for keyword in deteriorating_keywords):
-            return "deteriorating"
+            return "deteriorating" # Re-confirm based on AI output if needed
          if any(keyword in updated_plan_lower for keyword in improvement_keywords):
-             return "improving"
+             return "improving" # Re-confirm based on AI output if needed
+
 
+    # Default if no specific keywords found
     return "stable"
 
 
@@ -241,30 +276,45 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
 
     styles = getSampleStyleSheet()
 
+    # Custom Styles
     title_style = ParagraphStyle(
         'Title',
         parent=styles['Heading1'],
-        fontSize=22, alignment=1, spaceAfter=25, textColor=colors.HexColor("#4e73df")
+        fontSize=22, alignment=TA_CENTER, spaceAfter=25, textColor=colors.HexColor("#4e73df"),
+        fontName='Helvetica-Bold' # Use bold font
     )
 
     heading_style = ParagraphStyle(
         'Heading',
         parent=styles['Heading2'],
-        fontSize=15, spaceAfter=8, spaceBefore=18, textColor=colors.HexColor("#1cc88a")
+        fontSize=15, spaceAfter=8, spaceBefore=18, textColor=colors.HexColor("#1cc88a"),
+        fontName='Helvetica-Bold' # Use bold font
     )
 
     normal_style = ParagraphStyle(
         'Normal',
         parent=styles['Normal'],
-        fontSize=11, spaceAfter=6, leading=14, textColor=colors.HexColor("#5a5c69")
+        fontSize=11, spaceAfter=6, leading=14, textColor=colors.HexColor("#5a5c69"),
+        alignment=TA_JUSTIFY # Justify text
     )
 
     bullet_style = ParagraphStyle(
         'Bullet',
         parent=styles['Normal'],
-        fontSize=11, spaceAfter=3, leftIndent=20, leading=14, bulletIndent=10, textColor=colors.HexColor("#5a5c69")
+        fontSize=11, spaceAfter=3, leftIndent=20, leading=14, bulletIndent=10, textColor=colors.HexColor("#5a5c69"),
+        alignment=TA_JUSTIFY # Justify text
     )
 
+    feedback_style = ParagraphStyle(
+         'Feedback',
+         parent=normal_style,
+         spaceBefore=10, spaceAfter=10, backColor=colors.HexColor("#f8f9fc"),
+         borderWidth=0.5, borderColor=colors.HexColor("#dee2e6"), borderPadding=6,
+         borderRadius=5,
+         textColor=colors.HexColor("#212529") # Darker text for readability on light background
+    )
+
+
     status_colors = {
         'emergency': colors.HexColor("#e74a3b"),
         'deteriorating': colors.HexColor("#f6c23e"),
@@ -274,11 +324,11 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
     }
 
     status_text_styles = {
-         'emergency': ParagraphStyle('StatusEmergency', parent=styles['Heading2'], fontSize=16, spaceBefore=10, spaceAfter=15, textColor=status_colors['emergency'], alignment=1, fontName='Helvetica-Bold'),
-         'deteriorating': ParagraphStyle('StatusDeteriorating', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=status_colors['deteriorating'], alignment=1, fontName='Helvetica-Bold'),
-         'improving': ParagraphStyle('StatusImproving', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=status_colors['improving'], alignment=1, fontName='Helvetica-Bold'),
-         'stable': ParagraphStyle('StatusStable', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=status_colors['stable'], alignment=1, fontName='Helvetica-Bold'),
-         'unknown': ParagraphStyle('StatusUnknown', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=colors.black, alignment=1, fontName='Helvetica-Bold'),
+         'emergency': ParagraphStyle('StatusEmergency', parent=styles['Heading2'], fontSize=16, spaceBefore=10, spaceAfter=15, textColor=status_colors['emergency'], alignment=TA_CENTER, fontName='Helvetica-Bold'),
+         'deteriorating': ParagraphStyle('StatusDeteriorating', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=status_colors['deteriorating'], alignment=TA_CENTER, fontName='Helvetica-Bold'),
+         'improving': ParagraphStyle('StatusImproving', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=status_colors['improving'], alignment=TA_CENTER, fontName='Helvetica-Bold'),
+         'stable': ParagraphStyle('StatusStable', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=status_colors['stable'], alignment=TA_CENTER, fontName='Helvetica-Bold'),
+         'unknown': ParagraphStyle('StatusUnknown', parent=styles['Heading2'], fontSize=15, spaceBefore=10, spaceAfter=15, textColor=colors.black, alignment=TA_CENTER, fontName='Helvetica-Bold'),
     }
 
     story = []
@@ -286,10 +336,10 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
     story.append(Paragraph("Patient Care Plan", title_style))
 
     status_map_text = {
-        'emergency': "EMERGENCY - IMMEDIATE ACTION REQUIRED",
-        'deteriorating': "HIGH RISK - Condition Deteriorating",
-        'improving': "LOW RISK - Condition Improving",
-        'stable': "STABLE - Maintain Current Care",
+        'emergency': "🚨 EMERGENCY - IMMEDIATE ACTION REQUIRED 🚨",
+        'deteriorating': "⚠️ HIGH RISK - Condition Deteriorating ⚠️",
+        'improving': "✅ LOW RISK - Condition Improving ✅",
+        'stable': "🟦 STABLE - Maintain Current Care 🟦",
         'unknown': "Status: Unknown"
     }
     current_status_text = status_map_text.get(status, 'unknown')
@@ -304,11 +354,13 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         [Paragraph("<b>Generated Date:</b>", normal_style), Paragraph(datetime.now().strftime("%Y-%m-%d %H:%M"), normal_style)]
     ]
 
-    patient_table = Table(patient_data, colWidths=[150, 360])
+    # Using a Table for patient info
+    patient_table = Table(patient_data, colWidths=[doc.width/3, doc.width/3*2]) # Divide width into 1/3 and 2/3
     patient_table.setStyle(TableStyle([
         ('BACKGROUND', (0, 0), (0, -1), colors.HexColor("#f2f2f2")),
-        ('TEXTCOLOR', (0, 0), (0, -1), colors.black),
-        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+        ('ALIGN', (0, 0), (0, -1), 'LEFT'), # Left align headers
+        ('ALIGN', (1, 0), (-1, -1), 'LEFT'), # Left align details
         ('VALIGN', (0, 0), (-1, -1), 'TOP'),
         ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.HexColor("#dddddd")),
         ('BOX', (0, 0), (-1, -1), 0.25, colors.HexColor("#dddddd")),
@@ -321,31 +373,48 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
     story.append(patient_table)
     story.append(Spacer(1, 25))
 
+    # Add Feedback Section (if available)
+    if patient_info.get('feedback'):
+         story.append(Paragraph("Patient Feedback:", heading_style))
+         story.append(Spacer(1, 5))
+         # Using Paragraph with the feedback_style to format the text
+         story.append(Paragraph(patient_info['feedback'].replace('\n', '<br/>'), feedback_style)) # Replace newline with <br/> for ReportLab
+         story.append(Spacer(1, 15))
+
+
     story.append(Paragraph("Care Plan Details:", heading_style))
     story.append(Spacer(1, 10))
 
+    # Process care plan text line by line
     lines = care_plan_text.strip().split('\n')
     for line in lines:
         stripped_line = line.strip()
         if not stripped_line:
             continue
 
-        header_match = re.match(r'^([A-Z][A-Z\s]*):$', stripped_line)
+        # Check for section headers (e.g., "MEDICATIONS:", "ASSESSMENT:")
+        # Look for lines starting with one or more uppercase words followed by a colon
+        header_match = re.match(r'^([A-Z][A-Z\s]*)\b[ \t]*:', stripped_line)
         if header_match:
-            story.append(Spacer(1, 8))
-            story.append(Paragraph(stripped_line, heading_style))
+            story.append(Spacer(1, 8)) # Add space before a new section
+            story.append(Paragraph(stripped_line, 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('•'):
-             bullet_text = re.sub(r'^[-*•]\s*', '', line).strip()
+             # Remove the bullet character and any leading space/tab
+             bullet_text = re.sub(r'^[-*•][ \t]*', '', line).strip()
              if bullet_text:
-                 story.append(Paragraph(f"• {bullet_text}", bullet_style))
+                 # Use the bullet style, replace newline with <br/> for formatted text
+                 story.append(Paragraph(f"• {bullet_text.replace('\n', '<br/>')}", bullet_style))
              else:
+                 # Handle cases with just a bullet point on a line
                  story.append(Paragraph("• ", bullet_style))
         else:
-            story.append(Paragraph(line, normal_style))
+            # Handle regular paragraph text
+             story.append(Paragraph(line.strip().replace('\n', '<br/>'), normal_style)) # Use normal style, replace newline
 
     story.append(Spacer(1, 20))
-    footer_style = ParagraphStyle('Footer', parent=styles['Normal'], fontSize=9, alignment=1, textColor=colors.grey)
-    story.append(Paragraph(f"Generated by Patient Care Management System on {datetime.now().strftime('%Y-%m-%d')}", footer_style))
+    footer_style = ParagraphStyle('Footer', parent=styles['Normal'], fontSize=9, alignment=TA_CENTER, textColor=colors.grey)
+    story.append(Paragraph(f"Generated by Patient Care Management System on {datetime.now().strftime('%Y-%m-%d %H:%M')}", footer_style))
 
     try:
         doc.build(story)
@@ -354,6 +423,8 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         return buffer
     except Exception as e:
         print(f"Error building PDF: {e}")
+        import traceback
+        traceback.print_exc()
         error_buffer = io.BytesIO()
         c = canvas.Canvas(error_buffer, pagesize=letter)
         c.drawString(100, 750, "Error Generating Care Plan PDF")
@@ -367,7 +438,11 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
     """Send care plan via WhatsApp using Twilio with improved formatting"""
     if not twilio_client:
         print("Twilio client not configured. Cannot send WhatsApp message.")
-        return False
+        return False, "Twilio client not configured."
+
+    if not TWILIO_TO or not TWILIO_FROM:
+         print("Twilio TO or FROM number not set.")
+         return False, "Twilio TO or FROM number not configured."
 
     try:
         status_emoji = {
@@ -378,15 +453,34 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
             'unknown': "⚪ Status: Unknown"
         }
 
+        # Clean and format the plan text for WhatsApp
         formatted_plan = care_plan_text.strip()
+        # Replace multiple newlines with double newline for paragraphs
         formatted_plan = re.sub(r'\n{2,}', '\n\n', formatted_plan)
+        # Replace common list bullet formats with WhatsApp bullet
         formatted_plan = formatted_plan.replace('- ', '• ').replace('* ', '• ')
+        # Basic attempt to bold section headers - look for lines ending with a colon followed by a newline
+        # or a line starting with uppercase word(s) ending in a colon.
+        formatted_plan_lines = []
+        for line in formatted_plan.split('\n'):
+             stripped_line = line.strip()
+             if re.match(r'^[A-Z][A-Z\s]*\b[ \t]*:(\s|$)', stripped_line):
+                  formatted_plan_lines.append(f"*{stripped_line}*")
+             else:
+                  formatted_plan_lines.append(line)
+        formatted_plan = '\n'.join(formatted_plan_lines)
+
 
         message = f"*Care Plan Update*\n\n"
         message += f"*Patient Name:* {patient_info.get('name', 'N/A')}\n"
         message += f"*Age:* {patient_info.get('age', 'N/A')}\n"
         message += f"*Gender:* {patient_info.get('gender', 'N/A')}\n"
         message += f"*Status:* {status_emoji.get(status, 'Unknown')}\n\n"
+        # Add feedback if available
+        feedback_text = patient_info.get('feedback')
+        if feedback_text:
+             message += f"*Latest Feedback:*\n{feedback_text.strip()}\n\n"
+
         message += f"*Care Plan Details:*\n{formatted_plan}"
 
         print(f"Attempting to send WhatsApp message to {TWILIO_TO}...")
@@ -396,17 +490,19 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
             to=TWILIO_TO
         )
         print(f"WhatsApp message sent, SID: {message_sent.sid}")
-        return True
+        return True, "WhatsApp message sent successfully."
     except Exception as e:
         print(f"Error sending WhatsApp message: {e}")
-        return False
+        return False, f"Error sending WhatsApp: {e}"
 
 
 @app.route('/')
 def index():
     role = session.get('role', 'patient')
+    # If doctor role is in session but user visits '/', redirect to doctor dashboard
     if role == 'doctor':
         return redirect(url_for('doctor_dashboard'))
+    # Otherwise, render patient index
     return render_template('index.html')
 
 
@@ -415,12 +511,20 @@ def switch_role():
     role = request.form.get('role')
     if role in ['patient', 'doctor']:
         session['role'] = role
-        return jsonify({'success': True, 'role': 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': False, 'error': 'Invalid role'}), 400
 
 
 @app.route('/doctor_dashboard')
 def doctor_dashboard():
+    # Ensure user is marked as doctor in session when accessing this page directly
+    # This handles cases where someone might type the URL directly
+    if session.get('role') != 'doctor':
+         session['role'] = 'doctor'
     return render_template('doctor_dashboard.html')
 
 
@@ -433,18 +537,21 @@ def submit_feedback():
         name = request.form.get('name', 'Unnamed Patient')
         age = request.form.get('age')
         gender = request.form.get('gender', 'N/A')
-        feedback = request.form.get('feedback', '')
+        feedback = request.form.get('feedback', '').strip() # Strip whitespace
 
         if not name or not feedback:
              return jsonify({'success': False, 'error': 'Patient Name and Feedback are required.'}), 400
+
+        # Basic sanitization/validation for age
         if age:
             try:
                 age = int(age)
                 if age <= 0: raise ValueError("Age must be positive")
+                if age > 200: raise ValueError("Age seems unreasonably high") # Sanity check
             except ValueError:
                  return jsonify({'success': False, 'error': 'Invalid Age provided.'}), 400
         else:
-             age = None
+             age = None # Store as None if not provided
 
         care_plan_text = ""
         care_plan_format = None
@@ -452,16 +559,26 @@ def submit_feedback():
         if 'care_plan_pdf' in request.files:
             pdf_file = request.files['care_plan_pdf']
             if pdf_file and pdf_file.filename != '':
+                # Check file extension
+                if not pdf_file.filename.lower().endswith('.pdf'):
+                     return jsonify({'success': False, 'error': 'Invalid file type. Only PDF files are allowed.'}), 400
+
                 care_plan_text = extract_text_from_pdf(pdf_file)
-                if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text:
-                     care_plan_format = extract_care_plan_format(care_plan_text)
-                print(f"Extracted text length: {len(care_plan_text)}. Format found: {care_plan_format is not None}")
+
+                # 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
+                     print(f"PDF text extraction failed or empty: {care_plan_text}")
+                else:
+                    care_plan_format = extract_care_plan_format(care_plan_text)
+                    print(f"Extracted text length: {len(care_plan_text)}. Format found: {care_plan_format is not None}")
             else:
                  print("No PDF file uploaded or file is empty.")
 
 
+        # Define or get the format template
         if not care_plan_format or not care_plan_format.strip():
-            print("Using default care plan format.")
+            print("Using default care plan format as extraction failed or returned empty.")
             care_plan_format = """
 PATIENT INFORMATION:
 - Name: [Patient Name]
@@ -471,41 +588,43 @@ ASSESSMENT:
 - [Summary of patient's current condition based on feedback and previous plan]
 DAILY CARE PLAN:
 Morning:
-- [Morning activities/medications]
+- [Morning activities/medications/checks]
 Afternoon:
-- [Afternoon activities/medications]
+- [Afternoon activities/medications/checks]
 Evening:
-- [Evening activities/medications]
+- [Evening activities/medications/checks]
 Night:
-- [Night activities/medications/sleep instructions]
+- [Night activities/medications/sleep instructions/checks]
 MEDICATIONS:
-- [List of medications, dosage, frequency, and time]
+- [List of medications, dosage, frequency, and time, including PRN (as needed) instructions]
 DIET AND HYDRATION:
-- [Dietary recommendations and hydration goals]
+- [Specific dietary recommendations (e.g., low sodium, diabetic), hydration goals]
 PHYSICAL ACTIVITY/EXERCISE:
-- [Recommended physical activities, duration, frequency]
+- [Recommended physical activities, duration, frequency, limitations, and progression]
 SYMPTOM MANAGEMENT:
-- [Instructions for managing specific symptoms, including what to do if they worsen]
+- [Detailed instructions for managing specific symptoms (e.g., pain, nausea, shortness of breath), non-pharmacological interventions]
 RED FLAGS / WHEN TO SEEK HELP:
-- [Clear instructions on symptoms requiring immediate medical attention (Emergency)]
-- [Instructions on symptoms requiring contact with doctor/clinic (Urgent but not Emergency)]
+- [Clear, actionable instructions on symptoms requiring immediate medical attention (Emergency - call 911/local emergency, go to ER)]
+- [Instructions on symptoms requiring contact with doctor/clinic (Urgent but not Emergency - call office, visit clinic)]
 ADDITIONAL RECOMMENDATIONS:
-- [Other relevant advice, e.g., rest, monitoring, specific precautions]
+- [Other relevant advice, e.g., rest, monitoring specific vital signs, wound care instructions, mental health support, caregiver tips]
 FOLLOW-UP:
-- [Details about next appointment or when to contact healthcare provider]
-            """
-        else:
-            print("Using extracted care plan format.")
+- [Details about next scheduled appointment, or criteria for scheduling follow-up (e.g., "call if symptoms worsen significantly")]
+            """ # Enhanced default format
 
+        # Determine initial status based primarily on feedback
         initial_status = determine_patient_status(care_plan_text, "", feedback)
 
 
         generated_plan_text = ""
-        status = initial_status
+        status = initial_status # Start with feedback-determined status
 
+        # Only generate AI plan if status isn't immediate emergency based on feedback
+        # If feedback triggers "emergency", the generated_plan_text is a fixed emergency plan.
         if status == 'emergency':
             print("Emergency status detected from feedback. Generating emergency plan.")
             generated_plan_text = (
+                "🚨 *EMERGENCY - IMMEDIATE ACTION REQUIRED* 🚨\n\n"
                 "PATIENT INFORMATION:\n"
                 f"- Name: {name}\n"
                 f"- Age: {age if age is not None else 'N/A'}\n"
@@ -513,39 +632,52 @@ FOLLOW-UP:
                 "ASSESSMENT:\n"
                 f"- Emergency symptoms reported: {feedback}. Immediate medical attention required.\n\n"
                 "EMERGENCY ACTION PLAN:\n"
-                "- Call emergency services immediately at 104/108/109/112 or your local emergency number.\n"
-                "- Do not delay seeking medical help.\n"
-                "- If conscious, try to remain calm.\n"
-                "- Do not eat or drink anything until evaluated by medical professionals.\n"
-                "- Follow instructions from emergency responders.\n\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 escalation.\n\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 as soon as medically stable.\n"
-                "- Review and update care plan only after emergency situation is resolved and evaluated by medical professionals.\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"
             )
+            # For emergency, the generated plan text *is* the final plan to save/send.
+            final_plan_to_save = generated_plan_text
+            final_status_to_save = 'emergency' # Explicitly keep emergency status
 
-        else:
+        else: # Status is not emergency based on feedback, proceed with AI generation
             prompt = f"""
-You are a helpful assistant generating updated patient care plans.
-Based on the patient's personal information, their current symptoms/feedback, and their previous care plan, create a NEW, comprehensive, and well-structured daily care plan.
+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:
 Name: {name}
 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 else "No previous care plan provided."}
+{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 using the exact following format template. Fill in the details based on the patient's information, feedback, and integrate relevant elements from the previous plan if helpful.
-2. Be specific and actionable in your recommendations.
-3. Ensure the language is clear and easy to understand.
-4. Include realistic times for medications if applicable (e.g., "Take 1 tablet in the morning with food").
-5. Highlight important instructions or warnings, especially regarding symptom management and when to seek help.
-6. Do NOT include any introductory or concluding sentences outside the plan format itself (like "Here is the updated plan:" or "Let me know if you need further assistance."). Provide ONLY the structured plan content.
-7. If the previous care plan text indicates it was unreadable or had errors, acknowledge that and generate a new plan based primarily on the feedback and patient info, using the format template.
+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).
+5. Ensure the language is clear, empathetic, and easy for a patient or caregiver to understand. Avoid overly technical jargon where possible.
+6. Include clear instructions in the "RED FLAGS / WHEN TO SEEK HELP" section, distinguishing between immediate emergency (e.g., call 911/local emergency) and urgent but non-emergency situations (e.g., call doctor's office).
+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. 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.
+
 Care Plan Format Template:
 {care_plan_format}
 """
@@ -555,29 +687,41 @@ Care Plan Format Template:
                 response = model.generate_content(prompt)
                 generated_plan_text = response.text.strip()
 
+                # Remove markdown code block formatting if present
                 if generated_plan_text.startswith('```') and generated_plan_text.endswith('```'):
                     generated_plan_text = generated_plan_text[3:-3].strip()
-                    if generated_plan_text.startswith('text'):
+                    # Remove language identifier if present (e.g., 'text', 'markdown')
+                    if generated_plan_text.lower().startswith('text'):
                          generated_plan_text = generated_plan_text[4:].strip()
+                    elif generated_plan_text.lower().startswith('markdown'):
+                         generated_plan_text = generated_plan_text[8:].strip()
+
 
                 print(f"AI Response received. Length: {len(generated_plan_text)}")
 
-                status = determine_patient_status(care_plan_text, generated_plan_text, feedback)
+                # Re-evaluate status based on generated plan content in conjunction with feedback
+                # This is a secondary check. The primary status is from feedback.
+                # We only update status here if the *generated plan* explicitly uses keywords
+                # that might contradict or strongly reinforce the initial feedback-based status.
+                # However, to avoid AI hallucination changing status, let's stick to feedback-driven status for submission for now.
+                # The UI can highlight AI warnings if the plan mentions critical things the feedback didn't.
+                # For simplicity, the status saved to the DB will be the one determined *before* AI generation based on feedback.
+                final_plan_to_save = generated_plan_text
+                final_status_to_save = status # Use the status determined before AI call
 
             except Exception as ai_error:
                 print(f"Error generating content from AI: {ai_error}")
+                # 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:
-                     generated_plan_text += "Showing original plan due to AI error:\n\n" + care_plan_text
-                     status = determine_patient_status(care_plan_text, care_plan_text, feedback)
+                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:
+                     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, not just AI failure
+                     final_status_to_save = determine_patient_status(care_plan_text, care_plan_text, feedback)
                 else:
                      generated_plan_text += "No previous plan available."
-                     status = initial_status
-
-                # Even if AI fails, we still create a record with the error/fallback plan
-                # and the determined status (e.g., 'emergency' if feedback indicated).
-                # Continue to store the patient record below.
+                     final_status_to_save = status # Keep the feedback-determined status
 
+                final_plan_to_save = generated_plan_text
 
         # Create and store patient record in the database
         new_patient = Patient(
@@ -585,46 +729,39 @@ Care Plan Format Template:
             age=age,
             gender=gender,
             feedback=feedback,
-            original_plan=care_plan_text,
-            updated_plan=generated_plan_text,
-            status=status,
+            original_plan=care_plan_text, # Store extracted text, could be error message
+            updated_plan=final_plan_to_save, # Store generated/fallback plan text
+            status=final_status_to_save, # Store determined status
             timestamp=datetime.utcnow()
         )
         db.session.add(new_patient)
         db.session.commit()
         patient_id = new_patient.id
 
-        print(f"Patient {patient_id} added to DB with status: {status}.")
+        print(f"Patient {patient_id} added to DB with status: {final_status_to_save}.")
 
         # Generate PDF for downloading using the stored data
-        patient_info_for_pdf = {
-            'name': name,
-            'age': age,
-            'gender': gender
-        }
-        pdf_buffer = generate_care_plan_pdf(patient_info_for_pdf, generated_plan_text, status)
+        # 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_base64 = base64.b64encode(pdf_buffer.getvalue()).decode('utf-8')
         print("PDF generated and base64 encoded.")
 
-        # Send care plan via WhatsApp
-        patient_info_for_whatsapp = {
-             'name': name,
-             'age': age,
-             'gender': gender
-        }
-        whatsapp_sent = send_whatsapp_care_plan(patient_info_for_whatsapp, generated_plan_text, status)
-        print(f"WhatsApp message attempt sent: {whatsapp_sent}")
+        # Send care plan via WhatsApp (using the final saved data)
+        # 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)
+        print(f"WhatsApp message attempt sent: {whatsapp_sent}, message: {whatsapp_message}")
 
-        # Return success response even if AI failed, but include error message
+        # Return success response, include relevant data
         return jsonify({
             'success': True, # Indicate that patient record was created/updated
-            'updated_plan': generated_plan_text,
+            'updated_plan': new_patient.updated_plan, # Return the final saved plan
             'pdf_data': pdf_base64,
             'patient_id': patient_id,
-            'status': status,
+            'status': new_patient.status, # Return the final determined status
             'whatsapp_sent': whatsapp_sent,
-            'ai_error': not model # Indicate if AI was even attempted (model exists)
-                      or ("Error generating updated plan" in generated_plan_text) # Check if error message was inserted
+            'whatsapp_message': whatsapp_message,
+            'ai_error': (not model) or ("Error generating updated plan" in new_patient.updated_plan) # Indicate if AI failed or was skipped
         })
 
     except Exception as e:
@@ -637,6 +774,86 @@ Care Plan Format Template:
             'error': f'An unexpected server error occurred: {str(e)}'
         }), 500
 
+# --- New routes for Doctor Dashboard actions ---
+
+@app.route('/update_care_plan/<patient_id>', methods=['PUT'])
+def update_care_plan(patient_id):
+    """Endpoint for doctor to save edited care plan text."""
+    try:
+        data = request.get_json()
+        if not data or 'updated_plan' not in data:
+            return jsonify({'success': False, 'error': 'Invalid data provided.'}), 400
+
+        updated_plan_text = data['updated_plan'].strip()
+
+        patient = Patient.query.get(patient_id)
+
+        if not patient:
+            print(f"Patient ID {patient_id} not found for update.")
+            return jsonify({'success': False, 'error': 'Patient not found.'}), 404
+
+        # Optional: Re-determine status based on the manually updated plan + existing feedback/original?
+        # For simplicity, we'll keep the existing status unless explicitly changed via another mechanism.
+        # If doctor edits to add critical info, the status should ideally be manually updated too.
+        # But for this request, just saving the text is sufficient.
+        # patient.status = determine_patient_status(patient.original_plan, updated_plan_text, patient.feedback) # This would make saving potentially change status
+
+        patient.updated_plan = updated_plan_text
+        db.session.commit()
+        print(f"Updated plan saved for patient ID: {patient_id}")
+
+        return jsonify({
+            'success': True,
+            'message': 'Care plan saved successfully.',
+            'patient_id': patient_id,
+            # Optionally return the updated status if determined above
+            # 'status': patient.status
+        })
+
+    except Exception as e:
+        print(f"Error updating care plan for ID {patient_id}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        db.session.rollback()
+        return jsonify({'success': False, 'error': f'An error occurred while saving the plan: {str(e)}'}), 500
+
+
+@app.route('/send_whatsapp_doctor/<patient_id>', methods=['POST'])
+def send_whatsapp_doctor(patient_id):
+    """Endpoint for doctor to send WhatsApp message for a patient."""
+    try:
+        patient = Patient.query.get(patient_id)
+
+        if not patient:
+            print(f"Patient ID {patient_id} not found for WhatsApp send.")
+            return jsonify({'success': False, 'error': 'Patient not found.'}), 404
+
+        # Use the latest data from the database for the message
+        patient_info_for_whatsapp = patient.to_dict() # Gets name, age, gender, feedback etc.
+        care_plan_text_to_send = patient.updated_plan
+        status_to_send = patient.status
+
+        whatsapp_sent, whatsapp_message = send_whatsapp_care_plan(
+            patient_info_for_whatsapp,
+            care_plan_text_to_send,
+            status_to_send
+        )
+
+        if whatsapp_sent:
+            print(f"WhatsApp sent successfully for patient ID: {patient_id}")
+            return jsonify({'success': True, 'message': whatsapp_message})
+        else:
+            print(f"WhatsApp failed for patient ID: {patient_id} - {whatsapp_message}")
+            return jsonify({'success': False, 'error': whatsapp_message}), 500 # Use 500 for server-side error
+
+    except Exception as e:
+        print(f"Error triggering WhatsApp send for ID {patient_id}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'success': False, 'error': f'An error occurred while sending WhatsApp: {str(e)}'}), 500
+
+
+# --- Existing routes remain below ---
 
 @app.route('/download_pdf/<patient_id>')
 def download_pdf(patient_id):
@@ -649,13 +866,9 @@ def download_pdf(patient_id):
             print(f"Patient ID {patient_id} not found in database for download.")
             return "Patient data not found.", 404
 
-        patient_info_for_pdf = {
-            'name': patient.name,
-            'age': patient.age,
-            'gender': patient.gender
-        }
+        # Pass the full patient dict to PDF generator for feedback inclusion
         pdf_buffer = generate_care_plan_pdf(
-            patient_info_for_pdf,
+            patient.to_dict(),
             patient.updated_plan,
             patient.status
         )
@@ -681,9 +894,11 @@ def download_pdf(patient_id):
 
 @app.route('/get_emergency_notifications')
 def get_emergency_notifications():
+    # Only include patients whose status is 'emergency'
     emergency_patients_query = Patient.query.filter_by(status='emergency').order_by(Patient.timestamp.desc())
 
-    notifications = [p.to_dict() for p in emergency_patients_query.all()]
+    # Only return basic info needed for the alert, not full patient details
+    notifications = [{'id': p.id, 'name': p.name, 'status': p.status} for p in emergency_patients_query.all()]
 
     return jsonify({
         'success': True,
@@ -694,6 +909,7 @@ def get_emergency_notifications():
 @app.route('/get_patients')
 def get_patients():
     all_patients_query = Patient.query.order_by(Patient.timestamp.desc())
+    # Include status in the dictionary representation
     patients_list = [p.to_dict() for p in all_patients_query.all()]
     return jsonify({
         'success': True,
@@ -711,12 +927,13 @@ def get_patient(patient_id):
         return jsonify({'success': False, 'error': 'Patient not found.'}), 404
 
     print(f"Found patient {patient_id}: {patient.name}")
+    # Return the full patient data including original and updated plans
     return jsonify({
         'success': True,
         'patient': patient.to_dict()
     })
 
-# New route to handle patient deletion
+# Route to handle patient deletion
 @app.route('/delete_patient/<patient_id>', methods=['DELETE'])
 def delete_patient(patient_id):
     print(f"Delete requested for patient ID: {patient_id}")
@@ -744,7 +961,9 @@ def delete_patient(patient_id):
 
 
 if __name__ == '__main__':
+    # Create database tables if they don't exist within the application context
     with app.app_context():
         db.create_all()
     # Use a more robust development server like Waitress or Gunicorn in production
+    # For development, debug=True is fine
     app.run(debug=True)