"""
Cliente WebSocket Production-Ready para Gemini 2.0 Flash Multimodal Live API
Incluye: autenticación, error handling, retry logic, logging, connection pooling
"""
import asyncio
import websockets
import json
import base64
from google.oauth2 import service_account
from google.auth.transport.requests import Request
import logging
from typing import Optional, Dict, Any
import backoff

# Configurar logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)


class GeminiWebSocketClient:
    """Cliente WebSocket para Gemini 2.0 Flash con manejo robusto de conexiones"""

    def __init__(
        self,
        project_id: str,
        location: str = "us-central1",
        model: str = "gemini-2.0-flash-exp",
        service_account_path: Optional[str] = None
    ):
        self.project_id = project_id
        self.location = location
        self.model = model
        self.service_account_path = service_account_path
        self.websocket: Optional[websockets.WebSocketClientProtocol] = None
        self.credentials = None

        # Configuración
        self.ws_url = f"wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent"
        self.max_retries = 5
        self.retry_delay = 1  # segundos

    def _get_access_token(self) -> str:
        """Obtener access token de Google Cloud con Service Account"""
        if not self.credentials:
            if self.service_account_path:
                self.credentials = service_account.Credentials.from_service_account_file(
                    self.service_account_path,
                    scopes=['https://www.googleapis.com/auth/cloud-platform']
                )
            else:
                # Usar Application Default Credentials (ADC)
                from google.auth import default
                self.credentials, _ = default(
                    scopes=['https://www.googleapis.com/auth/cloud-platform']
                )

        # Refrescar token si expiró
        if not self.credentials.valid:
            self.credentials.refresh(Request())

        return self.credentials.token

    @backoff.on_exception(
        backoff.expo,
        (websockets.exceptions.WebSocketException, ConnectionError),
        max_tries=5,
        max_time=60
    )
    async def connect(self) -> bool:
        """
        Establecer conexión WebSocket con retry exponential backoff
        Returns:
            True si conexión exitosa, False si falla después de retries
        """
        try:
            access_token = self._get_access_token()

            # Headers de autenticación
            headers = {
                "Authorization": f"Bearer {access_token}",
                "Content-Type": "application/json"
            }

            logger.info(f"Conectando a Gemini Live API: {self.ws_url}")

            # Establecer conexión WebSocket
            self.websocket = await websockets.connect(
                self.ws_url,
                extra_headers=headers,
                ping_interval=20,  # Keep-alive cada 20s
                ping_timeout=10,   # Timeout de ping
                close_timeout=10   # Timeout al cerrar
            )

            logger.info("✅ Conexión WebSocket establecida exitosamente")

            # Enviar configuración inicial del modelo
            setup_message = {
                "setup": {
                    "model": f"models/{self.model}",
                    "generation_config": {
                        "temperature": 0.7,
                        "top_p": 0.95,
                        "top_k": 40,
                        "max_output_tokens": 8192,
                        "response_modalities": ["TEXT", "AUDIO"]  # Multimodal output
                    }
                }
            }

            await self.websocket.send(json.dumps(setup_message))
            logger.info("Configuración inicial enviada")

            # Esperar confirmación del servidor
            response = await asyncio.wait_for(self.websocket.recv(), timeout=10)
            setup_response = json.loads(response)

            if "setupComplete" in setup_response:
                logger.info("✅ Setup completado - Cliente listo para streaming")
                return True
            else:
                logger.error(f"Setup falló: {setup_response}")
                return False

        except websockets.exceptions.WebSocketException as e:
            logger.error(f"Error WebSocket: {e}")
            raise  # backoff lo reintentará
        except Exception as e:
            logger.error(f"Error inesperado conectando: {e}")
            return False

    async def send_audio_chunk(self, audio_data: bytes, mime_type: str = "audio/pcm") -> None:
        """
        Enviar chunk de audio al modelo
        Args:
            audio_data: Bytes del audio (PCM 16kHz mono recomendado)
            mime_type: Tipo MIME del audio
        """
        if not self.websocket:
            raise RuntimeError("WebSocket no conectado. Llama a connect() primero.")

        # Codificar audio en base64
        audio_b64 = base64.b64encode(audio_data).decode('utf-8')

        message = {
            "realtimeInput": {
                "mediaChunks": [
                    {
                        "mimeType": mime_type,
                        "data": audio_b64
                    }
                ]
            }
        }

        await self.websocket.send(json.dumps(message))
        logger.debug(f"Audio chunk enviado: {len(audio_data)} bytes")

    async def send_text_message(self, text: str) -> None:
        """Enviar mensaje de texto al modelo"""
        if not self.websocket:
            raise RuntimeError("WebSocket no conectado")

        message = {
            "clientContent": {
                "turns": [
                    {
                        "role": "user",
                        "parts": [{"text": text}]
                    }
                ],
                "turnComplete": True
            }
        }

        await self.websocket.send(json.dumps(message))
        logger.info(f"Mensaje de texto enviado: {text[:50]}...")

    async def receive_responses(self) -> Dict[str, Any]:
        """
        Recibir respuestas streaming del modelo
        Yields:
            Diccionarios con las respuestas (text, audio, etc)
        """
        if not self.websocket:
            raise RuntimeError("WebSocket no conectado")

        try:
            async for message in self.websocket:
                response = json.loads(message)

                # Procesar diferentes tipos de respuesta
                if "serverContent" in response:
                    content = response["serverContent"]

                    # Extraer texto si existe
                    if "modelTurn" in content:
                        for part in content["modelTurn"].get("parts", []):
                            if "text" in part:
                                yield {"type": "text", "content": part["text"]}
                            elif "inlineData" in part:
                                # Audio o imagen inline
                                yield {
                                    "type": "media",
                                    "mimeType": part["inlineData"]["mimeType"],
                                    "data": part["inlineData"]["data"]
                                }

                    # Verificar si el turn está completo
                    if content.get("turnComplete"):
                        logger.info("✅ Turn completado")
                        break

                elif "toolCall" in response:
                    # Manejar function calling
                    logger.info(f"Tool call recibido: {response['toolCall']}")
                    yield {"type": "tool_call", "content": response["toolCall"]}

                else:
                    logger.warning(f"Tipo de respuesta desconocido: {response}")

        except websockets.exceptions.ConnectionClosed:
            logger.warning("Conexión WebSocket cerrada por el servidor")
        except Exception as e:
            logger.error(f"Error recibiendo respuestas: {e}")

    async def close(self) -> None:
        """Cerrar conexión WebSocket limpiamente"""
        if self.websocket:
            await self.websocket.close()
            logger.info("Conexión WebSocket cerrada")


