Update app.py

app.py

@@ -1,5 +1,5 @@
 from flask import Flask, render_template, request, jsonify, session, redirect, url_for, send_file
-from flask_sqlalchemy import SQLAlchemy # Import SQLAlchemy
+from flask_sqlalchemy import SQLAlchemy
 import google.generativeai as genai
 import PyPDF2
 import os
@@ -16,13 +16,15 @@ from reportlab.lib import colors
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
 
+# Explicitly set instance_path for writable storage
 app = Flask(__name__, instance_path='/tmp')
 
 # Use a strong, unique secret key
 app.secret_key = os.getenv('SECRET_KEY', '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c') # CHANGE THIS IN PRODUCTION
 
 # Database Configuration
-# Use SQLite for simplicity
+# Use SQLite for simplicity, store in /tmp (instance_path)
+# Flask-SQLAlchemy interprets 'sqlite:///patients.db' relative to instance_path if specified
 app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///patients.db')
 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 
@@ -53,6 +55,7 @@ class Patient(db.Model):
             'original_plan': self.original_plan,
             'updated_plan': self.updated_plan,
             'status': self.status,
+            # Format timestamp as string for JSON response
             'timestamp': self.timestamp.strftime("%Y-%m-%d %H:%M:%S") if self.timestamp else None
         }
 
@@ -62,64 +65,56 @@ def create_tables():
     db.create_all()
 
 
+# Upload folder configuration (used by patient view for initial PDF processing if needed,
+# but not for long-term storage - data is in DB text fields)
 upload_base = os.getenv('UPLOAD_DIR', '/tmp/uploads')
 upload_folder = os.path.join(upload_base, 'pdfs')
-
 app.config['UPLOAD_FOLDER'] = upload_folder
-
-# Ensure the folder exists at runtime
 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_TO = os.getenv('TWILIO_TO_NUMBER', 'whatsapp:+917559355282') # Hardcoded number as requested
 
-# Initialize Twilio client
 twilio_client = None
 if ACCOUNT_SID and AUTH_TOKEN and TWILIO_FROM and TWILIO_TO:
     try:
         twilio_client = Client(ACCOUNT_SID, AUTH_TOKEN)
-        # Basic check to ensure credentials are valid (optional but good)
-        # twilio_client.api.accounts.get(ACCOUNT_SID)
         print("Twilio client initialized successfully.")
     except Exception as e:
         print(f"Error initializing Twilio client (check SID/Token/Network): {e}")
+        twilio_client = None
 else:
      print("Twilio environment variables not set. WhatsApp sending disabled.")
 
 
 # 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
 model = None
 if GENAI_API_KEY:
     try:
         genai.configure(api_key=GENAI_API_KEY)
-        # Simple test to check connectivity
-        # list(genai.list_models()) # Can take time, maybe skip in prod startup
         print("Gemini API configured successfully.")
 
         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
+            "temperature": 0.8,
+            "top_p": 0.9,
+            "top_k": 30,
+            "max_output_tokens": 4096,
         }
 
         model = genai.GenerativeModel(
-            model_name="gemini-1.5-flash-latest", # Recommended model alias
+            model_name="gemini-1.5-flash-latest",
             generation_config=generation_config,
         )
-        # Test model generation (optional)
-        # model.generate_content("Hello")
         print(f"Using Gemini model: {model.model_name}")
 
     except Exception as e:
          print(f"Error configuring Gemini API or loading model: {e}")
-         model = None # Handle cases where API configuration fails
+         model = None
 else:
     print("GENAI_API_KEY environment variable not set. AI generation disabled.")
 
@@ -127,36 +122,31 @@ else:
 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 = ""
-        # Handle potential decryption errors
         if pdf_reader.is_encrypted:
              try:
-                 pdf_reader.decrypt('') # Attempt decryption with empty password
+                 pdf_reader.decrypt('')
              except Exception as e:
                   print(f"PDF is encrypted and cannot be decrypted: {e}")
-                  return "[PDF Content Unavailable: File is encrypted]" # Return a message indicating failure
+                  return "[PDF Content Unavailable: File is encrypted]"
 
         for page in pdf_reader.pages:
             page_text = page.extract_text()
             if page_text:
