old/callbackmanager.py

import gradio as gr
from meldrx import MeldRxAPI
import json
import os
import tempfile
from datetime import datetime
import traceback
import logging
from huggingface_hub import InferenceClient  # Import InferenceClient
from urllib.parse import urlparse, parse_qs  # Import URL parsing utilities

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Import PDF utilities
from utils.pdfutils import PDFGenerator, generate_discharge_summary

# Import necessary libraries for new file types and AI analysis functions
import pydicom  # For DICOM
import hl7  # For HL7
from xml.etree import ElementTree  # For XML and CCDA
from pypdf import PdfReader  # For PDF
import csv  # For CSV
import io  # For IO operations
from PIL import Image  # For image handling

system_instructions = """
**Discharge Guard - Medical Data Analysis Assistant**
**Core Role:** I am Discharge Guard, an advanced AI designed for deep medical data analysis and informational insights. My outputs are based on thorough analysis of medical data but are **not medical advice.**
**Important Guidelines:**
1.  **Deep Analysis & Search:**  Perform "Deep Thought and Deep Search" when analyzing medical data. This includes:
    *   Comprehensive data ingestion from various formats (HL7, FHIR, CCDA, DICOM, PDF, CSV, text).
    *   Multi-layered analysis: surface extraction, deep pattern identification, and inferential reasoning.
    *   Contextual understanding of medical data.
    *   Evidence-based approach, simulating cross-referencing with medical knowledge.
    *   Structured output with clear explanations.
2.  **Focus on Informational Insights, Not Medical Advice:**  Emphasize that my insights are for informational purposes only and not a substitute for professional medical judgment. **Never provide diagnoses or specific treatment recommendations.**
3.  **Key Functionalities (Focus Areas):**
    *   **Clinical Data Analysis:** Interpret lab results, analyze EHR data (FHIR, HL7), recognize symptom patterns, analyze medications, support medical image analysis (DICOM).
    *   **Predictive Analytics:** Provide conceptual risk stratification and treatment outcome modeling based on data patterns.
    *   **Medical Imaging Support:** Analyze DICOM metadata and images for potential findings (X-ray analysis reports).
    *   **Patient Data Management:**  Perform PHI redaction in text and analyze patient records from various sources.
4.  **Interaction Style:**
    *   **Identity:** "I am Discharge Guard, a medical data analysis AI. My insights are informational only and not medical advice."
    *   **Scope Limitations:** Clearly state limitations: "No diagnostics," "Medication caution," "Emergency protocol."
    *   **Response Protocol:**
        *   Indicate "Deep Analysis" or "Deep Search" performed.
        *   Mention data sources and confidence levels (if applicable).
        *   Use medical terminology with optional layman's terms.
        *   For file analysis, provide a report title (e.g., "Deep X-Ray Analysis Report").
5.  **Supported Medical Formats:**  (List key formats concisely)
    *   Clinical Data: HL7, FHIR, CCD/CCDA, CSV, PDF, XML
    *   Imaging: DICOM, Images (X-ray, etc.)
6.  **Data Source:**  Access and prefer FHIR API endpoints from: https://app.meldrx.com/api/directories/fhir/endpoints.
**Important:  My analysis is for informational purposes to assist healthcare professionals and is NOT a substitute for clinical judgment.  Always recommend human expert verification for critical findings.**
"""

# Initialize Inference Client - Ensure YOUR_HF_TOKEN is set in environment variables or replace with your actual token
HF_TOKEN = os.getenv("HF_TOKEN")  # Or replace with your actual token string
if not HF_TOKEN:
    raise ValueError(
        "HF_TOKEN environment variable not set. Please set your Hugging Face API token."
    )
client = InferenceClient(api_key=HF_TOKEN)
model_name = "meta-llama/Llama-3.3-70B-Instruct"  # Specify the model to use


def analyze_dicom_file_with_ai(dicom_file_path):  # Modified to accept file path
    """Analyzes DICOM file metadata using Discharge Guard AI."""
    try:
        dicom_file = pydicom.dcmread(
            dicom_file_path.name
        )  # Read dicom using path, access file through .name for Gradio UploadedFile
        dicom_metadata_json = dicom_file.to_json_dict()
        prediction_response, trace_data_dicom_ai = analyze_dicom_content_ai(
            dicom_metadata_json
        )  # Call content analysis
        if prediction_response:
            report = f"Discharge Guard AI Analysis of DICOM Metadata:\n\nDICOM Metadata Analysis Report:\n{prediction_response}\n\nDisclaimer: The Discharge Guard -generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on DICOM *metadata* and not image interpretation."
            return report
        else:
            error_message = f"AI Analysis from DICOM Metadata: No predictions generated or analysis encountered an issue."
            if trace_data_dicom_ai and "error" in trace_data_dicom_ai:
                error_message += f"\nAI Analysis Failed: {trace_data_dicom_ai['error']}"
            return error_message

    except Exception as e:
        return f"Error during DICOM file processing in analyze_dicom_file_with_ai: {e}"


def analyze_dicom_content_ai(dicom_metadata_json):  # Copied from your code
    """Analyzes DICOM metadata JSON content using Discharge Guard AI."""
    prompt_text = f"""{system_instructions} \n\n Perform a **deep and comprehensive analysis** of the following DICOM metadata in JSON format to provide a **structured summary and identify potential clinically relevant information with deep insights**. Focus not just on summarizing fields, but on **interpreting their clinical significance, identifying subtle patterns, and drawing inferences about the study's implications**. Think like an experienced radiologist reviewing this metadata for crucial diagnostic clues. Remember this is metadata, not the image itself, so focus on what can be gleaned from the data itself. Provide a "**Deep DICOM Metadata Analysis Report**". Important: Use the API Directories fhir endpoints FROM THIS LINK: https://app.meldrx.com/api/directories/fhir/endpoints.
    **DICOM Metadata (JSON):**
    ```json
    {json.dumps(dicom_metadata_json, indent=2)}
    ```
        *   Remember, this deep analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on deep summarization and structuring the extracted metadata in a highly clinically relevant way.
    """

    trace_data_detail_dicom_analysis = {
        "prompt": "DICOM Metadata Analysis Request",
        "language": "English",
        "response_length": "Comprehensive",
        "model_name": "Discharge Guard v1.0",
        "generated_text": "N/A",
        "input_file_types": ["DICOM Metadata JSON"],
        "mode": "DICOM Metadata Analysis",
        "candidates": [],
        "usage_metadata": {},
        "prompt_feedback": "N/A",
    }

    try:
        response = client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": prompt_text}],
            temperature=0.4,
            max_tokens=1024,  # Adjust as needed
            top_p=0.9,
        )
        the_response = response.choices[0].message.content
        return the_response, trace_data_detail_dicom_ai

    except Exception as e:
        error_message = f"AI Analysis Error in analyze_dicom_content_ai (DICOM Metadata): {e}"
        trace_data_detail_dicom_analysis["error"] = f"AI Analysis Error: {e}"
        return error_message, trace_data_detail_dicom_image_analysis


