Update app.py

app.py

@@ -14,81 +14,74 @@ 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
-import traceback # Import traceback for better error logging
 
 app = Flask(__name__)
 
 # Use a strong, unique secret key
 app.secret_key = os.getenv('SECRET_KEY', '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c') # CHANGE THIS IN PRODUCTION
 
-# Configure upload folder (not strictly used for persistent storage in this demo)
 upload_base = os.getenv('UPLOAD_DIR', './uploads')
 upload_folder = os.path.join(upload_base, 'pdfs') # Changed folder name for clarity
 
 app.config['UPLOAD_FOLDER'] = upload_folder
-os.makedirs(upload_folder, exist_ok=True) # Ensure upload directory exists
+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') # Twilio Sandbox number example
+TWILIO_FROM = os.getenv('TWILIO_FROM_NUMBER', 'whatsapp:+14155238886')
 TWILIO_TO = os.getenv('TWILIO_TO_NUMBER', 'whatsapp:+917559355282') # Hardcoded number as requested
 
 # Initialize Twilio client
-twilio_client = None
 try:
-    if ACCOUNT_SID and AUTH_TOKEN:
-        twilio_client = Client(ACCOUNT_SID, AUTH_TOKEN)
-        # Optional: Verify account SID is valid (can raise error if not)
-        # twilio_client.api.account.fetch()
-        print("Twilio client initialized successfully.")
-    else:
-         print("TWILIO_ACCOUNT_SID or TWILIO_AUTH_TOKEN not set. WhatsApp sending disabled.")
+    twilio_client = Client(ACCOUNT_SID, AUTH_TOKEN)
+    print("Twilio client initialized successfully.")
 except Exception as e:
     print(f"Error initializing Twilio client: {e}")
-    traceback.print_exc()
-    twilio_client = None # Ensure client is None if initialization fails
-
+    twilio_client = None # Handle cases where Twilio initialization fails
 
 # 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 - Use your actual key
+GENAI_API_KEY = os.getenv('GENAI_API_KEY', "AIzaSyD54ejbjVIVa-F3aD_Urnp8m1EFLUGR__I") # CHANGE THIS KEY
+try:
+    genai.configure(api_key=GENAI_API_KEY)
+    # Simple test to check connectivity
+    list(genai.list_models())
+    print("Gemini API configured successfully.")
+except Exception as e:
+     print(f"Error configuring Gemini API: {e}")
+     genai = None # Handle cases where API configuration fails
+
+
+generation_config = {
+    "temperature": 0.8, # Slightly reduced temp for more stable output
+    "top_p": 0.9,     # Adjusted top_p
+    "top_k": 30,      # Adjusted top_k
+    "max_output_tokens": 4096, # Reduced token limit slightly if needed, or increase if plans are long
+}
+
+# Use a more capable model if available and affordable
+# "gemini-1.5-pro" or "gemini-1.5-flash" are better choices than gemini-2.0-flash if 2.0 means an older preview
+# Let's assume gemini-2.0-flash is a valid, accessible model alias
 model = None
-if GENAI_API_KEY:
+if genai:
     try:
-        genai.configure(api_key=GENAI_API_KEY)
-        # Simple test to check connectivity (optional, can slow down startup)
-        # list(genai.list_models())
-        print("Gemini API configured successfully.")
-
-        generation_config = {
-            "temperature": 0.8,
-            "top_p": 0.9,
-            "top_k": 30,
-            "max_output_tokens": 4096,
-        }
-        # Using a recommended stable model alias
         model = genai.GenerativeModel(
-            model_name="gemini-1.5-flash-latest",
+            model_name="gemini-1.5-flash-latest", # Recommended model alias
             generation_config=generation_config,
         )
-        # Optional: Test model generation (can slow down startup)
+        # Test model generation
         # model.generate_content("Hello")
         print(f"Using Gemini model: {model.model_name}")
-
     except Exception as e:
-         print(f"Error configuring or initializing Gemini API/model: {e}")
-         traceback.print_exc()
-         model = None # Ensure model is None if configuration or initialization fails
-else:
-    print("GENAI_API_KEY not set. AI generation disabled.")
+        print(f"Error initializing Gemini model: {e}")
+        model = None # Handle cases where model initialization fails
 
 
-# Patient database (in-memory for DEMO ONLY - DATA WILL BE LOST ON SERVER RESTART)
-# Replace with a database (SQLite, PostgreSQL, etc.) for production use.
+# Patient database (in-memory for demo - WILL BE RESET ON SERVER RESTART)
+# For persistence, replace this with a database (SQLite, PostgreSQL, etc.)
 patients_db = {}
-print("Patient database initialized (in-memory). Data will be lost on server restart.")
 
 def extract_text_from_pdf(pdf_file):
     """Extract text from uploaded PDF file"""
@@ -104,37 +97,38 @@ def extract_text_from_pdf(pdf_file):
         return text.strip()
     except Exception as e:
         print(f"Error extracting PDF text: {e}")
-        traceback.print_exc()
         return ""
 
 def extract_care_plan_format(pdf_text):
     """Extract a general format template from PDF text by identifying common section headers."""
     if not pdf_text:
-        print("No PDF text provided for format extraction.")
         return None
 
