import tensorflow as tf
import numpy as np
import cv2
import gradio as gr
import os

# Fonction pour chercher le modèle dans tout le système de fichiers
def find_model_file(filename="generator.h5"):
    # Parcourir tous les répertoires du serveur pour trouver le fichier
    for root, dirs, files in os.walk("/"):
        if filename in files:
            model_path = os.path.join(root, filename)
            print(f"Modèle trouvé à : {model_path}")
            return model_path
    return None

# Fonction pour charger le modèle en toute sécurité
def load_model_safe(model_path):
    try:
        # Charger le modèle sans compilation pour éviter des erreurs liées au batch_shape
        model = tf.keras.models.load_model(model_path, compile=False)
        return model
    except ValueError as e:
        print(f"Erreur lors du chargement du modèle: {e}")
        return None

# Chercher le modèle 'generator.h5' dans le système
model_path = find_model_file("generator.h5")

# Vérifier si le modèle est trouvé et charger
if model_path is not None:
    generator = load_model_safe(model_path)
    print(f"Modèle chargé depuis : {model_path}")
else:
    print("Le modèle 'generator.h5' n'a pas été trouvé sur le serveur.")
    generator = None

# Fonction pour générer une vidéo à partir du générateur
def generate_video():
    if generator is None:
        return "Le modèle n'a pas pu être chargé."

    # Générer un bruit aléatoire (entrée pour le générateur)
    noise = np.random.normal(0, 1, (1, 16, 64, 64, 3))  # Exemple de bruit pour 16 frames de 64x64x3
    generated_video = generator.predict(noise)  # Générer la vidéo

    # Vérifier la forme des données générées
    print(f"Shape of generated video: {generated_video.shape}")
    
    # Normaliser les données générées
    video = (generated_video[0] * 255).astype(np.uint8)  # Convertir en entier 8 bits

    # Vérifier si la vidéo générée a la bonne forme
    if len(video.shape) != 4 or video.shape[0] != 16:
        return "Erreur dans les dimensions de la vidéo générée."

    # Créer le répertoire pour la vidéo
    output_dir = "/content/generated_videos"
    os.makedirs(output_dir, exist_ok=True)
    filename = os.path.join(output_dir, "generated_video.mp4")
    
    # Enregistrer la vidéo avec OpenCV
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Codec vidéo
    height, width, _ = video[0].shape
    out = cv2.VideoWriter(filename, fourcc, 15, (width, height))  # 15 FPS

    # Ajouter les frames dans le fichier vidéo
    for frame in video:
        out.write(frame)
    out.release()

    # Retourner le chemin de la vidéo générée
    return filename

# Interface Gradio
def interface_function():
    # Appeler la fonction de génération et retourner la vidéo générée
    video_file = generate_video()
    return video_file

# Définir l'interface avec Gradio
gr.Interface(
    fn=interface_function,  # Fonction à exécuter
    inputs=[],              # Pas d'entrée utilisateur
    outputs=gr.Video(label="Vidéo générée", type="file"),  # Vidéo en sortie avec type 'file' pour le téléchargement
    title="Générateur de Vidéos avec IA",
    description="Cliquez sur le bouton ci-dessous pour générer une vidéo aléatoire avec l'IA."
).launch(server_name="0.0.0.0", server_port=7860)