-                text += page_text + "\n" # Add newline between pages
-        return text.strip() or "[No readable text found in PDF]" # Return placeholder if no text
+                text += page_text + "\n"
+        return text.strip() or "[No readable text found in PDF]"
     except Exception as e:
         print(f"Error extracting PDF text: {e}")
-        return f"[Error extracting PDF text: {e}]" # Include error in placeholder
+        return f"[Error extracting PDF text: {e}]"
 
 
 def extract_care_plan_format(pdf_text):
     """Extract a general format template from PDF text by identifying common section headers."""
     if not pdf_text or "[No readable text found" in pdf_text or "[Error extracting PDF text" in pdf_text:
-        return None # Cannot extract format from empty or error 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,
@@ -164,19 +154,17 @@ def extract_care_plan_format(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 in PDF.")
-         return None # No recognizable format found
+         return None
 
     format_template = ""
     for section_title, _ in sections:
-        format_template += f"{section_title.strip()}:\n- [Details]\n" # Use a placeholder bullet structure
+        format_template += f"{section_title.strip()}:\n- [Details]\n"
     print(f"Extracted sections: {[s[0].strip() for s in sections]}")
     return format_template if format_template.strip() else None
 
@@ -188,8 +176,6 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     original_plan_lower = original_plan.lower() if original_plan else ""
     updated_plan_lower = updated_plan.lower()
 
-    # Comprehensive keywords indicating condition worsening or emergency
-    # Prioritize feedback keywords
     emergency_keywords = [
         "severe chest pain", "heart attack", "sudden shortness of breath",
         "difficulty breathing", "loss of consciousness", "extreme pain",
@@ -226,7 +212,6 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "pain decreased", "more energy", "walking further"
     ]
 
-    # Check feedback first
     if any(keyword in feedback_lower for keyword in emergency_keywords):
         return "emergency"
     if any(keyword in feedback_lower for keyword in deteriorating_keywords):
@@ -234,7 +219,6 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     if any(keyword in feedback_lower for keyword in improvement_keywords):
         return "improving"
 
-    # Fallback: If no strong indicator in feedback, analyze the updated plan if it exists and differs
     if updated_plan_lower != original_plan_lower:
          if any(keyword in updated_plan_lower for keyword in emergency_keywords):
              return "emergency"
@@ -243,7 +227,6 @@ def determine_patient_status(original_plan, updated_plan, feedback):
          if any(keyword in updated_plan_lower for keyword in improvement_keywords):
              return "improving"
 
-    # Default to stable if no clear indicators of change are found
     return "stable"
 
 
@@ -251,58 +234,42 @@ 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,
                             leftMargin=72, rightMargin=72,
-                            topMargin=72, bottomMargin=72) # Add margins
+                            topMargin=72, bottomMargin=72)
 
     styles = getSampleStyleSheet()
 
-    # Create custom styles
     title_style = ParagraphStyle(
         'Title',
         parent=styles['Heading1'],
-        fontSize=22, # Slightly larger title
-        alignment=1,  # Center alignment
-        spaceAfter=25, # More space after title
-        textColor=colors.HexColor("#4e73df") # Primary color
+        fontSize=22, alignment=1, spaceAfter=25, textColor=colors.HexColor("#4e73df")
     )
 
     heading_style = ParagraphStyle(
         'Heading',
         parent=styles['Heading2'],
-        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
+        fontSize=15, spaceAfter=8, spaceBefore=18, textColor=colors.HexColor("#1cc88a")
     )
 
     normal_style = ParagraphStyle(
         'Normal',
         parent=styles['Normal'],
-        fontSize=11,
-        spaceAfter=6, # More space after paragraphs
-        leading=14,
-        textColor=colors.HexColor("#5a5c69") # Dark color
+        fontSize=11, spaceAfter=6, leading=14, textColor=colors.HexColor("#5a5c69")
     )
 
     bullet_style = ParagraphStyle(
         'Bullet',
         parent=styles['Normal'],
-        fontSize=11,
-        spaceAfter=3,
-        leftIndent=20,
-        leading=14,
-        bulletIndent=10, # Space between bullet and text
-        textColor=colors.HexColor("#5a5c69") # Dark color
+        fontSize=11, spaceAfter=3, leftIndent=20, leading=14, bulletIndent=10, textColor=colors.HexColor("#5a5c69")
     )
 
