Update app.py

app.py

@@ -1,729 +1,432 @@
 import gradio as gr
-import pandas as pd
-from datetime import datetime, timedelta
-import logging
-import plotly.express as px
-import plotly.graph_objects as go
-from sklearn.ensemble import IsolationForest
-from concurrent.futures import ThreadPoolExecutor
-import os
-import io
-import time
-import asyncio
+import librosa
+import numpy as np
+import torch
+from transformers import WhisperProcessor, WhisperForConditionalGeneration
 from simple_salesforce import Salesforce
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# Salesforce configuration
+import os
+from datetime import datetime
+import logging
+import webrtcvad
+import google.generativeai as genai
+from gtts import gTTS
+import tempfile
+import base64
+import re
+import subprocess
+from cryptography.fernet import Fernet
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+usage_metrics = {"total_assessments": 0, "assessments_by_language": {}}
+
+# Environment variables
+SF_USERNAME = os.getenv("SF_USERNAME", "smartvoicebot@voice.com")
+SF_PASSWORD = os.getenv("SF_PASSWORD", "voicebot1")
+SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN", "jq4VVHUFti6TmzJDjjegv2h6b")
+SF_INSTANCE_URL = os.getenv("SF_INSTANCE_URL", "https://swe42.sfdc-cehfhs.salesforce.com")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "AIzaSyBzr5vVpbe8CV1v70l3pGDp9vRJ76yCxdk")
+ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY", Fernet.generate_key().decode())
+DEFAULT_EMAIL = os.getenv("SALESFORCE_USER_EMAIL", "default@mindcare.com")
+
+# Initialize encryption
+cipher = Fernet(ENCRYPTION_KEY)
+
+# Initialize Salesforce
 try:
     sf = Salesforce(
-        username='multi-devicelabopsdashboard@sathkrutha.com',
-        password='Team@1234',
-        security_token=os.getenv('SF_SECURITY_TOKEN', ''),
-        domain='login'
+        username=SF_USERNAME,
+        password=SF_PASSWORD,
+        security_token=SF_SECURITY_TOKEN,
+        instance_url=SF_INSTANCE_URL
     )
-    logging.info("Salesforce connection established")
+    logger.info(f"Connected to Salesforce at {SF_INSTANCE_URL}")
 except Exception as e:
-    logging.error(f"Failed to connect to Salesforce: {str(e)}")
+    logger.error(f"Salesforce connection failed: {str(e)}")
     sf = None
 
-# Try to import reportlab
+# Initialize Google Gemini
 try:
-    from reportlab.lib.pagesizes import letter
-    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
-    from reportlab.lib.styles import getSampleStyleSheet
-    from reportlab.lib import colors
-    reportlab_available = True
-    logging.info("reportlab module successfully imported")
-except ImportError:
-    logging.warning("reportlab module not found. PDF generation disabled.")
-    reportlab_available = False
-
-# Cache picklist values at startup
-def get_picklist_values(field_name):
-    if sf is None:
-        return []
-    try:
-        obj_desc = sf.SmartLog__c.describe()
-        for field in obj_desc['fields']:
-            if field['name'] == field_name:
-                return [value['value'] for value in field['picklistValues'] if value['active']]
-        return []
-    except Exception as e:
-        logging.error(f"Failed to fetch picklist values for {field_name}: {str(e)}")
-        return []
-
-status_values = get_picklist_values('Status__c') or ["Active", "Inactive", "Pending"]
-log_type_values = get_picklist_values('Log_Type__c') or ["Smart Log", "Cell Analysis", "UV Verification"]
-logging.info(f"Valid Status__c values: {status_values}")
-logging.info(f"Valid Log_Type__c values: {log_type_values}")
-
-# Map invalid picklist values
-picklist_mapping = {
-    'Status__c': {
-        'normal': 'Active',
-        'error': 'Inactive',
-        'warning': 'Pending',
-        'ok': 'Active',
-        'failed': 'Inactive'
-    },
-    'Log_Type__c': {
-        'maint': 'Smart Log',
-        'error': 'Cell Analysis',
-        'ops': 'UV Verification',
-        'maintenance': 'Smart Log',
-        'cell': 'Cell Analysis',
-        'uv': 'UV Verification',
-        'weight log': 'Smart Log'
-    }
-}
-
-# Cache folder ID for Salesforce reports
-def get_folder_id(folder_name):
-    if sf is None:
-        return None
-    try:
-        query = f"SELECT Id FROM Folder WHERE Name = '{folder_name}' AND Type = 'Report'"
-        result = sf.query(query)
-        if result['totalSize'] > 0:
-            folder_id = result['records'][0]['Id']
-            logging.info(f"Found folder ID for '{folder_name}': {folder_id}")
-            return folder_id
-        else:
-            logging.error(f"Folder '{folder_name}' not found in Salesforce.")
-            return None
-    except Exception as e:
-        logging.error(f"Failed to fetch folder ID for '{folder_name}': {str(e)}")
-        return None
-
-LABOPS_REPORTS_FOLDER_ID = get_folder_id('LabOps Reports')
-
-# Salesforce report creation
-def create_salesforce_reports(df):
-    if sf is None or not LABOPS_REPORTS_FOLDER_ID:
-        logging.error("Cannot create Salesforce reports: No connection or folder ID")
-        return
-    try:
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        reports = [
-            {
-                "reportMetadata": {
-                    "name": f"SmartLog_Usage_Report_{timestamp}",
-                    "developerName": f"SmartLog_Usage_Report_{timestamp}",
-                    "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
-                    "reportFormat": "TABULAR",
-                    "reportBooleanFilter": None,
-                    "reportFilters": [],
-                    "detailColumns": ["SmartLog__c.Device_Id__c", "SmartLog__c.Usage_Hours__c"],
-                    "folderId": LABOPS_REPORTS_FOLDER_ID
-                }
-            },
-            {
-                "reportMetadata": {
-                    "name": f"SmartLog_AMC_Reminders_{timestamp}",
-                    "developerName": f"SmartLog_AMC_Reminders_{timestamp}",
-                    "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
-                    "reportFormat": "TABULAR",
-                    "reportBooleanFilter": None,
-                    "reportFilters": [],
-                    "detailColumns": ["SmartLog__c.Device_Id__c", "SmartLog__c.AMC_Date__c"],
-                    "folderId": LABOPS_REPORTS_FOLDER_ID
-                }
-            }
-        ]
-        for report in reports:
-            sf.restful('analytics/reports', method='POST', json=report)
-        logging.info("Salesforce reports created successfully")
-    except Exception as e:
-        logging.error(f"Failed to create Salesforce reports: {str(e)}")
-
-# Save to Salesforce
-def save_to_salesforce(df, reminders_df):
-    if sf is None:
-        logging.error("No Salesforce connection available")
-        return
-    try:
-        logging.info("Starting Salesforce save operation")
-        current_date = datetime.now()
-        next_30_days = current_date + timedelta(days=30)
-        records = []
-        reminder_device_ids = set(reminders_df['device_id']) if not reminders_df.empty else set()
-        logging.info(f"Processing {len(df)} records for Salesforce")
-
-        for idx, row in df.iterrows():
-            status = str(row['status']).lower()
-            log_type = str(row['log_type']).lower()
-            status_mapped = picklist_mapping['Status__c'].get(status, status_values[0] if status_values else 'Active')
-            log_type_mapped = picklist_mapping['Log_Type__c'].get(log_type, log_type_values[0] if log_type_values else 'Smart Log')
-            
-            if not status_mapped or not log_type_mapped:
-                logging.warning(f"Skipping record {idx}: Invalid status ({status}) or log_type ({log_type})")
-                continue
-
-            amc_date_str = None
-            if pd.notna(row['amc_date']):
-                try:
-                    amc_date = pd.to_datetime(row['amc_date']).strftime('%Y-%m-%d')
-                    amc_date_str = amc_date
-                    amc_date_dt = datetime.strptime(amc_date, '%Y-%m-%d')
-                    if status_mapped == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
-                        logging.info(f"AMC Reminder for Device ID {row['device_id']}: {amc_date}")
-                except Exception as e:
-                    logging.warning(f"Invalid AMC date for Device ID {row['device_id']}: {str(e)}")
-
-            record = {
-                'Device_Id__c': str(row['device_id'])[:50],
-                'Log_Type__c': log_type_mapped,
-                'Status__c': status_mapped,
-                'Timestamp__c': row['timestamp'].isoformat() if pd.notna(row['timestamp']) else None,
-                'Usage_Hours__c': float(row['usage_hours']) if pd.notna(row['usage_hours']) else 0.0,
-                'Downtime__c': float(row['downtime']) if pd.notna(row['downtime']) else 0.0,
-                'AMC_Date__c': amc_date_str
-            }
-            records.append(record)
-
-        if records:
-            batch_size = 100
-            for i in range(0, len(records), batch_size):
-                batch = records[i:i + batch_size]
-                try:
-                    result = sf.bulk.SmartLog__c.insert(batch)
-                    logging.info(f"Saved {len(batch)} records to Salesforce in batch {i//batch_size + 1}")
-                    for res in result:
-                        if not res['success']:
-                            logging.error(f"Failed to save record: {res['errors']}")
-                except Exception as e:
-                    logging.error(f"Failed to save batch {i//batch_size + 1}: {str(e)}")
-        else:
-            logging.warning("No records to save to Salesforce")
-    except Exception as e:
-        logging.error(f"Failed to save to Salesforce: {str(e)}")
-
-# Summarize logs
-def summarize_logs(df):
-    try:
-        total_devices = df["device_id"].nunique()
-        total_usage = df["usage_hours"].sum() if "usage_hours" in df.columns else 0
-        return f"{total_devices} devices processed with {total_usage:.2f} total usage hours."
-    except Exception as e:
-        logging.error(f"Summary generation failed: {str(e)}")
-        return "Failed to generate summary."
-
-# Anomaly detection
-def detect_anomalies(df):
-    try:
-        if "usage_hours" not in df.columns or "downtime" not in df.columns:
-            return "Anomaly detection requires 'usage_hours' and 'downtime' columns.", pd.DataFrame()
-        features = df[["usage_hours", "downtime"]].fillna(0)
-        if len(features) > 50:
-            features = features.sample(n=50, random_state=42)
-        iso_forest = IsolationForest(contamination=0.1, random_state=42)
-        df["anomaly"] = iso_forest.fit_predict(features)
-        anomalies = df[df["anomaly"] == -1][["device_id", "usage_hours", "downtime", "timestamp"]]
-        if anomalies.empty:
-            return "No anomalies detected.", anomalies
-        return "\n".join([f"- Device ID: {row['device_id']}, Usage: {row['usage_hours']}, Downtime: {row['downtime']}, Timestamp: {row['timestamp']}" for _, row in anomalies.head(5).iterrows()]), anomalies
-    except Exception as e:
-        logging.error(f"Anomaly detection failed: {str(e)}")
-        return f"Anomaly detection failed: {str(e)}", pd.DataFrame()
-
-# AMC reminders
-def check_amc_reminders(df, current_date):
-    try:
-        if "device_id" not in df.columns or "amc_date" not in df.columns:
-            return "AMC reminders require 'device_id' and 'amc_date' columns.", pd.DataFrame()
-        df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
-        current_date = pd.to_datetime(current_date)
-        df["days_to_amc"] = (df["amc_date"] - current_date).dt.days
-        reminders = df[(df["days_to_amc"] >= 0) & (df["days_to_amc"] <= 30)][["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]]
-        if reminders.empty:
-            return "No AMC reminders due within the next 30 days.", reminders
-        return "\n".join([f"- Device ID: {row['device_id']}, AMC Date: {row['amc_date']}" for _, row in reminders.head(5).iterrows()]), reminders
-    except Exception as e:
-        logging.error(f"AMC reminder generation failed: {str(e)}")
-        return f"AMC reminder generation failed: {str(e)}", pd.DataFrame()
-
-# Dashboard insights
-def generate_dashboard_insights(df):
-    try:
-        total_devices = df["device_id"].nunique()
-        avg_usage = df["usage_hours"].mean() if "usage_hours" in df.columns else 0
-        return f"{total_devices} devices with average usage of {avg_usage:.2f} hours."
-    except Exception as e:
-        logging.error(f"Dashboard insights generation failed: {str(e)}")
-        return "Failed to generate insights."
-
-# Placeholder chart for empty data
-def create_placeholder_chart(title):
-    fig = go.Figure()
-    fig.add_annotation(
-        text="No data available for this chart",
-        xref="paper", yref="paper",
-        x=0.5, y=0.5, showarrow=False,
-        font=dict(size=16)
-    )
-    fig.update_layout(title=title, margin=dict(l=20, r=20, t=40, b=20))
-    return fig
-
-# Create usage chart
-def create_usage_chart(df):
-    try:
-        if df.empty or "usage_hours" not in df.columns or "device_id" not in df.columns:
-            logging.warning("Insufficient data for usage chart")
-            return create_placeholder_chart("Usage Hours per Device")
-        usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
-        if len(usage_data) > 5:
-            usage_data = usage_data.nlargest(5, "usage_hours")
-        fig = px.bar(
-            usage_data,
-            x="device_id",
-            y="usage_hours",
-            title="Usage Hours per Device",
-            labels={"device_id": "Device ID", "usage_hours": "Usage Hours"}
-        )
-        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
-        return fig
-    except Exception as e:
-        logging.error(f"Failed to create usage chart: {str(e)}")
-        return create_placeholder_chart("Usage Hours per Device")
-
-# Create downtime chart
-def create_downtime_chart(df):
+    genai.configure(api_key=GEMINI_API_KEY)
+    gemini_model = genai.GenerativeModel('gemini-1.5-flash')
+    chat = gemini_model.start_chat(history=[])
+    logger.info("Connected to Google Gemini")
+except Exception as e:
+    logger.error(f"Google Gemini initialization failed: {str(e)}")
+    chat = None
+
+# Load Whisper model
+SUPPORTED_LANGUAGES = {"en": "english", "es": "spanish", "hi": "hindi", "zh": "mandarin"}
+SALESFORCE_LANGUAGE_MAP = {"en": "English", "es": "Spanish", "hi": "Hindi", "zh": "Mandarin"}
+whisper_processor = WhisperProcessor.from_pretrained("openai/whisper-small")
+whisper_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small")
+vad = webrtcvad.Vad(mode=2)
+
+# Context for chatbot
+base_info = """
+You are MindCare, an AI health assistant providing support in:
+- Mental health: Emotional support, stress management
+- Medical guidance: Symptom analysis, general advice
+- General health: Lifestyle and wellness recommendations
+Tone: Empathetic, supportive, informative. Always suggest professional consultation for medical issues.
+"""
+context = [base_info]
+
+def encrypt_data(data):
     try:
-        if df.empty or "downtime" not in df.columns or "device_id" not in df.columns:
-            logging.warning("Insufficient data for downtime chart")
-            return create_placeholder_chart("Downtime per Device")
-        downtime_data = df.groupby("device_id")["downtime"].sum().reset_index()
-        if len(downtime_data) > 5:
-            downtime_data = downtime_data.nlargest(5, "downtime")
-        fig = px.bar(
-            downtime_data,
-            x="device_id",
-            y="downtime",
-            title="Downtime per Device",
-            labels={"device_id": "Device ID", "downtime": "Downtime (Hours)"}
-        )
-        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
-        return fig
+        return cipher.encrypt(data.encode('utf-8')).decode('utf-8')
     except Exception as e:
-        logging.error(f"Failed to create downtime chart: {str(e)}")
-        return create_placeholder_chart("Downtime per Device")
+        logger.error(f"Encryption failed: {str(e)}")
+        return data
 
-# Create daily log trends chart
-def create_daily_log_trends_chart(df):
+def decrypt_data(encrypted_data):
     try:
-        if df.empty or "timestamp" not in df.columns:
-            logging.warning("Insufficient data for daily log trends chart")
-            return create_placeholder_chart("Daily Log Trends")
-        df['date'] = pd.to_datetime(df['timestamp'], errors='coerce').dt.date
-        daily_logs = df.groupby('date').size().reset_index(name='log_count')
-        if daily_logs.empty:
-            return create_placeholder_chart("Daily Log Trends")
-        fig = px.line(
-            daily_logs,
-            x='date',
-            y='log_count',
-            title="Daily Log Trends",
-            labels={"date": "Date", "log_count": "Number of Logs"}
-        )
-        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
-        return fig
+        return cipher.decrypt(encrypted_data.encode('utf-8')).decode('utf-8')
     except Exception as e:
-        logging.error(f"Failed to create daily log trends chart: {str(e)}")
-        return create_placeholder_chart("Daily Log Trends")
+        logger.error(f"Decryption failed: {str(e)}")
+        return encrypted_data
 
-# Create weekly uptime chart
-def create_weekly_uptime_chart(df):
+def extract_health_features(audio, sr):
     try:
-        if df.empty or "timestamp" not in df.columns or "usage_hours" not in df.columns or "downtime" not in df.columns:
-            logging.warning("Insufficient data for weekly uptime chart")
-            return create_placeholder_chart("Weekly Uptime Percentage")
-        df['week'] = pd.to_datetime(df['timestamp'], errors='coerce').dt.isocalendar().week
-        df['year'] = pd.to_datetime(df['timestamp'], errors='coerce').dt.year
-        weekly_data = df.groupby(['year', 'week']).agg({
-            'usage_hours': 'sum',
-            'downtime': 'sum'
-        }).reset_index()
-        weekly_data['uptime_percent'] = (weekly_data['usage_hours'] / (weekly_data['usage_hours'] + weekly_data['downtime'])) * 100
-        weekly_data['year_week'] = weekly_data['year'].astype(str) + '-W' + weekly_data['week'].astype(str)
-        if weekly_data.empty:
-            return create_placeholder_chart("Weekly Uptime Percentage")
-        fig = px.bar(
-            weekly_data,
-            x='year_week',
-            y='uptime_percent',
-            title="Weekly Uptime Percentage",
-            labels={"year_week": "Year-Week", "uptime_percent": "Uptime %"}
-        )
-        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
-        return fig
+        audio = audio / np.max(np.abs(audio)) if np.max(np.abs(audio)) != 0 else audio
+        frame_duration = 30
+        frame_samples = int(sr * frame_duration / 1000)
+        frames = [audio[i:i + frame_samples] for i in range(0, len(audio), frame_samples)]
+        voiced_frames = [frame for frame in frames if len(frame) == frame_samples and vad.is_speech((frame * 32768).astype(np.int16).tobytes(), sr)]
+        if not voiced_frames:
+            raise ValueError("No voiced segments detected")
+        voiced_audio = np.concatenate(voiced_frames)
+        
+        # Enhanced feature extraction
+        pitches, magnitudes = librosa.piptrack(y=voiced_audio, sr=sr, fmin=75, fmax=300)
+        valid_pitches = [p for p in pitches[magnitudes > 0] if 75 <= p <= 300]
+        pitch = np.mean(valid_pitches) if valid_pitches else 0
+        jitter = np.std(valid_pitches) / pitch if pitch and valid_pitches else 0
+        jitter = min(jitter, 10)  # Cap jitter
+        amplitudes = librosa.feature.rms(y=voiced_audio, frame_length=2048, hop_length=512)[0]
+        shimmer = np.std(amplitudes) / np.mean(amplitudes) if np.mean(amplitudes) else 0
+        shimmer = min(shimmer, 10)  # Cap shimmer
+        energy = np.mean(librosa.feature.rms(y=voiced_audio, frame_length=2048, hop_length=512)[0])
+        
+        # Additional features
+        mfcc = np.mean(librosa.feature.mfcc(y=voiced_audio, sr=sr, n_mfcc=13), axis=1)
+        spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=voiced_audio, sr=sr))
+        
+        return {
+            "pitch": pitch,
+            "jitter": jitter * 100,
+            "shimmer": shimmer * 100,
+            "energy": energy,
+            "mfcc_mean": np.mean(mfcc),
+            "spectral_centroid": spectral_centroid
+        }
     except Exception as e:
-        logging.error(f"Failed to create weekly uptime chart: {str(e)}")
-        return create_placeholder_chart("Weekly Uptime Percentage")
+        logger.error(f"Feature extraction failed: {str(e)}")
+        raise
 
-# Create anomaly alerts chart
-def create_anomaly_alerts_chart(anomalies_df):
+def transcribe_audio(audio, language="en"):
     try:
-        if anomalies_df is None or anomalies_df.empty or "timestamp" not in anomalies_df.columns:
-            logging.warning("Insufficient data for anomaly alerts chart")
-            return create_placeholder_chart("Anomaly Alerts Over Time")
-        anomalies_df['date'] = pd.to_datetime(anomalies_df['timestamp'], errors='coerce').dt.date
-        anomaly_counts = anomalies_df.groupby('date').size().reset_index(name='anomaly_count')
-        if anomaly_counts.empty:
-            return create_placeholder_chart("Anomaly Alerts Over Time")
-        fig = px.scatter(
-            anomaly_counts,
-            x='date',
-            y='anomaly_count',
-            title="Anomaly Alerts Over Time",
-            labels={"date": "Date", "anomaly_count": "Number of Anomalies"}
+        whisper_model.config.forced_decoder_ids = whisper_processor.get_decoder_prompt_ids(
+            language=SUPPORTED_LANGUAGES.get(language, "english"), task="transcribe"
         )
-        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
-        return fig
+        inputs = whisper_processor(audio, sampling_rate=16000, return_tensors="pt")
+        with torch.no_grad():
+            generated_ids = whisper_model.generate(inputs["input_features"])
+        transcription = whisper_processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        logger.info(f"Transcription (language: {language}): {transcription}")
+        return transcription
     except Exception as e:
-        logging.error(f"Failed to create anomaly alerts chart: {str(e)}")
-        return create_placeholder_chart("Anomaly Alerts Over Time")
+        logger.error(f"Transcription failed: {str(e)}")
+        return None
 
-# Generate device cards
-def generate_device_cards(df):
+def get_chatbot_response(message, language="en"):
+    if not chat or not message:
+        return "Unable to generate response.", None
+    full_context = "\n".join(context) + f"\nUser: {message}\nMindCare:"
     try:
-        if df.empty:
-            return '<p>No devices available to display.</p>'
-        device_stats = df.groupby('device_id').agg({
-            'status': 'last',
-            'timestamp': 'max',
-        }).reset_index()
-        device_stats['count'] = df.groupby('device_id').size().reindex(device_stats['device_id']).values
-        device_stats['health'] = device_stats['status'].map({
-            'Active': 'Healthy',
-            'Inactive': 'Unhealthy',
-            'Pending': 'Warning'
-        }).fillna('Unknown')
-        cards_html = '<div style="display: flex; flex-wrap: wrap; gap: 20px;">'
-        for _, row in device_stats.iterrows():
-            health_color = {'Healthy': 'green', 'Unhealthy': 'red', 'Warning': 'orange', 'Unknown': 'gray'}.get(row['health'], 'gray')
-            timestamp_str = str(row['timestamp']) if pd.notna(row['timestamp']) else 'Unknown'
-            cards_html += f"""
-                <div style="border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px; width: 200px;">
-                    <h4>Device: {row['device_id']}</h4>
-                    <p><b>Health:</b> <span style="color: {health_color}">{row['health']}</span></p>
-                    <p><b>Usage Count:</b> {row['count']}</p>
-                    <p><b>Last Log:</b> {timestamp_str}</p>
-                </div>
-            """
-        cards_html += '</div>'
-        return cards_html
+        response = chat.send_message(full_context).text
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
+            tts = gTTS(text=response, lang=language, slow=False)
+            tts.save(temp_audio.name)
+            audio_path = temp_audio.name
+        return response, audio_path
     except Exception as e:
-        logging.error(f"Failed to generate device cards: {str(e)}")
-        return f'<p>Error generating device cards: {str(e)}</p>'
-
-# Generate PDF content
-def generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights, device_cards_html, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart):
-    if not reportlab_available:
+        logger.error(f"Chatbot response failed: {str(e)}")
+        return "Error generating response.", None
+
+def analyze_symptoms(text, features):
+    feedback = []
+    text = text.lower() if text else ""
+    
+    # Voice-based health assessment
+    if features["jitter"] > 2.0 or features["shimmer"] > 3.0:
+        feedback.append("Your voice shows signs of irregularity (high jitter or shimmer), which may indicate respiratory or vocal strain. Consider a medical evaluation.")
+    if features["energy"] < 0.01:
+        feedback.append("Low vocal energy detected, which might suggest fatigue or low mood. Rest and professional consultation are recommended.")
+    if features["pitch"] < 100 or features["pitch"] > 250:
+        feedback.append(f"Unusual pitch range ({features['pitch']:.2f} Hz) detected, which could indicate vocal cord issues or emotional stress.")
+    if features["spectral_centroid"] > 2000:
+        feedback.append("High spectral centroid suggests tense or strained speech, possibly linked to stress or anxiety.")
+    
+    # Text-based symptom analysis
+    if "cough" in text or "breath" in text:
+        feedback.append("Your description suggests respiratory symptoms. Possible conditions include bronchitis or asthma. Please consult a doctor.")
+    if "stress" in text or "anxious" in text:
+        feedback.append("You mentioned stress or anxiety. Try deep breathing exercises or mindfulness. Consider speaking with a mental health professional.")
+    if "pain" in text:
+        feedback.append("Pain reported. For mild pain, consider Paracetamol; for inflammation, Ibuprofen may help. Consult a doctor before taking medication.")
+    if not feedback:
+        feedback.append("No specific health concerns detected from voice or text. Maintain a healthy lifestyle and consult a doctor if symptoms arise.")
+    
+    return "\n".join(feedback)
+
+def store_user_consent(language):
+    if not sf:
+        logger.warning("Salesforce not connected; skipping consent storage")
         return None
     try:
-        pdf_path = f"status_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
-        doc = SimpleDocTemplate(pdf_path, pagesize=letter)
-        styles = getSampleStyleSheet()
-        story = []
-
-        def safe_paragraph(text, style):
-            return Paragraph(str(text).replace('\n', '<br/>'), style) if text else Paragraph("", style)
-
-        story.append(Paragraph("LabOps Status Report", styles['Title']))
-        story.append(Paragraph(f"Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
-        story.append(Spacer(1, 12))
-
-        story.append(Paragraph("Summary Report", styles['Heading2']))
-        story.append(safe_paragraph(summary, styles['Normal']))
-        story.append(Spacer(1, 12))
-
-        story.append(Paragraph("Log Preview", styles['Heading2']))
-        if not preview_df.empty:
-            data = [preview_df.columns.tolist()] + preview_df.head(5).values.tolist()
-            table = Table(data)
-            table.setStyle(TableStyle([
-                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
-                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
-                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-                ('FONTSIZE', (0, 0), (-1, 0), 12),
-                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
-                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
-                ('TEXTCOLOR', (0, 1), (-1, -1), colors.black),
-                ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
-                ('FONTSIZE', (0, 1), (-1, -1), 10),
-                ('GRID', (0, 0), (-1, -1), 1, colors.black)
-            ]))
-            story.append(table)
+        user = sf.query(f"SELECT Id FROM HealthUser__c WHERE Email__c = '{DEFAULT_EMAIL}'")
+        user_id = None
+        if user["totalSize"] == 0:
+            user = sf.HealthUser__c.create({
+                "Email__c": DEFAULT_EMAIL,
+                "Language__c": SALESFORCE_LANGUAGE_MAP.get(language, "English"),
+                "ConsentGiven__c": True
+            })
+            user_id = user["id"]
+            logger.info(f"Created new user with email: {DEFAULT_EMAIL}")
         else:
-            story.append(safe_paragraph("No preview available.", styles['Normal']))
-        story.append(Spacer(1, 12))
-
-        story.append(Paragraph("Device Cards", styles['Heading2']))
-        device_cards_text = device_cards_html.replace('<div>', '').replace('</div>', '\n').replace('<h4>', '').replace('</h4>', '\n').replace('<p>', '').replace('</p>', '\n').replace('<b>', '').replace('</b>', '').replace('<span style="color: green">', '').replace('<span style="color: red">', '').replace('<span style="color: orange">', '').replace('<span style="color: gray">', '').replace('</span>', '')
-        story.append(safe_paragraph(device_cards_text, styles['Normal']))
-        story.append(Spacer(1, 12))
-
-        story.append(Paragraph("Anomaly Detection", styles['Heading2']))
-        story.append(safe_paragraph(anomalies, styles['Normal']))
-        story.append(Spacer(1, 12))
-
-        story.append(Paragraph("AMC Reminders", styles['Heading2']))
-        story.append(safe_paragraph(amc_reminders, styles['Normal']))
-        story.append(Spacer(1, 12))
-
-        story.append(Paragraph("Dashboard Insights", styles['Heading2']))
-        story.append(safe_paragraph(insights, styles['Normal']))
-        story.append(Spacer(1, 12))
-
-        story.append(Paragraph("Charts", styles['Heading2']))
-        story.append(Paragraph("[Chart placeholders - see dashboard for visuals]", styles['Normal']))
-
-        doc.build(story)
-        logging.info(f"PDF generated at {pdf_path}")
-        return pdf_path
+            user_id = user["records"][0]["Id"]
+            sf.HealthUser__c.update(user_id, {
+                "Language__c": SALESFORCE_LANGUAGE_MAP.get(language, "English"),
+                "ConsentGiven__c": True
+            })
+            logger.info(f"Updated user with email: {DEFAULT_EMAIL}")
+        sf.ConsentLog__c.create({
+            "HealthUser__c": user_id,
+            "ConsentType__c": "Voice Analysis",
+            "ConsentDate__c": datetime.utcnow().isoformat()
+        })
+        return user_id
     except Exception as e:
-        logging.error(f"Failed to generate PDF: {str(e)}")
+        logger.error(f"Consent storage failed: {str(e)}")
         return None
 
-# Main processing function
-async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_range, cached_df_state, last_modified_state):
-    start_time = time.time()
+def generate_pdf_report(feedback, transcription, features, language):
     try:
-        if not file_obj:
-            return "No file uploaded.", "<p>No data available.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None, cached_df_state, last_modified_state
-
-        file_path = file_obj.name
-        current_modified_time = os.path.getmtime(file_path)
-
-        # Read file only if it's new or modified
-        if cached_df_state is None or current_modified_time != last_modified_state:
-            logging.info(f"Processing new or modified file: {file_path}")
-            if not file_path.endswith(".csv"):
-                return "Please upload a CSV file.", "<p>Invalid file format.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, cached_df_state, last_modified_state
-
-            required_columns = ["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]
-            dtypes = {
-                "device_id": "string",
-                "log_type": "string",
-                "status": "string",
-                "usage_hours": "float32",
-                "downtime": "float32",
-                "amc_date": "string"
-            }
-            df = pd.read_csv(file_path, dtype=dtypes)
-            missing_columns = [col for col in required_columns if col not in df.columns]
-            if missing_columns:
-                return f"Missing columns: {missing_columns}", "<p>Missing required columns.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, cached_df_state, last_modified_state
-
-            df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
-            df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
-            if df["timestamp"].dt.tz is None:
-                df["timestamp"] = df["timestamp"].dt.tz_localize('UTC').dt.tz_convert('Asia/Kolkata')
-            if df.empty:
-                return "No data available.", "<p>No data available.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, df, current_modified_time
+        feedback = feedback.replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#')
+        transcription = transcription.replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#') if transcription else "None"
+        email = DEFAULT_EMAIL.replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#')
+        latex_content = f"""
+\\documentclass[a4paper,12pt]{{article}}
+\\usepackage[utf8]{{inputenc}}
+\\usepackage{{geometry}}
+\\usepackage{{parskip}}
+\\usepackage{{titlesec}}
+\\usepackage{{times}}
+\\geometry{{margin=1in}}
+\\titleformat{{\\section}}{{\\large\\bfseries}}{{\\thesection}}{{1em}}{{}}
+\\titleformat{{\\subsection}}{{\\bfseries}}{{\\thesubsection}}{{1em}}{{}}
+\\usepackage{{datetime}}
+\\newdateformat{{isodate}}{{\\THEDAY{ }\\shortmonthname[\\THEMONTH] \\THEYEAR}}
+\\begin{{document}}
+\\begin{{center}}
+    \\textbf{{\\large MindCare Health Assistant Report}} \\\\
+    \\vspace{{0.5cm}}
+    Generated on \\isodate\\today\\ at \\currenttime
+\\end{{center}}
+\\section*{{User Information}}
+\\begin{{itemize}}
+    \\item \\textbf{{Email}}: {email}
+    \\item \\textbf{{Language}}: {SALESFORCE_LANGUAGE_MAP.get(language, "English")}
+\\end{{itemize}}
+\\section*{{Voice Analysis Results}}
+\\subsection*{{Health Assessment}}
+{feedback}
+\\subsection*{{Transcription}}
+{transcription}
+\\subsection*{{Voice Metrics}}
+\\begin{{itemize}}
+    \\item \\textbf{{Pitch}}: {features['pitch']:.2f} Hz
+    \\item \\textbf{{Jitter}}: {features['jitter']:.2f}\\%
+    \\item \\textbf{{Shimmer}}: {features['shimmer']:.2f}\\%
+    \\item \\textbf{{Energy}}: {features['energy']:.4f}
+    \\item \\textbf{{MFCC Mean}}: {features['mfcc_mean']:.2f}
+    \\item \\textbf{{Spectral Centroid}}: {features['spectral_centroid']:.2f} Hz
+\\end{{itemize}}
+\\section*{{Disclaimer}}
+This report is a preliminary analysis and not a medical diagnosis. Always consult a healthcare provider.
+\\end{{document}}
+"""
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".tex") as tex_file:
+            tex_file.write(latex_content.encode('utf-8'))
+            tex_file_path = tex_file.name
+        pdf_path = tex_file_path.replace('.tex', '.pdf')
+        result = subprocess.run(['latexmk', '-pdf', '-pdflatex=pdflatex', '-interaction=nonstopmode', tex_file_path], 
+                              capture_output=True, text=True, check=True)
+        logger.info(f"PDF generation output: {result.stdout}")
+        for ext in ['.aux', '.log', '.out', '.fls', '.fdb_latexmk']:
+            try:
+                os.remove(tex_file_path.replace('.tex', ext))
+            except:
+                pass
+        if os.path.exists(pdf_path):
+            logger.info(f"Generated PDF report: {pdf_path}")
+            return pdf_path
         else:
-            df = cached_df_state
-
-        # Apply filters
-        filtered_df = df.copy()
-        if lab_site_filter and lab_site_filter != 'All' and 'lab_site' in filtered_df.columns:
-            filtered_df = filtered_df[filtered_df['lab_site'] == lab_site_filter]
-        if equipment_type_filter and equipment_type_filter != 'All' and 'equipment_type' in filtered_df.columns:
-            filtered_df = filtered_df[filtered_df['equipment_type'] == equipment_type_filter]
-        if date_range is not None:
-            if isinstance(date_range, (int, float)):
-                # Convert single value to a range for a single day
-                days = int(date_range)
-                date_range = [days, days]
-                logging.info(f"Converted single value {days} to range {date_range}")
-            if len(date_range) != 2 or not all(isinstance(x, (int, float)) for x in date_range):
-                logging.error(f"Invalid date range format: {date_range}. Expected [start, end] or single integer.")
-                return "Invalid date range format. Please use [start, end] (e.g., [-7, 0]) or a single integer (e.g., -1).", "<p>Error processing data.</p>", None, '<p>Error processing data.</p>', None, None, None, None, "", "", "", None, df, current_modified_time
-            days_start, days_end = date_range
-            today = pd.to_datetime(datetime.now()).tz_localize('Asia/Kolkata')
-            start_date = today + pd.Timedelta(days=days_start)
-            end_date = today + pd.Timedelta(days=days_end) + pd.Timedelta(days=1) - pd.Timedelta(seconds=1)
-            start_date = start_date.tz_convert('Asia/Kolkata') if start_date.tzinfo else start_date.tz_localize('Asia/Kolkata')
-            end_date = end_date.tz_convert('Asia/Kolkata') if end_date.tzinfo else end_date.tz_localize('Asia/Kolkata')
-            logging.info(f"Date range filter applied: start_date={start_date}, end_date={end_date}")
-            logging.info(f"Before date filter: {len(filtered_df)} rows")
-            filtered_df = filtered_df[(filtered_df['timestamp'] >= start_date) & (filtered_df['timestamp'] <= end_date)]
-            logging.info(f"After date filter: {len(filtered_df)} rows")
-            if days_start > days_end:
-                logging.warning("Start date is after end date; results may be empty or unexpected.")
-
-        if filtered_df.empty:
-            return "No data after applying filters.", "<p>No data after filters.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, df, current_modified_time
-
-        # Generate table for preview
-        preview_df = filtered_df[['device_id', 'log_type', 'status', 'timestamp', 'usage_hours', 'downtime', 'amc_date']].head(5)
-        preview_html = preview_df.to_html(index=False, classes='table table-striped', border=0)
-
-        # Run critical tasks concurrently
-        with ThreadPoolExecutor(max_workers=2) as executor:
-            future_anomalies = executor.submit(detect_anomalies, filtered_df)
-            future_amc = executor.submit(check_amc_reminders, filtered_df, datetime.now())
-
-            summary = f"Step 1: Summary Report\n{summarize_logs(filtered_df)}"
-            anomalies, anomalies_df = future_anomalies.result()
-            anomalies = f"Anomaly Detection\n{anomalies}"
-            amc_reminders, reminders_df = future_amc.result()
-            amc_reminders = f"AMC Reminders\n{amc_reminders}"
-            insights = f"Dashboard Insights\n{generate_dashboard_insights(filtered_df)}"
-
-        # Generate charts sequentially
-        usage_chart = create_usage_chart(filtered_df)
-        downtime_chart = create_downtime_chart(filtered_df)
-        daily_log_chart = create_daily_log_trends_chart(filtered_df)
-        weekly_uptime_chart = create_weekly_uptime_chart(filtered_df)
-        anomaly_alerts_chart = create_anomaly_alerts_chart(anomalies_df)
-        device_cards = generate_device_cards(filtered_df)
-
-        # Save to Salesforce after all other processing
-        save_to_salesforce(filtered_df, reminders_df)
-        create_salesforce_reports(filtered_df)
-
-        elapsed_time = time.time() - start_time
-        logging.info(f"Processing completed in {elapsed_time:.2f} seconds")
-        if elapsed_time > 3:
-            logging.warning(f"Processing time exceeded 3 seconds: {elapsed_time:.2f} seconds")
-
-        return (summary, preview_html, usage_chart, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart, anomalies, amc_reminders, insights, None, df, current_modified_time)
-    except Exception as e:
-        logging.error(f"Failed to process file: {str(e)}")
-        return f"Error: {str(e)}", "<p>Error processing data.</p>", None, '<p>Error processing data.</p>', None, None, None, None, "", "", "", None, cached_df_state, last_modified_state
-
-# Generate PDF separately
-async def generate_pdf(summary, preview_html, usage_chart, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart, anomalies, amc_reminders, insights):
-    try:
-        preview_df = pd.read_html(preview_html)[0]
-        pdf_file = generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart)
-        return pdf_file
+            logger.error("PDF file was not created")
+            return None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"PDF generation failed: {e.stderr}")
+        return None
     except Exception as e:
-        logging.error(f"Failed to generate PDF: {str(e)}")
+        logger.error(f"PDF generation failed: {str(e)}")
         return None
 
-# Update filters
-def update_filters(file_obj, current_file_state):
-    if not file_obj or file_obj.name == current_file_state:
-        return gr.update(), gr.update(), current_file_state
+def store_in_salesforce(user_id, audio_file, feedback, respiratory_score, mental_health_score, features, transcription, language):
+    if not sf:
+        logger.warning("Salesforce not connected; skipping storage")
+        return
     try:
-        with open(file_obj.name, 'rb') as f:
-            csv_content = f.read().decode('utf-8')
-        df = pd.read_csv(io.StringIO(csv_content))
-        df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
+        with open(audio_file, "rb") as f:
+            audio_content = base64.b64encode(f.read()).decode()
+        content_version = sf.ContentVersion.create({
+            "Title": f"Voice_Assessment_{datetime.utcnow().isoformat()}",
+            "PathOnClient": os.path.basename(audio_file),
+            "VersionData": audio_content,
+            "IsMajorVersion": True
+        })
+        content_document_id = sf.query(f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version['id']}'")["records"][0]["ContentDocumentId"]
+        file_url = f"{SF_INSTANCE_URL}/lightning/r/ContentDocument/{content_document_id}/view"
+
+        feedback_str = feedback.encode('utf-8').decode('utf-8')
+        encrypted_feedback = encrypt_data(feedback_str)
+        if len(encrypted_feedback) > 131072:
+            encrypted_feedback = encrypted_feedback[:131072]
+
+        assessment = sf.VoiceAssessment__c.create({
+            "HealthUser__c": user_id,
+            "VoiceRecording__c": file_url,
+            "AssessmentResult__c": encrypted_feedback,
+            "AssessmentDate__c": datetime.utcnow().isoformat(),
+            "ConfidenceScore__c": 95.0,
+            "RespiratoryScore__c": float(respiratory_score),
+            "MentalHealthScore__c": float(mental_health_score),
+            "Pitch__c": float(features["pitch"]),
+            "Jitter__c": float(features["jitter"]),
+            "Shimmer__c": float(features["shimmer"]),
+            "Energy__c": float(features["energy"]),
+            "Transcription__c": transcription or "None",
+            "Language__c": SALESFORCE_LANGUAGE_MAP.get(language, "English")
+        })
+        sf.ContentDocumentLink.create({
+            "ContentDocumentId": content_document_id,
+            "LinkedEntityId": assessment["id"],
+            "ShareType": "V"
+        })
+        logger.info(f"Stored assessment in Salesforce: {assessment['id']}")
+    except Exception as e:
+        logger.error(f"Salesforce storage failed: {str(e)}")
+        raise
 
