import gradio as gr  
from moviepy.editor import VideoFileClip  
import os  
import openai  
  
# Asegúrate de configurar tu cliente de OpenAI aquí con las claves adecuadas.  
from openai import OpenAI  
client = OpenAI(api_key="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")  # Reemplaza 'tu_api_key' con tu clave real de la API.  
  
# Función para interactuar con OpenAI      
def chat_with_openai(message, system_message="You are a helpful assistant."):      
    response = client.chat.completions.create(      
        model="gpt-4-turbo-preview",      
        messages=[      
            {"role": "system", "content": system_message},      
            {"role": "user", "content": message}      
        ]      
    )      
    return response.choices[0].message.content      
      
# Función que se llamará cuando se haga clic en los botones      
def procesar_con_openai(transcripcion, system_message):      
    return chat_with_openai(transcripcion, system_message)      
      
# Arreglo con la información de los botones      
botones_info = [      
    {"system_message": "Resumen el siguiente texto.", "titulo": "Resumir"},      
    {"system_message": "Proporciona contexto adicional para el siguiente texto.", "titulo": "Generar Contexto"},      
    {"system_message": "Mejora la redacción del siguiente texto.", "titulo": "Mejorar Redacción"}      
]   


def resumir_texto(transcripcion):
    return chat_with_openai(transcripcion, system_message="Resumen el siguiente texto.")

def generar_contexto(transcripcion):
    return chat_with_openai(transcripcion, system_message="Proporciona contexto adicional para el siguiente texto.")

def mejorar_redaccion(transcripcion):
    return chat_with_openai(transcripcion, system_message="Mejora la redacción del siguiente texto.")

def guardar_archivo(transcripcion, guardar):
    if guardar and transcripcion:
        ruta_archivo = "./data/transcripcion.txt"
        with open(ruta_archivo, "w") as archivo:
            archivo.write(transcripcion)
        return ruta_archivo
    return None


# Función para transcribir audio con Whisper  
def transcribe_with_whisper(audio_path):  
    try:  
        with open(audio_path, "rb") as audio_file:  
            transcript = client.audio.transcriptions.create(  
                model="whisper-1",  
                file=audio_file,  
                language="es"  
            )  
        print(f"Transcripción: {transcript}")
        return transcript.text
    except Exception as e:  
        print(f"Error al transcribir el archivo: {e}")  
        return ""  

# Función para manejar la carga y reproducción de audio  
def handle_audio(audio_data):  
    if audio_data is not None:  
        transcripcion = transcribe_with_whisper(audio_data)  
        return audio_data, transcripcion  
    return None, ""  
  
# Función para manejar la carga y reproducción de video  
def handle_video(file_info):  
    if file_info is not None:  
        video_path = file_info["file"]  # Obtener la ruta del archivo de video  
        video_extension = os.path.splitext(video_path)[1].lower()  
        if video_extension == ".mp4":  
            video = VideoFileClip(video_path)  
            ruta_audio = os.path.join("./data/", "audio_extraido.mp3")  
            video.audio.write_audiofile(ruta_audio)  
            # Implementa la lógica para transcribir el audio utilizando Whisper.  
            transcripcion = transcribe_with_whisper(ruta_audio)  
            return video_path, transcripcion  
        else:  
            return video_path, "Formato de video no soportado para transcripción."  
    return None, ""  

# Interfaces para audio y video  
audio_interface = gr.Interface(  
    fn=handle_audio,  
    inputs=gr.Audio(sources=["upload", "microphone"]),  
    outputs=[gr.Audio(label="Reproducción de Audio"), "text"]  
)  
  
video_interface = gr.Interface(  
    fn=handle_video,  
    inputs=gr.Video(sources=["upload"]),  
    outputs=[gr.Video(label="Reproducción de Video"), "text"]  
)  
  
# Crear la interfaz con pestañas  
tabbed_interface = gr.TabbedInterface([audio_interface, video_interface], ["Audio", "Video"]) 
  
# Creación de la interfaz Gradio  
with gr.Blocks() as iface:  
    gr.Markdown("Esta herramienta convierte archivos de audio y video a texto usando OpenAI y permite su reproducción.")  
    tabbed_interface.render()  
  
    salida_transcripcion = gr.Textbox(label="Transcripción")  
    salida_procesada = gr.Textbox(label="Texto Procesado")  
    boton_guardar = gr.Button("Guardar Resultado")  
    salida_descarga = gr.File(label="Descargar Resultado")  
  
    # Contenedor para botones dinámicos  
    with gr.Row():  
        for boton in botones_info:  
            boton_accion = gr.Button(boton["titulo"])  
            boton_accion.click(  
                procesar_con_openai,  
                inputs=[salida_transcripcion],  
                outputs=[salida_procesada]  
            )  
  
    # Función para guardar el archivo de transcripción  
    def guardar_archivo_fn(transcripcion, guardar):  
        if guardar:  
            return guardar_archivo(transcripcion, guardar)  
        return None  
  
    boton_guardar.click(  
        guardar_archivo_fn,  
        inputs=[salida_transcripcion, gr.Checkbox(label="¿Guardar el resultado en un archivo?")],  
        outputs=[salida_descarga]  
    )  
  
if __name__ == "__main__":  
    iface.launch(share=True)