-    # Improved regex to find lines that look like headers
-    # Looks for lines starting with 1+ uppercase letters (possibly with spaces)
-    # followed by a colon, optionally with a dot or other punctuation, end of line
-    # Example: ASSESSMENT: or DAILY CARE PLAN: or MEDICATIONS.
-    potential_headers = re.findall(r'^[A-Z][A-Z\s]*(?:[:.]\s*)?\n?', pdf_text, re.MULTILINE)
+    # Look for lines that seem like headers (e.g., capitalized words ending with :, followed by content)
+    # This regex is an attempt to capture common patterns but might not be perfect for all PDFs.
+    # It looks for uppercase words (potentially with spaces), followed by a colon, then captures subsequent lines until another similar pattern or end.
+    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 potential_headers:
-         print("No potential headers found in PDF text.")
+    if not sections:
+        # Fallback: If strict section matching fails, try to find prominent lines as potential headers
+         potential_headers = re.findall(r'^[A-Z][A-Za-z\s,]*[.:]?$', pdf_text, re.MULTILINE)
+         if potential_headers:
+             # Just list the potential headers as a basic format guess
+             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))}")
+             return format_template if format_template.strip() else None
+         print("No sections or potential headers found.")
          return None # No recognizable format found
 
-    # Use a set to get unique headers, clean them up
-    cleaned_headers = sorted(list(set([h.strip(' :.\n') for h in potential_headers if h.strip()])))
-
-    if not cleaned_headers:
-         print("Cleaned headers list is empty.")
-         return None
-
     format_template = ""
-    for header in cleaned_headers:
-        format_template += f"{header.strip()}:\n- [Details based on feedback and previous plan]\n" # Use a placeholder bullet structure
-    print(f"Extracted format template based on headers: {cleaned_headers}")
-    return format_template.strip() if format_template.strip() else None
+    for section_title, _ in sections:
+        format_template += f"{section_title.strip()}:\n- [Details]\n" # Use a placeholder bullet structure
+    print(f"Extracted sections: {[s[0].strip() for s in sections]}")
+    return format_template if format_template.strip() else None
 
 
 def determine_patient_status(original_plan, updated_plan, feedback):
@@ -145,75 +139,69 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     updated_plan_lower = updated_plan.lower()
 
     # Comprehensive keywords indicating condition worsening or emergency
-    # Added more specific medical terms
     emergency_keywords = [
         "severe chest pain", "heart attack", "sudden shortness of breath",
-        "difficulty breathing", "severe difficulty breathing", "air hunger", "gasping", "wheezing",
-        "loss of consciousness", "syncope", "extreme pain", "unbearable pain", "10/10 pain",
-        "sudden weakness", "paralysis", "numbness", "confusion", "sudden confusion", "disorientation",
-        "slurred speech", "sudden slurred speech", "drooping face", # Stroke symptoms
-        "severe headache", "sudden severe headache", "thunderclap headache",
-        "severe abdominal pain", "acute abdomen", "persistent vomiting", "vomiting blood", "hematemesis",
-        "uncontrolled bleeding", "heavy bleeding", "hemorrhage",
-        "severe allergic reaction", "anaphylaxis", "swelling face", "swollen tongue",
-        "immediate medical attention", "emergency", "call 911", "urgent care", "hospital", "critical", "ambulance",
-        "collapsed", "unconscious", "unresponsive", "stroke", "seizure", "convulsion", "status epilepticus",
-        "not breathing", "apnea", "blue lips", "cyanosis", "blue face", "cardiac arrest", "no pulse",
-        "high fever", "fever over 104f", "signs of shock", "low blood pressure", "rapid heart rate",
-        "severe dehydration", "unable to keep fluids down", "acute change", "rapidly worsening",
-        "unstable vitals", "chest pressure", "radiating pain", "vision loss", "sudden vision change"
+        "difficulty breathing", "loss of consciousness", "extreme pain",
+        "sudden weakness", "confusion", "slurred speech", "severe headache",
+        "severe abdominal pain", "persistent vomiting", "uncontrolled bleeding",
+        "severe allergic reaction", "anaphylaxis", "immediate medical attention",
+        "emergency", "call 911", "urgent care", "hospital", "critical", "ambulance",
+        "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"
     ]
 
     deteriorating_keywords = [
-        "worsening", "increased pain", "pain getting worse", "not improving", "no improvement", "deteriorating",
-        "elevated", "higher", "levels rising", "more frequent", "happening more often", "concerning", "cause for concern",
-        "decline", "decreased function", "less able", "more difficult", "worse", "getting worse",
-        "aggravated", "intensified", "escalating", "progressing", "progressive", "regressing", "setback",
-        "not responding", "treatment ineffective", "increased symptoms", "symptoms worsening", "more severe",
-        "complicated", "adverse change", "unstable", "needs attention", "spike in", "significant increase",
-        "new symptoms", "trouble with", "difficulty with", "reduced appetite", "poor appetite",
-        "difficulty sleeping", "insomnia", "increased fatigue", "more tired", "losing weight", "significant weight loss",
-        "swelling increasing", "redness spreading", "discharge increasing", "uncontrolled", "lab values changing negatively"
+        "worsening", "increased pain", "not improving", "deteriorating",
+        "elevated", "higher", "more frequent", "concerning", "monitor closely",
+        "decline", "decreased function", "less able", "more difficult", "worse",
+        "getting worse", "aggravated", "intensified", "escalating", "degrading",
+        "weakening", "relapse", "recurrence", "regressing", "not responding",
+        "increased symptoms", "more severe", "progressing", "progressive", "complicated",
+        "adverse change", "unstable", "needs attention", "spike in", "significant increase",
+        "new symptoms", "trouble with", "reduced appetite", "difficulty sleeping"
     ]
 
     improvement_keywords = [
-        "improving", "better", "feeling better", "reduced", "lower", "less pain", "pain decreased",
-        "increased function", "easier to move", "healing", "recovery", "progress", "stable", "maintained", "consistent",
-        "well-controlled", "under control", "responsive", "responding well", "good progress", "getting better", "positive change",
-        "improved", "enhancement", "advancement", "resolving", "resolved", "clearing up", "recovering",
-        "normalized", "normal range", "responding positively", "effective treatment", "successful treatment",
-        "managed well", "symptoms decreased", "less severe symptoms", "feeling stronger", "better sleep", "increased appetite",
-        "weight stable", "swelling decreasing", "redness decreasing", "discharge decreasing", "lab values improving",
-        "more energy", "easier to breathe"
+        "improving", "better", "reduced", "lower", "less pain", "increased function",
+        "healing", "recovery", "progress", "stable", "maintained", "consistent",
+        "well-controlled", "responsive", "good progress", "getting better", "positive",
+        "improved", "enhancement", "advancement", "resolving", "resolved", "recovering",
+        "normalized", "normal range", "responding well", "responding positively",
+        "effective treatment", "successful treatment", "managed well", "under control",
+        "symptoms decreased", "feeling stronger", "better sleep", "increased appetite"
     ]
 
