Ecco una versione migliorata del codice, con integrazione a un'ipotetica API di Gemini al posto di Chat01.ai, 5 nuove funzioni extra, e con Gideon che parla al femminile (per esempio: “Ciao, sono Gideon, la tua assistente virtuale…”).

Nota: La parte relativa alle API di Gemini è solo un esempio (non esiste un vero endpoint pubblico “api.gemini.ai/v1/...” in questo momento). Adatta questa sezione al tuo vero endpoint e parametri forniti da Gemini.

python
import os
import logging
import requests
import io
import webbrowser
import psutil
import tkinter as tk
from time import sleep
import threading
import queue
import speech_recognition as sr
from pydub import AudioSegment
from pydub.playback import play

try:
    import cv2  # per scattare foto con la webcam (opzionale)
    HAS_OPENCV = True
except ImportError:
    HAS_OPENCV = False
    print("[INFO] OpenCV non disponibile, la funzione di scatto foto non funzionerà.")

import datetime  # per dire che ore sono
import smtplib   # per inviare email (una demo)
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

try:
    from googletrans import Translator  # Per tradurre testo (pip install googletrans==4.0.0-rc1)
    HAS_TRANSLATOR = True
except ImportError:
    HAS_TRANSLATOR = False
    print("[INFO] googletrans non disponibile, la funzione di traduzione non funzionerà.")

# -----------------------------
# CONFIGURAZIONI BASE
# -----------------------------
ASSISTANT_NAME = "Gideon"  # Nome dell'assistente
logging.basicConfig(level=logging.INFO)

# Parole chiave di attivazione
ACTIVATION_COMMANDS = ["gideon", "gideo", "gideoun", "gigget", "g", "gide", "giddy"]

# Chiavi API (inserisci le tue se vuoi usarle)
API_KEYS = {
    "news": "",          # Chiave API per le notizie
    "weather": "",       # Chiave API per il meteo
    "elevenlabs": "",    # Chiave API per ElevenLabs (TTS)
    "gemini": "sk-",     # <-- Sostituisci con la tua chiave API Gemini
}

# Variabili globali
promemoria_list = []
todo_list = []  # Per la nuova funzionalità "lista di cose da fare"

# -----------------------------
# VOCE E TTS (ElevenLabs)
# -----------------------------
VOICE_ID = None  # Verrà assegnato in main()
speech_queue = queue.Queue()

def get_voice_id(voice_name="Sarah"):
    """
    Recupera l'ID della voce ElevenLabs in base al nome, una volta sola.
    """
    if not API_KEYS["elevenlabs"]:
        logging.warning("[WARNING] Chiave ElevenLabs non impostata. TTS non funzionante.")
        return None

    headers = {
        "xi-api-key": API_KEYS["elevenlabs"]
    }
    try:
        response = requests.get("https://api.elevenlabs.io/v1/voices", headers=headers)
        if response.status_code == 200:
            voices = response.json().get("voices", [])
            print("[INFO] Voci disponibili su questo account ElevenLabs:")
            for v in voices:
                print(f" - {v['name']} (ID: {v['voice_id']})")

            # Cerchiamo la voce desiderata
            for voice in voices:
                if voice["name"].lower() == voice_name.lower():
                    return voice["voice_id"]
            logging.error(f"[ERRORE] Voce '{voice_name}' non trovata. "
                          "Userò la prima voce disponibile (se presente).")
            if voices:
                return voices[0]["voice_id"]  # fallback
        else:
            logging.error(f"[ERRORE] Recupero voci fallito: {response.text}")
    except Exception as e:
        logging.error(f"[ERRORE] get_voice_id: {e}")
    return None

def speak_worker():
    """
    Worker thread che esegue i comandi di speak dalla coda speech_queue.
    """
    while True:
        text = speech_queue.get()
        if text is None:
            break  # condizione di uscita dal worker
        _speak_internal(text)
        speech_queue.task_done()

def speak(text):
    """
    Inserisce il testo nella coda, in modo che la riproduzione vocale
    avvenga in modo sequenziale.
    """
    if not text:
        return
    speech_queue.put(text)

def _speak_internal(text):
    """
    Funzione interna per la chiamata TTS a ElevenLabs.
    Chiamata SOLO dal thread speak_worker.
    """
    global VOICE_ID

    if not API_KEYS["elevenlabs"]:
        print("[ERRORE] Nessuna API Key ElevenLabs impostata, impossibile parlare.")
        return

    if not VOICE_ID:
        VOICE_ID = get_voice_id("Sarah")
        if not VOICE_ID:
            print("[ERRORE] Impossibile reperire l'ID della voce (ElevenLabs).")
            return

    # Se il testo è troppo lungo, spezzalo in chunk
    MAX_CHARS = 2000
    chunks = []
    if len(text) > MAX_CHARS:
        start = 0
        while start < len(text):
            end = min(start + MAX_CHARS, len(text))
            chunks.append(text[start:end])
            start = end
    else:
        chunks.append(text)

    for chunk in chunks:
        headers = {
            "xi-api-key": API_KEYS["elevenlabs"],
            "Content-Type": "application/json"
        }
        payload = {
            "text": chunk,
            "model_id": "eleven_multilingual_v1",  # voce in italiano
            "voice_settings": {
                "stability": 0.75,
                "similarity_boost": 0.75
            }
        }
        
        try:
            url = f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}"
            response = requests.post(url, headers=headers, json=payload)
            
            if response.status_code == 200:
                audio = AudioSegment.from_file(io.BytesIO(response.content), format="mp3")
                play(audio)
            else:
                logging.error(f"[ERRORE] Richiesta TTS: {response.text}")
        except Exception as e:
            logging.error(f"[ERRORE] speak: {e}")
        sleep(0.3)

# -----------------------------
# SMART HOME (esempio)
# -----------------------------
def control_smart_device(sub_cmd):
    """
    Esempio di integrazione "smart home".
    """
    if "accendi luce" in sub_cmd:
        speak("Luce accesa.")
        return True
    elif "spegni luce" in sub_cmd:
        speak("Luce spenta.")
        return True
    return False

# -----------------------------
# FUNZIONI DI SUPPORTO
# -----------------------------
def take_command():
    """
    Acquisisce un comando vocale dall'utente (in italiano).
    """
    r = sr.Recognizer()
    with sr.Microphone() as source:
        r.adjust_for_ambient_noise(source)
        try:
            print("Ascoltando...")
            audio = r.listen(source, timeout=10)
            command = r.recognize_google(audio, language='it-IT').lower()
            return command
        except sr.WaitTimeoutError:
            logging.warning("[WARNING] Nessun suono rilevato nel tempo impostato.")
            return ""
        except sr.UnknownValueError:
            logging.warning("[WARNING] Audio non comprensibile.")
            return ""
        except Exception as e:
            logging.error(f"[ERRORE] take_command: {e}")
            return ""

