app.py

import gradio as gr
import requests, zipfile, os, shutil, json, re

# -----------------------
# Free API keys (TMDb e OMDb) ottenute automaticamente
def get_free_keys():
    """
    Simula il comportamento del pacchetto 'freekeys'
    Restituisce le free API keys per TMDb e OMDb.
    """
    return {
        "tmdb_key": "e547e17d4e91f3e62a571655cd1ccaff",
        "imdb_key": "966c4f4f"
    }

free_keys = get_free_keys()
TMDB_API_KEY = free_keys["tmdb_key"]

# -----------------------
# FILE DI CONFIGURAZIONE E VIDEOTECA
SETTINGS_FILE = "settings.json"
LIBRARY_FILE = "videoteca.json"

DEFAULT_SETTINGS = {
    "videolibrarypath": "path/to/videolibrary",
    "folder_tvshows": "Serie TV",
    "folder_movies": "Film",
    "videolibrary_kodi": False
}

def load_settings():
    """Carica le impostazioni dal file JSON oppure restituisce quelle di default."""
    if os.path.exists(SETTINGS_FILE):
        try:
            with open(SETTINGS_FILE, "r", encoding="utf-8") as f:
                return json.load(f)
        except Exception:
            return DEFAULT_SETTINGS
    else:
        return DEFAULT_SETTINGS

def save_settings(new_settings):
    """Salva le impostazioni su file JSON."""
    try:
        with open(SETTINGS_FILE, "w", encoding="utf-8") as f:
            json.dump(new_settings, f, indent=4, ensure_ascii=False)
        return "Impostazioni salvate correttamente."
    except Exception as e:
        return f"Errore nel salvataggio delle impostazioni: {str(e)}"

def get_current_settings():
    """Restituisce le impostazioni correnti in formato JSON formattato."""
    settings = load_settings()
    return json.dumps(settings, indent=4, ensure_ascii=False)

def update_settings(videolibrarypath, folder_tvshows, folder_movies, videolibrary_kodi):
    """Aggiorna le impostazioni a partire dai valori forniti."""
    new_settings = {
        "videolibrarypath": videolibrarypath,
        "folder_tvshows": folder_tvshows,
        "folder_movies": folder_movies,
        "videolibrary_kodi": videolibrary_kodi
    }
    return save_settings(new_settings)

def load_library():
    """Carica la videoteca dal file JSON."""
    if os.path.exists(LIBRARY_FILE):
        try:
            with open(LIBRARY_FILE, "r", encoding="utf-8") as f:
                return json.load(f)
        except Exception:
            return []
    else:
        return []

def save_library(lib):
    """Salva la videoteca nel file JSON."""
    with open(LIBRARY_FILE, "w", encoding="utf-8") as f:
        json.dump(lib, f, indent=4, ensure_ascii=False)

def add_to_library(item_str: str, item_type: str) -> str:
    """
    Aggiunge un elemento (film o serie TV) alla videoteca.
    L'elemento è una stringa formattata con [ID: ...].
    """
    lib = load_library()
    match = re.search(r'\[ID: (\d+)\]', item_str)
    if not match:
        return "Impossibile estrarre l'ID dall'elemento."
    item_id = match.group(1)
    # Controlla duplicati
    for item in lib:
        if item["id"] == item_id and item["type"] == item_type:
            return "Elemento già presente in videoteca."
    new_item = {"id": item_id, "title": item_str, "type": item_type}
    lib.append(new_item)
    save_library(lib)
    return "Elemento aggiunto in videoteca."

def get_library_items(item_type: str) -> list:
    """Restituisce una lista di elementi della videoteca filtrata per tipo."""
    lib = load_library()
    return [item["title"] for item in lib if item["type"] == item_type]

# -----------------------
# FUNZIONALITÀ DI AGGIORNAMENTO DELL'APPLICAZIONE
def get_branches():
    """
    Recupera la lista dei branch disponibili dal repository GitHub.
    Ordina dando priorità a 'stable' e 'master'.
    """
    url = "https://api.github.com/repos/stream4me/addon/branches"
    try:
        response = requests.get(url)
        response.raise_for_status()
        branches = [branch["name"] for branch in response.json()]
        ordered = []
        for b in ['stable', 'master']:
            if b in branches:
                ordered.append(b)
        ordered.extend([b for b in branches if b not in ['stable', 'master']])
        return ordered
    except Exception:
        return ["stable", "master"]

