from flask import Flask, render_template
from flask_socketio import SocketIO
import speech_recognition as sr

app = Flask(__name__)
socketio = SocketIO(app)

@app.route('/')
def index():
    return render_template('index.html')

@socketio.on('message')
def handle_message(message):
    print(f'Received: {message}')
    socketio.emit('response', message)

@socketio.on('recognize_speech')
def recognize_speech():
    r = sr.Recognizer()
    with sr.Microphone() as source:
        print("Escuchando...")
        audio = r.listen(source)
        try:
            recognized_text = r.recognize_google(audio, language='es-ES')
            print(f"Texto reconocido: {recognized_text}")
            socketio.emit('response', recognized_text)
        except sr.UnknownValueError:
            print("No se pudo reconocer el audio")
        except sr.RequestError as e:
            print(f"Error en la solicitud a Google: {e}")

if __name__ == '__main__':
    socketio.run(app)



















#from flask import Flask, render_template
##from deepgram import Deepgram
#from dotenv import load_dotenv
#import os
#import asyncio
#from aiohttp import web
#from aiohttp_wsgi import WSGIHandler

#from typing import Dict, Callable


#load_dotenv()

#app = Flask('aioflask')

##dg_client = Deepgram(os.getenv('DEEPGRAM_API_KEY'))

#async def process_audio(fast_socket: web.WebSocketResponse):
#    async def get_transcript(data: Dict) -> None:
#        if 'channel' in data:
#            transcript = data['channel']['alternatives'][0]['transcript']
        
#            if transcript:
#                await fast_socket.send_str(transcript)

#    deepgram_socket = await connect_to_deepgram(get_transcript)
#    #########################################
#    #r = sr.Recognizer()
#    #with sr.Microphone() as source:
#    #    print("Listening...")
#    #    r.pause_threshold = 1
#    #    audio = r.adjust_for_ambient_noise(source)
#    #    audio = r.listen(source)
#    #try:
#    #    print("Recognizing...")
#    #    query = r.recognize_google(get_transcript, language='es-ES')
#    #    print(f"User said: {query}\n")
#    #except Exception as e:
#    #    print(e)
#    #    print("Unable to Recognize your voice.")
#    #    return "none"




#    ########################################
#    return deepgram_socket

#async def connect_to_deepgram(transcript_received_handler: Callable[[Dict], None]) -> str:
#    try:
#        socket = await dg_client.transcription.live({'punctuate': True, 'interim_results': False})
#        socket.registerHandler(socket.event.CLOSE, lambda c: print(f'Connection closed with code {c}.'))
#        socket.registerHandler(socket.event.TRANSCRIPT_RECEIVED, transcript_received_handler)

#        return socket
#    except Exception as e:
#        raise Exception(f'Could not open socket: {e}')

#@app.route('/')
#def index():
#    return render_template('index.html')

#async def socket(request):
#    ws = web.WebSocketResponse()
#    await ws.prepare(request) 

#    deepgram_socket = await process_audio(ws)

#    while True:
#        data = await ws.receive_bytes()
#        deepgram_socket.send(data)

  

#if __name__ == "__main__":
#    loop = asyncio.get_event_loop()
#    aio_app = web.Application()
#    wsgi = WSGIHandler(app)
#    aio_app.router.add_route('*', '/{path_info: *}', wsgi.handle_request)
#    aio_app.router.add_route('GET', '/listen', socket)
#    web.run_app(aio_app, port=5555)