Update app.py

app.py

@@ -12,10 +12,18 @@ from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, ListItem, ListFlowable
 from reportlab.lib.units import inch
 from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+import logging # Import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
 
 app = Flask(__name__)
 
-app.secret_key = '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c'  # Add this for session management
+# Use a more secure way to generate secret key in production
+app.secret_key = os.getenv('SECRET_KEY', '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c') # Ensure this is strong and secret
+
+# Directory configuration
 upload_base = os.getenv('UPLOAD_DIR', 'static')
 upload_folder = os.path.join(upload_base, 'uploads')
 pdf_folder = os.path.join(upload_base, 'pdfs')
@@ -26,7 +34,8 @@ os.makedirs(upload_folder, exist_ok=True)
 os.makedirs(pdf_folder, exist_ok=True)
 
 # Gemini API Configuration
-genai.configure(api_key="AIzaSyCizcswP6vlKDMdB3HRAtVi2JbifOpbPvA")
+# Replace with your actual API key, ideally from environment variables
+genai.configure(api_key=os.getenv("GEMINI_API_KEY", "YOUR_GEMINI_API_KEY")) # Replace with your key or env var
 
 generation_config = {
     "temperature": 1,
@@ -35,96 +44,155 @@ generation_config = {
     "max_output_tokens": 8192,
 }
 
-model = genai.GenerativeModel(
-    model_name="gemini-2.0-flash",
-    generation_config=generation_config,
-)
+try:
+    model = genai.GenerativeModel(
+        model_name="gemini-2.0-flash", # Using flash model
+        generation_config=generation_config,
+    )
+    logging.info("Gemini model initialized successfully.")
+except Exception as e:
+    logging.error(f"Error initializing Gemini model: {e}")
+    model = None # Set model to None if initialization fails
 
 # Twilio Configuration
-ACCOUNT_SID = 'AC490e071f8d01bf0df2f03d086c788d87'
-AUTH_TOKEN = '224b23b950ad5a4052aba15893fdf083'
-TWILIO_FROM = 'whatsapp:+14155238886'
+# Replace with your actual Twilio credentials, ideally from environment variables
+ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID", "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") # Replace
+AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN", "your_auth_token") # Replace
+TWILIO_FROM = os.getenv("TWILIO_FROM_NUMBER", "whatsapp:+14155238886") # Replace
+
+try:
+    twilio_client = Client(ACCOUNT_SID, AUTH_TOKEN)
+    logging.info("Twilio client initialized successfully.")
+except Exception as e:
+    logging.error(f"Error initializing Twilio client: {e}")
+    twilio_client = None # Set client to None if initialization fails
+
+
+# In-memory storage for update history (replace with database in production)
+app.update_history = []
 
 def extract_text_from_pdf(pdf_file):
+    """Extract text from a PDF file object."""
     try:
+        # Ensure the 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()
+            text += page.extract_text() or "" # Handle pages with no extractable text
+        pdf_file.seek(0) # Reset pointer after reading
         return text.strip()
     except Exception as e:
-        print(f"Error extracting PDF text: {e}")
+        logging.error(f"Error extracting PDF text: {e}")
         return ""
 
 def extract_care_plan_format(pdf_text):
-    """Extract the care plan format from PDF text"""
+    """
+    Extract a potential care plan format from PDF text by identifying headings.
+    Returns a string representing the discovered structure.
+    """
+    if not pdf_text:
+        return None
     try:
-        # Find sections and their content in the PDF using regex
+        # Look for lines that look like section headings (uppercase words potentially followed by :)
+        # And capture the content block following them
+        # This regex is an approximation and might need tuning based on actual PDF formats
         sections = re.findall(
-            r'([A-Z][A-Z\s]+)[:|\n]((?:(?!\n[A-Z][A-Z\s]+[:|\n]).)*)',
+            r'^([A-Z\s]+(?:[:\n]|$))([\s\S]*?)(?=\n^[A-Z\s]+(?:[:\n]|$)|$)',
             pdf_text,
-            re.DOTALL
+            re.MULTILINE | re.DOTALL
         )
 
+        format_template = ""
         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
+            for i, (section_heading_match, content) in enumerate(sections):
+                 # Clean up heading - take the part before : or just the line if no :
+                heading = section_heading_match.strip()
+                if heading.endswith(':'):
+                    heading = heading[:-1].strip()
+                elif heading.endswith('\n'):
+                     heading = heading[:-1].strip()
+
+                if heading:
+                     format_template += f"{heading.strip()}:\n"
+                     # Attempt to find bullet points within the content
+                     bullets = re.findall(r'^[-\*•]\s*(.*?)$', content, re.MULTILINE)
+                     if bullets:
+                         for bullet in bullets:
+                             format_template += f"- {bullet.strip()}\n"
+                     else:
+                         # If no obvious bullets, just add a placeholder
+                         format_template += "[Details]\n"
+                     format_template += "\n"
+
+            logging.info("Extracted format from PDF.")
+            return format_template.strip() if format_template else None
+
+        logging.warning("No distinct sections found using regex for format extraction.")
         return None
     except Exception as e:
-        print(f"Error extracting format: {e}")
+        logging.error(f"Error extracting format: {e}")
         return None
 
 def create_care_plan_pdf(care_plan_text, patient_name="Patient"):
-    """Generate a beautifully formatted PDF with the care plan"""
+    """Generate a beautifully formatted PDF with the care plan."""
     buffer = io.BytesIO()
-    doc = SimpleDocTemplate(buffer, pagesize=letter)
+    doc = SimpleDocTemplate(buffer, pagesize=letter,
+                            rightMargin=72, leftMargin=72,
+                            topMargin=72, bottomMargin=18) # Adjusted margins
     styles = getSampleStyleSheet()
-    
+
     # Create custom styles
     styles.add(ParagraphStyle(
         name='Title',
         parent=styles['Heading1'],
-        fontSize=18,
+        fontSize=20, # Slightly larger title
+        leading=24,
         alignment=TA_CENTER,
-        spaceAfter=20,
+        spaceAfter=24, # More space after title
         textColor=colors.HexColor('#0d6efd')
     ))
-    
+
     styles.add(ParagraphStyle(
         name='SectionHeading',
         parent=styles['Heading2'],
         fontSize=14,
-        spaceAfter=6,
-        spaceBefore=12,
-        textColor=colors.HexColor('#0a58ca')
+        leading=16,
+        spaceAfter=8, # More space after section heading
+        spaceBefore=16, # More space before section heading
+        textColor=colors.HexColor('#0a58ca'),
+        bold=True # Make headings bold
     ))
-    
+
     styles.add(ParagraphStyle(
         name='BodyText',
         parent=styles['Normal'],
         fontSize=11,
+        leading=14, # Line spacing
         alignment=TA_JUSTIFY,
-        spaceBefore=2,
-        spaceAfter=2
+        spaceBefore=4,
+        spaceAfter=4
     ))
-    
-    # Add logo path or use a placeholder
-    # logo_path = os.path.join("static", "images", "logo.png")
-    
+
+     # Style for list items within the ListFlowable
+    styles.add(ParagraphStyle(
+        name='ListItemText',
+        parent=styles['BodyText'],
+        leftIndent=0, # Managed by ListFlowable
+        bulletIndent=0, # Managed by ListFlowable
+        spaceBefore=0,
+        spaceAfter=0,
+        leading=14 # Inherit leading
+    ))
+
+
     # Create story elements
     story = []
-    
+
     # Add title
     timestamp = datetime.now().strftime("%B %d, %Y")
-    title = Paragraph(f"UPDATED CARE PLAN<br/><br/>{timestamp}", styles["Title"])
+    # Use paragraphs for multi-line elements in title
+    title = Paragraph("UPDATED CARE PLAN", styles["Title"])
     story.append(title)
     story.append(Spacer(1, 0.25*inch))
 
@@ -132,106 +200,149 @@ def create_care_plan_pdf(care_plan_text, patient_name="Patient"):
     patient_info = Paragraph(f"<b>Patient:</b> {patient_name}", styles["BodyText"])
     story.append(patient_info)
     story.append(Spacer(1, 0.15*inch))
-    
+
     # Process care plan sections
-    sections = care_plan_text.split("\n\n")
+    # Splitting by double newline should generally work if the AI adheres to the format
+    sections = care_plan_text.strip().split("\n\n")
+
     for section in sections:
-        if not section.strip():
+        section = section.strip()
+        if not section:
             continue
-            
-        lines = section.strip().split("\n")
+
+        lines = section.split("\n")
         if not lines:
             continue
-            
-        # Add section heading
+
+        # Assume the first line is the heading, potentially followed by a colon
         heading_line = lines[0].strip()
-        if ":" in heading_line:
-            heading = heading_line.split(":", 1)[0].strip()
-            story.append(Paragraph(heading, styles["SectionHeading"]))
-            
-            # Process bullet points and content
-            content_lines = lines[1:] if len(lines) > 1 else []
-            bullet_items = []
-            normal_text = ""
-            
-            for line in content_lines:
-                line = line.strip()
-                if line.startswith("-") or line.startswith("•"):
-                    bullet_text = line[1:].strip()
-                    bullet_items.append(ListItem(Paragraph(bullet_text, styles["BodyText"])))
-                else:
-                    normal_text += line + " "
-            
-            # Add normal text if present
-            if normal_text:
-                story.append(Paragraph(normal_text, styles["BodyText"]))
-                
-            # Add bullet points if present
-            if bullet_items:
-                bullet_list = ListFlowable(
-                    bullet_items,
-                    bulletType='bullet',
-                    start=None,
-                    bulletFontName='Helvetica',
-                    bulletFontSize=11,
-                    leftIndent=20,
-                    bulletOffsetY=0
-                )
-                story.append(bullet_list)
-                
-            story.append(Spacer(1, 0.1*inch))
-    
+        heading = heading_line.split(":", 1)[0].strip()
+
+        if heading: # Only add if a heading was found
+             story.append(Paragraph(heading, styles["SectionHeading"]))
+
+        content_lines = lines[1:] if len(lines) > 1 else []
+        bullet_items = []
+        normal_paragraphs = []
+        current_paragraph = ""
+
+        # Process content lines, distinguishing between bullets and normal text
+        for line in content_lines:
+            line = line.strip()
+            if not line:
+                continue # Skip empty lines within content
+
+            if line.startswith("-") or line.startswith("•"):
+                # If there was collected normal text, add it before the list
+                if current_paragraph:
+                    normal_paragraphs.append(Paragraph(current_paragraph.strip(), styles["BodyText"]))
+                    current_paragraph = ""
+                bullet_text = line[1:].strip()
+                # Use ListItem with Paragraph for better formatting control
+                bullet_items.append(ListItem(Paragraph(bullet_text, styles["ListItemText"]), leftIndent=20))
+            else:
+                # Collect normal text into a paragraph
+                current_paragraph += line + " "
+
+        # Add the last collected normal paragraph if it exists
+        if current_paragraph:
+             normal_paragraphs.append(Paragraph(current_paragraph.strip(), styles["BodyText"]))
+
+        # Add collected normal paragraphs
+        for para in normal_paragraphs:
+            story.append(para)
+
+        # Add bullet points if present
+        if bullet_items:
+             # ListFlowable handles the bullet rendering and indent
+             story.append(ListFlowable(
+                 bullet_items,
+                 bulletType='bullet',
+                 start='disc', # Use disc for bullet point appearance
+                 leftIndent=20, # Indent the entire list block
+                 bulletAnchor='start'
+             ))
+
+        # Add spacing after the section content if there was content
+        if content_lines:
+             story.append(Spacer(1, 0.15*inch)) # Space after section content
+
     # Add footer
     footer_text = """This care plan has been automatically generated based on your feedback. Please consult with your healthcare provider before making any changes to your current treatment plan."""
     footer = Paragraph(f"<i>{footer_text}</i>", styles["BodyText"])
-    story.append(Spacer(1, 0.25*inch))
+    story.append(Spacer(1, 0.35*inch)) # More space before footer
     story.append(footer)
-    
+
     # Build PDF
-    doc.build(story)
-    buffer.seek(0)
-    return buffer
+    try:
+        doc.build(story)
+        buffer.seek(0)
+        logging.info("PDF generated successfully.")
+        return buffer
+    except Exception as e:
+         logging.error(f"Error building PDF: {e}")
+         return None
+
 
-def send_whatsapp_message(message, recipient, pdf_data=None, pdf_name=None):
+def send_whatsapp_message(message, recipient, pdf_data=None, pdf_filename=None):
     """
     Sends a WhatsApp message using Twilio.
-    If pdf_data is provided, it attaches the PDF to the message.
+    If pdf_data is provided, it attempts to attach the PDF to the message.
+    NOTE: Attaching media requires the media to be accessible via a public URL.
+    In a local development environment, this will likely fail unless you use a service like ngrok
+    to expose your Flask app publicly and configure the URL correctly.
+    For this demo, the message will be sent, but the PDF attachment part might not work
+    unless the URL is valid.
     """
+    if not twilio_client:
+        logging.warning("Twilio client not initialized. Cannot send message.")
+        return {'success': False, 'error': 'Twilio client not configured.'}
+
+    if not recipient:
+         logging.warning("Recipient number is empty. Cannot send message.")
+         return {'success': False, 'error': 'Recipient number not provided.'}
+
     try:
-        client = Client(ACCOUNT_SID, AUTH_TOKEN)
-        
         # Check if recipient needs WhatsApp prefix
         if not recipient.startswith('whatsapp:'):
             recipient = f'whatsapp:{recipient}'
-        
+            logging.info(f"Formatted recipient number: {recipient}")
+
         message_params = {
             'from_': TWILIO_FROM,
             'body': message,
             'to': recipient
         }
-        
-        # If we have a PDF to send, attach it
-        if pdf_data and pdf_name:
-            # Create a temporary file
-            temp_pdf_path = os.path.join(app.config['PDF_FOLDER'], pdf_name)
-            with open(temp_pdf_path, 'wb') as f:
-                f.write(pdf_data.getvalue())
-            
-            # Add media URL (would be your app's URL in production)
-            media_url = f'https://your-app-domain.com/static/pdfs/{pdf_name}'
-            
-            # In development, use a public URL service like ngrok
-            # or just mention that we'd need a public URL in production
-            # For now, we'll just send the message without the attachment
-            message_params['body'] += "\n\nYour care plan PDF has been generated and would normally be attached here. Due to development environment limitations, please view it in the web interface."
-        
-        msg = client.messages.create(**message_params)
+
+        # --- IMPORTANT NOTE ABOUT PDF ATTACHMENT ---
+        # To send a PDF via Twilio WhatsApp, the PDF must be hosted
+        # somewhere publicly accessible online, and you provide Twilio with that URL.
+        # Example: media_url = f'https://your-app-domain.com/static/pdfs/{pdf_filename}'
+        # In this local development setup, this URL won't be publicly accessible
+        # unless you use a service like ngrok.
+        # For this demo, we will skip adding the media_url directly,
+        # and instead just mention in the body that the PDF is available.
+        # If you set up public hosting (e.g., ngrok), you would add:
+        # if pdf_data and pdf_filename:
+        #     # Assuming 'static/pdfs/' is served publicly at '/static/pdfs/'
+        #     public_base_url = os.getenv("PUBLIC_APP_URL", "YOUR_PUBLIC_URL") # e.g. "https://abcdef123456.ngrok.io"
+        #     if public_base_url != "YOUR_PUBLIC_URL":
+        #          media_url = f'{public_base_url}/static/pdfs/{pdf_filename}'
+        #          message_params['media_url'] = [media_url] # Twilio expects a list of URLs
+        #          logging.info(f"Attempting to attach PDF from URL: {media_url}")
+        #     else:
+        #          logging.warning("PUBLIC_APP_URL not set. Cannot attach PDF to WhatsApp message.")
+        #          message_params['body'] += "\n\nYour care plan PDF is available via the web link."
+
+
+        msg = twilio_client.messages.create(**message_params)
+        logging.info(f"WhatsApp message sent successfully to {recipient}. SID: {msg.sid}")
         return {
-            'success': True, 
+            'success': True,
             'sid': msg.sid
         }
     except Exception as e:
-        print(f"Error sending WhatsApp message: {e}")
+        logging.error(f"Error sending WhatsApp message to {recipient}: {e}")
         return {
             'success': False,
             'error': str(e)
@@ -239,195 +350,277 @@ def send_whatsapp_message(message, recipient, pdf_data=None, pdf_name=None):
 
 @app.route('/')
 def index():
-    return render_template('index.html')
+    """Render the patient feedback page."""
+    # Default role to patient
+    if 'role' not in session:
+        session['role'] = 'patient'
 
-@app.route('/switch_role', methods=['POST'])
-def switch_role():
-    role = request.form.get('role')
-    session['role'] = role
-    return jsonify({'success': True, 'role': role})
+    # Redirect to doctor dashboard if role is doctor
+    if session.get('role') == 'doctor':
+        return redirect(url_for('doctor_dashboard'))
+
+    return render_template('index.html')
 
 @app.route('/doctor_dashboard')
 def doctor_dashboard():
+    """Render the doctor dashboard."""
+    # Redirect to patient page if role is not doctor
     if session.get('role') != 'doctor':
-        return redirect('/')
+        return redirect(url_for('index'))
+
     return render_template('doctor_dashboard.html')
 
+@app.route('/switch_role', methods=['POST'])
+def switch_role():
+    """Endpoint to switch user role."""
+    role = request.form.get('role')
+    if role in ['patient', 'doctor']:
+        session['role'] = role
+        logging.info(f"User role switched to: {role}")
+        return jsonify({'success': True, 'role': role})
+    return jsonify({'success': False, 'error': 'Invalid role'}), 400
+
 @app.route('/download_pdf/<filename>')
 def download_pdf(filename):
+    """Serve the generated PDF file for download."""
     try:
+        pdf_path = os.path.join(app.config['PDF_FOLDER'], filename)
+        if not os.path.exists(pdf_path):
+            logging.warning(f"Attempted download of non-existent file: {filename}")
+            return "File not found", 404
+
+        logging.info(f"Serving PDF for download: {filename}")
         return send_file(
-            os.path.join(app.config['PDF_FOLDER'], filename),
+            pdf_path,
             as_attachment=True,
-            download_name=filename
+            download_name=filename,
+            mimetype='application/pdf'
         )
     except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
+        logging.error(f"Error serving PDF file {filename}: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
 
 @app.route('/submit_feedback', methods=['POST'])
 def submit_feedback():
+    """Handles patient feedback submission, generates/updates care plan."""
+    if model is None:
+         return jsonify({'success': False, 'error': 'AI model is not initialized.'}), 500
+    if twilio_client is None:
+         logging.warning("Twilio client not initialized, WhatsApp messages will not be sent.")
+         # Allow processing to continue, but indicate failure later
+
     try:
-        feedback = request.form.get('feedback', '')
-        patient_name = request.form.get('patient_name', 'Patient')
-        patient_phone = request.form.get('patient_phone', '')
+        patient_name = request.form.get('patient_name', 'Patient').strip()
+        patient_phone = request.form.get('patient_phone', '').strip()
+        feedback = request.form.get('feedback', '').strip()
         care_plan_text = ""
         care_plan_format = None
+        pdf_filename = None # Initialize PDF filename
+
+        logging.info(f"Received feedback for {patient_name}. Phone: {patient_phone}. Feedback: '{feedback[:100]}...'")
 
         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 != '':
+                logging.info(f"Processing uploaded PDF: {pdf_file.filename}")
                 care_plan_text = extract_text_from_pdf(pdf_file)
                 care_plan_format = extract_care_plan_format(care_plan_text)
+                logging.info(f"Extracted PDF text length: {len(care_plan_text)}")
+                if care_plan_format:
+                    logging.info(f"Extracted format:\n{care_plan_format}")
+
 
-        # If no format is found in the PDF, use a default format
+        # Use a default format if extraction failed or no PDF was uploaded
         if not care_plan_format:
+            logging.warning("No format extracted or PDF missing. Using default format.")
             care_plan_format = """
 ASSESSMENT:
-[Assessment details]
-
+- [Brief summary based on feedback]
 DAILY CARE PLAN:
 Morning:
-- [Morning activities]
+- [Morning activities/meds]
 Afternoon:
-- [Afternoon activities]
+- [Afternoon activities/meds]
 Evening:
-- [Evening activities]
-
+- [Evening activities/meds]
 MEDICATIONS:
-- [Medication details]
-
+- [Review current list, note changes or adherence issues based on feedback]
 ADDITIONAL RECOMMENDATIONS:
-- [Recommendations]
-
+- [Suggestions based on feedback, e.g., rest, hydration, specific exercises]
 FOLLOW-UP:
-[Follow-up details]
+- [Suggested next steps, e.g., monitor symptoms, contact doctor if symptoms worsen]
             """
 
         # Define emergency keywords to check for severe symptoms
         emergency_keywords = [
             # Cardiovascular
-            "severe chest pain", "heart attack", "shortness of breath",
-            "dizziness", "loss of consciousness", "extreme pain",
-
+            "severe chest pain", "heart attack", "sudden shortness of breath",
+            "passing out", "loss of consciousness", "extreme pain", "uncontrolled bleeding",
             # Neurological
-            "sudden weakness", "confusion", "slurred speech", "severe headache",
-
+            "sudden weakness", "confusion", "slurred speech", "severe headache", "stroke symptoms",
             # Respiratory
             "difficulty breathing", "severe shortness of breath", "wheezing", "respiratory distress",
-
             # Gastrointestinal
-            "severe abdominal pain", "persistent vomiting", "uncontrolled bleeding",
-
+            "severe abdominal pain", "persistent vomiting", "vomiting blood", "black stool",
             # Others
-            "severe allergic reaction", "anaphylaxis"
+            "severe allergic reaction", "anaphylaxis", "high fever that won't come down", "sudden swelling",
+            "can't feel", "paralysis"
         ]
 
         feedback_lower = feedback.lower()
         is_emergency = any(keyword in feedback_lower for keyword in emergency_keywords)
 
+        status = 'normal' # Default status
+        updated_plan = ""
+        message_sent_status = False
+        pdf_download_url = None # Initialize PDF URL
+
         if is_emergency:
-            # Store emergency notification
-            emergency_data = {
-                'patient_name': patient_name,
-                'patient_phone': patient_phone,
-                'patient_feedback': feedback,
-                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                'status': 'urgent'
-            }
-            
-            # In a real application, you would store this in a database
-            # For now, we'll use a global variable (not recommended for production)
-            if not hasattr(app, 'emergency_notifications'):
-                app.emergency_notifications = []
-            app.emergency_notifications.append(emergency_data)
-
-            # If emergency symptoms are detected, instruct immediate emergency response
-            emergency_message = (
-                "Emergency symptoms detected. Please call emergency services immediately at 104/108/109/112."
+            status = 'urgent'
+            updated_plan = (
+                "Emergency symptoms detected. Please call emergency services immediately "
+                f"at 104/108/109/112. Do not wait for a care plan update."
             )
-            
-            # Send emergency message to patient if phone number is provided
+            logging.warning(f"Emergency detected for {patient_name}. Feedback: '{feedback}'")
+
+            # Send immediate emergency message to patient if phone number is provided
             if patient_phone:
-                send_whatsapp_message(
-                    message=emergency_message,
-                    recipient=patient_phone
+                message_result = send_whatsapp_message(
+                    message=updated_plan, # Send the emergency instruction message
+                    recipient=patient_phone # Use the patient's phone number
                 )
-                
-            return jsonify({
-                'success': True,
-                'is_emergency': True,
-                'updated_plan': emergency_message
-            })
-
-        # Prepare a prompt for Gemini AI for a perfect, attractively formatted day care plan.
-        prompt = f"""
+                message_sent_status = message_result.get('success', False)
+                logging.info(f"Emergency WhatsApp message result: {message_result}")
+
+        else:
+            # Not an emergency, generate updated plan
+            prompt = f"""
 Patient Care Plan Update Request:
 Patient Name: {patient_name}
 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:
+{f"Current Care Plan (extracted from previous PDF): {care_plan_text}" if care_plan_text else "No previous care plan provided."}
+
+Based on the patient's feedback and, if provided, the current care plan, please provide an updated daily care plan.
+Follow this format strictly where applicable, filling in or updating sections based *only* on the provided feedback. If a section is not relevant to the feedback, keep the placeholder or indicate it's unchanged.
+
 {care_plan_format}
-Please ensure the following:
-- The response is well-structured with clear section headings.
-- Use bullet points for list items without including any asterisk (*) symbols.
-- Format the text attractively and professionally.
-- Remove any extraneous symbols.
+
+Ensure the following:
+- The response is structured exactly with the provided section headings ({', '.join([h.strip() for h in care_plan_format.strip().split(':\n') if h.strip()])}...).
+- Use bullet points (-) for list items where the format shows them.
+- Do not include any asterisk (*) or other symbols not in the format.
+- Provide actionable advice based *only* on the feedback and general health principles (do not invent medical advice).
+- If the feedback indicates symptoms that need professional medical attention but aren't strictly emergency keywords (e.g., persistent mild pain, concerning but non-severe symptoms), include a recommendation to consult their doctor.
+- The tone should be professional and supportive.
 """
-        # Get response from Gemini AI
-        response = model.generate_content(prompt)
-        # Remove any asterisk symbols from the response text
-        updated_plan = response.text.replace("*", "")
-        
-        # Generate PDF
-        pdf_buffer = create_care_plan_pdf(updated_plan, patient_name)
-        
-        # Save the PDF to file system with a unique name
-        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
-        safe_name = re.sub(r'[^a-zA-Z0-9]', '_', patient_name)
-        pdf_filename = f"care_plan_{safe_name}_{timestamp}.pdf"
-        pdf_path = os.path.join(app.config['PDF_FOLDER'], pdf_filename)
-        
-        with open(pdf_path, 'wb') as f:
-            f.write(pdf_buffer.getvalue())
-        
-        # Reset the buffer pointer for potential reuse
-        pdf_buffer.seek(0)
-        
-        # Send WhatsApp message with PDF if phone number is provided
-        message_result = None
-        if patient_phone:
-            message_result = send_whatsapp_message(
-                message=f"Hello {patient_name}, your updated care plan is ready. Please review it and contact your healthcare provider if you have any questions.",
-                recipient=patient_phone,
-                pdf_data=pdf_buffer,
-                pdf_name=pdf_filename
-            )
-        
+            logging.info("Sending prompt to Gemini...")
+            logging.debug(f"Gemini Prompt:\n{prompt}")
+
+            try:
+                response = model.generate_content(prompt)
+                # Remove any asterisk symbols from the response text
+                updated_plan = response.text.replace("*", "").strip()
+                logging.info("Received response from Gemini.")
+                logging.debug(f"Gemini Response:\n{updated_plan}")
+
+                # Generate PDF for normal updates
+                pdf_buffer = create_care_plan_pdf(updated_plan, patient_name)
+
+                if pdf_buffer:
+                    # Save the PDF to file system with a unique name
+                    timestamp_str = datetime.now().strftime("%Y%m%d%H%M%S")
+                    # Sanitize name for filename
+                    safe_name = re.sub(r'[^\w\s-]', '', patient_name).strip().replace(' ', '_')
+                    if not safe_name:
+                         safe_name = "Patient"
+                    pdf_filename = f"care_plan_{safe_name}_{timestamp_str}.pdf"
+                    pdf_path = os.path.join(app.config['PDF_FOLDER'], pdf_filename)
+
+                    with open(pdf_path, 'wb') as f:
+                        f.write(pdf_buffer.getvalue())
+                    logging.info(f"PDF saved: {pdf_path}")
+
+                    # Construct download URL (relative path)
+                    pdf_download_url = url_for('download_pdf', filename=pdf_filename)
+                    logging.info(f"PDF download URL: {pdf_download_url}")
+
+                    # Reset the buffer pointer for potential reuse (e.g., sending via WhatsApp)
+                    pdf_buffer.seek(0)
+
+                    # Send WhatsApp message with PDF link/info if phone number is provided
+                    if patient_phone:
+                         whatsapp_message_body = (
+                             f"Hello {patient_name},\n\nYour updated care plan is ready based on your feedback. "
+                             f"You can view or download it here: [Link Placeholder - See app for actual download] "
+                             f"\n\nPlease review it and contact your healthcare provider if you have any questions or if your symptoms change."
+                         )
+                         # Note: The PDF is not actually attached via media_url in this local demo setup
+                         # due to public URL requirements. The message body tells the user where to find it.
+                         message_result = send_whatsapp_message(
+                             message=whatsapp_message_body,
+                             recipient=patient_phone
+                             # media_url would go here if using a public URL service
+                         )
+                         message_sent_status = message_result.get('success', False)
+                         logging.info(f"Normal WhatsApp message result: {message_result}")
+                else:
+                    logging.error("PDF buffer is None after creation attempt.")
+                    # Handle case where PDF creation failed
+                    updated_plan += "\n\nNOTE: There was an error generating the PDF version of this plan."
+
+            except Exception as e:
+                logging.error(f"Error during Gemini interaction or PDF generation: {e}")
+                updated_plan = f"Error updating care plan based on feedback: {e}"
+                status = 'error' # Add an error status if AI/PDF fails
+
+        # Store the update history (in-memory list)
+        app.update_history.append({
+            'patient_name': patient_name,
+            'patient_phone': patient_phone,
+            'feedback': feedback,
+            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            'status': status,
+            'updated_plan_text': updated_plan if status == 'normal' else None, # Store text only for normal updates
+            'pdf_filename': pdf_filename, # Store filename for download link
+            'message_sent': message_sent_status,
+            'raw_feedback': feedback # Store original feedback for doctor view
+        })
+        logging.info(f"Update history recorded. Total entries: {len(app.update_history)}")
+
+
         return jsonify({
             'success': True,
             'updated_plan': updated_plan,
-            'pdf_filename': pdf_filename,
-            'message_sent': message_result['success'] if message_result else False,
-            'is_emergency': False
+            'status': status,
+            'pdf_filename': pdf_filename, # Send filename back
+            'pdf_download_url': pdf_download_url, # Send URL back
+            'message_sent': message_sent_status,
         })
 
     except Exception as e:
         import traceback
         traceback.print_exc()
+        logging.error(f"Critical error in submit_feedback: {e}")
         return jsonify({
             'success': False,
-            'error': str(e)
-        })
+            'error': str(e),
+            'status': 'error'
+        }), 500
 
 
-@app.route('/get_emergency_notifications')
-def get_emergency_notifications():
+@app.route('/get_update_history')
+def get_update_history():
+    """Endpoint for doctor dashboard to fetch update history."""
     if session.get('role') != 'doctor':
-        return jsonify({'success': False, 'error': 'Unauthorized'})
+        return jsonify({'success': False, 'error': 'Unauthorized'}), 403
+
+    # Return history in reverse chronological order
+    sorted_history = sorted(app.update_history, key=lambda x: x['timestamp'], reverse=True)
 
-    notifications = getattr(app, 'emergency_notifications', [])
-    return jsonify({'success': True, 'notifications': notifications})
+    return jsonify({'success': True, 'history': sorted_history})
 
 
 if __name__ == '__main__':
-    app.run(debug=True)
+    # In production, use a production-ready server like Gunicorn or uWSGI
+    # and ensure secret key, API keys, and Twilio credentials are set as environment variables.
+    app.run(debug=True) # debug=True should NOT be used in production