# Ejemplo de uso
async def main():
    """Ejemplo de implementación completa"""
    # Inicializar cliente
    client = GeminiWebSocketClient(
        project_id="tu-proyecto-gcp",
        service_account_path="/path/to/service-account.json"  # Opcional, usa ADC si no se especifica
    )

    # Conectar
    if await client.connect():
        # Enviar mensaje de texto
        await client.send_text_message("Hola, ¿puedes ayudarme con análisis multimodal?")

        # Recibir y procesar respuestas streaming
        async for response in client.receive_responses():
            if response["type"] == "text":
                print(f"Respuesta: {response['content']}")
            elif response["type"] == "media":
                print(f"Media recibido: {response['mimeType']}")
                # Guardar audio o procesar

        # Cerrar conexión
        await client.close()
    else:
        logger.error("No se pudo conectar al servicio")


if __name__ == "__main__":
    asyncio.run(main())

"""
Voice Activity Detection (VAD) para segmentar audio en chunks semánticos
Evita enviar silencio innecesario y mejora sincronización multimodal
"""
import webrtcvad
import collections
import numpy as np
from typing import Generator, Tuple


class AudioSegmenter:
    """Segmenta audio usando WebRTC VAD para mejorar streaming multimodal"""

    def __init__(
        self,
        sample_rate: int = 16000,
        frame_duration_ms: int = 30,
        vad_mode: int = 3,  # 0=least aggressive, 3=most aggressive
        padding_duration_ms: int = 300
    ):
        self.sample_rate = sample_rate
        self.frame_duration_ms = frame_duration_ms
        self.vad = webrtcvad.Vad(vad_mode)

        # Configuración de buffering
        self.num_padding_frames = int(padding_duration_ms / frame_duration_ms)
        self.ring_buffer = collections.deque(maxlen=self.num_padding_frames)
        self.triggered = False

        # Calcular tamaño de frame en bytes
        self.frame_size = int(sample_rate * frame_duration_ms / 1000)

    def segment_audio_stream(
        self,
        audio_data: bytes
    ) -> Generator[Tuple[bytes, bool], None, None]:
        """
        Segmenta stream de audio en chunks con voice activity
        Args:
            audio_data: Audio PCM 16-bit mono a sample_rate especificado
        Yields:
            Tupla de (audio_chunk, is_speech) donde is_speech indica si contiene voz
        """
        # Dividir audio en frames del tamaño correcto
        num_frames = len(audio_data) // (self.frame_size * 2)  # *2 porque 16-bit = 2 bytes

        for i in range(num_frames):
            start = i * self.frame_size * 2
            end = start + self.frame_size * 2
            frame = audio_data[start:end]

            # Detectar actividad de voz en este frame
            is_speech = self.vad.is_speech(frame, self.sample_rate)

            if not self.triggered:
                # Estado: NO hablando actualmente
                self.ring_buffer.append((frame, is_speech))
                num_voiced = len([f for f, speech in self.ring_buffer if speech])

                # Si suficientes frames con voz, comenzar segmento
                if num_voiced > 0.9 * self.ring_buffer.maxlen:
                    self.triggered = True
                    # Yield todos los frames del buffer (incluye padding pre-speech)
                    for buffered_frame, _ in self.ring_buffer:
                        yield (buffered_frame, True)
                    self.ring_buffer.clear()
            else:
                # Estado: Hablando actualmente
                yield (frame, is_speech)
                self.ring_buffer.append((frame, is_speech))
                num_unvoiced = len([f for f, speech in self.ring_buffer if not speech])

                # Si suficientes frames sin voz, finalizar segmento
                if num_unvoiced > 0.9 * self.ring_buffer.maxlen:
                    self.triggered = False
                    self.ring_buffer.clear()
                    # Yield silencio como marcador de fin
                    yield (b'', False)