-    # Check for emergency keywords first (highest priority)
-    # Prioritize feedback first, then the generated plan text
+    # Check for emergency keywords first (highest priority), primarily in feedback as it's direct input
     if any(keyword in feedback_lower for keyword in emergency_keywords):
-        print("Emergency keywords found in feedback.")
         return "emergency"
+    # Then check updated plan, as AI might interpret feedback and include emergency terms
     if any(keyword in updated_plan_lower for keyword in emergency_keywords):
-        print("Emergency keywords found in updated plan.")
         return "emergency"
 
     # Check for deteriorating keywords
     if any(keyword in feedback_lower for keyword in deteriorating_keywords):
-        print("Deteriorating keywords found in feedback.")
         return "deteriorating"
+    # Check updated plan for deteriorating indicators
     if any(keyword in updated_plan_lower for keyword in deteriorating_keywords):
-        print("Deteriorating keywords found in updated plan.")
         return "deteriorating"
 
     # Check for improvement keywords
     if any(keyword in feedback_lower for keyword in improvement_keywords):
-        print("Improvement keywords found in feedback.")
         return "improving"
+    # Check updated plan for improvement indicators
     if any(keyword in updated_plan_lower for keyword in improvement_keywords):
-        print("Improvement keywords found in updated plan.")
         return "improving"
 
-    # Default to stable if no clear indicators are found
-    print("No clear status indicators found. Defaulting to stable.")
+    # Compare original vs updated plan length/content as a weak signal (optional, can be removed if unreliable)
+    # if len(updated_plan) < len(original_plan) * 0.8 and any(k in updated_plan_lower for k in improvement_keywords):
+    #     return "improving"
+    # if len(updated_plan) > len(original_plan) * 1.2 and any(k in updated_plan_lower for k in deteriorating_keywords):
+    #     return "deteriorating"
+
+
+    # Default to stable if no clear indicators of change are found
     return "stable"
 
 
@@ -235,8 +223,7 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         fontSize=22, # Slightly larger title
         alignment=1,  # Center alignment
         spaceAfter=25, # More space after title
-        textColor=colors.HexColor("#4e73df"), # Primary color
-        fontName='Helvetica-Bold'
+        textColor=colors.HexColor("#4e73df") # Primary color
     )
 
     heading_style = ParagraphStyle(
@@ -245,8 +232,7 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         fontSize=15, # Slightly larger headings
         spaceAfter=8, # Less space after heading for tighter look
         spaceBefore=18, # More space before heading
-        textColor=colors.HexColor("#1cc88a"), # Secondary color
-        fontName='Helvetica-Bold'
+        textColor=colors.HexColor("#1cc88a") # Secondary color
     )
 
     normal_style = ParagraphStyle(
@@ -255,8 +241,7 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         fontSize=11,
         spaceAfter=6, # More space after paragraphs
         leading=14,
-        textColor=colors.HexColor("#5a5c69"), # Dark color
-        fontName='Helvetica'
+        textColor=colors.HexColor("#5a5c69") # Dark color
     )
 
     bullet_style = ParagraphStyle(
@@ -267,9 +252,7 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         leftIndent=20,
         leading=14,
         bulletIndent=10, # Space between bullet and text
-        textColor=colors.HexColor("#5a5c69"), # Dark color
-        fontName='Helvetica',
-        bulletText='•' # Explicitly set bullet character
+        textColor=colors.HexColor("#5a5c69") # Dark color
     )
 
     # Status color mapping
@@ -277,8 +260,7 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         'emergency': colors.HexColor("#e74a3b"), # Danger color
         'deteriorating': colors.HexColor("#f6c23e"), # Warning color
         'improving': colors.HexColor("#1cc88a"), # Success color
-        'stable': colors.HexColor("#36b9cc"), # Info color
-        'unknown': colors.HexColor("#5a5c69") # Dark grey color
+        'stable': colors.HexColor("#36b9cc") # Info color
     }
 
     status_text_styles = {
@@ -286,7 +268,7 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
          '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=status_colors['unknown'], 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'),
     }
 
 
@@ -339,58 +321,94 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
     story.append(Paragraph("Care Plan Details:", heading_style))
     story.append(Spacer(1, 10))
 