-        lab_site_options = ['All'] + [site for site in df['lab_site'].dropna().astype(str).unique().tolist() if site.strip()] if 'lab_site' in df.columns else ['All']
-        equipment_type_options = ['All'] + [equip for equip in df['equipment_type'].dropna().astype(str).unique().tolist() if equip.strip()] if 'equipment_type' in df.columns else ['All']
+def analyze_voice(audio_file=None, language="en"):
+    global usage_metrics
+    usage_metrics["total_assessments"] += 1
+    usage_metrics["assessments_by_language"][language] = usage_metrics["assessments_by_language"].get(language, 0) + 1
 
-        return gr.update(choices=lab_site_options, value='All'), gr.update(choices=equipment_type_options, value='All'), file_obj.name
+    try:
+        if not audio_file or not os.path.exists(audio_file):
+            raise ValueError("No valid audio file provided")
+        
+        audio, sr = librosa.load(audio_file, sr=16000)
+        if len(audio) < sr:
+            raise ValueError("Audio too short (minimum 1 second)")
+
+        user_id = store_user_consent(language)
+        if not user_id:
+            return "Error: Failed to store user consent.", None
+
+        features = extract_health_features(audio, sr)
+        transcription = transcribe_audio(audio, language)
+        feedback = analyze_symptoms(transcription, features)
+
+        respiratory_score = features["jitter"]
+        mental_health_score = features["shimmer"]
+        
+        feedback += f"\n\n**Voice Analysis Details**:\n"
+        feedback += f"- Pitch: {features['pitch']:.2f} Hz\n"
+        feedback += f"- Jitter: {features['jitter']:.2f}% (voice stability)\n"
+        feedback += f"- Shimmer: {features['shimmer']:.2f}% (amplitude variation)\n"
+        feedback += f"- Energy: {features['energy']:.4f} (vocal intensity)\n"
+        feedback += f"- MFCC Mean: {features['mfcc_mean']:.2f} (timbre quality)\n"
+        feedback += f"- Spectral Centroid: {features['spectral_centroid']:.2f} Hz (voice brightness)\n"
+        feedback += f"- Transcription: {transcription if transcription else 'None'}\n"
+        feedback += "\n**Disclaimer**: This is a preliminary analysis. Consult a healthcare provider for professional evaluation."
+
+        if sf:
+            store_in_salesforce(user_id, audio_file, feedback, respiratory_score, mental_health_score, features, transcription, language)
+
+        pdf_path = generate_pdf_report(feedback, transcription, features, language)
+
+        try:
+            os.remove(audio_file)
+            logger.info(f"Deleted audio file: {audio_file}")
+        except Exception as e:
+            logger.error(f"Failed to delete audio file: {str(e)}")
+
+        return feedback, pdf_path
     except Exception as e:
-        logging.error(f"Failed to update filters: {str(e)}")
-        return gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All'), current_file_state
+        logger.error(f"Audio processing failed: {str(e)}")
+        return f"Error: {str(e)}", None
 
-# Gradio Interface
-try:
-    logging.info("Initializing Gradio interface...")
-    with gr.Blocks(css="""
-        .dashboard-container {border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px;}
-        .dashboard-title {font-size: 24px; font-weight: bold; margin-bottom: 5px;}
-        .dashboard-section {margin-bottom: 20px;}
-        .dashboard-section h3 {font-size: 18px; margin-bottom: 2px;}
-        .dashboard-section p {margin: 1px 0; line-height: 1.2;}
-        .dashboard-section ul {margin: 2px 0; padding-left: 20px;}
-        .table {width: 100%; border-collapse: collapse;}
-        .table th, .table td {border: 1px solid #ddd; padding: 8px; text-align: left;}
-        .table th {background-color: #f2f2f2;}
-        .table tr:nth-child(even) {background-color: #f9f9f9;}
-    """) as iface:
-        gr.Markdown("<h1>LabOps Log Analyzer Dashboard</h1>")
-        gr.Markdown("Upload a CSV file to analyze. Click 'Analyze' to refresh the dashboard. Use 'Export PDF' for report download. Date Range can be [start, end] (e.g., [-7, 0] for June 11 to June 18) or a single integer (e.g., -1 for June 17).")
-
-        last_modified_state = gr.State(value=None)
-        current_file_state = gr.State(value=None)
-        cached_df_state = gr.State(value=None)
+def launch():
+    with gr.Blocks(title="MindCare Health Assistant", css=".gradio-container {max-width: 1200px; margin: auto; font-family: Arial, sans-serif;}") as demo:
+        gr.Markdown("# MindCare Health Assistant")
+        gr.Markdown("Record your voice or type a message for health assessments and suggestions.")
 
         with gr.Row():