# Integración con GeminiWebSocketClient
async def stream_audio_with_vad(client: GeminiWebSocketClient, audio_stream: bytes):
    """Ejemplo de integración VAD + WebSocket streaming"""
    segmenter = AudioSegmenter(
        sample_rate=16000,
        vad_mode=3,  # Agresivo para minimizar ruido
        padding_duration_ms=300  # 300ms padding antes/después de speech
    )

    current_segment = []

    for frame, is_speech in segmenter.segment_audio_stream(audio_stream):
        if is_speech:
            # Acumular frames con voz
            current_segment.append(frame)

            # Enviar en chunks de ~1 segundo (evitar fragmentación excesiva)
            if len(current_segment) >= 33:  # 33 frames @ 30ms = ~1 segundo
                full_chunk = b''.join(current_segment)
                await client.send_audio_chunk(full_chunk, mime_type="audio/pcm")
                current_segment = []
        else:
            # Fin de segmento de voz
            if current_segment:
                # Enviar último chunk parcial
                full_chunk = b''.join(current_segment)
                await client.send_audio_chunk(full_chunk, mime_type="audio/pcm")
                current_segment = []

"""
  Pipeline híbrido Gemini 2.0 Flash + 1.5 Pro para PDF processing
  Inspirado en arquitectura Moody's Analytics
  """
  from google.cloud import aiplatform
  from google.cloud.aiplatform import gapic
  import PyPDF2
  from typing import Dict, List
  import json


  class HybridPDFPipeline:
      """Pipeline multimodal para procesamiento eficiente de PDFs"""

      def __init__(self, project_id: str, location: str = "us-central1"):
          self.project_id = project_id
          self.location = location

          # Inicializar clientes Vertex AI
          aiplatform.init(project=project_id, location=location)

          # Modelos
          self.flash_model = "gemini-2.0-flash"  # Filtering (barato)
          self.pro_model = "gemini-1.5-pro"      # Extraction (preciso)

      def classify_document_relevance(self, pdf_path: str) -> Dict:
          """
          Etapa 1: Clasificar PDF como relevante/irrelevante usando Flash
          Returns:
              {"relevant": bool, "confidence": float, "reasoning": str}
          """
          # Extraer texto del PDF
          with open(pdf_path, 'rb') as file:
              reader = PyPDF2.PdfReader(file)
              text = ""

              # Leer primeras 5 páginas para clasificación rápida
              for page_num in range(min(5, len(reader.pages))):
                  text += reader.pages[page_num].extract_text()

          # Prompt para clasificación
          classification_prompt = f"""
  Analiza este documento financiero y determina si es RELEVANTE para análisis de riesgo crediticio.

  Documento a clasificar (primeras 5 páginas):
  {text[:8000]}  # Limitar a 8k chars para speed

  Criterios RELEVANTE:
  - Contiene métricas financieras (revenue, EBITDA, ratios)
  - Menciona riesgos corporativos o industria
  - Incluye proyecciones financieras

  Criterios IRRELEVANTE:
  - Documento genérico marketing/PR
  - Sin datos numéricos financieros
  - Nota de prensa sin sustancia

  Responde en JSON:
  {{
    "relevant": true/false,
    "confidence": 0.0-1.0,
    "reasoning": "breve explicación 1-2 frases"
  }}
  """

          # Llamar Gemini 2.0 Flash (barato, rápido)
          model = aiplatform.GenerativeModel(self.flash_model)
          response = model.generate_content(
              classification_prompt,
              generation_config={
                  "temperature": 0.3,  # Baja temp para consistency
                  "max_output_tokens": 256
              }
          )

          # Parsear JSON response
          try:
              result = json.loads(response.text)
              return result
          except json.JSONDecodeError:
              # Fallback si respuesta no es JSON válido
              return {
                  "relevant": False,
                  "confidence": 0.0,
                  "reasoning": "Error parsing response"
              }

      def extract_structured_data(self, pdf_path: str) -> Dict:
          """
          Etapa 2: Extraer datos estructurados usando Gemini 1.5 Pro
          Returns:
              Dict con métricas financieras extraídas
          """
          # Leer PDF completo
          with open(pdf_path, 'rb') as file:
              reader = PyPDF2.PdfReader(file)
              full_text = ""
              for page in reader.pages:
                  full_text += page.extract_text()

          # Prompt para extracción estructurada
          extraction_prompt = f"""
  Extrae las siguientes métricas financieras de este documento:

  Documento completo:
  {full_text[:100000]}  # 1.5 Pro puede manejar contexto largo

  Extrae en JSON:
  {{
    "company_name": "string",
    "fiscal_year": "YYYY",
    "revenue": {{
      "value": float,
      "currency": "USD/EUR/etc",
      "growth_yoy_pct": float
    }},
    "ebitda": {{
      "value": float,
      "margin_pct": float
    }},
    "debt_to_equity_ratio": float,
    "credit_rating": "AAA/AA/A/BBB/etc",
    "risk_factors": [
      "factor 1",
      "factor 2"
    ],
    "outlook": "positive/negative/stable"
  }}

  Si algún dato NO está disponible, usa null.
  Solo datos EXPLÍCITOS del documento - NO inferir.
  """

          # Llamar Gemini 1.5 Pro (caro pero preciso)
          model = aiplatform.GenerativeModel(self.pro_model)
          response = model.generate_content(
              extraction_prompt,
              generation_config={
                  "temperature": 0.1,  # Muy baja temp para máxima precisión
                  "max_output_tokens": 2048
              }
          )

          try:
              return json.loads(response.text)
          except json.JSONDecodeError:
              return {"error": "Failed to parse structured data"}

      def process_pdf_batch(self, pdf_paths: List[str]) -> List[Dict]:
          """
          Procesar batch de PDFs con pipeline híbrido
          Returns:
              Lista de documentos procesados con datos extraídos
          """
          results = []

          for pdf_path in pdf_paths:
              # Etapa 1: Clasificación con Flash (rápido y barato)
              classification = self.classify_document_relevance(pdf_path)

              if classification["relevant"] and classification["confidence"] > 0.7:
                  # Etapa 2: Extracción con Pro (solo si relevante)
                  structured_data = self.extract_structured_data(pdf_path)
                  results.append({
                      "pdf_path": pdf_path,
                      "classification": classification,
                      "extracted_data": structured_data,
                      "processed_with": "hybrid_pipeline"
                  })
              else:
                  # Skip documentos irrelevantes (ahorro de costes)
                  results.append({
                      "pdf_path": pdf_path,
                      "classification": classification,
                      "extracted_data": None,
                      "processed_with": "flash_only"
                  })

          return results


  # Ejemplo de uso
  if __name__ == "__main__":
      pipeline = HybridPDFPipeline(project_id="tu-proyecto-gcp")

      # Procesar batch de PDFs
      pdf_files = [
          "/path/to/financial_report_1.pdf",
          "/path/to/financial_report_2.pdf",
          # ... 10,000+ files
      ]

      results = pipeline.process_pdf_batch(pdf_files)

      # Guardar resultados
      with open("processed_results.json", "w") as f:
          json.dump(results, f, indent=2)

