# client_generate_av.py
import os
import requests
import time
import base64
from dotenv import load_dotenv

# Cargar variables de entorno desde .env
load_dotenv()

# Obtener la URL base de la API y el token desde las variables de entorno
API_BASE_URL = os.getenv("API_BASE_URL", "https://veureu-tts.hf.space")
API_SHARED_TOKEN = os.getenv("API_SHARED_TOKEN")

# Función para generar un MP3 de audiodescripción gratuita
def generate_free_ad_mp3(text: str, speaker_id: str, output_path: str):
    """
    Llama a la API para generar un MP3 de audiodescripción a partir de un texto.
    Utiliza el endpoint gratuito.
    """
    if not API_SHARED_TOKEN:
        raise ValueError("API_SHARED_TOKEN no está configurado en las variables de entorno.")

    url = f"{API_BASE_URL}/free_ad_mp3/"
    headers = {
        "Authorization": f"Bearer {API_SHARED_TOKEN}"
    }
    payload = {
        "text": text,
        "speaker_id": speaker_id
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()  # Lanza una excepción para códigos de error HTTP

        # Guardar el contenido del MP3 en el archivo de salida
        with open(output_path, "wb") as f:
            f.write(response.content)
        print(f"MP3 guardado exitosamente en {output_path}")
        return output_path

    except requests.exceptions.RequestException as e:
        print(f"Error al llamar a la API: {e}")
        if e.response is not None:
            print(f"Respuesta de la API: {e.response.text}")
        return None

# Función para generar un vídeo con audiodescripción de Une
def generate_une_ad_video(video_path: str, ad_text: str, speaker_id: str, output_path: str):
    """
    Llama a la API para generar un vídeo con audiodescripción (norma UNE).
    """
    if not API_SHARED_TOKEN:
        raise ValueError("API_SHARED_TOKEN no está configurado en las variables de entorno.")

    url = f"{API_BASE_URL}/une_ad_video/"
    headers = {
        "Authorization": f"Bearer {API_SHARED_TOKEN}"
    }

    try:
        with open(video_path, "rb") as video_file:
            video_b64 = base64.b64encode(video_file.read()).decode('utf-8')

        payload = {
            "video_b64": video_b64,
            "ad_text": ad_text,
            "speaker_id": speaker_id
        }

        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()

        # La respuesta es un JSON que contiene el vídeo en base64
        response_data = response.json()
        video_content_b64 = response_data.get("video_b64")

        if video_content_b64:
            video_data = base64.b64decode(video_content_b64)
            with open(output_path, "wb") as f:
                f.write(video_data)
            print(f"Vídeo con AD guardado exitosamente en {output_path}")
            return output_path
        else:
            print("La respuesta de la API no contenía el vídeo en base64.")
            return None

    except requests.exceptions.RequestException as e:
        print(f"Error al llamar a la API: {e}")
        if e.response is not None:
            print(f"Respuesta de la API: {e.response.text}")
        return None
    except Exception as e:
        print(f"Ocurrió un error inesperado: {e}")
        return None

# Ejemplo de uso (para pruebas locales)
if __name__ == '__main__':
    # Crear un directorio de salida si no existe
    os.makedirs("temp_output", exist_ok=True)

    # --- Prueba de generación de MP3 ---
    print("Probando generación de MP3...")
    mp3_output = "temp_output/ad_test.mp3"
    test_text = "El sol se pone en el horizonte, tiñendo el cielo de colores anaranjados y rojizos."
    speaker = "una-nina"
    generate_free_ad_mp3(test_text, speaker, mp3_output)

    # --- Prueba de generación de vídeo ---
    print("\nProbando generación de vídeo...")
    # Crear un vídeo de prueba si no existe
    video_input_path = "temp_output/test_video.mp4"
    if not os.path.exists(video_input_path):
        print("Creando vídeo de prueba falso...")
        with open(video_input_path, "wb") as f:
            f.write(os.urandom(1024 * 10)) # 10 KB de datos aleatorios

    video_output_path = "temp_output/ad_video_output.mp4"
    ad_text_video = "Un gato negro camina sigilosamente por el tejado."
    generate_une_ad_video(video_input_path, ad_text_video, speaker, video_output_path)