def analyze_hl7_file_with_ai(hl7_file_path):
    """Analyzes HL7 file content using Discharge Guard AI."""
    try:
        with open(hl7_file_path.name, "r") as f:  # Open file using path, access file through .name for Gradio UploadedFile
            hl7_message_raw = f.read()
        prediction_response, trace_data_hl7_ai = analyze_hl7_content_ai(
            hl7_message_raw
        )

        if prediction_response:
            report = f"Discharge Guard AI Analysis of HL7 Message:\n\nHL7 Message Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on HL7 message content."
            return report
        else:
            error_message = f"AI Analysis from HL7 Message: No predictions generated or analysis encountered an issue."
            if trace_data_hl7_ai and "error" in trace_data_hl7_ai:
                error_message += f"AI Analysis Failed: {trace_data_hl7_ai['error']}"
            return error_message

    except Exception as e:
        return f"Error during HL7 file processing in analyze_hl7_file_with_ai: {e}"


def analyze_hl7_content_ai(hl7_message_string):  # Copied from your code
    """Analyzes HL7 message content using Discharge Guard AI."""
    prompt_text = f"""{system_instructions} \n\n Conduct a **deep and thorough analysis** of the following HL7 message content to provide a **structured summary and identify key clinical information with deep understanding**.  Go beyond basic parsing; aim to **interpret the clinical narrative** embedded within the HL7 message.  **Engage in deep search to contextualize medical codes and terminology**. Provide a "**Comprehensive HL7 Message Analysis Report**".
    **HL7 Message Content:**
    ```hl7
    {hl7_message_string}
    ```
        *   Remember, this deep analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on deep summarization and structuring the extracted data in a highly clinically relevant way based on the HL7 content.
    """
    # ... (rest of the function code) ...
    trace_data_detail_hl7_analysis = {
        "prompt": "HL7 Message Analysis Request",
        "language": "English",
        "response_length": "Comprehensive",
        "model_name": "Discharge Guard v1.0",
        "generated_text": "N/A",
        "input_file_types": ["HL7 Message"],
        "mode": "HL7 Message Analysis",
        "candidates": [],
        "usage_metadata": {},
        "prompt_feedback": "N/A",
    }

    try:
        response = client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": prompt_text}],
            temperature=0.4,
            max_tokens=1024,  # Adjust as needed
            top_p=0.9,
        )
        the_response = response.choices[0].message.content
        return the_response, trace_data_detail_hl7_analysis

    except Exception as e:
        error_message = f"AI Analysis Error in analyze_hl7_content_ai (HL7 Message): {e}"
        trace_data_detail_hl7_analysis["error"] = f"AI Analysis Error: {e}"
        return error_message, trace_data_detail_hl7_analysis


def analyze_cda_xml_file_with_ai(cda_xml_file_path):  # Modified to accept file path
    """Analyzes generic CDA or XML file content using Discharge Guard AI (more generalized version) Important: Use the API Directories fhir endpoints FROM THIS LINK: https://app.meldrx.com/api/directories/fhir/endpoints."""
    try:
        with open(
            cda_xml_file_path.name, "r"
        ) as f:  # Open file using path, access file through .name for Gradio UploadedFile
            cda_xml_content = f.read()
        prediction_response, trace_data_cda_xml_ai = analyze_cda_xml_content_ai(
            cda_xml_content
        )
        if prediction_response:
            report = f"Discharge Guard AI Analysis of Medical XML/CDA Data:\n\nMedical Document Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on XML/CDA content."
            return report
        else:
            error_message = f"AI Analysis from XML/CDA Data: No predictions generated or analysis encountered an issue."
            if trace_data_cda_xml_ai and "error" in trace_data_cda_xml_ai:
                error_message += f"AI Analysis Failed: {trace_data_cda_xml_ai['error']}"
            return error_message

    except Exception as e:
        return f"Error during XML/CDA file processing in analyze_cda_xml_file_with_ai: {e}"


def analyze_cda_xml_content_ai(cda_xml_content):  # Copied from your code
    """Analyzes generic CDA or XML content using Discharge Guard AI (more generalized version)."""

    prompt_text = f"""{system_instructions} \n\n Analyze the following medical XML/CDA content to provide a **structured and comprehensive patient data analysis**, similar to how a medical professional would review a patient's chart or a clinical document. You need to parse the XML structure yourself to extract the relevant information. Use bullet points, tables, or numbered steps for complex tasks. Provide a "Medical Document Analysis" report.
    **Instructions for Discharge Guard AI:**
    1.  **Parse the XML content above.** Understand the XML structure to identify sections that are relevant to clinical information.  For CDA specifically, look for sections like Problems, Medications, Allergies, Encounters, Results, and Vital Signs. For generic medical XML, adapt based on the tags present.
    2.  **Extract and Summarize Key Medical Information:** Focus on extracting the following information if present in the XML:
        *   **Patient Demographics Summary:** (If available, summarize demographic details)
        ... (rest of your prompt_text for CDA/XML analysis) ...
        *   Remember, this analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on summarizing and structuring the extracted data in a clinically relevant way based on the XML/CDA content.
    """

    trace_data_detail_cda_xml_analysis = {
        "prompt": "Generic CDA/XML Analysis Request",
        "language": "English",
        "response_length": "Comprehensive",
        "model_name": "Discharge Guard v1.0",
        "generated_text": "N/A",
        "input_file_types": ["CDA/XML"],
        "mode": "Generic XML/CDA Analysis",
        "candidates": [],
        "usage_metadata": {},
        "prompt_feedback": "N/A",
    }

    try:
        response = client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": prompt_text}],
            temperature=0.4,
            max_tokens=1024,  # Adjust as needed
            top_p=0.9,
        )
        the_response = response.choices[0].message.content
        return the_response, trace_data_detail_cda_xml_analysis

    except Exception as e:
        error_message = f"AI Analysis Error in analyze_cda_xml_content_ai (Generic XML/CDA): {e}"
        trace_data_detail_cda_xml_analysis["error"] = f"AI Analysis Error: {e}"
        return error_message, trace_data_detail_cda_xml_analysis