-    # Process care plan text by lines/paragraphs
-    # Simple split by double newline to separate major blocks
-    blocks = re.split(r'\n\s*\n', care_plan_text.strip())
-
-    for block in blocks:
-        lines = block.strip().split('\n')
-        if not lines:
-            continue
-
-        first_line = lines[0].strip()
-
-        # Check if the first line looks like a section header
-        # Example: "ASSESSMENT:", "DAILY CARE PLAN:"
-        if re.match(r'^[A-Z][A-Z\s]*:?\s*$', first_line):
-             # Use heading style for the header
-             story.append(Paragraph(first_line, heading_style))
-             content_lines = lines[1:] # Rest of the lines are content
-             story.append(Spacer(1, 5)) # Small space after header
-
-             # Process content lines for bullets
-             bullet_points = re.findall(r'^\s*[-•*]\s*(.*?)$', "\n".join(content_lines), re.MULTILINE)
-
-             if bullet_points:
-                  for point in bullet_points:
-                       if point.strip():
-                           story.append(Paragraph(f"• {point.strip()}", bullet_style))
-             else:
-                 # If no bullet points found, treat as regular paragraph content
-                 content_text = "\n".join(content_lines).strip()
-                 if content_text:
-                     story.append(Paragraph(content_text, normal_style))
-
+    # Process care plan text by lines or sections for better formatting
+    lines = care_plan_text.strip().split('\n')
+    current_section = []
+    is_bullet_section = False
+
+    def add_section_to_story(section_lines, is_bullet):
+        if not section_lines:
+            return
+        text = "\n".join(section_lines).strip()
+        if not text:
+            return
+
+        # Attempt to identify potential sub-headings within content
+        sub_sections = re.split(r'\n(?=[A-Z][A-Z\s]*:)', text)
+
+        for i, sub_text in enumerate(sub_sections):
+             if i > 0: # Add space before subsequent sections
+                 story.append(Spacer(1, 8))
+
+             # Check if the sub_text starts with a potential sub-heading
+             header_match = re.match(r'([A-Z][A-Z\s]*):', sub_text)
+             if header_match:
+                 header_title = header_match.group(1).strip()
+                 content_after_header = sub_text[header_match.end():].strip()
+                 story.append(Paragraph(header_title + ":", heading_style)) # Use heading style for sub-sections too
+
+                 # Process content after the potential header
+                 content_lines = content_after_header.split('\n')
+                 sub_is_bullet = any(re.match(r'^\s*[-•*]', line) for line in content_lines)
+
+                 if sub_is_bullet:
+                      sub_bullet_points = re.findall(r'^\s*[-•*]\s*(.*?)$', content_after_header, re.MULTILINE)
+                      if sub_bullet_points:
+                           for point in sub_bullet_points:
+                               if point.strip():
+                                   story.append(Paragraph(f"• {point.strip()}", bullet_style))
+                      else: # Fallback if regex misses some bullets
+                           for line in content_lines:
+                                cleaned_line = re.sub(r'^\s*[-•*]\s*', '', line).strip()
+                                if cleaned_line:
+                                    story.append(Paragraph(f"• {cleaned_line}", bullet_style))
+
+                 else: # Not a bulleted sub-section
+                      cleaned_content = content_after_header.strip()
+                      if cleaned_content:
+                          story.append(Paragraph(cleaned_content, normal_style))
+
+             else: # If no sub-heading found at the start, treat as a single block of content
+                  if is_bullet:
+                       bullet_points = re.findall(r'^\s*[-•*]\s*(.*?)$', text, re.MULTILINE)
+                       if bullet_points:
+                            for point in bullet_points:
+                                if point.strip():
+                                    story.append(Paragraph(f"• {point.strip()}", bullet_style))
+                       else: # Fallback if regex misses some bullets
+                            for line in section_lines:
+                                cleaned_line = re.sub(r'^\s*[-•*]\s*', '', line).strip()
+                                if cleaned_line:
+                                     story.append(Paragraph(f"• {cleaned_line}", bullet_style))
+                  else:
+                       story.append(Paragraph(text, normal_style))
+
+    for line in lines:
+        stripped_line = line.strip()
+        # Check if line is a potential section header
+        header_match = re.match(r'^([A-Z][A-Z\s]*):$', stripped_line)
+
+        if header_match:
+            # Add previous section before starting a new one
+            add_section_to_story(current_section, is_bullet_section)
+            story.append(Paragraph(stripped_line, heading_style)) # Add the new header
+            current_section = [] # Reset current section content
+            is_bullet_section = False # Assume new section is not bulleted initially
+        elif stripped_line.startswith('-') or stripped_line.startswith('•') or stripped_line.startswith('*'):
+            # Line is a bullet point, add it to the current section content
+            current_section.append(line)
+            is_bullet_section = True # Mark the current section as potentially bulleted
         else:
-            # If the block doesn't start with a header, treat the whole block as a paragraph
-            content_text = "\n".join(lines).strip()
-            if content_text:
-                 # Also check if this block contains bullets, format accordingly
-                 bullet_points = re.findall(r'^\s*[-•*]\s*(.*?)$', content_text, re.MULTILINE)
-                 if bullet_points:
-                     for point in bullet_points:
-                          if point.strip():
-                               story.append(Paragraph(f"• {point.strip()}", bullet_style))
-                 else:
-                     story.append(Paragraph(content_text, normal_style))
-
-        story.append(Spacer(1, 12)) # Space between blocks
+            # Line is regular content, add it to the current section
+             current_section.append(line)
 
+    # Add the last section
+    add_section_to_story(current_section, is_bullet_section)
 
     # Add footer or timestamp if desired
     story.append(Spacer(1, 20))