"""
FastAPI WebSocket Proxy para Gemini 2.0 Flash Multimodal Live API
Incluye: autenticación JWT, rate limiting, error handling, monitoring
"""
from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Depends, HTTPException, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import asyncio
import json
import logging
from typing import Dict, Optional
from prometheus_client import Counter, Histogram, generate_latest
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded
import os
from gemini_websocket_client import GeminiWebSocketClient  # Import del código anterior

# Configuración
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Métricas Prometheus
REQUESTS_COUNTER = Counter('gemini_requests_total', 'Total de requests multimodales')
LATENCY_HISTOGRAM = Histogram('gemini_latency_seconds', 'Latency de respuestas Gemini')
ERRORS_COUNTER = Counter('gemini_errors_total', 'Total de errores', ['error_type'])

# Rate limiting
limiter = Limiter(key_func=get_remote_address)

# FastAPI app
app = FastAPI(title="Gemini Multimodal Proxy API")
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

# CORS (configurar origins permitidos en producción)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],  # Frontend React
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Security
security = HTTPBearer()

# Almacenar clientes WebSocket activos
active_clients: Dict[str, GeminiWebSocketClient] = {}


def verify_jwt_token(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
    """
    Verificar JWT token del usuario
    En producción: validar contra Firebase Auth, Auth0, o tu sistema de autenticación
    """
    token = credentials.credentials

    # TODO: Implementar validación real de JWT
    # Ejemplo con Firebase:
    # from firebase_admin import auth
    # decoded_token = auth.verify_id_token(token)
    # return decoded_token['uid']

    # DEMO: Solo validar que existe token
    if not token:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Token inválido"
        )

    return "demo_user_id"  # Retornar user ID real en producción