def update_from_zip(branch: str) -> str:
    """
    Scarica il file zip del branch selezionato da GitHub,
    lo estrae in una cartella target ("s4me_app") e restituisce un log.
    """
    log = []
    try:
        url = f"https://github.com/stream4me/addon/archive/{branch}.zip"
        log.append(f"Avvio download da: {url}")
        response = requests.get(url, stream=True)
        response.raise_for_status()
        zip_filename = f"{branch}.zip"
        with open(zip_filename, "wb") as f:
            for chunk in response.iter_content(chunk_size=8192):
                if chunk:
                    f.write(chunk)
        log.append("Download completato.")

        extract_base = f"s4me_app_{branch}"
        target_dir = "s4me_app"

        if os.path.isdir(target_dir):
            shutil.rmtree(target_dir)
            log.append(f"Vecchia cartella '{target_dir}' rimossa.")

        log.append("Inizio estrazione...")
        with zipfile.ZipFile(zip_filename, "r") as zip_ref:
            zip_ref.extractall(extract_base)
        log.append("Estrazione completata.")

        extracted_folder = os.path.join(extract_base, f"addon-{branch}")
        if os.path.isdir(extracted_folder):
            os.rename(extracted_folder, target_dir)
            log.append(f"Cartella rinominata in '{target_dir}'.")
        else:
            log.append("Errore: cartella estratta non trovata.")

        os.remove(zip_filename)
        shutil.rmtree(extract_base)
        log.append("Pulizia completata. Aggiornamento eseguito con successo.")
    except Exception as e:
        log.append(f"Errore durante l'aggiornamento: {str(e)}")
    return "\n".join(log)

def perform_update(selected_branch: str) -> str:
    """Funzione chiamata dal pulsante di aggiornamento nell’interfaccia."""
    return update_from_zip(selected_branch)

# -----------------------
# FUNZIONALITÀ DI RICERCA E STREAMING PER FILM
def search_movie_list(movie_title: str):
    """
    Cerca film tramite TMDb e restituisce una lista per il dropdown.
    Formato: "Titolo (Data) [ID: movie_id]".
    """
    if not movie_title:
        return []
    url = f"https://api.themoviedb.org/3/search/movie?api_key={TMDB_API_KEY}&query={movie_title}"
    try:
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
        results = data.get("results", [])
        choices = []
        for movie in results:
            title = movie.get("title", "Sconosciuto")
            release_date = movie.get("release_date", "Data sconosciuta")
            movie_id = movie.get("id")
            choices.append(f"{title} ({release_date}) [ID: {movie_id}]")
        return choices
    except Exception as e:
        return [f"Errore durante la ricerca: {str(e)}"]

def get_streaming_providers(movie_choice: str) -> str:
    """
    Data la scelta del film (contenente l'ID),
    richiama l'endpoint TMDb per ottenere i provider streaming.
    """
    match = re.search(r'\[ID: (\d+)\]', movie_choice)
    if not match:
         return "Impossibile estrarre l'ID del film."
    movie_id = match.group(1)
    url = f"https://api.themoviedb.org/3/movie/{movie_id}/watch/providers?api_key={TMDB_API_KEY}"
    try:
         response = requests.get(url)
         response.raise_for_status()
         data = response.json()
         results = data.get("results", {})
         if "IT" in results:
              providers = results["IT"].get("flatrate", [])
         elif "US" in results:
              providers = results["US"].get("flatrate", [])
         else:
              providers = []
         if not providers:
              return "Nessun canale streaming diretto trovato."
         output = [provider.get("provider_name", "Sconosciuto") for provider in providers]
         return "Canali streaming trovati:\n" + "\n".join(output)
    except Exception as e:
         return f"Errore durante la ricerca dei canali: {str(e)}"

# -----------------------
# FUNZIONALITÀ DI RICERCA PER SERIE TV
def search_tv_list(tv_title: str):
    """
    Cerca serie TV tramite TMDb e restituisce una lista per il dropdown.
    Formato: "Nome Serie (Data) [ID: tv_id]".
    """
    if not tv_title:
         return []
    url = f"https://api.themoviedb.org/3/search/tv?api_key={TMDB_API_KEY}&query={tv_title}"
    try:
         response = requests.get(url)
         response.raise_for_status()
         data = response.json()
         results = data.get("results", [])
         choices = []
         for tv in results:
              name = tv.get("name", "Sconosciuto")
              first_air_date = tv.get("first_air_date", "Data sconosciuta")
              tv_id = tv.get("id")
              choices.append(f"{name} ({first_air_date}) [ID: {tv_id}]")
         return choices
    except Exception as e:
         return [f"Errore durante la ricerca: {str(e)}"]