-    footer_style = ParagraphStyle('Footer', parent=styles['Normal'], fontSize=9, alignment=1, textColor=colors.grey, fontName='Helvetica')
-    story.append(Paragraph(f"Generated by Patient Care Management System on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", footer_style))
+    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))
 
 
     # Build the PDF
@@ -404,9 +422,6 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
     if not twilio_client:
         print("Twilio client not initialized. Cannot send WhatsApp message.")
         return False
-    if not TWILIO_FROM or not TWILIO_TO:
-         print("TWILIO_FROM or TWILIO_TO number not set. Cannot send WhatsApp message.")
-         return False
 
     try:
         # Status emoji mapping
@@ -414,8 +429,7 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
             'emergency': "🚨 EMERGENCY",
             'deteriorating': "⚠️ HIGH RISK",
             'improving': "✅ IMPROVING",
-            'stable': "🟦 STABLE",
-            'unknown': "❓ STATUS UNKNOWN"
+            'stable': "🟦 STABLE"
         }
 
         # Format message for WhatsApp including patient details and the full plan text
@@ -423,27 +437,20 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         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"
-        message += f"*Care Plan Details:*\n\n{care_plan_text.strip()}" # Include the full plan text
+        message += f"*Status:* {status_emoji.get(status, 'Unknown')}\n\n"
+        message += f"*Care Plan Details:*\n{care_plan_text.strip()}" # Include the full plan text
 
-        # Send WhatsApp message using the configured numbers
+        # Send WhatsApp message using hardcoded number
         message = twilio_client.messages.create(
             from_=TWILIO_FROM,
             body=message,
             to=TWILIO_TO
         )
-        print(f"WhatsApp message sent successfully, SID: {message.sid}")
+        print(f"WhatsApp message sent, SID: {message.sid}")
         return True
     except Exception as e:
         print(f"Error sending WhatsApp message: {e}")
-        traceback.print_exc()
-        # Log specific Twilio error details if available
-        if hasattr(e, 'status'):
-            print(f"Twilio API Error Status: {e.status}")
-        if hasattr(e, 'code'):
-            print(f"Twilio API Error Code: {e.code}")
-        if hasattr(e, 'msg'):
-             print(f"Twilio API Error Message: {e.msg}")
+        # Twilio error handling can be more specific (e.g., check e.status)
         return False
 
 
@@ -463,50 +470,44 @@ def switch_role():
     role = request.form.get('role')
     if role in ['patient', 'doctor']:
         session['role'] = role
-        # Redirect to the appropriate page after switching role
-        if role == 'doctor':
-             return jsonify({'success': True, 'role': role, 'redirect': url_for('doctor_dashboard')})
-        else: # patient
-             return jsonify({'success': True, 'role': role, 'redirect': url_for('index')})
-
+        return jsonify({'success': True, 'role': role})
     return jsonify({'success': False, 'error': 'Invalid role'}), 400
 
 
 @app.route('/doctor_dashboard')
 def doctor_dashboard():
     # This route will render the dashboard template
-    # The patient list and details will be loaded via AJAX by the JavaScript
+    # The patient list will be loaded via AJAX by the JavaScript
     return render_template('doctor_dashboard.html')
 
 
-# This route is not strictly needed for displaying patient details anymore
-# as the doctor_dashboard.html handles it via AJAX based on URL parameter
-# Keeping it as a redirect target for potentially old links or direct access attempts
+# This route is not strictly needed anymore as patient details are loaded via AJAX on doctor_dashboard
+# Keeping it for backward compatibility or direct linking if desired, but AJAX is preferred.
 @app.route('/patient_details/<patient_id>')
-def patient_details_redirect(patient_id):
-     print(f"Redirecting to doctor_dashboard with patient ID: {patient_id}")
-     # Redirect to the main dashboard route with the patient ID as a query parameter
-     return redirect(url_for('doctor_dashboard', patient_id=patient_id))
+def patient_details(patient_id):
+     print(f"Attempting to load patient details page for ID: {patient_id}")
+     print(f"Current patients_db keys: {patients_db.keys()}")
+     patient = patients_db.get(patient_id)
+     if not patient:
+         print(f"Patient ID {patient_id} not found in patients_db.")
+         # Redirect to dashboard, perhaps with an error message
+         return redirect(url_for('doctor_dashboard', error="Patient not found"))
+     # Render the dashboard template, passing the specific patient ID
+     # The JS on doctor_dashboard.html will detect this ID in the URL and load the details
+     return render_template('doctor_dashboard.html', selected_patient_id=patient_id)
 
 
 @app.route('/submit_feedback', methods=['POST'])
 def submit_feedback():
     if not model:
-        print("AI model not initialized.")
-        return jsonify({'success': False, 'error': 'AI model not initialized. Please check API key and configuration.'}), 500
+        return jsonify({'success': False, 'error': 'AI model not initialized. Please check API key.'}), 500
 
     try:
         # Get patient information from form
-        name = request.form.get('name', 'Unnamed Patient').strip()
-        age = request.form.get('age', 'N/A').strip()
-        gender = request.form.get('gender', 'N/A').strip()
-        feedback = request.form.get('feedback', '').strip()
-
-        if not feedback:
-            return jsonify({'success': False, 'error': 'Feedback is required.'}), 400
-        if not name or not age or gender == 'N/A':
-             return jsonify({'success': False, 'error': 'Patient Name, Age, and Gender are required.'}), 400
-
+        name = request.form.get('name', 'Unnamed Patient')
+        age = request.form.get('age', 'N/A')
+        gender = request.form.get('gender', 'N/A')
+        feedback = request.form.get('feedback', '')
 
         care_plan_text = ""
         care_plan_format = None