def analyze_pdf_file_with_ai(pdf_file_path):  # Modified to accept file path
    """Analyzes PDF file content using Discharge Guard AI."""
    try:
        with open(
            pdf_file_path.name, "rb"
        ) as f:  # Open file in binary mode for PdfReader, access file through .name for Gradio UploadedFile
            pdf_file = f  # Pass file object to PdfReader
            pdf_reader = PdfReader(pdf_file)
            text_content = ""
            for page in pdf_reader.pages:
                text_content += page.extract_text()

        prediction_response, trace_data_pdf_ai = analyze_pdf_content_ai(
            text_content
        )

        if prediction_response:
            report = f"Discharge Guard AI Analysis of PDF Content:\n\nMedical Report Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on PDF text content."
            return report
        else:
            error_message = f"AI Analysis from PDF Content: No predictions generated or analysis encountered an issue."
            if trace_data_pdf_ai and "error" in trace_data_pdf_ai:
                error_message += f"AI Analysis Failed: {trace_data_pdf_ai['error']}"
            return error_message

    except Exception as e:
        return f"Error during PDF file processing in analyze_pdf_file_with_ai: {e}"


def analyze_pdf_content_ai(pdf_text_content):  # Copied from your code
    """Analyzes PDF text content using Discharge Guard AI."""
    prompt_text = f"""{system_instructions} \n\n Analyze the following medical PDF text content to provide a **structured summary and identify key clinical information**. Focus on patient demographics, medical history, findings, diagnoses, medications, recommendations, and any important clinical details conveyed in the document. Provide a "Medical Report Analysis" report.
    **Medical PDF Text Content:**
    ```text
    {pdf_text_content}
    ```
        *   Remember, this analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on deep summarization and structuring the extracted data in a clinically relevant way based on the PDF content.
    """

    trace_data_detail_pdf_analysis = {
        "prompt": "PDF Text Analysis Request",
        "language": "English",
        "response_length": "Comprehensive",
        "model_name": "Discharge Guard v1.0",
        "generated_text": "N/A",
        "input_file_types": ["PDF Text"],
        "mode": "PDF Text Analysis",
        "candidates": [],
        "usage_metadata": {},
        "prompt_feedback": "N/A",
    }

    try:
        response = client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": prompt_text}],
            temperature=0.4,
            max_tokens=1024,  # Adjust as needed
            top_p=0.9,
        )
        the_response = response.choices[0].message.content
        return the_response, trace_data_detail_pdf_analysis

    except Exception as e:
        error_message = f"AI Analysis Error in analyze_pdf_content_ai (PDF Text): {e}"
        trace_data_detail_pdf_analysis["error"] = f"AI Analysis Error: {e}"
        return error_message, trace_data_detail_pdf_analysis


def analyze_csv_file_with_ai(csv_file_path):  # Modified to accept file path
    """Analyzes CSV file content using Discharge Guard AI."""
    try:
        csv_content = csv_file_path.read().decode(
            "utf-8"
        )  # Read content directly from UploadedFile
        prediction_response, trace_data_csv_ai = analyze_csv_content_ai(csv_content)

        if prediction_response:
            report = f"Discharge Guard AI Analysis of CSV Data:\n\nData Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on CSV data content."
            return report
        else:
            error_message = f"AI Analysis from CSV Data: No predictions generated or analysis encountered an issue."
            if trace_data_csv_ai and "error" in trace_data_csv_ai:
                error_message += f"AI Analysis Failed: {trace_data_csv_ai['error']}"
            return error_message

    except Exception as e:
        return f"Error during CSV file processing in analyze_csv_file_with_ai: {e}"


def analyze_csv_content_ai(csv_content_string):  # Copied from your code
    """Analyzes CSV content (string) using Discharge Guard AI."""
    prompt_text = f"""{system_instructions} \n\n Analyze the following medical CSV data to provide a **structured summary and identify potential clinical insights**. Assume the CSV represents patient-related medical data. Focus on understanding the columns, summarizing key data points, identifying trends or patterns, and noting any potential clinical significance of the data. Provide a "Data Analysis" report.
    **Medical CSV Data:**
    ```csv
    {csv_content_string}
    ```
        *   Remember, this analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on summarizing and structuring the data in a clinically relevant way based on the CSV content.
    """

    trace_data_detail_csv_analysis = {
        "prompt": "CSV Data Analysis Request",
        "language": "English",
        "response_length": "Comprehensive",
        "model_name": "Discharge Guard v1.0",
        "generated_text": "N/A",
        "input_file_types": ["CSV Data"],
        "mode": "CSV Data Analysis",
        "candidates": [],
        "usage_metadata": {},
        "prompt_feedback": "N/A",
    }

    try:
        response = client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": prompt_text}],
            temperature=0.4,
            max_tokens=1024,  # Adjust as needed
            top_p=0.9,
        )
        the_response = response.choices[0].message.content
        return the_response, trace_data_detail_csv_analysis

    except Exception as e:
        error_message = f"AI Analysis Error in analyze_csv_content_ai (CSV Data): {e}"
        trace_data_detail_csv_analysis["error"] = f"AI Analysis Error: {e}"
        return error_message, trace_data_detail_csv_analysis


