import { useCallback } from "react";
import {
  createConversation,
  sendConversationAudio,
} from "../api/conversationApi";
import { trackMetric } from "../api/metricsApi";
import { playAudio, stopAudio } from "../services/audio/player";
import { absoluteUrl } from "../utils/formatters";
import { ENV } from "../config/environment";
import { useAppStore } from "../store/appStore";
import { useConversationStore } from "../store/conversationStore";
import { useProductStore } from "../store/productStore";
import { logger } from "../utils/logger";

export function useConversation() {
  const deviceId = useAppStore((s) => s.deviceId);
  const product = useProductStore((s) => s.product);
  const {
    conversationId,
    productId: conversationProductId,
    messages,
    characterState,
    lastLatency,
    setConversation,
    appendMessage,
    setCharacterState,
    setLastLatency,
    reset,
  } = useConversationStore();

  const ensureConversation = useCallback(async () => {
    if (!product) throw new Error("No hay producto cargado");

    // Si ya hay conversación pero es de otro producto, empezar de cero.
    if (conversationId && conversationProductId === product.id) {
      return conversationId;
    }
    if (conversationId && conversationProductId !== product.id) {
      reset();
    }

    const created = await createConversation(product.id, deviceId);
    setConversation(created.conversation_id, product.id);
    await trackMetric({
      event: "conversation_started",
      product_id: product.id,
      character_id: product.character_id,
      conversation_id: created.conversation_id,
      device_id: deviceId,
    });
    return created.conversation_id;
  }, [
    conversationId,
    conversationProductId,
    deviceId,
    product,
    reset,
    setConversation,
  ]);

  const sendAudio = useCallback(
    async (uri: string) => {
      const id = await ensureConversation();
      setCharacterState("thinking");
      try {
        const result = await sendConversationAudio(id, uri);
        appendMessage({ role: "user", text: result.user_text });
        appendMessage({
          role: "assistant",
          text: result.assistant_text,
          audio_url: result.audio_url,
        });
        setLastLatency(result.latency);
        setCharacterState("talking");
        const audioUrl = absoluteUrl(ENV.API_BASE_URL, result.audio_url);
        logger.info("TTS url", audioUrl);
        try {
          await playAudio(audioUrl, () => setCharacterState("idle"));
        } catch (playError) {
          logger.error("No se pudo reproducir TTS", playError);
          setCharacterState("idle");
          throw playError;
        }
        return result;
      } catch (e) {
        setCharacterState("idle");
        logger.error(e);
        throw e;
      }
    },
    [
      appendMessage,
      ensureConversation,
      setCharacterState,
      setLastLatency,
    ],
  );

  const stop = useCallback(async () => {
    await stopAudio();
    setCharacterState("idle");
  }, [setCharacterState]);

  return {
    conversationId,
    messages,
    characterState,
    lastLatency,
    ensureConversation,
    sendAudio,
    stop,
    reset,
  };
}