@@ -515,18 +516,13 @@ def submit_feedback():
         if 'care_plan_pdf' in request.files:
             pdf_file = request.files['care_plan_pdf']
             if pdf_file and pdf_file.filename != '':
-                print(f"Processing uploaded PDF: {pdf_file.filename}")
+                # Read the PDF content from the file stream
                 care_plan_text = extract_text_from_pdf(pdf_file)
                 if care_plan_text:
                      care_plan_format = extract_care_plan_format(care_plan_text)
-                print(f"Extracted text length: {len(care_plan_text) if care_plan_text else 0}. Format found: {care_plan_format is not None}")
-                if not care_plan_text:
-                     print("PDF text extraction failed.")
-                     # Optionally return an error or proceed without the PDF content
-                     # For now, we'll proceed, treating it like no PDF was uploaded.
+                print(f"Extracted text length: {len(care_plan_text)}. Format found: {care_plan_format is not None}")
 
-
-        # If no format is found in the PDF, use a robust default format
+        # If no format is found in the PDF, use a default format
         if not care_plan_format or not care_plan_format.strip():
             print("Using default care plan format.")
             care_plan_format = """
@@ -549,23 +545,23 @@ Night:
 - [Night activities/medications/sleep instructions]
 
 MEDICATIONS:
-- [List of medications, dosage, frequency, and time. Be specific if possible.]
+- [List of medications, dosage, frequency, and time]
 
 DIET AND HYDRATION:
 - [Dietary recommendations and hydration goals]
 
 PHYSICAL ACTIVITY/EXERCISE:
-- [Recommended physical activities, duration, frequency, precautions]
+- [Recommended physical activities, duration, frequency]
 
 SYMPTOM MANAGEMENT:
 - [Instructions for managing specific symptoms, including what to do if they worsen]
 
 RED FLAGS / WHEN TO SEEK HELP:
-- [Clear instructions on symptoms requiring IMMEDIATE (Emergency) medical attention - CALL 911/local emergency number]
-- [Instructions on symptoms requiring URGENT contact with doctor/clinic (not Emergency)]
+- [Clear instructions on symptoms requiring immediate medical attention (Emergency)]
+- [Instructions on symptoms requiring contact with doctor/clinic (Urgent but not Emergency)]
 
 ADDITIONAL RECOMMENDATIONS:
-- [Other relevant advice, e.g., rest, monitoring, specific precautions, mental health]
+- [Other relevant advice, e.g., rest, monitoring, specific precautions]
 
 FOLLOW-UP:
 - [Details about next appointment or when to contact healthcare provider]
@@ -573,14 +569,29 @@ FOLLOW-UP:
         else:
             print("Using extracted care plan format.")
 
-        # Determine initial status based on feedback alone for immediate emergency check
-        initial_status = determine_patient_status(care_plan_text, "", feedback) # Pass "" for updated_plan for initial check
+        # Check for emergency symptoms FIRST in feedback
+        emergency_keywords_check = [
+            "severe chest pain", "heart attack", "shortness of breath",
+            "dizziness", "loss of consciousness", "extreme pain",
+            "sudden weakness", "confusion", "slurred speech", "severe headache",
+            "difficulty breathing", "severe shortness of breath", "wheezing",
+            "severe abdominal pain", "persistent vomiting", "uncontrolled bleeding",
+            "severe allergic reaction", "anaphylaxis", "immediate medical attention",
+            "emergency", "call 911", "urgent care", "hospital", "critical", "ambulance",
+            "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"
+        ]
+
+        feedback_lower = feedback.lower()
+        is_emergency_feedback = any(keyword in feedback_lower for keyword in emergency_keywords_check)
 
         generated_plan_text = ""
-        status = initial_status # Start with status based on feedback
+        status = 'stable' # Default status
 
-        if status == 'emergency':
-            print("Emergency status detected from feedback. Generating emergency instructions.")
+        if is_emergency_feedback:
+            print("Emergency keywords detected in feedback.")
             # If emergency symptoms are detected in feedback, generate emergency instructions
             generated_plan_text = (
                 "PATIENT INFORMATION:\n"
@@ -588,26 +599,25 @@ FOLLOW-UP:
                 f"- Age: {age}\n"
                 f"- Gender: {gender}\n\n"
                 "ASSESSMENT:\n"
-                f"- Emergency symptoms reported based on feedback: {feedback}. Immediate medical attention required.\n\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 (e.g., 911 in the US).\n"
-                "- Do not delay seeking medical help. This is a medical emergency.\n"
-                "- If conscious, try to remain calm and follow dispatcher instructions.\n"
-                "- If patient is unconscious or not breathing, begin CPR if trained and instructed by emergency services.\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"
-                "- Have patient's medication list and medical history ready for emergency responders.\n\n"
+                "- Follow instructions from emergency responders.\n\n"
                  "RED FLAGS / WHEN TO SEEK HELP:\n"
-                 "- *Any* worsening of reported symptoms or development of new severe symptoms requires urgent re-evaluation by emergency medical services.\n\n"
+                 "- *Any* worsening of reported emergency symptoms requires urgent escalation.\n\n"
                 "FOLLOW-UP:\n"
                 "- Immediate hospitalization or urgent medical evaluation is necessary.\n"
-                "- Inform your primary physician/specialist as soon as medically stable.\n"
-                "- Review and update this care plan *only* after the emergency situation is resolved and evaluated by medical professionals in a hospital setting.\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"
             )
-            # Status is already 'emergency'
+            status = 'emergency' # Set status to emergency
 
         else:
-            print(f"Initial status is {status}. Proceeding with AI plan generation.")
-            # Prepare a prompt for Gemini AI
+            # Prepare a prompt for Gemini AI for a perfect, attractively formatted day care plan.
+            # Include patient info directly in the prompt for context
             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.
@@ -620,41 +630,38 @@ Gender: {gender}
 Patient Feedback/Symptoms Update:
 {feedback}
 
-Previous Care Plan Details (if available, analyze this for context and structure, but provide an updated plan):
-{care_plan_text if care_plan_text else "No previous care plan provided. Generate a standard comprehensive daily plan based on patient info and feedback."}
+Previous Care Plan Details (if available):
+{care_plan_text if care_plan_text else "No previous care plan provided."}
 
 Instructions:
-1. Generate the updated care plan using a structure similar to the following format template. Adapt section titles as appropriate based on the previous plan or standard medical practice, but ensure all key areas are covered.
-2. Be specific, actionable, and medically sound in your recommendations. Avoid generic advice where possible.
-3. Ensure the language is clear and easy to understand for a patient.
-4. Include realistic times for medications if applicable.
-5. Highlight important instructions or warnings, especially regarding symptom management and when to seek help (clearly state what requires immediate emergency services vs. contacting the doctor).
-6. Do NOT include any introductory or concluding sentences outside the plan content itself. Provide ONLY the structured plan content.
-7. Ensure the generated plan incorporates information from BOTH the feedback and the previous plan.
-
-Care Plan Format Guideline (Adapt structure as needed, cover these topics):
+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.
+
+Care Plan Format Template:
 {care_plan_format}
 """
             print("Sending prompt to AI model...")
