app.py

import gradio as gr
import librosa
import numpy as np
import torch
from transformers import WhisperProcessor, WhisperForConditionalGeneration
from simple_salesforce import Salesforce
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
from cryptography.fernet import Fernet
import pytz
from reportlab.lib.pagesizes import A4
from reportlab.lib import colors
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, ListFlowable, ListItem
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import inch
import asyncio
import hashlib
from functools import lru_cache

# Set up logging with DEBUG level, adjusted for IST
logging.basicConfig(level=logging.DEBUG, 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=SF_USERNAME,
        password=SF_PASSWORD,
        security_token=SF_SECURITY_TOKEN,
        instance_url=SF_INSTANCE_URL
    )
    logger.info(f"Connected to Salesforce at {SF_INSTANCE_URL}")
except Exception as e:
    logger.error(f"Salesforce connection failed: {str(e)}")
    sf = None

# Initialize Google Gemini with retry logic
def initialize_gemini():
    try:
        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")
        return chat
    except Exception as e:
        logger.error(f"Google Gemini initialization failed: {str(e)}")
        return None

chat = initialize_gemini()

# Load Whisper model
SUPPORTED_LANGUAGES = {"English": "english", "Hindi": "hindi", "Spanish": "spanish", "Mandarin": "mandarin"}
SALESFORCE_LANGUAGE_MAP = {"English": "English", "Hindi": "Hindi", "Spanish": "Spanish", "Mandarin": "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 = """
MindCare is an AI health assistant focused on:
- **Mental health**: Emotional support, mindfulness, stress-relief, anxiety management.
- **Medical guidance**: Symptom analysis, possible conditions, medicine recommendations.
- **Decision-making**: Personal, professional, emotional choices.
- **General health**: Lifestyle, nutrition, physical and mental wellness.
- **Emergency assistance**: Suggest professional help or helplines for distress.
Tone: Empathetic, supportive, informative.
"""
mental_health = """
For stress/anxiety:
- Suggest mindfulness, deep breathing, gratitude journaling.
- Encourage breaks, hobbies, nature.
- Provide affirmations, self-care routines.
For distress:
- Offer emotional support, assure they’re not alone.
- Suggest trusted contacts or professionals.
- Provide crisis helplines.
"""
medical_assistance = """
For symptoms:
- Analyze and suggest possible conditions.
- Offer general advice, not replacing doctor consultation.
- Suggest lifestyle changes, home remedies.
- Advise medical attention for severe symptoms.
"""
medicine_recommendation = """
For medicine queries:
- Suggest common antibiotics (e.g., Amoxicillin), painkillers (e.g., Paracetamol, Ibuprofen).
- Note precautions, side effects.
- Stress doctor consultation before use.
"""
decision_guidance = """
For decisions:
- Weigh pros/cons logically.
- Consider values, goals, emotions.
- Suggest decision matrices or intuitive checks.
- Encourage trusted advice if needed.
"""
emergency_help = """
For severe distress:
- Provide immediate emotional support.
- Offer crisis helplines (region-specific).
- Encourage talking to trusted contacts or professionals.
- Assure help is available.
"""
context = [base_info, mental_health, medical_assistance, medicine_recommendation, decision_guidance, emergency_help]

def encrypt_data(data):
    try:
        return cipher.encrypt(data.encode('utf-8')).decode('utf-8')
    except Exception as e:
        logger.error(f"Encryption failed: {str(e)}")
        return data

def decrypt_data(encrypted_data):
    try:
        return cipher.decrypt(encrypted_data.encode('utf-8')).decode('utf-8')
    except Exception as e:
        logger.error(f"Decryption failed: {str(e)}")
        return encrypted_data

@lru_cache(maxsize=100)
def cached_transcribe(audio_file, language):
    try:
        audio, sr = librosa.load(audio_file, sr=16000)
        language_code = {"English": "en", "Hindi": "hi", "Spanish": "es", "Mandarin": "zh"}.get(language, "en")
        return transcribe_audio(audio, language_code)
    except Exception as e:
        logger.error(f"Cached transcription failed: {str(e)}")
        return None

def extract_health_features(audio, sr):
    try:
        audio = librosa.util.normalize(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)
        
        frame_step = max(1, len(voiced_audio) // (sr // 16))
        pitches, magnitudes = librosa.piptrack(y=voiced_audio[::frame_step], 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)
        amplitudes = librosa.feature.rms(y=voiced_audio, frame_length=512, hop_length=256)[0]
        shimmer = np.std(amplitudes) / np.mean(amplitudes) if np.mean(amplitudes) else 0
        shimmer = min(shimmer, 10)
        energy = np.mean(amplitudes)
        
        mfcc = np.mean(librosa.feature.mfcc(y=voiced_audio[::8], sr=sr, n_mfcc=4), axis=1)
        spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=voiced_audio[::8], sr=sr, n_fft=512, hop_length=256))
        
        logger.debug(f"Extracted features: pitch={pitch:.2f}, jitter={jitter*100:.2f}%, shimmer={shimmer*100:.2f}%, energy={energy:.4f}, mfcc_mean={np.mean(mfcc):.2f}, spectral_centroid={spectral_centroid:.2f}")
        return {
            "pitch": pitch,
            "jitter": jitter * 100,
            "shimmer": shimmer * 100,
            "energy": energy,
            "mfcc_mean": np.mean(mfcc),
            "spectral_centroid": spectral_centroid
        }
    except Exception as e:
        logger.error(f"Feature extraction failed: {str(e)}")
        return {
            "pitch": 0,
            "jitter": 0,
            "shimmer": 0,
            "energy": 0,
            "mfcc_mean": 0,
            "spectral_centroid": 0
        }

def transcribe_audio(audio, language="en"):
    try:
        whisper_model.config.forced_decoder_ids = whisper_processor.get_decoder_prompt_ids(
            language=SUPPORTED_LANGUAGES.get({"en": "English", "hi": "Hindi", "es": "Spanish", "zh": "Mandarin"}.get(language, "English"), "english"), task="transcribe"
        )
        inputs = whisper_processor(audio, sampling_rate=16000, return_tensors="pt")
        with torch.no_grad():
            generated_ids = whisper_model.generate(inputs["input_features"], max_new_tokens=20)
        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:
        logger.error(f"Transcription failed: {str(e)}")
        return None

async def get_chatbot_response(message, language="en", retries=2, timeout=10):
    global chat  # Declare global at the start
    if not message:
        return "No input provided. Please describe your symptoms or concerns.", None
    if not chat:
        logger.warning("Gemini chat object is None, attempting to reinitialize")
        chat = initialize_gemini()
        if not chat:
            return "Error: Unable to connect to Gemini API. Please check API key.", None
    
    language_code = {"English": "en", "Hindi": "hi", "Spanish": "es", "Mandarin": "zh"}.get(language, "en")
    full_context = "\n".join(context) + f"\nUser: {message}\nMindCare: Provide response in 6-8 simple bullet points, tailored to the user's input, in a clear and empathetic tone."
    
    for attempt in range(retries + 1):
        try:
            async with asyncio.timeout(timeout):
                response = await asyncio.get_event_loop().run_in_executor(None, lambda: chat.send_message(full_context).text)
                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
                    tts = gTTS(text=response, lang=language_code, slow=False)
                    tts.save(temp_audio.name)
                    audio_path = temp_audio.name
                logger.info(f"Generated response: {response[:100]}... and audio at {audio_path}")
                return response, audio_path
        except asyncio.TimeoutError:
            logger.error(f"Chatbot response timed out on attempt {attempt + 1}")
            if attempt == retries:
                return "Error: Response generation timed out.", None
        except Exception as e:
            logger.error(f"Chatbot response failed on attempt {attempt + 1}: {str(e)}")
            if attempt == retries:
                return f"Error generating response: {str(e)}", None
        await asyncio.sleep(1)
    return "Error: Unable to generate response after retries.", None

async def translate_text(text, target_language, retries=2, timeout=10):
    if not chat or not text:
        return text
    if target_language == "English":
        return text
    language_code = {"Hindi": "hi", "Spanish": "es", "Mandarin": "zh"}.get(target_language, "en")
    prompt = f"Translate the following text into {target_language} while preserving formatting (e.g., bullet points, newlines):\n\n{text}"
    
    for attempt in range(retries + 1):
        try:
            async with asyncio.timeout(timeout):
                response = await asyncio.get_event_loop().run_in_executor(None, lambda: chat.send_message(prompt).text)
                logger.info(f"Translated text to {target_language}: {response[:100]}...")
                return response
        except asyncio.TimeoutError:
            logger.error(f"Translation to {target_language} timed out on attempt {attempt + 1}")
            if attempt == retries:
                return text
        except Exception as e:
            logger.error(f"Translation to {target_language} failed on attempt {attempt + 1}: {str(e)}")
            if attempt == retries:
                return text
        await asyncio.sleep(1)
    return text

async def analyze_symptoms(text, features, language="English"):
    feedback = []
    suggestions = []
    text = text.lower() if text else ""
    
    if "cough" in text or "coughing" in text:
        feedback.append("You mentioned a cough, which may suggest a cold or respiratory issue.")
        suggestions.extend([
            "• Drink warm fluids like herbal tea or water to soothe your throat.",
            "• Rest to help your body recover from possible infection.",
            "• Use a humidifier to ease throat irritation.",
            "• Consider over-the-counter cough remedies, but consult a doctor first.",
            "• Monitor symptoms; see a doctor if the cough lasts over a week."
        ])
    elif "fever" in text or "temperature" in text:
        feedback.append("You mentioned a fever, which could indicate an infection.")
        suggestions.extend([
            "• Stay hydrated with water or electrolyte drinks.",
            "• Rest to support your immune system.",
            "• Monitor your temperature regularly.",
            "• Use paracetamol to reduce fever, but follow dosage instructions.",
            "• Seek medical advice if fever exceeds 100.4°F (38°C) for over 2 days."
        ])
    elif "headache" in text:
        feedback.append("You mentioned a headache, possibly due to stress or dehydration.")
        suggestions.extend([
            "• Drink plenty of water to stay hydrated.",
            "• Take short breaks to relax your mind.",
            "• Try a mild pain reliever like ibuprofen, but consult a doctor.",
            "• Practice deep breathing to reduce tension.",
            "• Ensure you're getting enough sleep (7-8 hours)."
        ])
    elif "stress" in text or "anxious" in text or "mental stress" in text:
        feedback.append("You mentioned stress or anxiety, which can affect well-being.")
        suggestions.extend([
            "• Try 5 minutes of deep breathing to calm your mind.",
            "• Write in a journal to process your thoughts.",
            "• Take a short walk in nature to relax.",
            "• Practice mindfulness or meditation daily.",
            "• Talk to a trusted friend or professional for support.",
            "• Prioritize sleep and avoid excessive caffeine."
        ])
    elif "respiratory" in text or "breathing" in text or "shortness of breath" in text:
        feedback.append("You mentioned breathing issues, which may indicate asthma or infection.")
        suggestions.extend([
            "• Avoid triggers like smoke or allergens.",
            "• Practice slow, deep breathing exercises.",
            "• Stay in a well-ventilated area.",
            "• Monitor symptoms and seek medical help if severe.",
            "• Rest to reduce strain on your respiratory system."
        ])
    elif "cold" in text:
        feedback.append("You mentioned a cold, likely a viral infection.")
        suggestions.extend([
            "• Drink warm fluids like soup or tea.",
            "• Rest to help your body fight the virus.",
            "• Use saline nasal spray to relieve congestion.",
            "• Take over-the-counter cold remedies, but consult a doctor.",
            "• Stay hydrated and avoid strenuous activity."
        ])
    
    if features["jitter"] > 6.5:
        feedback.append(f"High jitter ({features['jitter']:.2f}%) suggests vocal strain or respiratory issues.")
        suggestions.append("• Rest your voice and avoid shouting.")
    elif features["jitter"] > 4.0:
        feedback.append(f"Moderate jitter ({features['jitter']:.2f}%) indicates possible vocal instability.")
        suggestions.append("• Sip warm water to soothe your vocal cords.")
    
    if features["shimmer"] > 7.5:
        feedback.append(f"High shimmer ({features['shimmer']:.2f}%) may indicate emotional stress.")
        suggestions.append("• Try relaxation techniques like yoga or meditation.")
    elif features["shimmer"] > 5.0:
        feedback.append(f"Moderate shimmer ({features['shimmer']:.2f}%) suggests mild vocal strain.")
        suggestions.append("• Stay hydrated to support vocal health.")
    
    if features["energy"] < 0.003:
        feedback.append(f"Low vocal energy ({features['energy']:.4f}) may indicate fatigue.")
        suggestions.append("• Ensure 7-8 hours of sleep nightly.")
    elif features["energy"] < 0.007:
        feedback.append(f"Low vocal energy ({features['energy']:.4f}) suggests possible tiredness.")
        suggestions.append("• Take short naps to boost energy.")
    
    if features["pitch"] < 70 or features["pitch"] > 290:
        feedback.append(f"Unusual pitch ({features['pitch']:.2f} Hz) may indicate vocal issues.")
        suggestions.append("• Consult a doctor for a vocal health check.")
    elif 70 <= features["pitch"] <= 90 or 270 <= features["pitch"] <= 290:
        feedback.append(f"Pitch ({features['pitch']:.2f} Hz) is slightly outside typical range.")
        suggestions.append("• Avoid straining your voice during conversations.")
    
    if features["spectral_centroid"] > 2700:
        feedback.append(f"High spectral centroid ({features['spectral_centroid']:.2f} Hz) suggests tense speech.")
        suggestions.append("• Practice slow, calm speaking to reduce tension.")
    elif features["spectral_centroid"] > 2200:
        feedback.append(f"Elevated spectral centroid ({features['spectral_centroid']:.2f} Hz) may indicate mild tension.")
        suggestions.append("• Relax your jaw and shoulders while speaking.")
    
    if not feedback:
        feedback.append("No significant health concerns detected from voice or text analysis.")
        suggestions.extend([
            "• Maintain a balanced diet with fruits and vegetables.",
            "• Exercise regularly for overall health.",
            "• Stay hydrated with 8 glasses of water daily.",
            "• Get 7-8 hours of sleep each night.",
            "• Practice stress-relief techniques like meditation.",
            "• Schedule regular health check-ups."
        ])
    
    suggestions = list(dict.fromkeys(suggestions))[:8]
    if len(suggestions) < 6:
        suggestions.extend([
            "• Stay active with light exercise like walking.",
            "• Practice gratitude to boost mental well-being."
        ][:6 - len(suggestions)])
    
    feedback_text = "\n".join(feedback)
    suggestions_text = "\n".join(suggestions)
    try:
        translated_feedback = await translate_text(feedback_text, language)
        translated_suggestions = await translate_text(suggestions_text, language)
    except Exception as e:
        logger.error(f"Translation failed: {str(e)}")
        translated_feedback = feedback_text
        translated_suggestions = suggestions_text
    
    logger.debug(f"Generated feedback: {translated_feedback}, Suggestions: {translated_suggestions}")
    return translated_feedback, translated_suggestions

def store_user_consent(email, language):
    if not sf:
        logger.warning("Salesforce not connected; skipping consent storage")
        return None
    try:
        email_to_use = email.strip() if email and email.strip() else DEFAULT_EMAIL
        sanitized_email = email_to_use.replace("'", "\\'").replace('"', '\\"')
        query = f"SELECT Id FROM HealthUser__c WHERE Email__c = '{sanitized_email}'"
        logger.debug(f"Executing SOQL query: {query}")
        user = sf.query(query)
        user_id = None
        if user["totalSize"] == 0:
            logger.info(f"No user found for email: {sanitized_email}, creating new user")
            user = sf.HealthUser__c.create({
                "Email__c": sanitized_email,
                "Language__c": SALESFORCE_LANGUAGE_MAP.get(language, "English"),
                "ConsentGiven__c": True
            })
            user_id = user["id"]
            logger.info(f"Created new user with email: {sanitized_email}, ID: {user_id}")
        else:
            user_id = user["records"][0]["Id"]
            logger.info(f"Found existing user with email: {sanitized_email}, ID: {user_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: {sanitized_email}")
        sf.ConsentLog__c.create({
            "HealthUser__c": user_id,
            "ConsentType__c": "Voice Analysis",
            "ConsentDate__c": datetime.utcnow().isoformat()
        })
        logger.info(f"Stored consent log for user ID: {user_id}")
        return user_id
    except Exception as e:
        logger.error(f"Consent storage failed: {str(e)}")
        logger.exception("Stack trace for consent storage failure:")
        return None

def generate_pdf_report(feedback, transcription, features, language, email, suggestions):
    try:
        feedback = feedback.replace('<', '<').replace('>', '>').replace('&', '&')
        transcription = transcription.replace('<', '<').replace('>', '>').replace('&', '&') if transcription else "None"
        suggestions = suggestions.replace('<', '<').replace('>', '>').replace('&', '&') if suggestions else "None"
        email_to_use = email.strip() if email and email.strip() else DEFAULT_EMAIL
        email = email_to_use.replace('<', '<').replace('>', '>').replace('&', '&')
        language_display = SALESFORCE_LANGUAGE_MAP.get(language, "English")
        
        ist = pytz.timezone('Asia/Kolkata')
        ist_time = datetime.now(ist).strftime("%I:%M %p IST on %B %d, %Y")
        logger.debug(f"Generating PDF with IST time: {ist_time}, feedback: {feedback[:100]}..., transcription: {transcription[:100]}..., suggestions: {suggestions[:100]}..., language: {language_display}, email: {email}")
        
        debug_dir = "/tmp/mindcare_logs"
        os.makedirs(debug_dir, exist_ok=True)
        timestamp = datetime.now(ist).strftime("%Y%m%d_%H%M%S")
        pdf_path = os.path.join(debug_dir, f"report_{timestamp}.pdf")
        
        doc = SimpleDocTemplate(pdf_path, pagesize=A4, rightMargin=inch, leftMargin=inch, topMargin=inch, bottomMargin=inch)
        styles = getSampleStyleSheet()
        title_style = ParagraphStyle(
            name='Title',
            fontSize=16,
            leading=20,
            alignment=1,
            spaceAfter=12,
            fontName='Times-Bold'
        )
        heading_style = ParagraphStyle(
            name='Heading1',
            fontSize=14,
            leading=16,
            spaceBefore=12,
            spaceAfter=8,
            fontName='Times-Bold'
        )
        subheading_style = ParagraphStyle(
            name='Heading2',
            fontSize=12,
            leading=14,
            spaceBefore=10,
            spaceAfter=6,
            fontName='Times-Bold'
        )
        normal_style = ParagraphStyle(
            name='Normal',
            fontSize=12,
            leading=14,
            spaceAfter=6,
            fontName='Times-Roman'
        )
        bullet_style = ParagraphStyle(
            name='Bullet',
            fontSize=12,
            leading=14,
            leftIndent=20,
            firstLineIndent=-10,
            spaceAfter=4,
            fontName='Times-Roman'
        )
        
        section_titles = {
            "English": {
                "title": "MindCare Health Assistant Report",
                "user_info": "User Information",
                "voice_results": "Voice Analysis Results",
                "health_assessment": "Health Assessment",
                "health_suggestions": "Health Suggestions",
                "voice_details": "Voice Analysis Details",
                "transcription": "Transcription",
                "voice_metrics": "Voice Metrics",
                "disclaimer": "Disclaimer",
                "disclaimer_text": "This report is a preliminary analysis and not a medical diagnosis. Always consult a healthcare provider."
            },
            "Hindi": {
                "title": "माइंडकेयर स्वास्थ्य सहायक रिपोर्ट",
                "user_info": "उपयोगकर्ता जानकारी",
                "voice_results": "आवाज विश्लेषण परिणाम",
                "health_assessment": "स्वास्थ्य मूल्यांकन",
                "health_suggestions": "स्वास्थ्य सुझाव",
                "voice_details": "आवाज विश्लेषण विवरण",
                "transcription": "प्रतिलेखन",
                "voice_metrics": "आवाज मेट्रिक्स",
                "disclaimer": "अस्वीकरण",
                "disclaimer_text": "यह रिपोर्ट एक प्रारंभिक विश्लेषण है और चिकित्सा निदान नहीं है। हमेशा स्वास्थ्य सेवा प्रदाता से परामर्श करें।"
            },
            "Spanish": {
                "title": "Informe del Asistente de Salud MindCare",
                "user_info": "Información del Usuario",
                "voice_results": "Resultados del Análisis de Voz",
                "health_assessment": "Evaluación de Salud",
                "health_suggestions": "Sugerencias de Salud",
                "voice_details": "Detalles del Análisis de Voz",
                "transcription": "Transcripción",
                "voice_metrics": "Métricas de Voz",
                "disclaimer": "Descargo de Responsabilidad",
                "disclaimer_text": "Este informe es un análisis preliminar y no un diagnóstico médico. Siempre consulte a un proveedor de atención médica."
            },
            "Mandarin": {
                "title": "MindCare 健康助手报告",
                "user_info": "用户信息",
                "voice_results": "语音分析结果",
                "health_assessment": "健康评估",
                "health_suggestions": "健康建议",
                "voice_details": "语音分析详情",
                "transcription": "转录",
                "voice_metrics": "语音指标",
                "disclaimer": "免责声明",
                "disclaimer_text": "此报告为初步分析，非医疗诊断。请始终咨询医疗服务提供者。"
            }
        }
        titles = section_titles.get(language, section_titles["English"])
        
        story = []
        story.append(Paragraph(titles["title"], title_style))
        story.append(Paragraph(f"Generated on {ist_time}", normal_style))
        story.append(Spacer(1, 0.5 * inch))
        
        story.append(Paragraph(titles["user_info"], heading_style))
        user_info = [
            ListItem(Paragraph(f"<b>Email</b>: {email}", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"<b>Language</b>: {language_display}", bullet_style), bulletText="•")
        ]
        story.append(ListFlowable(user_info, bulletType='bullet'))
        story.append(Spacer(1, 0.25 * inch))
        
        story.append(Paragraph(titles["voice_results"], heading_style))
        story.append(Paragraph(titles["health_assessment"], subheading_style))
        for line in feedback.split('\n'):
            if line.strip():
                story.append(Paragraph(line, normal_style))
        story.append(Spacer(1, 0.1 * inch))
        
        story.append(Paragraph(titles["health_suggestions"], subheading_style))
        for line in suggestions.split('\n'):
            if line.strip():
                story.append(Paragraph(line, normal_style))
        story.append(Spacer(1, 0.1 * inch))
        
        story.append(Paragraph(titles["voice_details"], subheading_style))
        details = [
            ListItem(Paragraph(f"Pitch: {features['pitch']:.2f} Hz", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"Jitter: {features['jitter']:.2f}% (voice stability)", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"Shimmer: {features['shimmer']:.2f}% (amplitude variation)", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"Energy: {features['energy']:.4f} (vocal intensity)", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"MFCC Mean: {features['mfcc_mean']:.2f} (timbre quality)", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"Spectral Centroid: {features['spectral_centroid']:.2f} Hz (voice brightness)", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"Transcription: {transcription}", bullet_style), bulletText="•")
        ]
        story.append(ListFlowable(details, bulletType='bullet'))
        story.append(Spacer(1, 0.1 * inch))
        
        story.append(Paragraph(titles["transcription"], subheading_style))
        story.append(Paragraph(transcription, normal_style))
        story.append(Spacer(1, 0.1 * inch))
        
        story.append(Paragraph(titles["voice_metrics"], subheading_style))
        metrics = [
            ListItem(Paragraph(f"<b>Pitch</b>: {features['pitch']:.2f} Hz", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"<b>Jitter</b>: {features['jitter']:.2f}%", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"<b>Shimmer</b>: {features['shimmer']:.2f}%", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"<b>Energy</b>: {features['energy']:.4f}", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"<b>MFCC Mean</b>: {features['mfcc_mean']:.2f}", bullet_style), bulletText="•"),
            ListItem(Paragraph(f"<b>Spectral Centroid</b>: {features['spectral_centroid']:.2f} Hz", bullet_style), bulletText="•")
        ]
        story.append(ListFlowable(metrics, bulletType='bullet'))
        story.append(Spacer(1, 0.1 * inch))
        
        story.append(Paragraph(titles["disclaimer"], heading_style))
        story.append(Paragraph(titles["disclaimer_text"], normal_style))
        
        doc.build(story)
        logger.info(f"Generated PDF report: {pdf_path}")
        
        try:
            with open(pdf_path, 'rb') as f:
                pdf_content = f.read()
            if len(pdf_content) > 0 and pdf_content.startswith(b'%PDF'):
                return pdf_path, None
            else:
                logger.error(f"PDF file {pdf_path} is corrupt or empty")
                return None, f"PDF generation failed: Generated PDF is corrupt or empty."
        except Exception as e:
            logger.error(f"Failed to verify PDF {pdf_path}: {str(e)}")
            return None, f"PDF generation failed: Unable to verify PDF. Error: {str(e)}."
    except Exception as e:
        logger.error(f"PDF generation failed: {str(e)}")
        logger.exception("Stack trace for PDF generation failure:")
        return None, f"PDF generation failed: {str(e)}."

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(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[:32767]
        assessment = sf.VoiceAssessment__c.create({
            "HealthUser__c": user_id,
            "VoiceRecording__c": file_url,
            "AssessmentResult__c": feedback_str,
            "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)}")
        logger.exception("Stack trace for Salesforce storage failure:")
        raise

async def analyze_voice(audio_file=None, language="English", email=None):
    global usage_metrics
    usage_metrics["total_assessments"] += 1
    usage_metrics["assessments_by_language"][language] = usage_metrics["assessments_by_language"].get(language, 0) + 1

    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)
        max_duration = 5
        if len(audio) > max_duration * sr:
            audio = audio[:max_duration * sr]
            logger.info(f"Truncated audio to first {max_duration} seconds for faster processing")
        if len(audio) < sr:
            raise ValueError("Audio too short (minimum 1 second)")

        language_code = {"English": "en", "Hindi": "hi", "Spanish": "es", "Mandarin": "zh"}.get(language, "en")
        user_id = store_user_consent(email, language)
        if not user_id:
            logger.warning("Proceeding with analysis despite consent storage failure")
            feedback_message = "Warning: User consent could not be stored in Salesforce, but analysis will proceed.\n"
        else:
            feedback_message = ""

        features = extract_health_features(audio, sr)
        transcription = cached_transcribe(audio_file, language)
        try:
            feedback, suggestions = await analyze_symptoms(transcription, features, language)
        except Exception as e:
            logger.error(f"Symptom analysis failed: {str(e)}")
            feedback = "Error: Unable to analyze symptoms due to processing failure."
            suggestions = "\n".join([
                "• Maintain a balanced diet with fruits and vegetables.",
                "• Exercise regularly for overall health.",
                "• Stay hydrated with 8 glasses of water daily.",
                "• Get 7-8 hours of sleep each night.",
                "• Practice stress-relief techniques like meditation.",
                "• Schedule regular health check-ups."
            ])
            try:
                suggestions = await translate_text(suggestions, language)
            except Exception as e:
                logger.error(f"Fallback suggestion translation failed: {str(e)}")

        respiratory_score = features["jitter"]
        mental_health_score = features["shimmer"]

        feedback = feedback_message + feedback + "\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 += f"- Email: {email if email and email.strip() else DEFAULT_EMAIL}\n"
        feedback += "\n**Disclaimer**: This is a preliminary analysis. Consult a healthcare provider for professional evaluation."

        details_to_translate = (
            f"Voice Analysis Details:\n"
            f"- Pitch: {features['pitch']:.2f} Hz\n"
            f"- Jitter: {features['jitter']:.2f}% (voice stability)\n"
            f"- Shimmer: {features['shimmer']:.2f}% (amplitude variation)\n"
            f"- Energy: {features['energy']:.4f} (vocal intensity)\n"
            f"- MFCC Mean: {features['mfcc_mean']:.2f} (timbre quality)\n"
            f"- Spectral Centroid: {features['spectral_centroid']:.2f} Hz (voice brightness)\n"
            f"- Transcription: {transcription if transcription else 'None'}\n"
            f"- Email: {email if email and email.strip() else DEFAULT_EMAIL}\n"
            f"\nDisclaimer: This is a preliminary analysis. Consult a healthcare provider for professional evaluation."
        )
        try:
            translated_details = await translate_text(details_to_translate, language)
        except Exception as e:
            logger.error(f"Translation of feedback details failed: {str(e)}")
            translated_details = details_to_translate
        feedback = feedback_message + feedback.split("\n\n**Voice Analysis Details**")[0] + "\n\n**" + translated_details

        if user_id and sf:
            store_in_salesforce(user_id, audio_file, feedback, respiratory_score, mental_health_score, features, transcription, language)
        else:
            logger.warning("Skipping Salesforce storage due to missing user_id or Salesforce connection")

        file_path, pdf_error = generate_pdf_report(feedback, transcription, features, language, email, suggestions)
        if pdf_error:
            feedback += f"\n\n**Error**: {pdf_error}"
            return feedback, file_path, suggestions, None

        response_text = suggestions
        response, audio_path = await get_chatbot_response(response_text, language)
        if audio_path:
            logger.info(f"Generated audio response at {audio_path}")
        else:
            logger.warning("Failed to generate audio response")
            return feedback, file_path, suggestions, None

        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, file_path, response, audio_path
    except Exception as e:
        logger.error(f"Audio processing failed: {str(e)}")
        fallback_suggestions = "\n".join([
            "• Maintain a balanced diet with fruits and vegetables.",
            "• Exercise regularly for overall health.",
            "• Stay hydrated with 8 glasses of water daily.",
            "• Get 7-8 hours of sleep each night.",
            "• Practice stress-relief techniques like meditation.",
            "• Schedule regular health check-ups."
        ])
        try:
            fallback_suggestions = await translate_text(fallback_suggestions, language)
        except Exception as e:
            logger.error(f"Fallback suggestion translation failed: {str(e)}")
        return f"Error: {str(e)}", None, fallback_suggestions, None

def launch():
    custom_css = """
    .gradio-container {
        max-width: 1200px;
        margin: auto;
        font-family: 'Roboto', sans-serif;
        background-color: #f5f7fa;
        color: #333;
    }
    @import url('https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap');
    h1, h3 {
        background: linear-gradient(to right, #007bff, #0056b3);
        color: white;
        padding: 15px;
        border-radius: 8px;
        text-align: center;
        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
    }
    .gr-column {
        background: white;
        border-radius: 8px;
        padding: 20px;
        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
        margin: 10px;
    }
    .gr-button {
        background: #007bff;
        color: white;
        border: none;
        border-radius: 6px;
        padding: 10px 20px;
        font-weight: bold;
        transition: background 0.3s;
    }
    .gr-button:hover {
        background: #0056b3;
    }
    .gr-textbox, .gr-dropdown, .gr-checkbox, .gr-file, .gr-audio {
        border-radius: 6px;
        border: 1px solid #ced4da;
    }
    .gr-textbox textarea {
        font-size: 14px;
    }
    #health-results {
        background: #e9f7ef;
        border: 1px solid #28a745;
        border-radius: 6px;
    }
    .no-microphone-warning {
        color: red;
        font-weight: bold;
    }
    """

    def check_microphone_access():
        try:
            from navigator import mediaDevices
            devices = mediaDevices.enumerateDevices()
            for device in devices:
                if device.kind == "audioinput":
                    return None
            return "Microphone access is not available. Please upload an audio file or check browser permissions."
        except Exception as e:
            logger.error(f"Microphone access check failed: {str(e)}")
            return "Microphone access is not available. Please upload an audio file or check browser permissions."

    with gr.Blocks(title="MindCare Health Assistant", css=custom_css) as demo:
        gr.Markdown("Record your voice or type a message for health assessments and suggestions.")

        with gr.Row():
            with gr.Column():
                gr.Markdown("### Voice Analysis")
                mic_warning = gr.Markdown()
                mic_warning.value = check_microphone_access() or ""
                gr.Markdown("Upload voice (1+ sec) describing symptoms (e.g., 'I have a cough' or 'I feel stressed'). Note: Microphone recording may not be supported in all contexts; use file upload instead.")
                email_input = gr.Textbox(label="Enter Your Email", placeholder="e.g., user@example.com", value="")
                language_input = gr.Dropdown(choices=list(SUPPORTED_LANGUAGES.keys()), label="Select Language", value="English")
                consent_input = gr.Checkbox(label="I consent to data storage and voice analysis", value=True, interactive=False)
                audio_input = gr.Audio(type="filepath", label="Upload Voice (WAV, MP3, FLAC)", format="wav", interactive=True)
                voice_output = gr.Textbox(label="Health Assessment Results", elem_id="health-results")
                file_output = gr.File(label="Download Assessment Report (PDF)", file_types=[".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 or get suggestions based on voice analysis.")
                text_input = gr.Textbox(label="Enter your message (optional)")
                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, email_input],
            outputs=[voice_output, file_output, text_output, audio_output]
        )
        clear_btn.click(
            fn=lambda: (gr.update(value=None), gr.update(value="English"), gr.update(value=""), gr.update(value=""), gr.update(value=None), gr.update(value=""), gr.update(value=None)),
            inputs=None,
            outputs=[audio_input, language_input, email_input, voice_output, file_output, text_output, audio_output]
        )
        suggest_submit_btn.click(
            fn=get_chatbot_response,
            inputs=[text_input, language_input],
            outputs=[text_output, audio_output]
        )
        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__":
    launch()