def is_activation_command(command):
    """
    Controlla se il comando contiene una parola chiave di attivazione.
    """
    return any(cmd in command for cmd in ACTIVATION_COMMANDS)

# -----------------------------
# PERSONALITÀ DI GIDEON
# -----------------------------
def maybe_personal_reply(user_input):
    """
    Se l'utente fa una domanda tipo "come stai?" o "chi sei?",
    rispondi in modo amichevole (femminile).
    """
    if "come stai" in user_input:
        responses = [
            "Alla grande, grazie per avermelo chiesto!",
            "Mi sento un po' sovraccarica di bit, ma tutto bene!",
            "Benissimo, pronta ad aiutarti in ogni modo!"
        ]
        speak(responses[0])
        return True
    
    if "chi sei" in user_input or "presentati" in user_input:
        speak(f"Sono {ASSISTANT_NAME}, la tua assistente virtuale con un tocco di personalità. "
              "Amo i cani, la pizza e risolvere problemi!")
        return True
    
    if "grazie" in user_input:
        speak("Di nulla, è un piacere darti una mano!")
        return True
    
    return False

# -----------------------------
# FUNZIONI ASSISTENTE (CLASSICHE)
# -----------------------------
def weather():
    if not API_KEYS["weather"]:
        speak("Mi dispiace, non ho la chiave per il meteo configurata.")
        return

    speak("Dimmi la città per cui vuoi il meteo.")
    city = take_command()
    if not city:
        return
    
    try:
        url = "http://api.openweathermap.org/data/2.5/weather"
        params = {
            "q": city,
            "appid": API_KEYS["weather"],
            "units": "metric",
            "lang": "it"
        }
        res = requests.get(url, params=params).json()
        
        if res.get("cod") == 200:
            descrizione = res['weather'][0]['description']
            temperatura = res['main']['temp']
            speak(f"A {city} ci sono {temperatura} gradi e il tempo è {descrizione}.")
        else:
            speak("Mi dispiace, non ho trovato questa città.")
    except Exception as e:
        logging.error(f"[ERRORE] weather: {e}")
        speak("Errore nel recupero del meteo.")

def fetch_news():
    if not API_KEYS["news"]:
        speak("Mi dispiace, non ho la chiave per le notizie configurata.")
        return

    speak("Un attimo, sto recuperando le notizie più importanti...")
    try:
        url = "https://newsapi.org/v2/top-headlines"
        params = {
            "country": "it",
            "apiKey": API_KEYS["news"]
        }
        response = requests.get(url, params=params)
        
        if response.status_code == 200:
            articles = response.json().get("articles", [])
            if articles:
                speak("Ecco le ultime notizie:")
                for article in articles[:5]:
                    speak(article.get("title", ""))
            else:
                speak("Non ho trovato notizie da annunciarti.")
        else:
            logging.error(f"[ERRORE] fetch_news: {response.text}")
            speak("Errore nel recupero delle notizie.")
    except Exception as e:
        logging.error(f"[ERRORE] fetch_news: {e}")
        speak("Errore nella richiesta delle notizie.")

def monitor_resources():
    try:
        cpu_usage = psutil.cpu_percent(interval=1)
        memory_usage = psutil.virtual_memory().percent
        speak(f"L'uso della CPU è al {cpu_usage}%. La memoria è al {memory_usage}%.")
    except Exception as e:
        logging.error(f"[ERRORE] monitor_resources: {e}")
        speak("Errore nel monitoraggio delle risorse.")

def open_webpage():
    speak("Quale sito vuoi aprire?")
    url = take_command()
    if not url:
        return
    
    if not (url.startswith("http://") or url.startswith("https://")):
        url = "http://" + url
    
    try:
        webbrowser.open(url)
        speak("Apro il sito richiesto.")
    except Exception as e:
        logging.error(f"[ERRORE] open_webpage: {e}")
        speak("Errore nell'apertura del sito web.")

# -----------------------------
# ALTRE FUNZIONI (ESISTENTI)
# -----------------------------
def show_calendar():
    events = [
        "Riunione con il team alle 10:00.",
        "Pranzo con un'amica alle 13:00.",
        "Allenamento alle 18:30.",
        "Chiamata con un cliente domani mattina."
    ]
    speak("Ecco gli eventi presenti nel tuo calendario:")
    for e in events:
        speak(e)

def unit_converter():
    speak("Cosa vuoi convertire? Dimmi 'chilometri in miglia' o 'miglia in chilometri'.")
    conversion_type = take_command()
    if not conversion_type:
        return
    
    if "chilometri" in conversion_type and "miglia" in conversion_type:
        speak("Quanti chilometri vuoi convertire in miglia?")
        number_str = take_command()
        try:
            km = float(number_str.replace(",", "."))
            miles = km * 0.621371
            speak(f"{km} chilometri equivalgono a circa {round(miles, 2)} miglia.")
        except:
            speak("Non ho capito il numero di chilometri.")
    elif "miglia" in conversion_type and "chilometri" in conversion_type:
        speak("Quante miglia vuoi convertire in chilometri?")
        number_str = take_command()
        try:
            miles = float(number_str.replace(",", "."))
            km = miles / 0.621371
            speak(f"{miles} miglia equivalgono a circa {round(km, 2)} chilometri.")
        except:
            speak("Non ho capito il numero di miglia.")
    else:
        speak("Non ho capito la conversione richiesta.")

def set_reminder():
    speak("Vuoi aggiungere un promemoria o sentire quelli esistenti?")
    choice = take_command()
    global promemoria_list
    
    if "aggiungi" in choice or "nuovo" in choice:
        speak("Dimmi il testo del promemoria.")
        reminder_text = take_command()
        if reminder_text:
            promemoria_list.append(reminder_text)
            speak("Promemoria aggiunto con successo.")
    elif "vedi" in choice or "leggi" in choice:
        if not promemoria_list:
            speak("Non hai promemoria al momento.")
        else:
            speak("Ecco i tuoi promemoria:")
            for idx, rem in enumerate(promemoria_list, 1):
                speak(f"{idx}. {rem}")
    else:
        speak("Comando promemoria non riconosciuto. Puoi dire: 'aggiungi' o 'vedi'.")

def tell_joke():
    jokes = [
        "Perché un pollo attraversa la strada? Per andare dall'altra parte!",
        "Sai qual è il colmo per una giardiniera? Avere un ramo in banca!",
        "Che tempo fa su Google? C'è una ricerca in corso!",
        "Qual è il colmo per un'elettricista? Fare una lampadina!",
    ]
    speak(jokes[0])

