app.py

import streamlit as st
import os
from transformers import pipeline
from langdetect import detect, DetectorFactory
from groq import Groq

# Ensure consistent language detection
DetectorFactory.seed = 0

# Load Hugging Face token from environment
HF_TOKEN = os.environ.get("homeo_doc")
if not HF_TOKEN:
    st.error("❌ Missing Hugging Face API token. Set 'homeo_doc' in environment variables.")

# Initialize translation pipeline
try:
    translator = pipeline("translation", model="facebook/nllb-200-distilled-600M", token=HF_TOKEN)
except Exception as e:
    st.error(f"❌ Error initializing translation model: {e}")

# Initialize Groq client for AI-based homeopathic advice
GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
if not GROQ_API_KEY:
    st.error("❌ Missing GROQ API Key. Set 'GROQ_API_KEY' in environment variables.")

groq_client = Groq(api_key=GROQ_API_KEY)

# Language code mapping for NLLB-200
LANG_CODE_MAP = {
    'en': 'eng_Latn',    # English
    'ur': 'urd_Arab',    # Urdu
    'ar': 'arb_Arab',    # Arabic
    'es': 'spa_Latn',    # Spanish
    'hi': 'hin_Deva',    # Hindi
    'fr': 'fra_Latn'     # French
}

def translate_text(text, target_lang='eng_Latn'):
    """Translate text using NLLB-200 model."""
    try:
        source_lang = detect(text)
        source_code = LANG_CODE_MAP.get(source_lang, 'eng_Latn')  # Default to English if unknown
        
        st.write(f"🔄 Detected source: {source_code}, Target: {target_lang}")  # Debugging log

        translation = translator(
            text, 
            src_lang=source_code,   # Pass source language
            tgt_lang=target_lang    # Pass target language
        )

        return translation[0]['translation_text']
    
    except Exception as e:
        st.error(f"⚠️ Translation error: {str(e)}")
        return text  # Return original text if translation fails

def get_homeopathic_advice(symptoms):
    """Get medical advice using Groq AI API."""
    try:
        response = groq_client.chat.completions.create(
            model="llama3-70b-8192",
            messages=[{
                "role": "user",
                "content": f"Act as a homeopathic expert. Suggest remedies for: {symptoms}"
            }],
            temperature=0.3
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"❌ Error fetching homeopathic advice: {str(e)}"

# 🎨 Streamlit UI
st.set_page_config(page_title="Homeo Advisor", page_icon="🌿")
st.title("🌍 Multilingual Homeopathic Advisor")

# Chat interface (Persistent session)
if "messages" not in st.session_state:
    st.session_state.messages = []

# Display previous chat messages
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# User input box
if prompt := st.chat_input("Describe symptoms in any language..."):
    st.session_state.messages.append({"role": "user", "content": prompt})

    with st.spinner("🔍 Analyzing..."):
        # Translate user input to English
        english_input = translate_text(prompt, "eng_Latn")

        # Get homeopathic advice in English
        english_advice = get_homeopathic_advice(english_input)

        # Detect original language
        source_lang = detect(prompt)
        source_code = LANG_CODE_MAP.get(source_lang, 'eng_Latn')

        # Translate advice back to original language
        translated_advice = translate_text(english_advice, source_code)

        # Format response
        final_response = f"""
        **💡 English Recommendation:**  
        {english_advice}  
        
        **🌍 Translated Recommendation ({source_lang.upper()}):**  
        {translated_advice}
        """

    # Display response
    with st.chat_message("assistant"):
        st.markdown(final_response)
    
    # Save response in session history
    st.session_state.messages.append({"role": "assistant", "content": final_response})

# Disclaimer
st.caption("⚠️ This is not medical advice. Consult a professional.")