def load_tv_episodes(tv_series_choice: str) -> str:
    """
    Data la serie TV selezionata (con l'ID incluso), carica gli episodi della stagione 1.
    Restituisce una lista formattata degli episodi.
    """
    match = re.search(r'\[ID: (\d+)\]', tv_series_choice)
    if not match:
         return "Impossibile estrarre l'ID della serie TV."
    tv_id = match.group(1)
    url = f"https://api.themoviedb.org/3/tv/{tv_id}/season/1?api_key={TMDB_API_KEY}"
    try:
         response = requests.get(url)
         response.raise_for_status()
         data = response.json()
         episodes = data.get("episodes", [])
         if not episodes:
              return "Nessun episodio trovato per la stagione 1."
         output = []
         for ep in episodes:
              ep_num = ep.get("episode_number")
              name = ep.get("name", "Sconosciuto")
              overview = ep.get("overview", "")
              output.append(f"Episodio {ep_num}: {name}\n{overview}\n")
         return "\n".join(output)
    except Exception as e:
         return f"Errore durante il caricamento degli episodi: {str(e)}"

# -----------------------
# COSTRUZIONE DELL'INTERFACCIA CON GRADIO
def build_interface():
    """Costruisce l’interfaccia completa con più tab."""
    branches = get_branches()
    
    css_custom = """
    body { font-size: 32px; }
    .gradio-container { font-size: 32px; }
    .gr-button { font-size: 32px; padding: 20px; }
    .gr-input { font-size: 32px; padding: 10px; }
    .gr-dropdown { font-size: 32px; padding: 10px; }
    .gradio-container * { margin: 20px; }
    """
    js_script = """
    <script>
    document.addEventListener('keydown', function(event) {
        let focused = document.activeElement;
        if (!focused) return;
        let focusable = Array.from(document.querySelectorAll('button, input, select, textarea, a'));
        let index = focusable.indexOf(focused);
        if (event.key === 'ArrowDown') {
            index = (index + 1) % focusable.length;
            focusable[index].focus();
        } else if (event.key === 'ArrowUp') {
            index = (index - 1 + focusable.length) % focusable.length;
            focusable[index].focus();
        }
    });
    </script>
    """
    
    with gr.Blocks(css=css_custom, title="Stream4Me per Smart TV") as demo:
        gr.Markdown("# Stream4Me - Aggiornamento, Configurazione, Ricerca e Videoteca")
        gr.HTML(js_script)
        with gr.Tabs():
            with gr.TabItem("Aggiornamento"):
                gr.Markdown("## Aggiorna l'applicazione dal repository GitHub")
                branch_dropdown = gr.Dropdown(choices=branches, value=branches[0], label="Seleziona Branch")
                update_button = gr.Button("Avvia Aggiornamento")
                update_log = gr.Textbox(label="Log di Aggiornamento", lines=10)
                update_button.click(fn=perform_update, inputs=branch_dropdown, outputs=update_log)
            
            with gr.TabItem("Impostazioni"):
                gr.Markdown("## Configura le impostazioni")
                settings = load_settings()
                input_videolibrarypath = gr.Textbox(value=settings.get("videolibrarypath", ""), label="Percorso Video Library")
                input_folder_tvshows = gr.Textbox(value=settings.get("folder_tvshows", ""), label="Cartella Serie TV")
                input_folder_movies = gr.Textbox(value=settings.get("folder_movies", ""), label="Cartella Film")
                input_videolibrary_kodi = gr.Checkbox(value=settings.get("videolibrary_kodi", False), label="Integrazione Video Library (Kodi)")
                save_button = gr.Button("Salva Impostazioni")
                settings_status = gr.Textbox(label="Stato Impostazioni", lines=2)
                save_button.click(fn=update_settings, 
                                  inputs=[input_videolibrarypath, input_folder_tvshows, input_folder_movies, input_videolibrary_kodi],
                                  outputs=settings_status)
                gr.Markdown("### Impostazioni Correnti")
                current_settings_box = gr.Textbox(value=get_current_settings(), label="Impostazioni Correnti", lines=8)
                refresh_button = gr.Button("Ricarica Impostazioni")
                refresh_button.click(fn=get_current_settings, inputs=[], outputs=current_settings_box)
            
            with gr.TabItem("Ricerca Film & Streaming"):
                gr.Markdown("## Cerca un Film")
                film_input = gr.Textbox(placeholder="Inserisci il nome del film...", label="Nome del Film")
                film_search_button = gr.Button("Cerca Film")
                film_dropdown = gr.Dropdown(choices=[], label="Seleziona il Film")
                film_search_button.click(fn=search_movie_list, inputs=film_input, outputs=film_dropdown)
                gr.Markdown("### Streaming / Aggiungi in Videoteca")
                film_stream_button = gr.Button("Guarda Film (Streaming)")
                film_stream_results = gr.Textbox(label="Risultati Streaming", lines=10)
                film_stream_button.click(fn=get_streaming_providers, inputs=film_dropdown, outputs=film_stream_results)
                film_add_button = gr.Button("Aggiungi Film in Videoteca")
                film_add_status = gr.Textbox(label="Stato Aggiunta", lines=2)
                film_add_button.click(fn=lambda x: add_to_library(x, "film"), inputs=film_dropdown, outputs=film_add_status)
            
            with gr.TabItem("Ricerca Serie TV & Videoteca"):
                gr.Markdown("## Cerca una Serie TV")
                tv_input = gr.Textbox(placeholder="Inserisci il nome della serie TV...", label="Nome Serie TV")
                tv_search_button = gr.Button("Cerca Serie TV")
                tv_dropdown = gr.Dropdown(choices=[], label="Seleziona la Serie TV")
                tv_search_button.click(fn=search_tv_list, inputs=tv_input, outputs=tv_dropdown)
                gr.Markdown("### Aggiungi Serie TV in Videoteca")
                tv_add_button = gr.Button("Aggiungi Serie TV in Videoteca")
                tv_add_status = gr.Textbox(label="Stato Aggiunta", lines=2)
                tv_add_button.click(fn=lambda x: add_to_library(x, "tv"), inputs=tv_dropdown, outputs=tv_add_status)
            
            with gr.TabItem("Videoteca"):
                gr.Markdown("## Film in Videoteca")
                film_library_dropdown = gr.Dropdown(choices=get_library_items("film"), label="Film in Videoteca")
                film_library_button = gr.Button("Guarda Film (Streaming)")
                film_library_results = gr.Textbox(label="Streaming Film", lines=10)
                film_library_button.click(fn=get_streaming_providers, inputs=film_library_dropdown, outputs=film_library_results)
                
                gr.Markdown("## Serie TV in Videoteca")
                tv_library_dropdown = gr.Dropdown(choices=get_library_items("tv"), label="Serie TV in Videoteca")
                tv_library_button = gr.Button("Carica Episodi (Stagione 1)")
                tv_library_results = gr.Textbox(label="Episodi", lines=10)
                tv_library_button.click(fn=load_tv_episodes, inputs=tv_library_dropdown, outputs=tv_library_results)
                
                gr.Markdown("### Ricarica Videoteca")
                refresh_library_button = gr.Button("Ricarica Lista Videoteca")
                def refresh_library():
                    return get_library_items("film"), get_library_items("tv")
                film_lib_out, tv_lib_out = gr.Dropdown(choices=[], label=""), gr.Dropdown(choices=[], label="")
                refresh_library_button.click(fn=refresh_library, inputs=[], outputs=[film_library_dropdown, tv_library_dropdown])
            
            with gr.TabItem("Informazioni"):
                gr.Markdown("## Informazioni sul Progetto")
                gr.Markdown("""
                **Stream4Me** è un progetto stand-alone per gestire l’aggiornamento, la configurazione, la ricerca e la videoteca di film e serie TV,
                completamente indipendente da Kodi e ottimizzato per Smart TV.
                
                **Funzionalità:**
                - Aggiornamento automatico dal repository GitHub.
                - Configurazione personalizzata tramite interfaccia web.
                - Ricerca film e serie TV tramite TMDb.
                - Aggiunta in videoteca e visualizzazione dei provider streaming per i film.
                - Caricamento degli episodi (es. stagione 1) per le serie TV, per poterle guardare in sequenza.
                - Interfaccia responsive, con navigazione tramite telecomando.
                
                **Repository:** [Stream4Me su GitHub](https://github.com/Stream4me/addon)
                
                **Autore:** S4Me Team
                """)
        
    return demo

if __name__ == "__main__":
    demo = build_interface()
    demo.launch()