Update app.py

app.py

@@ -17,506 +17,656 @@ from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, Tabl
 
 app = Flask(__name__)
 
-app.secret_key = '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c'
+# Use a strong, unique secret key
+app.secret_key = os.getenv('SECRET_KEY', '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c') # CHANGE THIS IN PRODUCTION
+
 upload_base = os.getenv('UPLOAD_DIR', './uploads')
-upload_folder = os.path.join(upload_base, '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)
 
 # Twilio Configuration
-ACCOUNT_SID = 'AC490e071f8d01bf0df2f03d086c788d87'
-AUTH_TOKEN = '224b23b950ad5a4052aba15893fdf083'
-TWILIO_FROM = 'whatsapp:+14155238886'
-TWILIO_TO = 'whatsapp:+917559355282'  # Hardcoded number as requested
+# 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_TO = os.getenv('TWILIO_TO_NUMBER', 'whatsapp:+917559355282') # Hardcoded number as requested
 
 # Initialize Twilio client
-twilio_client = Client(ACCOUNT_SID, AUTH_TOKEN)
+try:
+    twilio_client = Client(ACCOUNT_SID, AUTH_TOKEN)
+    print("Twilio client initialized successfully.")
+except Exception as e:
+    print(f"Error initializing Twilio client: {e}")
+    twilio_client = None # Handle cases where Twilio initialization fails
 
 # Gemini API Configuration
-genai.configure(api_key="AIzaSyD54ejbjVIVa-F3aD_Urnp8m1EFLUGR__I")
+# 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
+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": 1,
-    "top_p": 0.95,
-    "top_k": 40,
-    "max_output_tokens": 8192,
+    "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
 }
 
-model = genai.GenerativeModel(
-    model_name="gemini-2.0-flash",
-    generation_config=generation_config,
-)
+# 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:
+    try:
+        model = genai.GenerativeModel(
+            model_name="gemini-1.5-flash-latest", # Recommended model alias
+            generation_config=generation_config,
+        )
+        # Test model generation
+        # model.generate_content("Hello")
+        print(f"Using Gemini model: {model.model_name}")
+    except Exception as e:
+        print(f"Error initializing Gemini model: {e}")
+        model = None # Handle cases where model initialization fails
 
-# Patient database (in-memory for demo, use a real database in production)
-patients_db = {}
 
+# Patient database (in-memory for demo - WILL BE RESET ON SERVER RESTART)
+# For persistence, replace this with a database (SQLite, PostgreSQL, etc.)
+patients_db = {}
 
 def extract_text_from_pdf(pdf_file):
     """Extract text from uploaded PDF file"""
     try:
+        # Ensure file pointer is at the beginning
+        pdf_file.seek(0)
         pdf_reader = PyPDF2.PdfReader(pdf_file)
         text = ""
         for page in pdf_reader.pages:
-            text += page.extract_text()
+            page_text = page.extract_text()
+            if page_text:
+                text += page_text + "\n" # Add newline between pages
         return text.strip()
     except Exception as e:
         print(f"Error extracting PDF text: {e}")
         return ""
 
-
 def extract_care_plan_format(pdf_text):
-    """Extract the care plan format from PDF text"""
-    try:
-        # Find sections and their content in the PDF using regex
-        sections = re.findall(
-            r'([A-Z][A-Z\s]+)[:|\n]((?:(?!\n[A-Z][A-Z\s]+[:|\n]).)*)',
-            pdf_text,
-            re.DOTALL
-        )
-
-        if sections:
-            format_template = ""
-            for section, content in sections:
-                format_template += f"{section.strip()}:\n"
-                # Extract bullet points if they exist and remove any asterisks
-                bullets = re.findall(r'[-•*]\s*(.*?)(?=[-•*]|\n|$)', content)
-                if bullets:
-                    for bullet in bullets:
-                        format_template += f"- {bullet.strip()}\n"
-                format_template += "\n"
-            return format_template
-        return None
-    except Exception as e:
-        print(f"Error extracting format: {e}")
+    """Extract a general format template from PDF text by identifying common section headers."""
+    if not pdf_text:
         return None
 