class CallbackManager:
    def __init__(self, redirect_uri: str, client_secret: str = None):
        client_id = os.getenv("APPID")
        if not client_id:
            raise ValueError("APPID environment variable not set.")
        workspace_id = os.getenv("WORKSPACE_URL")
        if not workspace_id:
            raise ValueError("WORKSPACE_URL environment variable not set.")
        self.api = MeldRxAPI(client_id, client_secret, workspace_id, redirect_uri)
        self.auth_code = None
        self.access_token = None

    def get_auth_url(self) -> str:
        return self.api.get_authorization_url()

    def set_auth_code(self, code: str) -> str:
        self.auth_code = code
        if self.api.authenticate_with_code(code):
            self.access_token = self.api.access_token
            return (
                f"<span style='color:#00FF7F;'>Authentication successful!</span> Access Token: {self.access_token[:10]}... (truncated)"  # Neon Green Success
            )
        return "<span style='color:#FF4500;'>Authentication failed. Please check the code.</span>"  # Neon Orange Error

    def get_patient_data(self) -> str:
        """Fetch patient data from MeldRx"""
        try:
            if not self.access_token:
                logger.warning("Not authenticated when getting patient data")
                return "<span style='color:#FF8C00;'>Not authenticated. Please provide a valid authorization code first.</span>"  # Neon Dark Orange

            # Real implementation with API call
            logger.info("Calling Meldrx API to get patients")
            patients = self.api.get_patients()
            if patients is not None:
                return (
                    json.dumps(patients, indent=2)
                    if patients
                    else "<span style='color:#FFFF00;'>No patient data returned.</span>"  # Neon Yellow
                )
            return "<span style='color:#DC143C;'>Failed to retrieve patient data.</span>"  # Crimson Error
        except Exception as e:
            error_msg = f"Error in get_patient_data: {str(e)}"
            logger.error(error_msg)
            return f"<span style='color:#FF6347;'>Error retrieving patient data: {str(e)}</span> {str(e)}"  # Tomato Error

    def get_patient_documents(self, patient_id: str = None):
        """Fetch patient documents from MeldRx"""
        if not self.access_token:
            return "<span style='color:#FF8C00;'>Not authenticated. Please provide a valid authorization code first.</span>"  # Neon Dark Orange

        try:
            # This would call the actual MeldRx API to get documents for a specific patient
            # For demonstration, we'll return mock document data
            return [
                {
                    "doc_id": "doc123",
                    "type": "clinical_note",
                    "date": "2023-01-16",
                    "author": "Dr. Sample Doctor",
                    "content": "Patient presented with symptoms of respiratory distress...",
                },
                {
                    "doc_id": "doc124",
                    "type": "lab_result",
                    "date": "2023-01-17",
                    "author": "Lab System",
                    "content": "CBC results: WBC 7.5, RBC 4.2, Hgb 14.1...",
                },
            ]
        except Exception as e:
            return f"<span style='color:#FF6347;'>Error retrieving patient documents: {str(e)}</span>: {str(e)}"  # Tomato Error


def display_form(
    first_name,
    last_name,
    middle_initial,
    dob,
    age,
    sex,
    address,
    city,
    state,
    zip_code,
    doctor_first_name,
    doctor_last_name,
    doctor_middle_initial,
    hospital_name,
    doctor_address,
    doctor_city,
    doctor_state,
    doctor_zip,
    admission_date,
    referral_source,
    admission_method,
    discharge_date,
    discharge_reason,
    date_of_death,
    diagnosis,
    procedures,
    medications,
    preparer_name,
    preparer_job_title,
):
    form = f"""
    <div style='color:#00FFFF; font-family: monospace;'>
    **Patient Discharge Form** <br>
    - Name: {first_name} {middle_initial} {last_name} <br>
    - Date of Birth: {dob}, Age: {age}, Sex: {sex} <br>
    - Address: {address}, {city}, {state}, {zip_code} <br>
    - Doctor: {doctor_first_name} {doctor_middle_initial} {doctor_last_name} <br>
    - Hospital/Clinic: {hospital_name} <br>
    - Doctor Address: {doctor_address}, {doctor_city}, {doctor_state}, {doctor_zip} <br>
    - Admission Date: {admission_date}, Source: {referral_source}, Method: {admission_method} <br>
    - Discharge Date: {discharge_date}, Reason: {discharge_reason} <br>
    - Date of Death: {date_of_death} <br>
    - Diagnosis: {diagnosis} <br>
    - Procedures: {procedures} <br>
    - Medications: {medications} <br>
    - Prepared By: {preparer_name}, {preparer_job_title}
    </div>
    """
    return form


def generate_pdf_from_form(
    first_name,
    last_name,
    middle_initial,
    dob,
    age,
    sex,
    address,
    city,
    state,
    zip_code,
    doctor_first_name,
    doctor_last_name,
    doctor_middle_initial,
    hospital_name,
    doctor_address,
    doctor_city,
    doctor_state,
    doctor_zip,
    admission_date,
    referral_source,
    admission_method,
    discharge_date,
    discharge_reason,
    date_of_death,
    diagnosis,
    procedures,
    medications,
    preparer_name,
    preparer_job_title,
):
    """Generate a PDF discharge form using the provided data"""

    # Create PDF generator
    pdf_gen = PDFGenerator()

    # Format data for PDF generation
    patient_info = {
        "first_name": first_name,
        "last_name": last_name,
        "dob": dob,
        "age": age,
        "sex": sex,
        "mobile": "",  # Not collected in the form
        "address": address,
        "city": city,
        "state": state,
        "zip": zip_code,
    }

    discharge_info = {
        "date_of_admission": admission_date,
        "date_of_discharge": discharge_date,
        "source_of_admission": referral_source,
        "mode_of_admission": admission_method,
        "discharge_against_advice": "Yes"
        if discharge_reason == "Discharge Against Advice"
        else "No",
    }

    diagnosis_info = {
        "diagnosis": diagnosis,
        "operation_procedure": procedures,
        "treatment": "",  # Not collected in the form
        "follow_up": "",  # Not collected in the form
    }

    medication_info = {
        "medications": [medications] if medications else [],
        "instructions": "",  # Not collected in the form
    }

    prepared_by = {
        "name": preparer_name,
        "title": preparer_job_title,
        "signature": "",  # Not collected in the form
    }

    # Generate PDF
    pdf_buffer = pdf_gen.generate_discharge_form(
        patient_info,
        discharge_info,
        diagnosis_info,
        medication_info,
        prepared_by,
    )

    # Create temporary file to save the PDF
    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
    temp_file.write(pdf_buffer.read())
    temp_file_path = temp_file.name
    temp_file.close()

    return temp_file_path