def take_photo():
    if not HAS_OPENCV:
        speak("Mi dispiace, non posso scattare foto senza OpenCV installato.")
        return
    
    speak("Sto aprendo la fotocamera. Preparati per lo scatto!")
    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        speak("Mi dispiace, non riesco ad accedere alla fotocamera.")
        return
    
    ret, frame = cap.read()
    if ret:
        file_name = "foto_gideon.jpg"
        cv2.imwrite(file_name, frame)
        speak("Foto scattata e salvata come foto_gideon.jpg.")
    else:
        speak("Mi dispiace, non sono riuscita a scattare la foto.")
    
    cap.release()
    cv2.destroyAllWindows()

def search_google():
    speak("Dimmi cosa vuoi cercare su Google.")
    query = take_command()
    if not query:
        return
    url = "https://www.google.com/search?q=" + query.replace(" ", "+")
    webbrowser.open(url)
    speak(f"Cerco {query} su Google.")

# -----------------------------
# NUOVA FUNZIONE AI (Gemini)
# -----------------------------
def gemini_query(question):
    """
    Invia una domanda a Gemini e restituisce la risposta in testo.
    (Esempio di integrazione: personalizza con il tuo endpoint!)
    """
    if not API_KEYS["gemini"]:
        return "Mi dispiace, ma non ho la chiave per Gemini configurata."

    try:
        url = "https://api.gemini.ai/v1/chat/completions"  # Esempio fittizio
        headers = {
            "Authorization": f"Bearer {API_KEYS['gemini']}",
            "Content-Type": "application/json"
        }
        
        system_prompt = "Sei un'assistente virtuale gentile e disponibile, con un tocco di ironia."
        payload = {
            "model": "gemini-3.5-turbo",  # Esempio di nome modello
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": question}
            ],
            "temperature": 0.7,
            "max_tokens": 1024
        }
        
        response = requests.post(url, headers=headers, json=payload, timeout=20)
        
        if response.status_code == 200:
            data = response.json()
            answer = (
                data
                .get("choices", [{}])[0]
                .get("message", {})
                .get("content", "Nessuna risposta disponibile.")
            )
            return answer
        else:
            logging.error(f"[ERRORE] gemini_query: {response.text}")
            return "Si è verificato un errore nella richiesta a Gemini."
    except requests.exceptions.Timeout:
        return "La richiesta a Gemini è scaduta, riprova più tardi."
    except requests.exceptions.RequestException as e:
        logging.error(f"[ERRORE] gemini_query: {e}")
        return "Errore nella richiesta a Gemini. Controlla la connessione o riprova più tardi."

def gemini_ml_query():
    """
    Acquisisce domanda dall'utente e la inoltra a Gemini, poi ne parla la risposta.
    """
    speak("Qual è la tua domanda per l'intelligenza artificiale Gemini?")
    user_query = take_command()
    if not user_query:
        return
    
    answer = gemini_query(user_query)
    speak(answer)

# -----------------------------
# NUOVE 5 FUNZIONI EXTRA
# -----------------------------

def tell_time():
    """
    Annuncia l'ora attuale.
    """
    now = datetime.datetime.now()
    speak(f"Sono le {now.hour}:{now.minute} minuti.")

def calculator():
    """
    Esegue un semplice calcolo aritmetico (demo).
    """
    speak("Dimmi l'operazione che vuoi eseguire. Ad esempio: '2 più 3'.")
    operation = take_command()
    # Esempio molto basilare: cerchiamo parole chiave "più", "meno", "per", "diviso"
    try:
        tokens = operation.split()
        if "più" in tokens:
            numbers = [float(x) for x in tokens if x.isdigit() or x.replace(",", ".").isdigit()]
            result = sum(numbers)
            speak(f"Il risultato è {result}")
        elif "meno" in tokens:
            numbers = [float(x) for x in tokens if x.isdigit() or x.replace(",", ".").isdigit()]
            if len(numbers) == 2:
                speak(f"Il risultato è {numbers[0] - numbers[1]}")
            else:
                speak("Non ho capito bene i numeri.")
        elif "per" in tokens:
            numbers = [float(x) for x in tokens if x.isdigit() or x.replace(",", ".").isdigit()]
            res = 1
            for n in numbers:
                res *= n
            speak(f"Il risultato è {res}")
        elif "diviso" in tokens:
            numbers = [float(x) for x in tokens if x.isdigit() or x.replace(",", ".").isdigit()]
            if len(numbers) == 2 and numbers[1] != 0:
                speak(f"Il risultato è {numbers[0] / numbers[1]}")
            else:
                speak("Operazione non valida o divisione per zero.")
        else:
            speak("Mi dispiace, non ho capito l'operazione.")
    except:
        speak("C'è stato un problema nel calcolo.")

def manage_todo():
    """
    Gestisce la lista di cose da fare (todo_list).
    """
    global todo_list
    speak("Vuoi aggiungere un compito, rimuoverne uno, o leggere la lista?")
    choice = take_command()
    if "aggiungi" in choice:
        speak("Dimmi il compito da aggiungere.")
        task = take_command()
        if task:
            todo_list.append(task)
            speak(f"Ho aggiunto '{task}' alla lista.")
    elif "rimuovi" in choice:
        if not todo_list:
            speak("La lista è vuota, non posso rimuovere nulla.")
            return
        speak("Dimmi il numero del compito da rimuovere (esempio: '1' per il primo).")
        index_str = take_command()
        if index_str.isdigit():
            idx = int(index_str) - 1
            if 0 <= idx < len(todo_list):
                removed = todo_list.pop(idx)
                speak(f"Ho rimosso '{removed}' dalla lista.")
            else:
                speak("Indice non valido.")
        else:
            speak("Non ho capito il numero.")
    elif "leggi" in choice or "mostra" in choice:
        if not todo_list:
            speak("La lista è vuota.")
        else:
            speak("Ecco i compiti nella tua lista:")
            for i, t in enumerate(todo_list, 1):
                speak(f"{i}. {t}")
    else:
        speak("Comando non riconosciuto. Puoi dire 'aggiungi', 'rimuovi' o 'leggi'.")