-            # print(f"Prompt:\n---\n{prompt}\n---") # Avoid printing full prompt in logs for privacy/length
+            print(f"Prompt:\n---\n{prompt}\n---")
 
             # Get response from Gemini AI
             try:
                 response = model.generate_content(prompt)
                 generated_plan_text = response.text.strip() # Get the text and strip leading/trailing whitespace
                 print(f"AI Response received. Length: {len(generated_plan_text)}")
-                # print(f"AI Response:\n---\n{generated_plan_text}\n---") # Avoid printing full response in logs
+                print(f"AI Response:\n---\n{generated_plan_text}\n---")
 
                 # Determine patient status based on AI's output and feedback
                 status = determine_patient_status(care_plan_text, generated_plan_text, feedback)
-                print(f"Determined status after AI generation: {status}")
 
             except Exception as ai_error:
                 print(f"Error generating content from AI: {ai_error}")
-                traceback.print_exc()
                 return jsonify({
                     'success': False,
-                    'error': f'Error generating care plan with AI: {ai_error}. Please check API key and model access.'
+                    'error': f'Error generating care plan: {ai_error}'
                 }), 500
 
         # --- Actions after plan generation (Emergency or AI) ---
@@ -670,9 +677,9 @@ Care Plan Format Guideline (Adapt structure as needed, cover these topics):
             'original_plan': care_plan_text, # Store original text from PDF
             'updated_plan': generated_plan_text, # Store the generated plan text
             'status': status,
-            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Consistent timestamp format
+            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         }
-        print(f"Patient {patient_id} added to in-memory DB with status: {status}. Current DB keys: {list(patients_db.keys())}")
+        print(f"Patient {patient_id} added to in-memory DB with status: {status}. Current DB keys: {patients_db.keys()}")
 
 
         # Generate PDF for downloading using the stored data
@@ -681,16 +688,11 @@ Care Plan Format Guideline (Adapt structure as needed, cover these topics):
             'age': age,
             'gender': gender
         }
-        # Use the already determined status and updated plan text
-        pdf_buffer = generate_care_plan_pdf(
-            patient_info_for_pdf,
-            generated_plan_text,
-            status
-        )
+        pdf_buffer = generate_care_plan_pdf(patient_info_for_pdf, generated_plan_text, status)
         pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode('utf-8')
-        print("PDF generated and base64 encoded for preview/download.")
+        print("PDF generated and base64 encoded.")
 