-            with gr.Column(scale=1):
-                file_input = gr.File(label="Upload Logs (CSV)", file_types=[".csv"])
-                with gr.Group():
-                    gr.Markdown("### Filters")
-                    lab_site_filter = gr.Dropdown(label="Lab Site", choices=['All'], value='All', interactive=True)
-                    equipment_type_filter = gr.Dropdown(label="Equipment Type", choices=['All'], value='All', interactive=True)
-                    date_range_filter = gr.Slider(label="Date Range (Days from Today)", minimum=-365, maximum=0, step=1, value=[-7, 0], interactive=True)
-                    submit_button = gr.Button("Analyze", variant="primary")
-                    pdf_button = gr.Button("Export PDF", variant="secondary")
-
-            with gr.Column(scale=2):
-                with gr.Group(elem_classes="dashboard-container"):
-                    gr.Markdown("<div class='dashboard-title'>Analysis Results</div>")
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Step 1: Summary Report")
-                        summary_output = gr.Markdown()
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Step 2: Log Preview")
-                        preview_output = gr.HTML()
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Device Cards")
-                        device_cards_output = gr.HTML()
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Charts")
-                        with gr.Tab("Usage Hours per Device"):
-                            usage_chart_output = gr.Plot()
-                        with gr.Tab("Downtime per Device"):
-                            downtime_chart_output = gr.Plot()
-                        with gr.Tab("Daily Log Trends"):
-                            daily_log_trends_output = gr.Plot()
-                        with gr.Tab("Weekly Uptime Percentage"):
-                            weekly_uptime_output = gr.Plot()
-                        with gr.Tab("Anomaly Alerts"):
-                            anomaly_alerts_output = gr.Plot()
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Step 4: Anomaly Detection")
-                        anomaly_output = gr.Markdown()
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Step 5: AMC Reminders")
-                        amc_output = gr.Markdown()
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Step 6: Insights")
-                        insights_output = gr.Markdown()
-                    with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Export Report")
-                        pdf_output = gr.File(label="Download Status Report as PDF")
-
-        file_input.change(
-            fn=update_filters,
-            inputs=[file_input, current_file_state],
-            outputs=[lab_site_filter, equipment_type_filter, current_file_state],
-            queue=False
+            with gr.Column():
+                gr.Markdown("### Voice Analysis")
+                gr.Markdown("Record or upload voice (1+ sec) describing symptoms (e.g., 'I have a cough' or 'I feel stressed').")
+                language_input = gr.Dropdown(choices=list(SUPPORTED_LANGUAGES.keys()), label="Select Language", value="en")
+                consent_input = gr.Checkbox(label="I consent to data storage and voice analysis", value=True, interactive=False)
+                audio_input = gr.Audio(type="filepath", label="Record or Upload Voice (WAV, MP3, FLAC)", format="wav")
+                voice_output = gr.Textbox(label="Health Assessment Results", elem_id="health-results")
+                pdf_output = gr.File(label="Download Assessment Report (PDF)")
+                submit_btn = gr.Button("Submit")
+                clear_btn = gr.Button("Clear")
+
+            with gr.Column():
+                gr.Markdown("### Health Suggestions")
+                gr.Markdown("Enter a message for personalized health advice.")
+                text_input = gr.Textbox(label="Enter your message")
+                text_output = gr.Textbox(label="Response")
+                audio_output = gr.Audio(label="Response Audio")
+                suggest_submit_btn = gr.Button("Submit")
+                suggest_clear_btn = gr.Button("Clear")
+
+        submit_btn.click(
+            fn=analyze_voice,
+            inputs=[audio_input, language_input],
+            outputs=[voice_output, pdf_output]
         )
-
-        submit_button.click(
-            fn=process_logs,
-            inputs=[file_input, lab_site_filter, equipment_type_filter, date_range_filter, cached_df_state, last_modified_state],
-            outputs=[summary_output, preview_output, usage_chart_output, device_cards_output, daily_log_trends_output, weekly_uptime_output, anomaly_alerts_output, downtime_chart_output, anomaly_output, amc_output, insights_output, pdf_output, cached_df_state, last_modified_state]
+        clear_btn.click(
+            fn=lambda: (gr.update(value=None), gr.update(value="en"), gr.update(value=""), gr.update(value=None)),
+            inputs=None,
+            outputs=[audio_input, language_input, voice_output, pdf_output]
         )
-
-        pdf_button.click(
-            fn=generate_pdf,
-            inputs=[summary_output, preview_output, usage_chart_output, device_cards_output, daily_log_trends_output, weekly_uptime_output, anomaly_alerts_output, downtime_chart_output, anomaly_output, amc_output, insights_output],
-            outputs=[pdf_output]
+        suggest_submit_btn.click(
+            fn=get_chatbot_response,
+            inputs=[text_input, language_input],
+            outputs=[text_output, audio_output]
         )
-
-        logging.info("Gradio interface initialized successfully")
-except Exception as e:
-    logging.error(f"Failed to initialize Gradio interface: {str(e)}")
-    raise e
+        suggest_clear_btn.click(
+            fn=lambda: (gr.update(value=""), gr.update(value=""), gr.update(value=None)),
+            inputs=None,
+            outputs=[text_input, text_output, audio_output]
+        )
+    demo.launch(server_name="0.0.0.0", server_port=7860)
 
 if __name__ == "__main__":
-    try:
-        logging.info("Launching Gradio interface...")
-        iface.launch(server_name="0.0.0.0", server_port=7860, debug=True, share=False)
-        logging.info("Gradio interface launched successfully")
-    except Exception as e:
-        logging.error(f"Failed to launch Gradio interface: {str(e)}")
-        print(f"Error launching app: {str(e)}")
-        raise e
+    launch()