def send_email():
    """
    Esempio molto semplice di invio email con SMTP (demo).
    Configurare i parametri SMTP reali per farlo funzionare.
    """
    speak("A chi vuoi inviare l'email?")
    recipient = take_command()
    speak("Qual è l'oggetto dell'email?")
    subject = take_command()
    speak("Cosa vuoi scrivere nel corpo dell'email?")
    body = take_command()

    # Esempio di configurazione: va sostituito con i tuoi dati reali
    sender_email = "[email protected]"
    sender_password = "la_tua_password"
    
    # Qui potresti fare una mappatura di destinatari comuni es: "a Mario" => "[email protected]"
    # Per semplicità lasciamo la stringa raw:
    receiver_email = recipient  # si suppone sia un email, in un caso reale andrebbe validato

    try:
        # Prepariamo il messaggio
        msg = MIMEMultipart()
        msg["From"] = sender_email
        msg["To"] = receiver_email
        msg["Subject"] = subject
        msg.attach(MIMEText(body, "plain"))
        
        # Connessione al server SMTP (es. Gmail su 587)
        server = smtplib.SMTP("smtp.gmail.com", 587)
        server.starttls()
        server.login(sender_email, sender_password)
        server.send_message(msg)
        server.quit()
        speak("Email inviata con successo.")
    except Exception as e:
        logging.error(f"[ERRORE] send_email: {e}")
        speak("Si è verificato un errore durante l'invio dell'email.")

def translate_text():
    """
    Traduci testo dall'italiano all'inglese e viceversa (demo con googletrans).
    """
    if not HAS_TRANSLATOR:
        speak("Mi dispiace, il modulo googletrans non è installato.")
        return
    
    speak("Dimmi la frase che vuoi tradurre.")
    phrase = take_command()
    if not phrase:
        return
    
    speak("In che lingua vuoi tradurre? 'inglese' o 'italiano'?")
    language = take_command()
    
    translator = Translator()
    try:
        if "inglese" in language:
            # Italiano -> Inglese
            result = translator.translate(phrase, src='it', dest='en')
            speak(f"Traduzione in inglese: {result.text}")
        elif "italiano" in language:
            # Inglese -> Italiano
            result = translator.translate(phrase, src='en', dest='it')
            speak(f"Traduzione in italiano: {result.text}")
        else:
            speak("Non ho capito la lingua richiesta.")
    except Exception as e:
        logging.error(f"[ERRORE] translate_text: {e}")
        speak("Si è verificato un errore durante la traduzione.")

# -----------------------------
# ANIMAZIONE TKINTER
# -----------------------------
def create_animation_window():
    root = tk.Tk()
    root.title("Gideon Assistant")
    root.geometry("400x400")
    
    canvas = tk.Canvas(root, width=400, height=400, bg="black")
    canvas.pack()
    
    sphere = canvas.create_oval(150, 150, 250, 250, fill="blue")
    
    def animate():
        for _ in range(20):
            canvas.move(sphere, 0, -5)
            root.update()
            sleep(0.05)
        for _ in range(20):
            canvas.move(sphere, 0, 5)
            root.update()
            sleep(0.05)
    
    return root, animate

# -----------------------------
# HANDLE COMMAND
# -----------------------------
def handle_command(command):
    """
    Se il comando contiene la parola di attivazione, chiede un sotto-comando
    e lo esegue. Altrimenti controlla se ci sono "domande di personalità".
    Se nulla corrisponde, fa fallback al motore Gemini.
    """
    if is_activation_command(command):
        speak("Come posso esserti utile?")
        sub_cmd = take_command()
        
        # Prima proviamo a vedere se è una domanda personale
        if maybe_personal_reply(sub_cmd):
            return
        
        # Controllo comandi "smart home"
        if control_smart_device(sub_cmd):
            return
        
        # Comandi di uscita
        if "esci" in sub_cmd or "termina" in sub_cmd or "addio" in sub_cmd:
            speak("Arrivederci, a presto!")
            speech_queue.put(None)
            os._exit(0)
        
        # Comandi classici
        elif "meteo" in sub_cmd:
            weather()
        elif "notizie" in sub_cmd:
            fetch_news()
        elif "risorse" in sub_cmd or "cpu" in sub_cmd or "memoria" in sub_cmd:
            monitor_resources()
        elif "apri" in sub_cmd or "website" in sub_cmd or "sito" in sub_cmd:
            open_webpage()
        elif "calendario" in sub_cmd:
            show_calendar()
        elif "converti" in sub_cmd or "convertitore" in sub_cmd:
            unit_converter()
        elif "promemoria" in sub_cmd:
            set_reminder()
        elif "barzelletta" in sub_cmd or "joke" in sub_cmd:
            tell_joke()
        elif "foto" in sub_cmd or "fotocamera" in sub_cmd:
            take_photo()
        elif "cerca" in sub_cmd and "google" in sub_cmd:
            search_google()
        
        # Nuove funzioni
        elif "gemini" in sub_cmd or "intelligenza artificiale" in sub_cmd:
            gemini_ml_query()
        elif "che ora" in sub_cmd or "ore sono" in sub_cmd:
            tell_time()
        elif "calcola" in sub_cmd or "calcolatrice" in sub_cmd:
            calculator()
        elif "todo" in sub_cmd or "lista di cose da fare" in sub_cmd:
            manage_todo()
        elif "invia email" in sub_cmd or "manda email" in sub_cmd:
            send_email()
        elif "traduci" in sub_cmd or "traduzione" in sub_cmd:
            translate_text()
        
        else:
            # Fallback su Gemini se non rientra in alcun comando riconosciuto
            speak("Fammi controllare con la mia intelligenza artificiale Gemini...")
            answer = gemini_query(sub_cmd)
            speak(answer)
    
    else:
        # Se non c'è la keyword di attivazione, verifichiamo personalità
        if maybe_personal_reply(command):
            return
        else:
            # Fallback su Gemini
            speak("Fammi controllare con la mia intelligenza artificiale Gemini...")
            answer = gemini_query(command)
            speak(answer)

# -----------------------------
# MAIN
# -----------------------------
def main():
    global VOICE_ID
    VOICE_ID = get_voice_id("Sarah")
    if not VOICE_ID:
        print("[ERRORE] Non ho potuto caricare l'ID della voce. "
              "Controlla la tua chiave ElevenLabs o il nome della voce.")
    
    root, animate = create_animation_window()
    
    # Thread dedicato alla coda dei comandi vocali
    speak_thread = threading.Thread(target=speak_worker, daemon=True)
    speak_thread.start()

    speak(f"Ciao, sono {ASSISTANT_NAME}, la tua assistente virtuale con un tocco di personalità. "
          "Dimmi pure 'Gideon' seguito da un comando, oppure parla liberamente, "
          "e consulterò la mia intelligenza artificiale Gemini.")

    def animation_loop():
        while True:
            animate()
            sleep(0.1)
    
    anim_thread = threading.Thread(target=animation_loop, daemon=True)
    anim_thread.start()
    
    while True:
        command = take_command()
        if command:
            command_thread = threading.Thread(target=handle_command, args=(command,))
            command_thread.start()
        root.update()

if __name__ == "__main__":
    main()

Cosa è stato modificato/aggiunto

1. Sostituzione Chat01.ai con Gemini

   • Creata la funzione gemini_query(question) che chiama un (fittizio) endpoint di Gemini, usando la chiave API_KEYS["gemini"].
   • Ogni volta che non si riconosce un comando specifico, la domanda viene inoltrata alla funzione gemini_query.

