from fastapi import FastAPI
import requests
import speech_recognition as sr
from pydub import AudioSegment
import os

app = FastAPI()

@app.get("/audio_texto")
async def convertir_audio_texto(audio_url: str):
    try:
        # Descargar el archivo de audio desde la URL proporcionada
        response = requests.get(audio_url, timeout=30)  # Límite de descarga 30 seg

        if response.status_code == 200:
            audio_content = response.content  # Obtener el contenido del archivo

            # Guardar el audio descargado como un archivo temporal
            temp_audio_path = "temp_audio"
            with open(temp_audio_path, "wb") as f:
                f.write(audio_content)

            # Convertir a WAV usando pydub
            try:
                audio = AudioSegment.from_file(temp_audio_path)
                temp_wav_path = "temp_audio.wav"
                audio.export(temp_wav_path, format="wav")

            except Exception as e:
                return {"error": f"Error al convertir el archivo de audio: {str(e)}", "estatus": 400}

            # Inicializar el reconocedor de voz
            recognizer = sr.Recognizer()
            extracted_text = []

            # Cargar el archivo WAV en pydub para dividirlo
            audio = AudioSegment.from_wav(temp_wav_path)
            chunk_duration = 60000  # 60 segundos en milisegundos
            chunks = [audio[i:i + chunk_duration] for i in range(0, len(audio), chunk_duration)]

            # Procesar cada fragmento
            for i, chunk in enumerate(chunks):
                chunk_path = f"chunk_{i}.wav"
                chunk.export(chunk_path, format="wav")  # Guardar el fragmento temporalmente

                with sr.AudioFile(chunk_path) as audio_file:
                    audio_data = recognizer.record(audio_file)

                    try:
                        # Convertir audio a texto
                        texto_fragmento = recognizer.recognize_google(audio_data, language="es-ES")
                        extracted_text.append(texto_fragmento)
                    except sr.UnknownValueError:
                        extracted_text.append("[Audio no reconocido]")
                    except sr.RequestError as e:
                        return {"error": f"Error con el servicio de reconocimiento: {str(e)}", "estatus": 400}

                os.remove(chunk_path)  # Eliminar el fragmento temporal

            # Eliminar archivos temporales
            os.remove(temp_audio_path)
            os.remove(temp_wav_path)

            # Retornar el texto extraído de todos los fragmentos
            return {"texto": " ".join(extracted_text), "estatus": 200}

        else:
            return {"error": "No se pudo descargar el archivo de audio", "estatus": 400}

    except Exception as e:
        return {"error": f"Error al procesar el archivo: {str(e)}", "estatus": 400}