+    # 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 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
+
+    format_template = ""
+    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):
     """Determine patient status based on care plan comparison and feedback"""
-    # Keywords indicating condition worsening
+
+    feedback_lower = feedback.lower()
+    original_plan_lower = original_plan.lower() if original_plan else ""
+    updated_plan_lower = updated_plan.lower()
+
+    # Comprehensive keywords indicating condition worsening or emergency
     emergency_keywords = [
-        "severe chest pain", "heart attack", "shortness of breath",
-        "dizziness", "loss of consciousness", "extreme pain",
+        "severe chest pain", "heart attack", "sudden shortness of breath",
+        "difficulty breathing", "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"
+        "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", "not improving", "deteriorating",
         "elevated", "higher", "more frequent", "concerning", "monitor closely",
         "decline", "decreased function", "less able", "more difficult", "worse",
         "getting worse", "aggravated", "intensified", "escalating", "degrading",
-        "falling", "weakening", "relapse", "recurrence", "regressing", "not responding",
+        "weakening", "relapse", "recurrence", "regressing", "not responding",
         "increased symptoms", "more severe", "progressing", "progressive", "complicated",
-        "concerning development", "adverse change", "unstable", "needs attention"
+        "adverse change", "unstable", "needs attention", "spike in", "significant increase",
+        "new symptoms", "trouble with", "reduced appetite", "difficulty sleeping"
     ]
-    
+
     improvement_keywords = [
         "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"
+        "effective treatment", "successful treatment", "managed well", "under control",
+        "symptoms decreased", "feeling stronger", "better sleep", "increased appetite"
     ]
-    
-    original_plan_lower = original_plan.lower() if original_plan else ""
-    updated_plan_lower = updated_plan.lower()
-    feedback_lower = feedback.lower()
-    
-    # Check for emergency keywords first - higher priority in feedback
+
+    # 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):
         return "emergency"
-    
-    # Check for emergency keywords in updated plan
+    # 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):
         return "emergency"
-    
+
     # Check for deteriorating keywords
     if any(keyword in feedback_lower for keyword in deteriorating_keywords):
         return "deteriorating"
-    
-    # Further check for deteriorating indicators in updated plan
+    # Check updated plan for deteriorating indicators
     if any(keyword in updated_plan_lower for keyword in deteriorating_keywords):
         return "deteriorating"
-    
+
     # Check for improvement keywords
     if any(keyword in feedback_lower for keyword in improvement_keywords):
         return "improving"
-    
-    # Further check for improvement indicators in updated plan
+    # Check updated plan for improvement indicators
     if any(keyword in updated_plan_lower for keyword in improvement_keywords):
         return "improving"
-    
-    # Default to stable if no clear indicators
+
+    # 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"
 
 
 def generate_care_plan_pdf(patient_info, care_plan_text, status):
     """Generate a PDF of the care plan with improved styling"""
     buffer = io.BytesIO()
-    
+
     # Create a PDF document
-    doc = SimpleDocTemplate(buffer, pagesize=letter)
+    doc = SimpleDocTemplate(buffer, pagesize=letter,
+                            leftMargin=72, rightMargin=72,
+                            topMargin=72, bottomMargin=72) # Add margins
+
     styles = getSampleStyleSheet()
-    
+
     # Create custom styles
     title_style = ParagraphStyle(
         'Title',
         parent=styles['Heading1'],
-        fontSize=20,
+        fontSize=22, # Slightly larger title
         alignment=1,  # Center alignment
-        spaceAfter=20,
-        textColor=colors.navy
+        spaceAfter=25, # More space after title
+        textColor=colors.HexColor("#4e73df") # Primary color
     )
-    
+
     heading_style = ParagraphStyle(
         'Heading',
         parent=styles['Heading2'],
-        fontSize=14,
-        spaceAfter=10,
-        spaceBefore=15,
-        textColor=colors.darkblue
+        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
     )
-    
+
     normal_style = ParagraphStyle(
         'Normal',
         parent=styles['Normal'],
         fontSize=11,
-        spaceAfter=5,
-        leading=14
+        spaceAfter=6, # More space after paragraphs
+        leading=14,
+        textColor=colors.HexColor("#5a5c69") # Dark color
     )