-    # Status color mapping
     status_colors = {
-        'emergency': colors.HexColor("#e74a3b"), # Danger color
-        'deteriorating': colors.HexColor("#f6c23e"), # Warning color
-        'improving': colors.HexColor("#1cc88a"), # Success color
-        'stable': colors.HexColor("#36b9cc") # Info color
+        'emergency': colors.HexColor("#e74a3b"),
+        'deteriorating': colors.HexColor("#f6c23e"),
+        'improving': colors.HexColor("#1cc88a"),
+        'stable': colors.HexColor("#36b9cc"),
+        'unknown': colors.black
     }
 
     status_text_styles = {
@@ -313,14 +280,10 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
          '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))
 
-    # Status indicator
     status_map_text = {
         'emergency': "EMERGENCY - IMMEDIATE ACTION REQUIRED",
         'deteriorating': "HIGH RISK - Condition Deteriorating",
@@ -333,70 +296,56 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
 
     story.append(Paragraph(current_status_text, current_status_style))
 
-
-    # Patient Information Table
     patient_data = [
         [Paragraph("<b>Patient Name:</b>", normal_style), Paragraph(patient_info.get('name', 'N/A'), normal_style)],
-        [Paragraph("<b>Age:</b>", normal_style), Paragraph(str(patient_info.get('age', 'N/A')), normal_style)], # Ensure age is string for Paragraph
+        [Paragraph("<b>Age:</b>", normal_style), Paragraph(str(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=[150, 360]) # Adjusted column widths
+    patient_table = Table(patient_data, colWidths=[150, 360])
     patient_table.setStyle(TableStyle([
-        ('BACKGROUND', (0, 0), (0, -1), colors.HexColor("#f2f2f2")), # Lighter grey
+        ('BACKGROUND', (0, 0), (0, -1), colors.HexColor("#f2f2f2")),
         ('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.HexColor("#dddddd")), # Lighter grid
+        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.HexColor("#dddddd")),
         ('BOX', (0, 0), (-1, -1), 0.25, colors.HexColor("#dddddd")),
         ('LEFTPADDING', (0, 0), (-1, -1), 6),
         ('RIGHTPADDING', (0, 0), (-1, -1), 6),
-        ('TOPPADDING', (0, 0), (-1, -1), 6), # Increased padding
-        ('BOTTOMPADDING', (0, 0), (-1, -1), 6), # Increased padding
+        ('TOPPADDING', (0, 0), (-1, -1), 6),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
     ]))
 
     story.append(patient_table)
-    story.append(Spacer(1, 25)) # More space after table
+    story.append(Spacer(1, 25))
 
-    # Care Plan Content
     story.append(Paragraph("Care Plan Details:", heading_style))
     story.append(Spacer(1, 10))
 
-    # Process care plan text by lines or sections for better formatting
-    # This logic attempts to render text, sections, and bullet points reasonably.
-    # Complex formatting in the AI output might require more sophisticated parsing.
     lines = care_plan_text.strip().split('\n')
     for line in lines:
         stripped_line = line.strip()
         if not stripped_line:
-            continue # Skip empty lines
+            continue
 
-        # Check for potential section headers (e.g., "SECTION TITLE:")
         header_match = re.match(r'^([A-Z][A-Z\s]*):$', stripped_line)
         if header_match:
-            story.append(Spacer(1, 8)) # Space before new section
+            story.append(Spacer(1, 8))
             story.append(Paragraph(stripped_line, heading_style))
-        # Check for bullet points (handles -, *, •)
         elif stripped_line.startswith('-') or stripped_line.startswith('*') or stripped_line.startswith('•'):
-             # Clean the bullet point text
-             bullet_text = re.sub(r'^[-*•]\s*', '', line).strip() # Use original line to preserve initial indentation
+             bullet_text = re.sub(r'^[-*•]\s*', '', line).strip()
              if bullet_text:
                  story.append(Paragraph(f"• {bullet_text}", bullet_style))
-             else: # Handle empty bullet points
+             else:
                  story.append(Paragraph("• ", bullet_style))
         else:
-            # Treat as normal paragraph content
-            story.append(Paragraph(line, normal_style)) # Use original line to preserve indentation/spacing within paragraphs
+            story.append(Paragraph(line, normal_style))
 
-
-    # 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
     try:
         doc.build(story)
         buffer.seek(0)
@@ -404,7 +353,6 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         return buffer
     except Exception as e:
         print(f"Error building PDF: {e}")
-        # Attempt to create a minimal error PDF
         error_buffer = io.BytesIO()
         c = canvas.Canvas(error_buffer, pagesize=letter)
         c.drawString(100, 750, "Error Generating Care Plan PDF")
@@ -421,7 +369,6 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         return False
 
     try:
-        # Status emoji mapping
         status_emoji = {
             'emergency': "🚨 EMERGENCY",
             'deteriorating': "⚠️ HIGH RISK",
@@ -430,24 +377,18 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
             'unknown': "⚪ Status: Unknown"
         }
 
-        # Basic sanitization for WhatsApp (avoid excessive newlines, etc.)
         formatted_plan = care_plan_text.strip()
-        # Replace multiple newlines with fewer for cleaner WhatsApp message
         formatted_plan = re.sub(r'\n{2,}', '\n\n', formatted_plan)
-        # Attempt to make bullet points more visible
         formatted_plan = formatted_plan.replace('- ', '• ').replace('* ', '• ')
 
-
-        # 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"*Age:* {patient_info.get('age', 'N/A')}\n" # Ensure age is string
         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{formatted_plan}" # Include the full plan text
+        message += f"*Care Plan Details:*\n{formatted_plan}"
 
         print(f"Attempting to send WhatsApp message to {TWILIO_TO}...")
-        # Send WhatsApp message using hardcoded number
         message_sent = twilio_client.messages.create(
             from_=TWILIO_FROM,
             body=message,
@@ -457,19 +398,14 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         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)
-        # Example: If the 'To' number is not registered for WhatsApp
         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')
 
 
@@ -484,8 +420,6 @@ def switch_role():
 
 @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')
 
 
@@ -495,32 +429,28 @@ def submit_feedback():
         return jsonify({'success': False, 'error': 'AI model not initialized. Please check API key or server logs.'}), 500
 
     try:
-        # Get patient information from form
         name = request.form.get('name', 'Unnamed Patient')
-        age = request.form.get('age') # Get as string initially
+        age = request.form.get('age')
         gender = request.form.get('gender', 'N/A')
         feedback = request.form.get('feedback', '')
 
-        # Validate required fields
         if not name or not feedback:
              return jsonify({'success': False, 'error': 'Patient Name and Feedback are required.'}), 400
         if age:
             try:
-                age = int(age) # Convert age to integer
+                age = int(age)
                 if age <= 0: raise ValueError("Age must be positive")
             except ValueError:
                  return jsonify({'success': False, 'error': 'Invalid Age provided.'}), 400
         else:
-             age = None # Store as None if not provided or invalid
+             age = None
 
         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 and pdf_file.filename != '':
-                # Read the PDF content from the file stream
                 care_plan_text = extract_text_from_pdf(pdf_file)
                 if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text:
                      care_plan_format = extract_care_plan_format(care_plan_text)
@@ -529,7 +459,6 @@ def submit_feedback():
                  print("No PDF file uploaded or file is empty.")
 
 
-        # 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 = """
@@ -567,16 +496,13 @@ FOLLOW-UP:
         else:
             print("Using extracted care plan format.")
 
-        # Determine status BEFORE calling AI, especially for emergency
-        initial_status = determine_patient_status(care_plan_text, "", feedback) # Compare against empty updated plan initially
-
+        initial_status = determine_patient_status(care_plan_text, "", feedback)
 
         generated_plan_text = ""
-        status = initial_status # Start with status determined from feedback
+        status = initial_status
 
         if status == 'emergency':
             print("Emergency status detected from feedback. Generating emergency plan.")
-            # If emergency symptoms are detected in feedback, generate emergency instructions
             generated_plan_text = (
                 "PATIENT INFORMATION:\n"
                 f"- Name: {name}\n"
@@ -597,11 +523,8 @@ FOLLOW-UP:
                 "- 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 remains '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.
@@ -612,7 +535,7 @@ Gender: {gender}
 Patient Feedback/Symptoms Update:
 {feedback}
 Previous Care Plan Details (if available):
-{care_plan_text if care_plan_text and "[No readable text found" not in care_plan_text else "No previous care plan provided."}
+{care_plan_text if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text 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.
@@ -625,49 +548,40 @@ Care Plan Format Template:
 {care_plan_format}
 """
             print("Sending prompt to AI model...")
-            # print(f"Prompt:\n---\n{prompt}\n---") # Avoid printing large prompts in logs
 
-            # 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
+                generated_plan_text = response.text.strip()
 
-                # Clean up common AI formatting issues (e.g., extra ```)
                 if generated_plan_text.startswith('```') and generated_plan_text.endswith('```'):
                     generated_plan_text = generated_plan_text[3:-3].strip()
-                    if generated_plan_text.startswith('text'): # Handle ```text...```
+                    if generated_plan_text.startswith('text'):
                          generated_plan_text = generated_plan_text[4:].strip()
 
-
                 print(f"AI Response received. Length: {len(generated_plan_text)}")
-                # print(f"AI Response (first 200 chars):\n---\n{generated_plan_text[:200]}\n---") # Print truncated response
-
 
-                # Re-determine patient status based on feedback AND the generated updated plan
+                # Recalculate status based on the *generated* updated plan as well as feedback
+                # Pass original plan text so determine_patient_status can compare
                 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}")
-                # Fallback: Use initial status and provide an error message in the plan
                 generated_plan_text = f"[Error generating updated plan from AI: {ai_error}]\n\n"
-                if care_plan_text and "[No readable text found" not in care_plan_text:
+                if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text:
                      generated_plan_text += "Showing original plan due to AI error:\n\n" + care_plan_text
-                     status = determine_patient_status(care_plan_text, care_plan_text, feedback) # Re-evaluate status based on original plan + feedback
+                     # If AI failed, the "updated plan" is the original one + error message.
+                     # Recalculate status based on this fallback updated plan and feedback.
+                     status = determine_patient_status(care_plan_text, generated_plan_text, feedback)
                 else:
                      generated_plan_text += "No previous plan available."
-                     status = initial_status # Keep the initial status if no original plan
-
-                return jsonify({
-                    'success': False,
-                    'error': f'Error generating care plan: {ai_error}',
-                    'fallback_plan': generated_plan_text, # Optionally send fallback plan
-                    'patient_info': {'name': name, 'age': age, 'gender': gender},
-                    'status': status,
-                    'original_plan': care_plan_text # Include original plan if any
-                }), 500 # Return 500 if AI fails, but provide some data
+                     # If no previous plan and AI failed, keep the initial status from feedback
+                     status = initial_status
 
+                # Even if AI fails, we still create a record with the error/fallback plan
+                # and the determined status (e.g., 'emergency' if feedback indicated).
+                # Continue to store the patient record below.
 
-        # --- Actions after plan generation (Emergency or AI) ---
 
         # Create and store patient record in the database
         new_patient = Patient(
@@ -675,18 +589,17 @@ Care Plan Format Template:
             age=age,
             gender=gender,
             feedback=feedback,
-            original_plan=care_plan_text, # Store original text
-            updated_plan=generated_plan_text, # Store the generated plan text
+            original_plan=care_plan_text,
+            updated_plan=generated_plan_text,
             status=status,
-            timestamp=datetime.utcnow() # Use UTC time
+            timestamp=datetime.utcnow()
         )
         db.session.add(new_patient)
         db.session.commit()
-        patient_id = new_patient.id # Get the generated ID
+        patient_id = new_patient.id
 
         print(f"Patient {patient_id} added to DB with status: {status}.")
 
-
         # Generate PDF for downloading using the stored data
         patient_info_for_pdf = {
             'name': name,
@@ -706,22 +619,22 @@ Care Plan Format Template:
         whatsapp_sent = send_whatsapp_care_plan(patient_info_for_whatsapp, generated_plan_text, status)
         print(f"WhatsApp message attempt sent: {whatsapp_sent}")
 
+        # Return success response (indicates record creation/update) even if AI failed, but include error message
         return jsonify({
             'success': True,
-            'updated_plan': generated_plan_text, # Send back the generated text
-            'pdf_data': pdf_base64, # Send base64 data for preview
-            'patient_id': patient_id, # Send the generated patient ID for download
+            'updated_plan': generated_plan_text,
+            'pdf_data': pdf_base64, # Include PDF data for patient preview
+            'patient_id': patient_id,
             'status': status,
-            'whatsapp_sent': whatsapp_sent
+            'whatsapp_sent': whatsapp_sent,
+            'ai_error': not model # Indicate if AI was configured
+                      or ("Error generating updated plan" in generated_plan_text) # Check if error message was inserted
         })
 
     except Exception as e:
-        # Catch any other unexpected errors
         print(f"An unexpected error occurred during submission: {str(e)}")
-        # Log the traceback for debugging
         import traceback
         traceback.print_exc()
-        # Rollback database session in case of error
         db.session.rollback()
         return jsonify({
             'success': False,
@@ -734,31 +647,27 @@ def download_pdf(patient_id):
     print(f"Download requested for patient ID: {patient_id}")
 
     try:
-        # Fetch patient from the database
         patient = Patient.query.get(patient_id)
 
         if not patient:
             print(f"Patient ID {patient_id} not found in database for download.")
             return "Patient data not found.", 404
 
-        # Use the patient's stored information to regenerate the PDF content
         patient_info_for_pdf = {
             'name': patient.name,
             'age': patient.age,
             'gender': patient.gender
         }
-        # Use the already determined status and updated plan text from the DB record
         pdf_buffer = generate_care_plan_pdf(
             patient_info_for_pdf,
             patient.updated_plan, # Use the stored updated plan
             patient.status # Use the stored status
         )
 
-        pdf_buffer.seek(0)  # Ensure buffer is at the start
+        pdf_buffer.seek(0)
 
-        # Sanitize patient name for filename
         safe_name = re.sub(r'[^a-zA-Z0-9_\-]', '', patient.name or 'patient').lower()
-        download_name = f"care_plan_{safe_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf" # Add timestamp to filename
+        download_name = f"care_plan_{safe_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
 
         print(f"Serving PDF for {patient_id} as {download_name}")
         return send_file(
@@ -776,7 +685,6 @@ def download_pdf(patient_id):
 
 @app.route('/get_emergency_notifications')
 def get_emergency_notifications():
-    # Filter patients with emergency status directly from the database
     emergency_patients_query = Patient.query.filter_by(status='emergency').order_by(Patient.timestamp.desc())
 
     notifications = [p.to_dict() for p in emergency_patients_query.all()]
@@ -789,17 +697,8 @@ def get_emergency_notifications():
 
 @app.route('/get_patients')
 def get_patients():
-    # Return all patients for the doctor dashboard from the database
-    # Order by timestamp, newest first
     all_patients_query = Patient.query.order_by(Patient.timestamp.desc())
-
-    # Convert SQLAlchemy objects to dictionaries
     patients_list = [p.to_dict() for p in all_patients_query.all()]
-
-    # Manual sorting by status priority for display if needed, but JS handles this
-    # Or you can add complex ordering to the query if using PostgreSQL etc.
-    # For simplicity, JS handles sorting after getting the timestamp-ordered list.
-
     return jsonify({
         'success': True,
         'patients': patients_list
@@ -809,8 +708,6 @@ def get_patients():
 @app.route('/get_patient/<patient_id>')
 def get_patient(patient_id):
     print(f"API request for patient ID: {patient_id}")
-
-    # Fetch patient from the database
     patient = Patient.query.get(patient_id)
 
     if not patient:
@@ -820,25 +717,116 @@ def get_patient(patient_id):
     print(f"Found patient {patient_id}: {patient.name}")
     return jsonify({
         'success': True,
-        'patient': patient.to_dict() # Return dictionary representation
+        'patient': patient.to_dict()
     })
 
-# Helper to serve PDF file directly (used by doctor dashboard PDF viewer)
-# Note: This route is potentially less secure than storing files on disk and serving them
-# or generating on demand. But for a demo, it works with the base64 data flow.
-# A better approach for large PDFs or production would be saving the PDF server-side
-# and serving a URL that points to the saved file, or using a dedicated PDF viewer lib.
-# For this fix, let's stick to serving the *generated* PDF data via download link,
-# and rely on the browser's embedding for the patient view preview on initial submit.
-# Doctor dashboard will just show the text content in tabs.
+@app.route('/delete_patient/<patient_id>', methods=['DELETE'])
+def delete_patient(patient_id):
+    print(f"Delete requested for patient ID: {patient_id}")
+    try:
+        patient = Patient.query.get(patient_id)
 
-# Removed the direct PDF view route as it's problematic.
-# The doctor dashboard will display the text content in the tabs.
+        if not patient:
+            print(f"Patient ID {patient_id} not found for deletion.")
+            return jsonify({'success': False, 'error': 'Patient not found.'}), 404
+
+        db.session.delete(patient)
+        db.session.commit()
+        print(f"Patient ID {patient_id} deleted successfully.")
+
+        return jsonify({'success': True, 'message': 'Patient deleted successfully.'})
+
+    except Exception as e:
+        print(f"Error deleting patient ID {patient_id}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        db.session.rollback()
+        return jsonify({'success': False, 'error': f'An error occurred during deletion: {str(e)}'}), 500
+
+# New route to save edited care plan
+@app.route('/save_care_plan/<patient_id>', methods=['PUT'])
+def save_care_plan(patient_id):
+    print(f"Save requested for patient ID: {patient_id}")
+    try:
+        # Get the edited plan text from the request body
+        data = request.get_json()
+        if not data or 'updated_plan' not in data:
+            return jsonify({'success': False, 'error': 'No updated_plan data provided.'}), 400
+
+        new_updated_plan = data['updated_plan']
+        if not new_updated_plan.strip():
+             return jsonify({'success': False, 'error': 'Care plan cannot be empty.'}), 400
+
+
+        # Find the patient by ID
+        patient = Patient.query.get(patient_id)
+
+        if not patient:
+            print(f"Patient ID {patient_id} not found for saving care plan.")
+            return jsonify({'success': False, 'error': 'Patient not found.'}), 404
+
+        # Update the care plan text and timestamp
+        patient.updated_plan = new_updated_plan
+        patient.timestamp = datetime.utcnow() # Update timestamp when plan is manually saved
+
+        # Optional: Re-evaluate status based on manual edits + original feedback/plan?
+        # For simplicity, we'll keep the status as is unless manually changed later,
+        # or you could add logic here:
+        # patient.status = determine_patient_status(patient.original_plan, patient.updated_plan, patient.feedback)
+        # Or prompt doctor to set status manually on save
+
+        db.session.commit()
+        print(f"Care plan for patient ID {patient_id} saved successfully.")
+
+        return jsonify({'success': True, 'message': 'Care plan saved successfully.', 'new_timestamp': patient.timestamp.strftime("%Y-%m-%d %H:%M:%S")})
+
+    except Exception as e:
+        print(f"Error saving care plan for patient ID {patient_id}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        db.session.rollback()
+        return jsonify({'success': False, 'error': f'An error occurred during saving: {str(e)}'}), 500
+
+# New route to resend WhatsApp message
+@app.route('/resend_whatsapp/<patient_id>', methods=['POST'])
+def resend_whatsapp(patient_id):
+    print(f"WhatsApp resend requested for patient ID: {patient_id}")
+
+    if not twilio_client:
+         return jsonify({'success': False, 'error': 'WhatsApp service not configured on the server.'}), 500
+
+    try:
+        # Find the patient by ID
+        patient = Patient.query.get(patient_id)
+
+        if not patient:
+            print(f"Patient ID {patient_id} not found for WhatsApp resend.")
+            return jsonify({'success': False, 'error': 'Patient not found.'}), 404
+
+        # Use the patient's current data (including potentially edited updated_plan)
+        patient_info = {
+            'name': patient.name,
+            'age': patient.age,
+            'gender': patient.gender
+        }
+        whatsapp_sent = send_whatsapp_care_plan(patient_info, patient.updated_plan, patient.status)
+
+        if whatsapp_sent:
+             print(f"WhatsApp message resent successfully for patient ID {patient_id}.")
+             return jsonify({'success': True, 'message': 'WhatsApp message sent successfully.', 'whatsapp_sent': True})
+        else:
+             print(f"Failed to resend WhatsApp message for patient ID {patient_id}.")
+             return jsonify({'success': True, 'message': 'Failed to send WhatsApp message.', 'whatsapp_sent': False}) # Return success=True but whatsapp_sent=False
+
+    except Exception as e:
+        print(f"Error resending WhatsApp for patient ID {patient_id}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'success': False, 'error': f'An error occurred during WhatsApp resend: {str(e)}'}), 500
 
 
 if __name__ == '__main__':
-    # Use a more robust development server like Waitress or Gunicorn in production
-    # Ensure database tables are created before running the app
     with app.app_context():
         db.create_all()
-    app.run(debug=True) # Explicitly set port
+    # Use a more robust development server like Waitress or Gunicorn in production
+    app.run(debug=True)