@app.get("/health")
async def health_check():
    """Health check endpoint para load balancers"""
    return {"status": "healthy", "active_connections": len(active_clients)}


@app.get("/metrics")
async def metrics():
    """Endpoint de métricas Prometheus"""
    return generate_latest()


@app.websocket("/ws/multimodal")
@limiter.limit("10/minute")  # Rate limit: 10 conexiones por minuto por IP
async def websocket_endpoint(
    websocket: WebSocket,
    user_id: str = Depends(verify_jwt_token)
):
    """
    WebSocket endpoint para streaming multimodal
    Cliente se conecta aquí y nosotros proxeamos a Vertex AI
    """
    await websocket.accept()
    logger.info(f"Nueva conexión WebSocket de user_id: {user_id}")

    # Crear cliente Gemini para este usuario
    client = GeminiWebSocketClient(
        project_id=os.getenv("GCP_PROJECT_ID"),
        service_account_path=os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
    )

    try:
        # Conectar a Vertex AI
        if not await client.connect():
            await websocket.send_json({
                "error": "No se pudo conectar a Gemini Live API"
            })
            await websocket.close()
            return

        # Guardar cliente activo
        active_clients[user_id] = client
        REQUESTS_COUNTER.inc()

        # Crear tasks para bidirectional streaming
        async def forward_to_gemini():
            """Task: Recibir del frontend y enviar a Gemini"""
            try:
                while True:
                    # Recibir del cliente frontend
                    data = await websocket.receive_json()
                    message_type = data.get("type")

                    if message_type == "text":
                        await client.send_text_message(data["content"])
                    elif message_type == "audio":
                        # Audio viene en base64
                        import base64
                        audio_bytes = base64.b64decode(data["content"])
                        await client.send_audio_chunk(audio_bytes)
                    elif message_type == "ping":
                        # Keep-alive
                        await websocket.send_json({"type": "pong"})

            except WebSocketDisconnect:
                logger.info(f"Cliente {user_id} desconectado")
            except Exception as e:
                logger.error(f"Error forwarding to Gemini: {e}")
                ERRORS_COUNTER.labels(error_type="forward_error").inc()

        async def forward_from_gemini():
            """Task: Recibir de Gemini y enviar a frontend"""
            try:
                async for response in client.receive_responses():
                    # Enviar al cliente frontend
                    await websocket.send_json(response)
                    LATENCY_HISTOGRAM.observe(0.5)  # TODO: medir latency real

            except Exception as e:
                logger.error(f"Error forwarding from Gemini: {e}")
                ERRORS_COUNTER.labels(error_type="receive_error").inc()

        # Ejecutar ambos tasks en paralelo
        await asyncio.gather(
            forward_to_gemini(),
            forward_from_gemini()
        )

    except Exception as e:
        logger.error(f"Error en WebSocket endpoint: {e}")
        ERRORS_COUNTER.labels(error_type="general").inc()
        await websocket.send_json({"error": str(e)})

    finally:
        # Cleanup
        if user_id in active_clients:
            await active_clients[user_id].close()
            del active_clients[user_id]
        logger.info(f"Conexión cerrada para {user_id}")


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "main:app",
        host="0.0.0.0",
        port=8000,
        reload=True,  # Solo desarrollo
        log_level="info"
    )