-    
+
     bullet_style = ParagraphStyle(
         'Bullet',
         parent=styles['Normal'],
         fontSize=11,
         spaceAfter=3,
         leftIndent=20,
-        leading=14
+        leading=14,
+        bulletIndent=10, # Space between bullet and text
+        textColor=colors.HexColor("#5a5c69") # Dark color
     )
-    
+
     # Status color mapping
     status_colors = {
-        'emergency': colors.red,
-        'deteriorating': colors.orange,
-        'improving': colors.green,
-        'stable': colors.blue
+        'emergency': colors.HexColor("#e74a3b"), # Danger color
+        'deteriorating': colors.HexColor("#f6c23e"), # Warning color
+        'improving': colors.HexColor("#1cc88a"), # Success color
+        'stable': colors.HexColor("#36b9cc") # Info color
     }
-    
-    status_style = ParagraphStyle(
-        'Status',
-        parent=styles['Heading2'],
-        fontSize=14,
-        spaceBefore=10,
-        spaceAfter=10,
-        textColor=status_colors.get(status, colors.black)
-    )
-    
+
+    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'),
+    }
+
+
     # Build the document content
     story = []
-    
+
     # Title
     story.append(Paragraph("Patient Care Plan", title_style))
-    story.append(Spacer(1, 10))
-    
+
     # Status indicator
-    status_text = {
+    status_map_text = {
         'emergency': "EMERGENCY - IMMEDIATE ACTION REQUIRED",
         'deteriorating': "HIGH RISK - Condition Deteriorating",
         'improving': "LOW RISK - Condition Improving",
-        'stable': "STABLE - Maintain Current Care"
+        'stable': "STABLE - Maintain Current Care",
+        'unknown': "Status: Unknown"
     }
-    
-    story.append(Paragraph(status_text.get(status, "Status: Unknown"), status_style))
-    story.append(Spacer(1, 15))
-    
+    current_status_text = status_map_text.get(status, 'unknown')
+    current_status_style = status_text_styles.get(status, status_text_styles['unknown'])
+
+    story.append(Paragraph(current_status_text, current_status_style))
+
+
     # Patient Information Table
     patient_data = [
-        ["Patient Name:", patient_info.get('name', 'N/A')],
-        ["Age:", patient_info.get('age', 'N/A')],
-        ["Gender:", patient_info.get('gender', 'N/A')],
-        ["Generated Date:", datetime.now().strftime("%Y-%m-%d %H:%M")]
+        [Paragraph("<b>Patient Name:</b>", normal_style), Paragraph(patient_info.get('name', 'N/A'), normal_style)],
+        [Paragraph("<b>Age:</b>", normal_style), Paragraph(patient_info.get('age', 'N/A'), normal_style)],
+        [Paragraph("<b>Gender:</b>", normal_style), Paragraph(patient_info.get('gender', 'N/A'), normal_style)],
+        [Paragraph("<b>Generated Date:</b>", normal_style), Paragraph(datetime.now().strftime("%Y-%m-%d %H:%M"), normal_style)]
     ]
-    
-    patient_table = Table(patient_data, colWidths=[120, 300])
+
+    patient_table = Table(patient_data, colWidths=[150, 360]) # Adjusted column widths
     patient_table.setStyle(TableStyle([
-        ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
         ('BACKGROUND', (0, 0), (0, -1), colors.lightgrey),
-        ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
-        ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+        ('TEXTCOLOR', (0, 0), (0, -1), colors.black),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('VALIGN', (0, 0), (-1, -1), 'TOP'),
+        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.grey), # Lighter grid
+        ('BOX', (0, 0), (-1, -1), 0.25, colors.grey),
         ('LEFTPADDING', (0, 0), (-1, -1), 6),
         ('RIGHTPADDING', (0, 0), (-1, -1), 6),
-        ('TOPPADDING', (0, 0), (-1, -1), 4),
-        ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+        ('TOPPADDING', (0, 0), (-1, -1), 6), # Increased padding
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 6), # Increased padding
     ]))
-    
+
     story.append(patient_table)