def generate_pdf_from_meldrx(patient_data):
    """Generate a PDF using patient data from MeldRx"""
    if isinstance(patient_data, str):
        # If it's a string (error message or JSON string), try to parse it
        try:
            patient_data = json.loads(patient_data)
        except:
            return None, "Invalid patient data format"

    if not patient_data:
        return None, "No patient data available"

    try:
        # For demonstration, we'll use the first patient in the list if it's a list
        if isinstance(patient_data, list) and len(patient_data):
            patient = patient_data[0]
        else:
            patient = patient_data

        # Extract patient info
        patient_info = {
            "name": f"{patient.get('name', {}).get('given', [''])[0]} {patient.get('name', {}).get('family', '')}",
            "dob": patient.get("birthDate", "Unknown"),
            "patient_id": patient.get("id", "Unknown"),
            "admission_date": datetime.now().strftime("%Y-%m-%d"),  # Mock data
            "physician": "Dr. Provider",  # Mock data
        }

        # Mock LLM-generated content -  This part needs to be replaced with actual AI generation if desired for MeldRx PDF
        llm_content = {
            "diagnosis": "Diagnosis information would be generated by AI based on patient data from MeldRx.",
            "treatment": "Treatment summary would be generated by AI based on patient data from MeldRx.",
            "medications": "Medication list would be generated by AI based on patient data from MeldRx.",
            "follow_up": "Follow-up instructions would be generated by AI based on patient data from MeldRx.",
            "special_instructions": "Special instructions would be generated by AI based on patient data from MeldRx.",
        }

        # Create discharge summary - Using No-AI PDF generation for now, replace with AI-content generation later
        output_dir = tempfile.mkdtemp()
        pdf_path = generate_discharge_summary(
            patient_info, llm_content, output_dir
        )  # Still using No-AI template

        return pdf_path, "PDF generated successfully (No AI Content in PDF yet)"  # Indicate No-AI content

    except Exception as e:
        return None, f"Error generating PDF: {str(e)}"


def generate_discharge_paper_one_click():
    """One-click function to fetch patient data and generate discharge paper with AI Content."""
    patient_data_str = CALLBACK_MANAGER.get_patient_data()
    if (
        patient_data_str.startswith("Not authenticated")
        or patient_data_str.startswith("Failed")
        or patient_data_str.startswith("Error")
    ):
        return None, patient_data_str  # Return error message if authentication or data fetch fails

    try:
        patient_data = json.loads(patient_data_str)

        # --- AI Content Generation for Discharge Summary ---
        # This is a placeholder - Replace with actual AI call using InferenceClient and patient_data to generate content
        ai_generated_content = generate_ai_discharge_content(
            patient_data
        )  # Placeholder AI function

        if not ai_generated_content:
            return None, "Error: AI content generation failed."

        # --- PDF Generation with AI Content ---
        pdf_path, status_message = generate_pdf_from_meldrx_with_ai_content(
            patient_data, ai_generated_content
        )  # Function to generate PDF with AI content

        if pdf_path:
            return pdf_path, status_message
        else:
            return None, status_message  # Return status message if PDF generation fails

    except json.JSONDecodeError:
        return None, "Error: Patient data is not in valid JSON format."
    except Exception as e:
        return None, f"Error during discharge paper generation: {str(e)}"


def generate_ai_discharge_content(patient_data):
    """Placeholder function to generate AI content for discharge summary.
    Replace this with actual AI call using InferenceClient and patient_data."""
    try:
        patient_name = (
            f"{patient_data['entry'][0]['resource']['name'][0]['given'][0]} {patient_data['entry'][0]['resource']['name'][0]['family']}"
            if patient_data.get("entry")
            else "Unknown Patient"
        )
        prompt_text = f"""{system_instructions}\n\nGenerate a discharge summary content (diagnosis, treatment, medications, follow-up instructions, special instructions) for patient: {patient_name}. Base the content on available patient data (if any provided, currently not provided in detail in this mock-up). Focus on creating clinically relevant and informative summary.  Remember this is for informational purposes and NOT medical advice."""

        response = client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": prompt_text}],
            temperature=0.6,  # Adjust temperature as needed for content generation
            max_tokens=1024,  # Adjust max_tokens as needed
            top_p=0.9,
        )
        ai_content = response.choices[0].message.content

        # Basic parsing of AI content - improve this based on desired output structure from LLM
        llm_content = {
            "diagnosis": "AI Generated Diagnosis (Placeholder):\n"
            + extract_section(ai_content, "Diagnosis"),  # Example extraction - refine based on LLM output
            "treatment": "AI Generated Treatment (Placeholder):\n"
            + extract_section(ai_content, "Treatment"),
            "medications": "AI Generated Medications (Placeholder):\n"
            + extract_section(ai_content, "Medications"),
            "follow_up": "AI Generated Follow-up (Placeholder):\n"
            + extract_section(ai_content, "Follow-up Instructions"),
            "special_instructions": "AI Generated Special Instructions (Placeholder):\n"
            + extract_section(ai_content, "Special Instructions"),
        }
        return llm_content

    except Exception as e:
        logger.error(f"Error generating AI discharge content: {e}")
        return None


def extract_section(ai_content, section_title):
    """Simple placeholder function to extract section from AI content.
    Improve this with more robust parsing based on LLM output format."""
    start_marker = f"**{section_title}:**"
    end_marker = "\n\n"  # Adjust based on typical LLM output structure
    start_index = ai_content.find(start_marker)
    if start_index != -1:
        start_index += len(start_marker)
        end_index = ai_content.find(end_marker, start_index)
        if end_index != -1:
            return ai_content[start_index:end_index].strip()
    return "Not found in AI output."


