Update app.py

app.py

@@ -1,4 +1,5 @@
 from flask import Flask, render_template, request, jsonify, session, redirect, url_for, send_file
+from flask_sqlalchemy import SQLAlchemy # Import SQLAlchemy
 import google.generativeai as genai
 import PyPDF2
 import os
@@ -20,6 +21,47 @@ app = Flask(__name__)
 # Use a strong, unique secret key
 app.secret_key = os.getenv('SECRET_KEY', '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c') # CHANGE THIS IN PRODUCTION
 
+# Database Configuration
+# Use SQLite for simplicity
+app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///patients.db')
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+
+db = SQLAlchemy(app)
+
+# Define the Patient Model
+class Patient(db.Model):
+    id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    name = db.Column(db.String(100), nullable=False)
+    age = db.Column(db.Integer)
+    gender = db.Column(db.String(50))
+    feedback = db.Column(db.Text, nullable=False)
+    original_plan = db.Column(db.Text) # Store text from uploaded PDF
+    updated_plan = db.Column(db.Text, nullable=False) # Store generated plan text
+    status = db.Column(db.String(50), default='stable')
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def __repr__(self):
+        return f"<Patient {self.name} ({self.id})>"
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'age': self.age,
+            'gender': self.gender,
+            'feedback': self.feedback,
+            'original_plan': self.original_plan,
+            'updated_plan': self.updated_plan,
+            'status': self.status,
+            'timestamp': self.timestamp.strftime("%Y-%m-%d %H:%M:%S") if self.timestamp else None
+        }
+
+# Create database tables if they don't exist
+@app.before_request
+def create_tables():
+    db.create_all()
+
+
 upload_base = os.getenv('UPLOAD_DIR', '/tmp/uploads')
 upload_folder = os.path.join(upload_base, 'pdfs')
 
@@ -36,54 +78,51 @@ 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
-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
+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}")
+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
-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:
+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
+        }
+
         model = genai.GenerativeModel(
             model_name="gemini-1.5-flash-latest", # Recommended model alias
             generation_config=generation_config,
         )
-        # Test model generation
+        # Test model generation (optional)
         # 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
 
+    except Exception as e:
+         print(f"Error configuring Gemini API or loading model: {e}")
+         model = None # Handle cases where API configuration fails
+else:
+    print("GENAI_API_KEY environment variable not set. AI generation disabled.")
 
-# 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"""
@@ -92,19 +131,28 @@ def extract_text_from_pdf(pdf_file):
         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
+             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
+
         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()
+        return text.strip() or "[No readable text found in PDF]" # Return placeholder if no text
     except Exception as e:
         print(f"Error extracting PDF text: {e}")
-        return ""
+        return f"[Error extracting PDF text: {e}]" # Include error in placeholder
+
 
 def extract_care_plan_format(pdf_text):
     """Extract a general format template from PDF text by identifying common section headers."""
-    if not pdf_text:
-        return None
+    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
 
     # 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.
@@ -123,7 +171,7 @@ def extract_care_plan_format(pdf_text):
              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.")
+         print("No sections or potential headers found in PDF.")
          return None # No recognizable format found
 
     format_template = ""
@@ -141,6 +189,7 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     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",
@@ -151,7 +200,7 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "collapsed", "unconscious", "unresponsive", "stroke", "seizure", "convulsion",
         "suffocating", "not breathing", "blue lips", "blue face", "cardiac arrest",
         "high fever", "signs of shock", "severe dehydration", "acute change",
-        "unstable vitals", "rapidly worsening"
+        "unstable vitals", "rapidly worsening", "can't breathe", "chest tight"
     ]
 
     deteriorating_keywords = [
@@ -162,7 +211,8 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "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"
+        "new symptoms", "trouble with", "reduced appetite", "difficulty sleeping",
+        "tired all the time", "much weaker", "feeling worse"
     ]
 
     improvement_keywords = [
@@ -172,36 +222,26 @@ def determine_patient_status(original_plan, updated_plan, feedback):
         "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"
+        "symptoms decreased", "feeling stronger", "better sleep", "increased appetite",
+        "pain decreased", "more energy", "walking further"
     ]
 
-    # Check for emergency keywords first (highest priority), primarily in feedback as it's direct input
+    # Check feedback first
     if any(keyword in feedback_lower for keyword in emergency_keywords):
         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):
-        return "emergency"
-
-    # Check for deteriorating keywords
     if any(keyword in feedback_lower for keyword in deteriorating_keywords):
         return "deteriorating"
-    # 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"
-    # Check updated plan for improvement indicators
-    if any(keyword in updated_plan_lower for keyword in improvement_keywords):
-        return "improving"
-
-    # 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"
 
+    # 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"
+         if any(keyword in updated_plan_lower for keyword in deteriorating_keywords):
+            return "deteriorating"
+         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"
@@ -297,19 +337,19 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
     # 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(patient_info.get('age', '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>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.setStyle(TableStyle([