-    story.append(Spacer(1, 20))
-    
+    story.append(Spacer(1, 25)) # More space after table
+
     # Care Plan Content
     story.append(Paragraph("Care Plan Details:", heading_style))
     story.append(Spacer(1, 10))
-    
-    # Process care plan text by sections
-    sections = re.findall(r'([A-Z][A-Z\s]+):(.*?)(?=\n[A-Z][A-Z\s]+:|$)', care_plan_text, re.DOTALL)
-    
-    if not sections:
-        # If no sections found, add the entire text as a paragraph
-        story.append(Paragraph(care_plan_text, normal_style))
-    else:
-        for section_title, section_content in sections:
-            story.append(Paragraph(section_title + ":", heading_style))
-            
-            # Process bullet points if they exist
-            bullet_points = re.findall(r'[-•]\s*(.*?)(?=[-•]|\n|$)', section_content.strip())
-            
-            if bullet_points:
-                for point in bullet_points:
-                    if point.strip():
-                        story.append(Paragraph(f"• {point.strip()}", bullet_style))
-            else:
-                # If no bullet points, add the content as a paragraph
-                cleaned_content = section_content.strip()
-                if cleaned_content:
-                    story.append(Paragraph(cleaned_content, normal_style))
-            
-            story.append(Spacer(1, 5))
-    
+
+    # 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:
+            # 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)
+    story.append(Paragraph(f"Generated by Patient Care Management System on {datetime.now().strftime('%Y-%m-%d')}", footer_style))
+
+
     # Build the PDF
     doc.build(story)
     buffer.seek(0)
     return buffer
 
 
-def send_whatsapp_care_plan(patient_name, care_plan_text, status):
+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 initialized. Cannot send WhatsApp message.")
+        return False
+
     try:
-        # Status emoji
+        # Status emoji mapping
         status_emoji = {
             'emergency': "🚨 EMERGENCY",
             'deteriorating': "⚠️ HIGH RISK",
             'improving': "✅ IMPROVING",
             'stable': "🟦 STABLE"
         }
-        
-        # Format message for WhatsApp with improved structure
-        message = f"*Care Plan Update for {patient_name}*\n\n"
-        message += f"*Status: {status_emoji.get(status, 'Unknown')}*\n\n"
-        
-        # Extract and format sections
-        sections = re.findall(r'([A-Z][A-Z\s]+):(.*?)(?=\n[A-Z][A-Z\s]+:|$)', care_plan_text, re.DOTALL)
-        
-        if not sections:
-            # If no sections found, add the entire text
-            message += care_plan_text
-        else:
-            for section_title, section_content in sections:
-                message += f"*{section_title}:*\n"
-                
-                # Process bullet points if they exist
-                bullet_points = re.findall(r'[-•]\s*(.*?)(?=[-•]|\n|$)', section_content.strip())
-                
-                if bullet_points:
-                    for point in bullet_points:
-                        if point.strip():
-                            message += f"• {point.strip()}\n"
-                else:
-                    # If no bullet points, add the content as a paragraph
-                    cleaned_content = section_content.strip()
-                    if cleaned_content:
-                        message += f"{cleaned_content}\n"
-                
-                message += "\n"
-        
+
+        # Format message for WhatsApp including patient details and the full plan text
+        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"
+        message += f"*Care Plan Details:*\n{care_plan_text.strip()}" # Include the full plan text
+
         # Send WhatsApp message using hardcoded number