def generate_pdf_from_meldrx_with_ai_content(patient_data, llm_content):
    """Generate a PDF using patient data from MeldRx and AI-generated content."""
    if isinstance(patient_data, str):
        try:
            patient_data = json.loads(patient_data)
        except:
            return None, "Invalid patient data format"

    if not patient_data:
        return None, "No patient data available"

    try:
        if isinstance(patient_data, list) and len(patient_data):
            patient = patient_data[0]
        else:
            patient = patient_data

        patient_info = {
            "name": f"{patient.get('name', {}).get('given', [''])[0]} {patient.get('name', {}).get('family', '')}",
            "dob": patient.get("birthDate", "Unknown"),
            "patient_id": patient.get("id", "Unknown"),
            "admission_date": datetime.now().strftime("%Y-%m-%d"),  # Mock data
            "physician": "Dr. AI Provider",  # Mock data - Indicate AI generated
        }

        output_dir = tempfile.mkdtemp()
        pdf_path = generate_discharge_summary(
            patient_info, llm_content, output_dir
        )  # Using AI content now

        return pdf_path, "PDF generated successfully with AI Content"  # Indicate AI content

    except Exception as e:
        return None, f"Error generating PDF with AI content: {str(e)}"


def extract_auth_code_from_url(redirected_url):
    """Extracts the authorization code from the redirected URL."""
    try:
        parsed_url = urlparse(redirected_url)
        query_params = parse_qs(parsed_url.query)
        if "code" in query_params:
            return query_params["code"][0], None  # Return code and no error
        else:
            return None, "Authorization code not found in URL."  # Return None and error message
    except Exception as e:
        return None, f"Error parsing URL: {e}"  # Return None and error message


# Create a simplified interface to avoid complex component interactions
CALLBACK_MANAGER = CallbackManager(
    redirect_uri="https://multitransformer-discharge-guard.hf.space/callback",
    client_secret=None,
)

# Define the cyberpunk theme - using a dark base and neon accents
cyberpunk_theme = gr.themes.Monochrome(
    primary_hue="cyan",
    secondary_hue="pink",
    neutral_hue="slate",
    font=["Source Code Pro", "monospace"],  # Retro monospace font
    font_mono=["Source Code Pro", "monospace"],
)