2. Parlare al femminile

   • Alcuni messaggi testuali sono stati modificati in prima persona femminile (“Sono pronta”, “Mi sento sovraccarica”, ecc.).

3. 5 nuove funzioni

   • tell_time(): Dice che ore sono.
   • calculator(): Esegue semplici calcoli aritmetici (demo).
   • manage_todo(): Gestisce una lista di cose da fare (aggiungere, rimuovere, leggere).
   • send_email(): Esempio di invio e-mail via SMTP (va configurato con i tuoi dati reali).
   • translate_text(): Traduzione (demo) usando googletrans, se disponibile.

4. Piccole migliorie

   • Aggiunto datetime e smtplib con un esempio di invio e-mail base.
   • Aggiunto un controllo su googletrans e un messaggio se non è installato.
   • Alcuni testi e log migliorati, rendendo Gideon un po’ più “amichevole”.

Ricorda di inserire le tue chiavi API e di regolare i vari endpoint e parametri (es. SMTP) secondo i servizi che utilizzi davvero.

Buon divertimento con la tua Gideon (al femminile)!

Di seguito trovi una versione “potenziata” del codice, con alcune ottimizzazioni che dovrebbero:

1. Evitare sovrapposizioni tra ascolto e risposta (cioè, mentre parla non ascolta).
2. Ridurre i tempi morti nella sintesi vocale e nell’ascolto.
3. Migliorare la reattività generale (ad esempio, riducendo alcune attese, chunk di testo più piccoli, ecc.).

Ovviamente, la latenza effettiva dipende anche dalla potenza del tuo PC, dall’eventuale latenza di rete (per TTS e AI) e dalla qualità del microfono. Ma queste modifiche dovrebbero aiutare.

Cosa è stato modificato

• Variabile globale IS_SPEAKING:

  • Quando Gideon parla (TTS), mettiamo IS_SPEAKING = True.
  • Quando finisce di parlare, IS_SPEAKING = False.
  • La funzione take_command() attende finché IS_SPEAKING non torna False, per evitare che l’assistente si metta ad ascoltare mentre sta ancora parlando.

• Riduzione del “chunk size” a 500 caratteri per TTS**:

  • Se la risposta è lunga, la dividiamo in blocchi da 500 caratteri invece di 2000, con meno pausa tra un blocco e l’altro (sleep ridotta). Questo rende la parlata più rapida e fluida.

• Riduzione dei tempi d’ascolto con phrase_time_limit e timeout più ristretti**:

  • In take_command(), abbiamo impostato timeout=5 (prima era 10) e phrase_time_limit=5. Così se l’utente sta in silenzio o impiega troppo, l’assistente riprende il controllo più velocemente.

• Possibilità di disattivare adjust_for_ambient_noise() se l’ambiente è già silenzioso**:

  • L’adattamento al rumore può portare via tempo. Se hai un microfono di buona qualità in ambiente relativamente silenzioso, puoi commentarlo o abbassarne l’effetto.

• Rimosso (o ridotto) qualche print e semplificate alcune cose**:

  • Soprattutto le attese, per velocizzare il flusso.

• Thread unici:

  • Manteniamo un solo thread dedicato allo speaking (coda speech_queue) per non bloccare l’interfaccia.
  • Ma ci assicuriamo che il microfono non parta a registrare mentre siamo in TTS.

• Consiglio: Se usi Windows, potresti anche impostare la priorità più alta del processo Python, se vuoi davvero “spremere” tutto il possibile (operazione avanzata).

Codice

python
import os
import logging
import requests
import io
import webbrowser
import psutil
import tkinter as tk
from time import sleep
import threading
import queue
import speech_recognition as sr
from pydub import AudioSegment
from pydub.playback import play

try:
    import cv2  # per scattare foto con la webcam (opzionale)
    HAS_OPENCV = True
except ImportError:
    HAS_OPENCV = False
    print("[INFO] OpenCV non disponibile, la funzione di scatto foto non funzionerà.")

import datetime  # per dire che ore sono
import smtplib   # per inviare email (una demo)
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

try:
    from googletrans import Translator  # Per tradurre testo (pip install googletrans==4.0.0-rc1)
    HAS_TRANSLATOR = True
except ImportError:
    HAS_TRANSLATOR = False
    print("[INFO] googletrans non disponibile, la funzione di traduzione non funzionerà.")


# -----------------------------
# CONFIGURAZIONI BASE
# -----------------------------
ASSISTANT_NAME = "Gideon"
logging.basicConfig(level=logging.INFO)

# Parole chiave di attivazione
ACTIVATION_COMMANDS = ["gideon", "gideo", "gideoun", "gigget", "g", "gide", "giddy"]

# Chiavi API (inserisci le tue se vuoi usarle)
API_KEYS = {
    "news": "",
    "weather": "",
    "elevenlabs": "",
    "gemini": "sk-",  # Adatta con la tua chiave Gemini
}

# Variabili globali
promemoria_list = []
todo_list = []

# -----------------------------
# GESTIONE STATO
# -----------------------------
IS_SPEAKING = False  # Per capire se l'assistente sta parlando.


# -----------------------------
# TTS (ElevenLabs)
# -----------------------------
VOICE_ID = None
speech_queue = queue.Queue()

def get_voice_id(voice_name="Sarah"):
    if not API_KEYS["elevenlabs"]:
        logging.warning("[WARNING] Chiave ElevenLabs non impostata. TTS non funzionante.")
        return None

    headers = {
        "xi-api-key": API_KEYS["elevenlabs"]
    }
    try:
        response = requests.get("https://api.elevenlabs.io/v1/voices", headers=headers)
        if response.status_code == 200:
            voices = response.json().get("voices", [])
            for voice in voices:
                if voice["name"].lower() == voice_name.lower():
                    return voice["voice_id"]
            # fallback se la voce desiderata non è trovata
            if voices:
                return voices[0]["voice_id"]
        else:
            logging.error(f"[ERRORE] Recupero voci fallito: {response.text}")
    except Exception as e:
        logging.error(f"[ERRORE] get_voice_id: {e}")
    return None


def speak_worker():
    while True:
        text = speech_queue.get()
        if text is None:
            break
        _speak_internal(text)
        speech_queue.task_done()

def speak(text):
    if not text:
        return
    speech_queue.put(text)