-        twilio_client.messages.create(
+        message = twilio_client.messages.create(
             from_=TWILIO_FROM,
             body=message,
             to=TWILIO_TO
         )
+        print(f"WhatsApp message sent, SID: {message.sid}")
         return True
     except Exception as e:
         print(f"Error sending WhatsApp message: {e}")
+        # Twilio error handling can be more specific (e.g., check e.status)
         return False
 
 
 @app.route('/')
 def index():
+    # Determine current role from session or default to patient
+    role = session.get('role', 'patient')
+    if role == 'doctor':
+        # If role is doctor, redirect to doctor dashboard
+        return redirect(url_for('doctor_dashboard'))
+    # Otherwise, render the patient index page
     return render_template('index.html')
 
 
 @app.route('/switch_role', methods=['POST'])
 def switch_role():
     role = request.form.get('role')
-    session['role'] = role
-    return jsonify({'success': True, 'role': role})
+    if role in ['patient', 'doctor']:
+        session['role'] = role
+        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 will be loaded via AJAX by the JavaScript
     return render_template('doctor_dashboard.html')
 
 
+# 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(patient_id):
-    patient = patients_db.get(patient_id)
-    if not patient:
-        return redirect('/doctor_dashboard')
-    return render_template('doctor_dashboard.html', selected_patient=patient)
+     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:
+        return jsonify({'success': False, 'error': 'AI model not initialized. Please check API key.'}), 500
+
     try:
-        # Get patient information
-        name = request.form.get('name', '')
-        age = request.form.get('age', '')
-        gender = request.form.get('gender', '')
+        # Get patient information from form
+        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
-        
+
+        # Handle PDF file upload
         if 'care_plan_pdf' in request.files:
             pdf_file = request.files['care_plan_pdf']
-            if pdf_file.filename != '':
+            if pdf_file and pdf_file.filename != '':
+                # Read the PDF content from the file stream
                 care_plan_text = extract_text_from_pdf(pdf_file)
-                care_plan_format = extract_care_plan_format(care_plan_text)
-        
+                if 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 no format is found in the PDF, use a default format
-        if not care_plan_format:
+        if not care_plan_format or not care_plan_format.strip():
+            print("Using default care plan format.")
             care_plan_format = """
+PATIENT INFORMATION:
+- Name: [Patient Name]
+- Age: [Age]
+- Gender: [Gender]
+
 ASSESSMENT:
-- [Assessment details]
+- [Summary of patient's current condition based on feedback and previous plan]
+
 DAILY CARE PLAN:
 Morning:
-- [Morning activities]
+- [Morning activities/medications]
 Afternoon:
-- [Afternoon activities]
+- [Afternoon activities/medications]
 Evening:
-- [Evening activities]
+- [Evening activities/medications]
+Night:
+- [Night activities/medications/sleep instructions]
+
 MEDICATIONS:
-- [Medication details]
+- [List of medications, dosage, frequency, and time]
+
+DIET AND HYDRATION:
+- [Dietary recommendations and hydration goals]
+
+PHYSICAL ACTIVITY/EXERCISE:
+- [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 medical attention (Emergency)]
+- [Instructions on symptoms requiring contact with doctor/clinic (Urgent but not Emergency)]
+
 ADDITIONAL RECOMMENDATIONS:
-- [Recommendations]
+- [Other relevant advice, e.g., rest, monitoring, specific precautions]
+
 FOLLOW-UP:
-- [Follow-up details]
+- [Details about next appointment or when to contact healthcare provider]
             """
-        
-        # Define emergency keywords to check for severe symptoms
-        emergency_keywords = [
-            # Cardiovascular
+        else:
+            print("Using extracted care plan format.")
+
+        # Check for emergency symptoms FIRST in feedback
+        emergency_keywords_check = [
             "severe chest pain", "heart attack", "shortness of breath",
             "dizziness", "loss of consciousness", "extreme pain",
-            
-            # Neurological
             "sudden weakness", "confusion", "slurred speech", "severe headache",
-            
-            # Respiratory
-            "difficulty breathing", "severe shortness of breath", "wheezing", "respiratory distress",
-            
-            # Gastrointestinal
+            "difficulty breathing", "severe shortness of breath", "wheezing",
             "severe abdominal pain", "persistent vomiting", "uncontrolled bleeding",
-            
-            # Others
-            "severe allergic reaction", "anaphylaxis"
+            "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 = any(keyword in feedback_lower for keyword in emergency_keywords)
-        
-        if is_emergency:
-            # If emergency symptoms are detected, instruct immediate emergency response
-            emergency_message = (
+        is_emergency_feedback = any(keyword in feedback_lower for keyword in emergency_keywords_check)
+
+        generated_plan_text = ""
+        status = 'stable' # Default status
+
+        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"
+                f"- Name: {name}\n"
+                f"- Age: {age}\n"
+                f"- Gender: {gender}\n\n"
                 "ASSESSMENT:\n"
-                "- Emergency symptoms detected. 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.\n"
+                "- Call emergency services immediately at 104/108/109/112 or your local emergency number.\n"
                 "- Do not delay seeking medical help.\n"
-                "- Do not eat or drink anything until evaluated by medical professionals.\n\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"
+                 "RED FLAGS / WHEN TO SEEK HELP:\n"
+                 "- *Any* worsening of reported emergency symptoms requires urgent escalation.\n\n"
                 "FOLLOW-UP:\n"
-                "- Immediate hospitalization may be required.\n"
-                "- Contact your primary physician as soon as possible.\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"
             )
-            
-            # Create a patient record with emergency status
-            patient_id = str(uuid.uuid4())
-            patients_db[patient_id] = {
-                'id': patient_id,
-                'name': name,
-                'age': age,
-                'gender': gender,
-                'feedback': feedback,
-                'original_plan': care_plan_text,
-                'updated_plan': emergency_message,
-                'status': 'emergency',
-                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            }
-            
-            # Generate PDF for emergency instructions
-            patient_info = {
-                'name': name,
-                'age': age,
-                'gender': gender
-            }
-            pdf_buffer = generate_care_plan_pdf(patient_info, emergency_message, 'emergency')
-            pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode('utf-8')
-            
-            # Send emergency WhatsApp message
-            send_whatsapp_care_plan(name, emergency_message, 'emergency')
-            
-            return jsonify({
-                'success': True,
-                'updated_plan': emergency_message,
-                'patient_id': patient_id,
-                'status': 'emergency',
-                'pdf_data': pdf_base64
-            })
-        
-        # Prepare a prompt for Gemini AI for a perfect, attractively formatted day care plan.
-        prompt = f"""
+            status = 'emergency' # Set status to emergency
+
+        else:
+            # 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.
+
 Patient Information:
 Name: {name}
 Age: {age}
 Gender: {gender}
-Patient Care Plan Update Request:
-Current Symptoms and Feedback: {feedback}
-Current Care Plan (extracted from PDF): {care_plan_text}
-Based on the patient's feedback and current care plan, please provide an updated, perfect daily care plan in the exact following format:
+
+Patient Feedback/Symptoms Update:
+{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 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}
-Please ensure the following:
-- The response is well-structured with clear section headings.
-- Use bullet points for list items.
-- Format the text attractively and professionally.
-- Be specific with recommendations based on the patient's feedback.
-- Include specific times for medications if applicable.
-- Provide clear follow-up instructions.
 """
-        # Get response from Gemini AI
-        response = model.generate_content(prompt)
-        # Remove any asterisk symbols from the response text
-        updated_plan = response.text.replace("*", "")
-        
-        # Determine patient status
-        status = determine_patient_status(care_plan_text, updated_plan, feedback)
-        
-        # Generate PDF for downloading
-        patient_info = {
-            'name': name,
-            'age': age,
-            'gender': gender
-        }
-        pdf_buffer = generate_care_plan_pdf(patient_info, updated_plan, status)
-        pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode('utf-8')
-        
-        # Create a new patient record or update existing
+            print("Sending prompt to AI model...")
+            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---")
+
+                # Determine patient status based on AI's output and feedback
+                status = determine_patient_status(care_plan_text, generated_plan_text, feedback)
+
+            except Exception as ai_error:
+                print(f"Error generating content from AI: {ai_error}")
+                return jsonify({
+                    'success': False,
+                    'error': f'Error generating care plan: {ai_error}'
+                }), 500
+
+        # --- Actions after plan generation (Emergency or AI) ---
+
+        # Store patient record (in-memory DB)
         patient_id = str(uuid.uuid4())
         patients_db[patient_id] = {
             'id': patient_id,
@@ -524,77 +674,118 @@ Please ensure the following:
             'age': age,
             'gender': gender,
             'feedback': feedback,
-            'original_plan': care_plan_text,
-            'updated_plan': updated_plan,
+            '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")
         }
-        
+        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
+        patient_info_for_pdf = {
+            'name': name,
+            'age': age,
+            'gender': gender
+        }
+        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.")
+
         # Send care plan via WhatsApp
-        whatsapp_sent = send_whatsapp_care_plan(name, updated_plan, status)
-        
+        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}")
+
         return jsonify({
             'success': True,
-            'updated_plan': updated_plan,
+            'updated_plan': generated_plan_text, # Send back the generated text
             'pdf_data': pdf_base64,
-            'patient_id': patient_id,
+            'patient_id': patient_id, # Send the generated patient ID
             'status': status,
             'whatsapp_sent': whatsapp_sent
         })
-    
+
     except Exception as e:
-        print(f"Error: {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': 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: {patients_db.keys()}")
+
     try:
-        if patient_id not in patients_db:
-            return "Patient not found", 404
-        
-        patient = patients_db[patient_id]
-        
-        # Use the patient's stored information to generate the PDF
-        pdf_buffer = generate_care_plan_pdf({
-            'name': patient['name'],
-            'age': patient['age'],
-            'gender': patient['gender']
-        }, patient['updated_plan'], patient['status'])
-        
+        patient = patients_db.get(patient_id)
+
+        if not patient:
+            print(f"Patient ID {patient_id} not found in patients_db for download.")
+            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 = {
+            'name': patient.get('name', 'N/A'),
+            'age': patient.get('age', 'N/A'),
+            'gender': patient.get('gender', 'N/A')
+        }
+        # Use the already determined status and updated plan text
+        pdf_buffer = generate_care_plan_pdf(
+            patient_info_for_pdf,
+            patient['updated_plan'],
+            patient['status']
+        )
+
         pdf_buffer.seek(0)  # Ensure buffer is at the start
-        
+
+        # Sanitize patient name for filename
+        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(
             pdf_buffer,
             as_attachment=True,
-            download_name=f"care_plan_{patient['name'].replace(' ', '_')}.pdf",
+            download_name=download_name,
             mimetype='application/pdf'
         )
     except Exception as e:
-        print(f"PDF Download Error: {str(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
 
 
 @app.route('/get_emergency_notifications')
 def get_emergency_notifications():
     # Filter patients with emergency status
-    emergency_patients = [p for p in patients_db.values() if p['status'] == 'emergency']
-    
+    emergency_patients = [p for p in patients_db.values() if p.get('status') == 'emergency']
+
+    # Sort by timestamp, newest first
+    emergency_patients.sort(key=lambda x: datetime.strptime(x['timestamp'], "%Y-%m-%d %H:%M:%S"), reverse=True)
+
     notifications = []
     for patient in emergency_patients:
         notifications.append({
             'patient_id': patient['id'],
-            'patient_name': patient['name'],
-            'patient_age': patient['age'],
-            'patient_gender': patient['gender'],
-            'patient_feedback': patient['feedback'],
-            'timestamp': patient['timestamp'],
-            'status': patient['status']
+            'patient_name': patient.get('name', 'N/A'),
+            'patient_age': patient.get('age', 'N/A'),
+            'patient_gender': patient.get('gender', 'N/A'),
+            'patient_feedback': patient.get('feedback', 'No feedback recorded.'),
+            'timestamp': patient.get('timestamp', 'N/A'),
+            'status': patient.get('status', 'unknown')
         })
-    
+
     return jsonify({
         'success': True,
         'notifications': notifications
@@ -604,22 +795,35 @@ def get_emergency_notifications():
 @app.route('/get_patients')
 def get_patients():
     # Return all patients for the doctor dashboard
+    # 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,
-        'patients': list(patients_db.values())
+        'patients': list(sorted_patients)
     })
 
 
 @app.route('/get_patient/<patient_id>')
 def get_patient(patient_id):
-    if patient_id not in patients_db:
-        return jsonify({'success': False, 'error': 'Patient not found'})
-    
+    print(f"API request for patient 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 for API request.")
+        return jsonify({'success': False, 'error': 'Patient not found or data cleared.'}), 404
+
+    print(f"Found patient {patient_id}: {patient.get('name')}")
     return jsonify({
         'success': True,
-        'patient': patients_db[patient_id]
+        'patient': patient
     })
 
 
 if __name__ == '__main__':
-    app.run(debug=True)
+    # Use a more robust development server like Waitress or Gunicorn in production
+    app.run(debug=True, port=5000) # Explicitly set port