import os
import io
import streamlit as st
from groq import Groq
import requests
import soundfile as sf
import google.generativeai as genai
from audiorecorder import audiorecorder

# Umgebungsvariablen laden
groq_api_key = os.getenv('groqwhisper')
gemini_api_key = os.getenv('geminiapi')
google_api_key = os.getenv('google_search')
cx="77f1602c0ff764edb"

if not groq_api_key or not gemini_api_key:
    st.error("Bitte setze die Umgebungsvariablen 'groqwhisper' und 'geminiapi'")
    st.stop()

# Groq Client initialisieren
groq_client = Groq(api_key=groq_api_key)

# Gemini konfigurieren
genai.configure(api_key=gemini_api_key)

# Modellkonfiguration
generation_config = {
    "temperature": 0.4,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 8192,
    "response_mime_type": "text/plain",
}

model = genai.GenerativeModel(
    model_name="gemini-2.0-flash-exp",
    generation_config=generation_config,
)

# Session State für Chatverlauf
if "chat_session" not in st.session_state:
    st.session_state.chat_session = model.start_chat(history=[])

if "display_history" not in st.session_state:
    st.session_state.display_history = []


def websearch(prompt):  
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
    }
    url = f"https://www.googleapis.com/customsearch/v1?key={google_api_key}&cx={cx}&q={prompt}"   
    response = requests.get(url, headers=headers)
    data = response.json()  # JSON-Daten direkt verarbeiten
    # Extrahieren des Textes aus den Ergebnissen
    items = data.get('items', []) 
    results = [item['snippet'] for item in items]
    result_text = '\n'.join(results)   
    # Formuliere die Antwort
    search_query = f"{prompt} antworte kurz und knapp. antworte auf deutsch. du findest die antwort hier: {result_text}"
    #result = predict(search_query)
    return result_text


def process_audio(audio_data):
    """Verarbeitet Audiodaten und gibt Transkript zurück."""
    try:
        sample_rate, samples = audio_data
        
        # WAV-Datei im Speicher erstellen
        with io.BytesIO() as wav_buffer:
            sf.write(wav_buffer, samples, sample_rate, format='WAV')
            wav_buffer.seek(0)
            
            # Transkription mit Groq
            transcription = groq_client.audio.transcriptions.create(
                file=("recording.wav", wav_buffer.read(), "audio/wav"),
                model="whisper-large-v3-turbo",
                prompt="transcribe",
                language="de",
                response_format="json",
                temperature=0.0
            )
        return transcription.text
    except Exception as e:
        return f"Fehler: {str(e)}"


st.subheader("Gemini-2/Websearch")
messages = st.container()

# Chatverlauf anzeigen
for role, text in st.session_state.display_history:
    with st.chat_message(role):
        st.markdown(text)

# Spracheingabe verarbeiten
audio_bytes = st.audio_input("Sprachnachricht aufnehmen")
if audio_bytes:
    try:
        audio_content = audio_bytes.getvalue()
        with io.BytesIO(audio_content) as wav_io:
            samples, sample_rate = sf.read(wav_io)
            if len(samples.shape) > 1 and samples.shape[1] == 2:
                samples = samples.mean(axis=1)
                
            with st.spinner("Transkription..."):
                transcription = process_audio((sample_rate, samples))
                
            if transcription:
                if transcription.startswith("Fehler:"):
                    st.error(transcription)
                else:
                    #st.session_state.display_history.append(("user", transcription))                    
                    websearch = websearch(transcription)
                    full_prompt = f"{transcription}\nAntworte immer auf Deutsch\n Du findest die Antwort hier:\n{websearch}"
                    response = st.session_state.chat_session.send_message(full_prompt)
                    response_text = response.candidates[0].content.parts[0].text if response.candidates else "Keine Antwort"
                    messages.chat_message("assistant").write(f"{response_text}")
                    #st.write(response_text)
                    #st.session_state.display_history.append(("assistant", response_text))
                    #st.rerun()
    except Exception as e:
        st.error(f"Audioprocessing fehlgeschlagen: {str(e)}")

# Texteingabe verarbeiten
user_input = st.text_input("Schreibe deine Frage:", key="user_input")
if user_input:
    websearch = websearch(user_input)   
    #st.session_state.display_history.append(("user", user_input))
    full_prompt = f"{user_input}\nAntworte immer auf Deutsch\n antworte kurz und knapp.\n Du findest die Antwort hier:\n{websearch}"
    response = st.session_state.chat_session.send_message(full_prompt)
    response_text = response.candidates[0].content.parts[0].text if response.candidates else "Keine Antwort"
    messages.chat_message("assistant").write(f"{response_text}")
    #st.markdown(response_text)
    #st.session_state.display_history.append(("assistant", response_text))
    #st.rerun()