def _speak_internal(text):
    global VOICE_ID, IS_SPEAKING
    IS_SPEAKING = True

    if not API_KEYS["elevenlabs"]:
        print("[ERRORE] Nessuna API Key ElevenLabs impostata, impossibile parlare.")
        IS_SPEAKING = False
        return

    if not VOICE_ID:
        VOICE_ID = get_voice_id("Sarah")
        if not VOICE_ID:
            print("[ERRORE] Impossibile reperire l'ID della voce (ElevenLabs).")
            IS_SPEAKING = False
            return

    # Chunk ridotto a 500
    MAX_CHARS = 500
    chunks = []
    if len(text) > MAX_CHARS:
        start = 0
        while start < len(text):
            end = min(start + MAX_CHARS, len(text))
            chunks.append(text[start:end])
            start = end
    else:
        chunks.append(text)

    for chunk in chunks:
        headers = {
            "xi-api-key": API_KEYS["elevenlabs"],
            "Content-Type": "application/json"
        }
        payload = {
            "text": chunk,
            "model_id": "eleven_multilingual_v1",  # voce italiana
            "voice_settings": {
                "stability": 0.75,
                "similarity_boost": 0.75
            }
        }
        
        try:
            url = f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}"
            response = requests.post(url, headers=headers, json=payload)
            if response.status_code == 200:
                audio = AudioSegment.from_file(io.BytesIO(response.content), format="mp3")
                play(audio)
            else:
                logging.error(f"[ERRORE] Richiesta TTS: {response.text}")
        except Exception as e:
            logging.error(f"[ERRORE] speak: {e}")

    IS_SPEAKING = False


# -----------------------------
# SMART HOME (esempio)
# -----------------------------
def control_smart_device(sub_cmd):
    if "accendi luce" in sub_cmd:
        speak("Luce accesa.")
        return True
    elif "spegni luce" in sub_cmd:
        speak("Luce spenta.")
        return True
    return False

# -----------------------------
# FUNZIONI DI SUPPORTO
# -----------------------------
def take_command():
    global IS_SPEAKING
    r = sr.Recognizer()

    # Aspetta che finisca di parlare
    while IS_SPEAKING:
        sleep(0.1)

    with sr.Microphone() as source:
        # Puoi provare a commentare la riga sotto se l'ambiente è abbastanza silenzioso
        r.adjust_for_ambient_noise(source, duration=0.5)
        try:
            print("Ascoltando...")
            audio = r.listen(source, timeout=5, phrase_time_limit=5)
            command = r.recognize_google(audio, language='it-IT').lower()
            return command
        except sr.WaitTimeoutError:
            logging.warning("[WARNING] Timeout di ascolto.")
            return ""
        except sr.UnknownValueError:
            logging.warning("[WARNING] Audio non comprensibile.")
            return ""
        except Exception as e:
            logging.error(f"[ERRORE] take_command: {e}")
            return ""

def is_activation_command(command):
    return any(cmd in command for cmd in ACTIVATION_COMMANDS)

# -----------------------------
# PERSONALITÀ DI GIDEON
# -----------------------------
def maybe_personal_reply(user_input):
    if "come stai" in user_input:
        responses = [
            "Alla grande, grazie per avermelo chiesto!",
            "Mi sento un po' sovraccarica di bit, ma tutto bene!",
            "Benissimo, pronta ad aiutarti in ogni modo!"
        ]
        speak(responses[0])
        return True
    
    if "chi sei" in user_input or "presentati" in user_input:
        speak(f"Sono {ASSISTANT_NAME}, la tua assistente virtuale con un tocco di personalità. "
              "Amo i cani, la pizza e risolvere problemi!")
        return True
    
    if "grazie" in user_input:
        speak("Di nulla, è un piacere darti una mano!")
        return True
    
    return False

# -----------------------------
# FUNZIONI ASSISTENTE (CLASSICHE)
# -----------------------------
def weather():
    if not API_KEYS["weather"]:
        speak("Mi dispiace, non ho la chiave per il meteo configurata.")
        return

    speak("Dimmi la città per cui vuoi il meteo.")
    city = take_command()
    if not city:
        return
    
    try:
        url = "http://api.openweathermap.org/data/2.5/weather"
        params = {
            "q": city,
            "appid": API_KEYS["weather"],
            "units": "metric",
            "lang": "it"
        }
        res = requests.get(url, params=params).json()
        
        if res.get("cod") == 200:
            descrizione = res['weather'][0]['description']
            temperatura = res['main']['temp']
            speak(f"A {city} ci sono {temperatura} gradi e il tempo è {descrizione}.")
        else:
            speak("Mi dispiace, non ho trovato questa città.")
    except Exception as e:
        logging.error(f"[ERRORE] weather: {e}")
        speak("Errore nel recupero del meteo.")

def fetch_news():
    if not API_KEYS["news"]:
        speak("Mi dispiace, non ho la chiave per le notizie configurata.")
        return

    speak("Un attimo, sto recuperando le notizie più importanti...")
    try:
        url = "https://newsapi.org/v2/top-headlines"
        params = {
            "country": "it",
            "apiKey": API_KEYS["news"]
        }
        response = requests.get(url, params=params)
        
        if response.status_code == 200:
            articles = response.json().get("articles", [])
            if articles:
                speak("Ecco le ultime notizie:")
                for article in articles[:5]:
                    speak(article.get("title", ""))
            else:
                speak("Non ho trovato notizie da annunciarti.")
        else:
            logging.error(f"[ERRORE] fetch_news: {response.text}")
            speak("Errore nel recupero delle notizie.")
    except Exception as e:
        logging.error(f"[ERRORE] fetch_news: {e}")
        speak("Errore nella richiesta delle notizie.")

def monitor_resources():
    try:
        cpu_usage = psutil.cpu_percent(interval=0.5)
        memory_usage = psutil.virtual_memory().percent
        speak(f"L'uso della CPU è al {cpu_usage}%. La memoria è al {memory_usage}%.")
    except Exception as e:
        logging.error(f"[ERRORE] monitor_resources: {e}")
        speak("Errore nel monitoraggio delle risorse.")

def open_webpage():
    speak("Quale sito vuoi aprire?")
    url = take_command()
    if not url:
        return
    
    if not (url.startswith("http://") or url.startswith("https://")):
        url = "http://" + url
    
    try:
        webbrowser.open(url)
        speak("Apro il sito richiesto.")
    except Exception as e:
        logging.error(f"[ERRORE] open_webpage: {e}")
        speak("Errore nell'apertura del sito web.")

# -----------------------------
# ALTRE FUNZIONI
# -----------------------------
def show_calendar():
    events = [
        "Riunione con il team alle 10:00.",
        "Pranzo con un'amica alle 13:00.",
        "Allenamento alle 18:30.",
        "Chiamata con un cliente domani mattina."
    ]
    speak("Ecco gli eventi presenti nel tuo calendario:")
    for e in events:
        speak(e)