# Create the UI with the cyberpunk theme
with gr.Blocks(theme=cyberpunk_theme) as demo:  # Apply the theme here
    gr.Markdown(
        "<h1 style='color:#00FFFF; text-shadow: 0 0 5px #00FFFF;'>Discharge Guard <span style='color:#FF00FF; text-shadow: 0 0 5px #FF00FF;'>Cyber</span></h1>"
    )  # Cyberpunk Title

    with gr.Tab("Authenticate with MeldRx", elem_classes="cyberpunk-tab"):  # Optional: Class for tab styling
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>SMART on FHIR Authentication</h2>"
        )  # Neon Tab Header
        auth_url_output = gr.Textbox(
            label="Authorization URL",
            value=CALLBACK_MANAGER.get_auth_url(),
            interactive=False,
        )
        gr.Markdown(
            "<p style='color:#A9A9A9;'>Copy the URL above, open it in a browser, log in, and paste the <span style='color:#00FFFF;'>entire redirected URL</span> from your browser's address bar below.</p>"
        )  # Subdued instructions with neon highlight
        redirected_url_input = gr.Textbox(label="Redirected URL")  # New textbox for redirected URL
        extract_code_button = gr.Button(
            "Extract Authorization Code", elem_classes="cyberpunk-button"
        )  # Cyberpunk button style
        extracted_code_output = gr.Textbox(
            label="Extracted Authorization Code", interactive=False
        )  # Textbox to show extracted code

        auth_code_input = gr.Textbox(
            label="Authorization Code (from above, or paste manually if extraction fails)",
            interactive=True,
        )  # Updated label to be clearer
        auth_submit = gr.Button(
            "Submit Code for Authentication", elem_classes="cyberpunk-button"
        )  # Cyberpunk button style
        auth_result = gr.HTML(label="Authentication Result")  # Use HTML for styled result

        patient_data_button = gr.Button(
            "Fetch Patient Data", elem_classes="cyberpunk-button"
        )  # Cyberpunk button style
        patient_data_output = gr.Textbox(label="Patient Data", lines=10)

        # Add button to generate PDF from MeldRx data (No AI)
        meldrx_pdf_button = gr.Button(
            "Generate PDF from MeldRx Data (No AI)", elem_classes="cyberpunk-button"
        )  # Renamed button
        meldrx_pdf_status = gr.Textbox(
            label="PDF Generation Status (No AI)"
        )  # Renamed status
        meldrx_pdf_download = gr.File(
            label="Download Generated PDF (No AI)"
        )  # Renamed download

        def process_redirected_url(redirected_url):
            """Processes the redirected URL to extract and display the authorization code."""
            auth_code, error_message = extract_auth_code_from_url(redirected_url)
            if auth_code:
                return auth_code, "<span style='color:#00FF7F;'>Authorization code extracted!</span>"  # Neon Green Success
            else:
                return "", f"<span style='color:#FF4500;'>Could not extract authorization code.</span> {error_message or ''}"  # Neon Orange Error

        extract_code_button.click(
            fn=process_redirected_url,
            inputs=redirected_url_input,
            outputs=[
                extracted_code_output,
                auth_result,
            ],  # Reusing auth_result for extraction status
        )

        auth_submit.click(
            fn=CALLBACK_MANAGER.set_auth_code,
            inputs=extracted_code_output,  # Using extracted code as input for authentication
            outputs=auth_result,
        )

    with gr.Tab(
        "Patient Dashboard", elem_classes="cyberpunk-tab"
    ):  # Optional: Class for tab styling
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Patient Data</h2>"
        )  # Neon Tab Header
        dashboard_output = gr.HTML(
            "<p style='color:#A9A9A9;'>Fetch patient data from the Authentication tab first.</p>"
        )  # Subdued placeholder text

        refresh_btn = gr.Button(
            "Refresh Data", elem_classes="cyberpunk-button"
        )  # Cyberpunk button style

        # Simple function to update dashboard based on fetched data
        def update_dashboard():
            try:
                data = CALLBACK_MANAGER.get_patient_data()
                if (
                    data.startswith("<span style='color:#FF8C00;'>Not authenticated")
                    or data.startswith("<span style='color:#DC143C;'>Failed")
                    or data.startswith("<span style='color:#FF6347;'>Error")
                ):
                    return f"<p style='color:#FF8C00;'>{data}</p>"  # Show auth errors in orange

                try:
                    # Parse the data
                    patients_data = json.loads(data)
                    patients = []

                    # Extract patients from bundle
                    for entry in patients_data.get("entry", []):
                        resource = entry.get("resource", {})
                        if resource.get("resourceType") == "Patient":
                            patients.append(resource)

                    # Generate HTML card
                    html = "<h3 style='color:#00FFFF; text-shadow: 0 0 2px #00FFFF;'>Patients</h3>"  # Neon Sub-header
                    for patient in patients:
                        # Extract name
                        name = patient.get("name", [{}])[0]
                        given = " ".join(name.get("given", ["Unknown"]))
                        family = name.get("family", "Unknown")

                        # Extract other details
                        gender = patient.get("gender", "unknown").capitalize()
                        birth_date = patient.get("birthDate", "Unknown")

                        # Generate HTML card with cyberpunk styling
                        html += f"""
                        <div style="border: 1px solid #00FFFF; padding: 10px; margin: 10px 0; border-radius: 5px; background-color: #222; box-shadow: 0 0 5px #00FFFF;">
                            <h4 style='color:#00FFFF;'>{given} {family}</h4>
                            <p style='color:#A9A9A9;'><strong>Gender:</strong> <span style='color:#00FFFF;'>{gender}</span></p>
                            <p style='color:#A9A9A9;'><strong>Birth Date:</strong> <span style='color:#00FFFF;'>{birth_date}</span></p>
                            <p style='color:#A9A9A9;'><strong>ID:</strong> <span style='color:#00FFFF;'>{patient.get("id", "Unknown")}</span></p>
                        </div>
                        """

                    return html
                except Exception as e:
                    return f"<p style='color:#FF6347;'>Error parsing patient data: {str(e)}</p>"  # Tomato Error
            except Exception as e:
                return f"<p style='color:#FF6347;'>Error fetching patient data: {str(e)}</p>"  # Tomato Error

        refresh_btn.click(fn=update_dashboard, inputs=None, outputs=dashboard_output)

    with gr.Tab("Discharge Form", elem_classes="cyberpunk-tab"):  # Optional: Class for tab styling
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Patient Details</h2>"
        )  # Neon Tab Header
        with gr.Row():
            first_name = gr.Textbox(label="First Name")
            last_name = gr.Textbox(label="Last Name")
            middle_initial = gr.Textbox(label="Middle Initial")
        with gr.Row():
            dob = gr.Textbox(label="Date of Birth")
            age = gr.Textbox(label="Age")
            sex = gr.Textbox(label="Sex")
        address = gr.Textbox(label="Address")
        with gr.Row():
            city = gr.Textbox(label="City")
            state = gr.Textbox(label="State")
            zip_code = gr.Textbox(label="Zip Code")
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Primary Healthcare Professional Details</h2>"
        )  # Neon Sub-header
        with gr.Row():
            doctor_first_name = gr.Textbox(label="Doctor's First Name")
            doctor_last_name = gr.Textbox(label="Doctor's Last Name")
            doctor_middle_initial = gr.Textbox(label="Doctor's Middle Initial")
        hospital_name = gr.Textbox(label="Hospital/Clinic Name")
        doctor_address = gr.Textbox(label="Address")
        with gr.Row():
            doctor_city = gr.Textbox(label="City")
            doctor_state = gr.Textbox(label="State")
            doctor_zip = gr.Textbox(label="Zip Code")
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Admission and Discharge Details</h2>"
        )  # Neon Sub-header
        with gr.Row():
            admission_date = gr.Textbox(label="Date of Admission")
            referral_source = gr.Textbox(label="Source of Referral")
        admission_method = gr.Textbox(label="Method of Admission")
        with gr.Row():
            discharge_date = gr.Textbox(label="Date of Discharge")
            discharge_reason = gr.Radio(
                ["Treated", "Transferred", "Discharge Against Advice", "Patient Died"],
                label="Discharge Reason",
            )
        date_of_death = gr.Textbox(label="Date of Death (if applicable)")
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Diagnosis & Procedures</h2>"
        )  # Neon Sub-header
        diagnosis = gr.Textbox(label="Diagnosis")
        procedures = gr.Textbox(label="Operation & Procedures")
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Medication Details</h2>"
        )  # Neon Sub-header
        medications = gr.Textbox(label="Medication on Discharge")
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Prepared By</h2>"
        )  # Neon Sub-header
        with gr.Row():
            preparer_name = gr.Textbox(label="Name")
            preparer_job_title = gr.Textbox(label="Job Title")

        # Add buttons for both display form and generate PDF
        with gr.Row():
            submit_display = gr.Button(
                "Display Form", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style
            submit_pdf = gr.Button(
                "Generate PDF (No AI)", elem_classes="cyberpunk-button"
            )  # Renamed button to clarify no AI and styled

        # Output areas
        form_output = gr.HTML()  # Use HTML to render styled form
        pdf_output = gr.File(
            label="Download PDF (No AI)"
        )  # Renamed output to clarify no AI

        # Connect the display form button
        submit_display.click(
            display_form,
            inputs=[
                first_name,
                last_name,
                middle_initial,
                dob,
                age,
                sex,
                address,
                city,
                state,
                zip_code,
                doctor_first_name,
                doctor_last_name,
                doctor_middle_initial,
                hospital_name,
                doctor_address,
                doctor_city,
                doctor_state,
                doctor_zip,
                admission_date,
                referral_source,
                admission_method,
                discharge_date,
                discharge_reason,
                date_of_death,
                diagnosis,
                procedures,
                medications,
                preparer_name,
                preparer_job_title,
            ],
            outputs=form_output,
        )

        # Connect the generate PDF button (No AI version)
        submit_pdf.click(
            generate_pdf_from_form,
            inputs=[
                first_name,
                last_name,
                middle_initial,
                dob,
                age,
                sex,
                address,
                city,
                state,
                zip_code,
                doctor_first_name,
                doctor_last_name,
                doctor_middle_initial,
                hospital_name,
                doctor_address,
                doctor_city,
                doctor_state,
                doctor_zip,
                admission_date,
                referral_source,
                admission_method,
                discharge_date,
                discharge_reason,
                date_of_death,
                diagnosis,
                procedures,
                medications,
                preparer_name,
                preparer_job_title,
            ],
            outputs=pdf_output,
        )

    with gr.Tab(
        "Medical File Analysis", elem_classes="cyberpunk-tab"
    ):  # Optional: Class for tab styling
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Analyze Medical Files with Discharge Guard AI</h2>"
        )  # Neon Tab Header
        with gr.Column():
            dicom_file = gr.File(
                file_types=[".dcm"], label="Upload DICOM File (.dcm)"
            )
            dicom_ai_output = gr.Textbox(label="DICOM Analysis Report", lines=5)
            analyze_dicom_button = gr.Button(
                "Analyze DICOM with AI", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style

            hl7_file = gr.File(file_types=[".hl7"], label="Upload HL7 File (.hl7)")
            hl7_ai_output = gr.Textbox(label="HL7 Analysis Report", lines=5)
            analyze_hl7_button = gr.Button(
                "Analyze HL7 with AI", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style

            xml_file = gr.File(file_types=[".xml"], label="Upload XML File (.xml)")
            xml_ai_output = gr.Textbox(label="XML Analysis Report", lines=5)
            analyze_xml_button = gr.Button(
                "Analyze XML with AI", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style

            ccda_file = gr.File(
                file_types=[".xml", ".cda", ".ccd"],
                label="Upload CCDA File (.xml, .cda, .ccd)",
            )
            ccda_ai_output = gr.Textbox(label="CCDA Analysis Report", lines=5)
            analyze_ccda_button = gr.Button(
                "Analyze CCDA with AI", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style

            ccd_file = gr.File(
                file_types=[".ccd"],
                label="Upload CCD File (.ccd)",
            )  # Redundant, as CCDA also handles .ccd, but kept for clarity
            ccd_ai_output = gr.Textbox(
                label="CCD Analysis Report", lines=5
            )  # Redundant
            analyze_ccd_button = gr.Button(
                "Analyze CCD with AI", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style # Redundant
            pdf_file = gr.File(file_types=[".pdf"], label="Upload PDF File (.pdf)")
            pdf_ai_output = gr.Textbox(label="PDF Analysis Report", lines=5)
            analyze_pdf_button = gr.Button(
                "Analyze PDF with AI", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style

            csv_file = gr.File(file_types=[".csv"], label="Upload CSV File (.csv)")
            csv_ai_output = gr.Textbox(label="CSV Analysis Report", lines=5)
            analyze_csv_button = gr.Button(
                "Analyze CSV with AI", elem_classes="cyberpunk-button"
            )  # Cyberpunk button style

        # Connect AI Analysis Buttons - using REAL AI functions now
        analyze_dicom_button.click(
            analyze_dicom_file_with_ai,  # Call REAL AI function
            inputs=dicom_file,
            outputs=dicom_ai_output,
        )
        analyze_hl7_button.click(
            analyze_hl7_file_with_ai,  # Call REAL AI function
            inputs=hl7_file,
            outputs=hl7_ai_output,
        )
        analyze_xml_button.click(
            analyze_cda_xml_file_with_ai,  # Call REAL AI function
            inputs=xml_file,
            outputs=xml_ai_output,
        )
        analyze_ccda_button.click(
            analyze_cda_xml_file_with_ai,  # Call REAL AI function
            inputs=ccda_file,
            outputs=ccda_ai_output,
        )
        analyze_ccd_button.click(  # Redundant button, but kept for UI if needed
            analyze_cda_xml_file_with_ai,  # Call REAL AI function
            inputs=ccd_file,
            outputs=ccd_ai_output,
        )
        analyze_pdf_button.click(
            analyze_pdf_file_with_ai, inputs=pdf_file, outputs=pdf_ai_output
        )
        analyze_csv_button.click(
            analyze_csv_file_with_ai, inputs=csv_file, outputs=csv_ai_output
        )

    with gr.Tab(
        "One-Click Discharge Paper (AI)", elem_classes="cyberpunk-tab"
    ):  # New Tab for One-Click Discharge Paper with AI, styled
        gr.Markdown(
            "<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>One-Click Medical Discharge Paper Generation with AI Content</h2>"
        )  # Neon Tab Header
        one_click_ai_pdf_button = gr.Button(
            "Generate Discharge Paper with AI (One-Click)",
            elem_classes="cyberpunk-button",
        )  # Updated button label and styled
        one_click_ai_pdf_status = gr.Textbox(
            label="Discharge Paper Generation Status (AI)"
        )  # Updated status label
        one_click_ai_pdf_download = gr.File(
            label="Download Discharge Paper (AI)"
        )  # Updated download label

        one_click_ai_pdf_button.click(
            generate_discharge_paper_one_click,  # Use the one-click function that now calls AI
            inputs=[],
            outputs=[one_click_ai_pdf_download, one_click_ai_pdf_status],
        )

    # Connect the patient data buttons
    patient_data_button.click(
        fn=CALLBACK_MANAGER.get_patient_data, inputs=None, outputs=patient_data_output
    )

    # Connect refresh button to update dashboard
    refresh_btn.click(fn=update_dashboard, inputs=None, outputs=dashboard_output)

    # Corrected the button click function name here to `generate_pdf_from_meldrx` (No AI PDF)
    meldrx_pdf_button.click(
        fn=generate_pdf_from_meldrx,
        inputs=patient_data_output,
        outputs=[meldrx_pdf_download, meldrx_pdf_status],
    )

    # Connect patient data updates to dashboard
    patient_data_button.click(
        fn=update_dashboard, inputs=None, outputs=dashboard_output
    )


# Launch with sharing enabled for public access
demo.launch(ssr_mode=False)