import React, { useState, useEffect, useRef } from 'react';

const MultimodalChat = () => {
const [isRecording, setIsRecording] = useState(false);
const [messages, setMessages] = useState([]);
const [ws, setWs] = useState(null);
const mediaRecorderRef = useRef(null);
const audioChunksRef = useRef([]);

// Conectar WebSocket al montar componente
useEffect(() => {
    const token = localStorage.getItem('auth_token'); // JWT token
    const websocket = new WebSocket(
    `ws://localhost:8000/ws/multimodal?token=${token}`
    );

    websocket.onopen = () => {
    console.log('✅ WebSocket conectado');
    setMessages(prev => [...prev, {
        type: 'system',
        content: 'Conectado a Gemini 2.0 Flash'
    }]);
    };

    websocket.onmessage = (event) => {
    const data = JSON.parse(event.data);

    if (data.type === 'text') {
        setMessages(prev => [...prev, {
        type: 'assistant',
        content: data.content
        }]);
    } else if (data.type === 'media' && data.mimeType.includes('audio')) {
        // Reproducir audio recibido
        playAudioResponse(data.data);
    }
    };

    websocket.onerror = (error) => {
    console.error('Error WebSocket:', error);
    };

    websocket.onclose = () => {
    console.log('WebSocket cerrado');
    setMessages(prev => [...prev, {
        type: 'system',
        content: 'Desconectado'
    }]);
    };

    setWs(websocket);
    return () => websocket.close();
}, []);

// Función para reproducir audio recibido de Gemini
const playAudioResponse = (base64Audio) => {
    const audioData = atob(base64Audio);
    const arrayBuffer = new ArrayBuffer(audioData.length);
    const view = new Uint8Array(arrayBuffer);

    for (let i = 0; i < audioData.length; i++) {
    view[i] = audioData.charCodeAt(i);
    }

    const blob = new Blob([arrayBuffer], { type: 'audio/pcm' });
    const audioUrl = URL.createObjectURL(blob);
    const audio = new Audio(audioUrl);
    audio.play();
};

// Iniciar grabación de audio
const startRecording = async () => {
    try {
    const stream = await navigator.mediaDevices.getUserMedia({
        audio: {
        channelCount: 1,
        sampleRate: 16000 // 16kHz requerido por Gemini
        }
    });

    const mediaRecorder = new MediaRecorder(stream, {
        mimeType: 'audio/webm'
    });

    mediaRecorderRef.current = mediaRecorder;
    audioChunksRef.current = [];

    mediaRecorder.ondataavailable = (event) => {
        if (event.data.size > 0) {
        audioChunksRef.current.push(event.data);

        // Enviar chunk inmediatamente para streaming
        const reader = new FileReader();
        reader.onloadend = () => {
            const base64Audio = reader.result.split(',')[1];
            ws.send(JSON.stringify({
            type: 'audio',
            content: base64Audio
            }));
        };
        reader.readAsDataURL(event.data);
        }
    };

    mediaRecorder.start(100); // Emitir chunks cada 100ms
    setIsRecording(true);
    setMessages(prev => [...prev, {
        type: 'system',
        content: '🎤 Grabando audio...'
    }]);
    } catch (error) {
    console.error('Error accediendo micrófono:', error);
    alert('No se pudo acceder al micrófono. Verifica permisos.');
    }
};

// Detener grabación
const stopRecording = () => {
    if (mediaRecorderRef.current && isRecording) {
    mediaRecorderRef.current.stop();
    mediaRecorderRef.current.stream.getTracks().forEach(track => track.stop());
    setIsRecording(false);
    setMessages(prev => [...prev, {
        type: 'system',
        content: '⏸️ Grabación detenida'
    }]);
    }
};

// Enviar mensaje de texto
const sendTextMessage = (text) => {
    if (ws && text.trim()) {
    ws.send(JSON.stringify({
        type: 'text',
        content: text
    }));
    setMessages(prev => [...prev, {
        type: 'user',
        content: text
    }]);
    }
};

return (
    

    {/* Header */}
    
Gemini 2.0 Flash Multimodal Chat
Audio + Text streaming en tiempo real

    {/* Messages */}
    

        {messages.map((msg, idx) => (
        

            {msg.content}
            
        ))}
    

    {/* Controls */}
    

            {isRecording ? '⏹️ Detener' : '🎤 Grabar Audio'}
         {
            if (e.key === 'Enter') {
                sendTextMessage(e.target.value);
                e.target.value = '';
            }
            }}
        />
        
);
};

export default MultimodalChat;