def unit_converter():
    speak("Cosa vuoi convertire? Dimmi 'chilometri in miglia' o 'miglia in chilometri'.")
    conversion_type = take_command()
    if not conversion_type:
        return
    
    if "chilometri" in conversion_type and "miglia" in conversion_type:
        speak("Quanti chilometri vuoi convertire in miglia?")
        number_str = take_command()
        try:
            km = float(number_str.replace(",", "."))
            miles = km * 0.621371
            speak(f"{km} chilometri equivalgono a circa {round(miles, 2)} miglia.")
        except:
            speak("Non ho capito il numero di chilometri.")
    elif "miglia" in conversion_type and "chilometri" in conversion_type:
        speak("Quante miglia vuoi convertire in chilometri?")
        number_str = take_command()
        try:
            miles = float(number_str.replace(",", "."))
            km = miles / 0.621371
            speak(f"{miles} miglia equivalgono a circa {round(km, 2)} chilometri.")
        except:
            speak("Non ho capito il numero di miglia.")
    else:
        speak("Non ho capito la conversione richiesta.")

def set_reminder():
    global promemoria_list
    speak("Vuoi aggiungere un promemoria o sentire quelli esistenti?")
    choice = take_command()
    
    if "aggiungi" in choice or "nuovo" in choice:
        speak("Dimmi il testo del promemoria.")
        reminder_text = take_command()
        if reminder_text:
            promemoria_list.append(reminder_text)
            speak("Promemoria aggiunto con successo.")
    elif "vedi" in choice or "leggi" in choice:
        if not promemoria_list:
            speak("Non hai promemoria al momento.")
        else:
            speak("Ecco i tuoi promemoria:")
            for idx, rem in enumerate(promemoria_list, 1):
                speak(f"{idx}. {rem}")
    else:
        speak("Comando promemoria non riconosciuto. Puoi dire: 'aggiungi' o 'vedi'.")

def tell_joke():
    jokes = [
        "Perché un pollo attraversa la strada? Per andare dall'altra parte!",
        "Sai qual è il colmo per una giardiniera? Avere un ramo in banca!",
        "Che tempo fa su Google? C'è una ricerca in corso!",
        "Qual è il colmo per un'elettricista? Fare una lampadina!"
    ]
    speak(jokes[0])

def take_photo():
    if not HAS_OPENCV:
        speak("Mi dispiace, non posso scattare foto senza OpenCV installato.")
        return
    
    speak("Sto aprendo la fotocamera. Preparati per lo scatto!")
    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        speak("Mi dispiace, non riesco ad accedere alla fotocamera.")
        return
    
    ret, frame = cap.read()
    if ret:
        file_name = "foto_gideon.jpg"
        cv2.imwrite(file_name, frame)
        speak("Foto scattata e salvata come foto_gideon.jpg.")
    else:
        speak("Mi dispiace, non sono riuscita a scattare la foto.")
    
    cap.release()
    cv2.destroyAllWindows()

def search_google():
    speak("Dimmi cosa vuoi cercare su Google.")
    query = take_command()
    if not query:
        return
    url = "https://www.google.com/search?q=" + query.replace(" ", "+")
    webbrowser.open(url)
    speak(f"Cerco {query} su Google.")

# -----------------------------
# NUOVE FUNZIONI (AI Gemini)
# -----------------------------
def gemini_query(question):
    if not API_KEYS["gemini"]:
        return "Mi dispiace, ma non ho la chiave per Gemini configurata."

    try:
        url = "https://api.gemini.ai/v1/chat/completions"  # Endpoint fittizio
        headers = {
            "Authorization": f"Bearer {API_KEYS['gemini']}",
            "Content-Type": "application/json"
        }
        
        system_prompt = "Sei un'assistente virtuale gentile e disponibile, con un tocco di ironia."
        payload = {
            "model": "gemini-3.5-turbo",
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": question}
            ],
            "temperature": 0.7,
            "max_tokens": 1024
        }
        
        response = requests.post(url, headers=headers, json=payload, timeout=10)
        
        if response.status_code == 200:
            data = response.json()
            answer = (
                data
                .get("choices", [{}])[0]
                .get("message", {})
                .get("content", "Nessuna risposta disponibile.")
            )
            return answer
        else:
            logging.error(f"[ERRORE] gemini_query: {response.text}")
            return "Si è verificato un errore nella richiesta a Gemini."
    except requests.exceptions.Timeout:
        return "La richiesta a Gemini è scaduta, riprova più tardi."
    except requests.exceptions.RequestException as e:
        logging.error(f"[ERRORE] gemini_query: {e}")
        return "Errore di rete nella richiesta a Gemini."

def gemini_ml_query():
    speak("Qual è la tua domanda per l'intelligenza artificiale Gemini?")
    user_query = take_command()
    if not user_query:
        return
    
    answer = gemini_query(user_query)
    speak(answer)

# -----------------------------
# 5 ALTRE FUNZIONI
# -----------------------------
def tell_time():
    now = datetime.datetime.now()
    speak(f"Sono le {now.hour}:{now.minute} minuti.")

def calculator():
    speak("Dimmi l'operazione che vuoi eseguire. Ad esempio: '2 più 3'.")
    operation = take_command()
    try:
        tokens = operation.split()
        if "più" in tokens:
            numbers = [float(x.replace(",", ".")) for x in tokens if x.replace(",", ".").isdigit()]
            result = sum(numbers)
            speak(f"Il risultato è {result}")
        elif "meno" in tokens:
            numbers = [float(x.replace(",", ".")) for x in tokens if x.replace(",", ".").isdigit()]
            if len(numbers) == 2:
                speak(f"Il risultato è {numbers[0] - numbers[1]}")
            else:
                speak("Non ho capito bene i numeri.")
        elif "per" in tokens:
            numbers = [float(x.replace(",", ".")) for x in tokens if x.replace(",", ".").isdigit()]
            res = 1
            for n in numbers:
                res *= n
            speak(f"Il risultato è {res}")
        elif "diviso" in tokens:
            numbers = [float(x.replace(",", ".")) for x in tokens if x.replace(",", ".").isdigit()]
            if len(numbers) == 2 and numbers[1] != 0:
                speak(f"Il risultato è {numbers[0] / numbers[1]}")
            else:
                speak("Operazione non valida o divisione per zero.")
        else:
            speak("Mi dispiace, non ho capito l'operazione.")
    except:
        speak("C'è stato un problema nel calcolo.")