-        ('BACKGROUND', (0, 0), (0, -1), colors.lightgrey),
+        ('BACKGROUND', (0, 0), (0, -1), colors.HexColor("#f2f2f2")), # Lighter grey
         ('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),
+        ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.HexColor("#dddddd")), # Lighter grid
+        ('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
@@ -324,88 +364,31 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
     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')
-    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 not stripped_line:
+            continue # Skip empty lines
 
+        # Check for potential section headers (e.g., "SECTION TITLE:")
+        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
+            story.append(Spacer(1, 8)) # Space before new section
+            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
+             if bullet_text:
+                 story.append(Paragraph(f"• {bullet_text}", bullet_style))
+             else: # Handle empty bullet points
+                 story.append(Paragraph("• ", bullet_style))
         else:
-            # Line is regular content, add it to the current section
-             current_section.append(line)
+            # Treat as normal paragraph content
+            story.append(Paragraph(line, normal_style)) # Use original line to preserve indentation/spacing within paragraphs
 
-    # Add the last section
-    add_section_to_story(current_section, is_bullet_section)
 
     # Add footer or timestamp if desired
     story.append(Spacer(1, 20))
@@ -414,15 +397,27 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
 
 
     # Build the PDF
-    doc.build(story)
-    buffer.seek(0)
-    return buffer
+    try:
+        doc.build(story)
+        buffer.seek(0)
+        print("PDF generated successfully.")
+        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")
+        c.drawString(100, 735, f"Details: {str(e)}")
+        c.save()
+        error_buffer.seek(0)
+        return error_buffer
 
 
 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.")
+        print("Twilio client not configured. Cannot send WhatsApp message.")
         return False
 
     try:
@@ -431,28 +426,39 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
             'emergency': "🚨 EMERGENCY",
             'deteriorating': "⚠️ HIGH RISK",
             'improving': "✅ IMPROVING",
-            'stable': "🟦 STABLE"
+            'stable': "🟦 STABLE",
+            '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"*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
+        message += f"*Care Plan Details:*\n{formatted_plan}" # Include the full plan text
 
+        print(f"Attempting to send WhatsApp message to {TWILIO_TO}...")
         # Send WhatsApp message using hardcoded number
-        message = twilio_client.messages.create(
+        message_sent = twilio_client.messages.create(
             from_=TWILIO_FROM,
             body=message,
             to=TWILIO_TO
         )
-        print(f"WhatsApp message sent, SID: {message.sid}")
+        print(f"WhatsApp message sent, SID: {message_sent.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)
+        # Example: If the 'To' number is not registered for WhatsApp
         return False
 
 
@@ -483,34 +489,30 @@ def doctor_dashboard():
     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):
-     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
+        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', 'N/A')
+        age = request.form.get('age') # Get as string initially
         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
+                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
+
         care_plan_text = ""
         care_plan_format = None
 
@@ -520,9 +522,12 @@ def submit_feedback():
             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:
+                if care_plan_text and "[No readable text found" not in care_plan_text and "[Error extracting PDF text" not in care_plan_text:
                      care_plan_format = extract_care_plan_format(care_plan_text)
                 print(f"Extracted text length: {len(care_plan_text)}. Format found: {care_plan_format is not None}")
+            else:
+                 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():
@@ -532,10 +537,8 @@ PATIENT INFORMATION:
 - Name: [Patient Name]
 - Age: [Age]
 - Gender: [Gender]
-
 ASSESSMENT:
 - [Summary of patient's current condition based on feedback and previous plan]
-
 DAILY CARE PLAN:
 Morning:
 - [Morning activities/medications]
@@ -545,60 +548,39 @@ Evening:
 - [Evening activities/medications]
 Night:
 - [Night activities/medications/sleep instructions]
-
 MEDICATIONS:
 - [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:
 - [Other relevant advice, e.g., rest, monitoring, specific precautions]
-
 FOLLOW-UP:
 - [Details about next appointment or when to contact healthcare provider]
             """
         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",
-            "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)
+        # Determine status BEFORE calling AI, especially for emergency
+        initial_status = determine_patient_status(care_plan_text, "", feedback) # Compare against empty updated plan initially
+
 
         generated_plan_text = ""
-        status = 'stable' # Default status
+        status = initial_status # Start with status determined from feedback
 
-        if is_emergency_feedback:
-            print("Emergency keywords detected in feedback.")
+        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"
-                f"- Age: {age}\n"
+                f"- Age: {age if age is not None else 'N/A'}\n"
                 f"- Gender: {gender}\n\n"
                 "ASSESSMENT:\n"
                 f"- Emergency symptoms reported: {feedback}. Immediate medical attention required.\n\n"
@@ -615,7 +597,7 @@ 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 = 'emergency' # Set status to emergency
+            # Status remains 'emergency'
 
         else:
             # Prepare a prompt for Gemini AI for a perfect, attractively formatted day care plan.
@@ -623,18 +605,14 @@ FOLLOW-UP:
             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}
+Age: {age if age is not None else 'N/A'}
 Gender: {gender}
-
 Patient Feedback/Symptoms Update:
 {feedback}
-
 Previous Care Plan Details (if available):
-{care_plan_text if care_plan_text else "No previous care plan provided."}
-
+{care_plan_text if care_plan_text and "[No readable text found" 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.
@@ -642,46 +620,71 @@ Instructions:
 4. Include realistic times for medications if applicable (e.g., "Take 1 tablet in the morning with food").
 5. Highlight important instructions or warnings, especially regarding symptom management and when to seek help.
 6. Do NOT include any introductory or concluding sentences outside the plan format itself (like "Here is the updated plan:" or "Let me know if you need further assistance."). Provide ONLY the structured plan content.
-
+7. If the previous care plan text indicates it was unreadable or had errors, acknowledge that and generate a new plan based primarily on the feedback and patient info, using the format template.
 Care Plan Format Template:
 {care_plan_format}
 """
             print("Sending prompt to AI model...")
-            print(f"Prompt:\n---\n{prompt}\n---")
+            # 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
+
+                # 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...```
+                         generated_plan_text = generated_plan_text[4:].strip()
+
+
                 print(f"AI Response received. Length: {len(generated_plan_text)}")
-                print(f"AI Response:\n---\n{generated_plan_text}\n---")
+                # print(f"AI Response (first 200 chars):\n---\n{generated_plan_text[:200]}\n---") # Print truncated response
+
 
-                # Determine patient status based on AI's output and feedback
+                # Re-determine patient status based on feedback AND the generated updated plan
                 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:
+                     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
+                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}'
-                }), 500
+                    '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
+
 
         # --- 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,
-            'name': name,
-            'age': age,
-            'gender': gender,
-            'feedback': feedback,
-            '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()}")
+        # Create and store patient record in the database
+        new_patient = Patient(
+            name=name,
+            age=age,
+            gender=gender,
+            feedback=feedback,
+            original_plan=care_plan_text, # Store original text
+            updated_plan=generated_plan_text, # Store the generated plan text
+            status=status,
+            timestamp=datetime.utcnow() # Use UTC time
+        )
+        db.session.add(new_patient)
+        db.session.commit()
+        patient_id = new_patient.id # Get the generated ID
+
+        print(f"Patient {patient_id} added to DB with status: {status}.")
 
 
         # Generate PDF for downloading using the stored data
@@ -706,53 +709,56 @@ Care Plan Format Template:
         return jsonify({
             'success': True,
             'updated_plan': generated_plan_text, # Send back the generated text
-            'pdf_data': pdf_base64,
-            'patient_id': patient_id, # Send the generated patient ID
+            'pdf_data': pdf_base64, # Send base64 data for preview
+            'patient_id': patient_id, # Send the generated patient ID for download
             'status': status,
             'whatsapp_sent': whatsapp_sent
         })
 
     except Exception as e:
-        print(f"An unexpected error occurred: {str(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,
-            'error': f'An unexpected error occurred: {str(e)}'
+            'error': f'An unexpected server 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:
-        patient = patients_db.get(patient_id)
+        # Fetch patient from the database
+        patient = Patient.query.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
+            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.get('name', 'N/A'),
-            'age': patient.get('age', 'N/A'),
-            'gender': patient.get('gender', 'N/A')
+            'name': patient.name,
+            'age': patient.age,
+            'gender': patient.gender
         }
-        # Use the already determined status and updated plan text
+        # 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'],
-            patient['status']
+            patient.updated_plan, # Use the stored updated plan
+            patient.status # Use the stored 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"
+        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
 
         print(f"Serving PDF for {patient_id} as {download_name}")
         return send_file(
@@ -765,28 +771,15 @@ def download_pdf(patient_id):
         print(f"PDF Download Error for ID {patient_id}: {str(e)}")
         import traceback
         traceback.print_exc()
-        return f"Error generating PDF: {str(e)}", 500
+        return f"Error generating PDF for download: {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.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.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')
-        })
+    # 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()]
 
     return jsonify({
         'success': True,
@@ -796,36 +789,56 @@ 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 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': list(sorted_patients)
+        'patients': patients_list
     })
 
 
 @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: {patients_db.keys()}")
 
-    patient = patients_db.get(patient_id)
+    # Fetch patient from the database
+    patient = Patient.query.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"Patient ID {patient_id} not found in database for API request.")
+        return jsonify({'success': False, 'error': 'Patient not found.'}), 404
 
-    print(f"Found patient {patient_id}: {patient.get('name')}")
+    print(f"Found patient {patient_id}: {patient.name}")
     return jsonify({
         'success': True,
-        'patient': patient
+        'patient': patient.to_dict() # Return dictionary representation
     })
 
+# 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.
+
+# Removed the direct PDF view route as it's problematic.
+# The doctor dashboard will display the text content in the tabs.
+
 
 if __name__ == '__main__':
     # Use a more robust development server like Waitress or Gunicorn in production
-    app.run(debug=True, port=5000) # Explicitly set port
+    # Ensure database tables are created before running the app
+    with app.app_context():
+        db.create_all()
+    app.run(debug=True) # Explicitly set port