-        # Send care plan via WhatsApp (Text Only)
+        # Send care plan via WhatsApp
         patient_info_for_whatsapp = {
              'name': name,
              'age': age,
@@ -702,36 +704,34 @@ Care Plan Format Guideline (Adapt structure as needed, cover these topics):
         return jsonify({
             'success': True,
             'updated_plan': generated_plan_text, # Send back the generated text
-            'pdf_data': pdf_base64, # Send base64 PDF for preview on index.html
+            'pdf_data': pdf_base64,
             'patient_id': patient_id, # Send the generated patient ID
             'status': status,
             'whatsapp_sent': whatsapp_sent
         })
 
     except Exception as e:
-        print(f"An unexpected error occurred during submission: {str(e)}")
+        print(f"An unexpected error occurred: {str(e)}")
+        # Log the traceback for debugging
+        import traceback
         traceback.print_exc()
         return jsonify({
             'success': False,
-            'error': f'An unexpected server error occurred: {str(e)}'
+            'error': f'An unexpected error occurred: {str(e)}'
         }), 500
 
 
 @app.route('/download_pdf/<patient_id>')
 def download_pdf(patient_id):
     print(f"Download requested for patient ID: {patient_id}")
-    # print(f"Current patients_db keys: {list(patients_db.keys())}") # Log DB state (can be noisy)
+    print(f"Current patients_db keys: {patients_db.keys()}")
 
     try:
         patient = patients_db.get(patient_id)
 
         if not patient:
             print(f"Patient ID {patient_id} not found in patients_db for download.")
-            # Check if it might be an older ID lost due to server restart
-            # For this demo, we just report it's not found in the current state
-            return "Patient data not found (it may have been cleared due to server restart). Please regenerate the plan.", 404
-
-        print(f"Found patient {patient_id} for download: {patient.get('name')}")
+            return "Patient data not found (it may have been cleared). Please regenerate the plan.", 404
 
         # Use the patient's stored information to regenerate the PDF content
         patient_info_for_pdf = {
@@ -742,16 +742,15 @@ def download_pdf(patient_id):
         # Use the already determined status and updated plan text
         pdf_buffer = generate_care_plan_pdf(
             patient_info_for_pdf,
-            patient.get('updated_plan', 'No updated plan available.'),
-            patient.get('status', 'unknown')
+            patient['updated_plan'],
+            patient['status']
         )
 
         pdf_buffer.seek(0)  # Ensure buffer is at the start
 
         # Sanitize patient name for filename
-        patient_name = patient.get('name', 'patient')
-        safe_name = re.sub(r'[^a-zA-Z0-9_\-]', '', patient_name.replace(' ', '_')).lower()
-        download_name = f"care_plan_{safe_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        safe_name = re.sub(r'[^a-zA-Z0-9_\-]', '', patient.get('name', 'patient')).lower()
+        download_name = f"care_plan_{safe_name}_{datetime.now().strftime('%Y%m%d')}.pdf"
 
         print(f"Serving PDF for {patient_id} as {download_name}")
         return send_file(
@@ -762,6 +761,7 @@ def download_pdf(patient_id):
         )
     except Exception as e:
         print(f"PDF Download Error for ID {patient_id}: {str(e)}")
+        import traceback
         traceback.print_exc()
         return f"Error generating PDF: {str(e)}", 500
 
@@ -772,13 +772,7 @@ def get_emergency_notifications():
     emergency_patients = [p for p in patients_db.values() if p.get('status') == 'emergency']
 
     # Sort by timestamp, newest first
-    try:
-        emergency_patients.sort(key=lambda x: datetime.strptime(x.get('timestamp', '1900-01-01 00:00:00'), "%Y-%m-%d %H:%M:%S"), reverse=True)
-    except ValueError:
-        print("Error sorting emergency patients by timestamp. Using unsorted list.")
-        # If timestamp format is unexpected, use unsorted list or fall back to another key
-        pass
-
+    emergency_patients.sort(key=lambda x: datetime.strptime(x['timestamp'], "%Y-%m-%d %H:%M:%S"), reverse=True)
 
     notifications = []
     for patient in emergency_patients:
@@ -801,21 +795,10 @@ def get_emergency_notifications():
 @app.route('/get_patients')
 def get_patients():
     # Return all patients for the doctor dashboard
-    # Sort by status priority (Emergency first) then timestamp (newest first)
-    status_priority = { 'emergency': 0, 'deteriorating': 1, 'improving': 2, 'stable': 3, 'unknown': 4 }
-
-    try:
-        sorted_patients = sorted(patients_db.values(),
-                                 key=lambda x: (status_priority.get(x.get('status', 'unknown'), 4),
-                                                datetime.strptime(x.get('timestamp', '1900-01-01 00:00:00'), "%Y-%m-%d %H:%M:%S")),
-                                 reverse=True) # Reverse timestamp sort for newest first
-    except ValueError:
-         print("Error sorting patients by timestamp/status. Using unsorted list.")
-         sorted_patients = list(patients_db.values()) # Fallback to unsorted
-
-    # Reverse the status priority sort so 0 (Emergency) comes first
-    sorted_patients = sorted(sorted_patients, key=lambda x: status_priority.get(x.get('status', 'unknown'), 4))
-
+    # Sort by timestamp, newest first by default, or add sorting logic here
+    sorted_patients = sorted(patients_db.values(),
+                             key=lambda x: datetime.strptime(x.get('timestamp', '1900-01-01 00:00:00'), "%Y-%m-%d %H:%M:%S"),
+                             reverse=True)
 
     return jsonify({
         'success': True,
@@ -826,16 +809,15 @@ def get_patients():
 @app.route('/get_patient/<patient_id>')
 def get_patient(patient_id):
     print(f"API request for patient ID: {patient_id}")
-    # print(f"Current patients_db keys: {list(patients_db.keys())}") # Log DB state (can be noisy)
+    print(f"Current patients_db keys: {patients_db.keys()}")
 
     patient = patients_db.get(patient_id)
 
     if not patient:
         print(f"Patient ID {patient_id} not found in patients_db for API request.")
-        return jsonify({'success': False, 'error': 'Patient not found or data cleared (server restart).'}), 404
+        return jsonify({'success': False, 'error': 'Patient not found or data cleared.'}), 404
 
-    print(f"Found patient {patient_id} for API request: {patient.get('name')}")
-    # Return the full patient object
+    print(f"Found patient {patient_id}: {patient.get('name')}")
     return jsonify({
         'success': True,
         'patient': patient
@@ -844,5 +826,4 @@ def get_patient(patient_id):
 
 if __name__ == '__main__':
     # Use a more robust development server like Waitress or Gunicorn in production
-    # For development, debug=True is fine
     app.run(debug=True, port=5000) # Explicitly set port