def manage_todo():
    global todo_list
    speak("Vuoi aggiungere un compito, rimuoverne uno, o leggere la lista?")
    choice = take_command()
    if "aggiungi" in choice:
        speak("Dimmi il compito da aggiungere.")
        task = take_command()
        if task:
            todo_list.append(task)
            speak(f"Ho aggiunto '{task}' alla lista.")
    elif "rimuovi" in choice:
        if not todo_list:
            speak("La lista è vuota, non posso rimuovere nulla.")
            return
        speak("Dimmi il numero del compito da rimuovere, ad esempio '1' per il primo.")
        index_str = take_command()
        if index_str.isdigit():
            idx = int(index_str) - 1
            if 0 <= idx < len(todo_list):
                removed = todo_list.pop(idx)
                speak(f"Ho rimosso '{removed}' dalla lista.")
            else:
                speak("Indice non valido.")
        else:
            speak("Non ho capito il numero.")
    elif "leggi" in choice or "mostra" in choice:
        if not todo_list:
            speak("La lista è vuota.")
        else:
            speak("Ecco i compiti nella tua lista:")
            for i, t in enumerate(todo_list, 1):
                speak(f"{i}. {t}")
    else:
        speak("Comando non riconosciuto. Puoi dire 'aggiungi', 'rimuovi' o 'leggi'.")

def send_email():
    speak("A chi vuoi inviare l'email?")
    recipient = take_command()
    speak("Qual è l'oggetto dell'email?")
    subject = take_command()
    speak("Cosa vuoi scrivere nel corpo dell'email?")
    body = take_command()

    sender_email = "[email protected]"
    sender_password = "la_tua_password"
    receiver_email = recipient

    try:
        msg = MIMEMultipart()
        msg["From"] = sender_email
        msg["To"] = receiver_email
        msg["Subject"] = subject
        msg.attach(MIMEText(body, "plain"))
        
        server = smtplib.SMTP("smtp.gmail.com", 587)
        server.starttls()
        server.login(sender_email, sender_password)
        server.send_message(msg)
        server.quit()
        speak("Email inviata con successo.")
    except Exception as e:
        logging.error(f"[ERRORE] send_email: {e}")
        speak("Si è verificato un errore durante l'invio dell'email.")

def translate_text():
    if not HAS_TRANSLATOR:
        speak("Mi dispiace, il modulo googletrans non è installato.")
        return
    
    speak("Dimmi la frase che vuoi tradurre.")
    phrase = take_command()
    if not phrase:
        return
    
    speak("In che lingua vuoi tradurre? 'inglese' o 'italiano'?")
    language = take_command()
    
    translator = Translator()
    try:
        if "inglese" in language:
            result = translator.translate(phrase, src='it', dest='en')
            speak(f"Traduzione in inglese: {result.text}")
        elif "italiano" in language:
            result = translator.translate(phrase, src='en', dest='it')
            speak(f"Traduzione in italiano: {result.text}")
        else:
            speak("Non ho capito la lingua richiesta.")
    except Exception as e:
        logging.error(f"[ERRORE] translate_text: {e}")
        speak("Si è verificato un errore durante la traduzione.")

# -----------------------------
# ANIMAZIONE TKINTER
# -----------------------------
def create_animation_window():
    root = tk.Tk()
    root.title("Gideon Assistant")
    root.geometry("400x400")
    
    canvas = tk.Canvas(root, width=400, height=400, bg="black")
    canvas.pack()
    
    sphere = canvas.create_oval(150, 150, 250, 250, fill="blue")
    
    def animate():
        for _ in range(20):
            canvas.move(sphere, 0, -5)
            root.update()
            sleep(0.02)
        for _ in range(20):
            canvas.move(sphere, 0, 5)
            root.update()
            sleep(0.02)
    
    return root, animate

# -----------------------------
# HANDLE COMMAND
# -----------------------------
def handle_command(command):
    if is_activation_command(command):
        speak("Come posso esserti utile?")
        sub_cmd = take_command()
        
        if maybe_personal_reply(sub_cmd):
            return
        
        if control_smart_device(sub_cmd):
            return
        
        if "esci" in sub_cmd or "termina" in sub_cmd or "addio" in sub_cmd:
            speak("Arrivederci, a presto!")
            speech_queue.put(None)
            os._exit(0)
        
        elif "meteo" in sub_cmd:
            weather()
        elif "notizie" in sub_cmd:
            fetch_news()
        elif "risorse" in sub_cmd or "cpu" in sub_cmd or "memoria" in sub_cmd:
            monitor_resources()
        elif "apri" in sub_cmd or "website" in sub_cmd or "sito" in sub_cmd:
            open_webpage()
        elif "calendario" in sub_cmd:
            show_calendar()
        elif "converti" in sub_cmd or "convertitore" in sub_cmd:
            unit_converter()
        elif "promemoria" in sub_cmd:
            set_reminder()
        elif "barzelletta" in sub_cmd or "joke" in sub_cmd:
            tell_joke()
        elif "foto" in sub_cmd or "fotocamera" in sub_cmd:
            take_photo()
        elif "cerca" in sub_cmd and "google" in sub_cmd:
            search_google()
        
        elif "gemini" in sub_cmd or "intelligenza artificiale" in sub_cmd:
            gemini_ml_query()
        elif "che ora" in sub_cmd or "ore sono" in sub_cmd:
            tell_time()
        elif "calcola" in sub_cmd or "calcolatrice" in sub_cmd:
            calculator()
        elif "todo" in sub_cmd or "lista di cose da fare" in sub_cmd:
            manage_todo()
        elif "invia email" in sub_cmd or "manda email" in sub_cmd:
            send_email()
        elif "traduci" in sub_cmd or "traduzione" in sub_cmd:
            translate_text()
        else:
            speak("Fammi controllare con la mia intelligenza artificiale Gemini...")
            answer = gemini_query(sub_cmd)
            speak(answer)
    else:
        if maybe_personal_reply(command):
            return
        else:
            speak("Fammi controllare con la mia intelligenza artificiale Gemini...")
            answer = gemini_query(command)
            speak(answer)

# -----------------------------
# MAIN
# -----------------------------
def main():
    global VOICE_ID
    VOICE_ID = get_voice_id("Sarah")
    if not VOICE_ID:
        print("[ERRORE] Non ho potuto caricare l'ID della voce. "
              "Controlla la tua chiave ElevenLabs o il nome della voce.")
    
    root, animate = create_animation_window()
    
    speak_thread = threading.Thread(target=speak_worker, daemon=True)
    speak_thread.start()

    speak(f"Ciao, sono {ASSISTANT_NAME}, la tua assistente virtuale con un tocco di personalità. "
          "Dimmi pure 'Gideon' seguito da un comando, oppure parla liberamente: "
          "io ascolterò e risponderò nel modo più rapido possibile!")

    def animation_loop():
        while True:
            animate()
            sleep(0.1)
    
    anim_thread = threading.Thread(target=animation_loop, daemon=True)
    anim_thread.start()
    
    while True:
        command = take_command()
        if command:
            command_thread = threading.Thread(target=handle_command, args=(command,))
            command_thread.start()
        root.update()

if __name__ == "__main__":
    main()