"use client";

import { useState, useEffect, useRef, useCallback } from "react";
import { getTranscriptView } from "@/lib/api";
import type { TranscriptStatusData } from "@/types/api";

interface UseTranscriptResult {
  data: TranscriptStatusData | null;
  loading: boolean;
  error: string | null;
  notFound: boolean;
  refetch: () => void;
}

export function useTranscript(meetingId: string, enabled: boolean): UseTranscriptResult {
  const [data, setData]       = useState<TranscriptStatusData | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError]     = useState<string | null>(null);
  const [notFound, setNotFound] = useState(false);

  // Prevent double-fetch on StrictMode double-invoke or re-renders
  const fetchedRef = useRef(false);

  const fetch = useCallback(async () => {
    if (!enabled || !meetingId) return;
    setLoading(true);
    setError(null);
    setNotFound(false);
    try {
      const res = await getTranscriptView(Number(meetingId));
      if (res.success) {
        setData(res.data);
      } else {
        setData(null);
        if (res.message.toLowerCase().includes("transcript not found")) {
          setNotFound(true);
        } else {
          setError(res.message);
        }
      }
    } catch (err) {
      setData(null);
      setError(err instanceof Error ? err.message : "Failed to load transcript.");
    } finally {
      setLoading(false);
    }
  }, [meetingId, enabled]);

  useEffect(() => {
    if (!enabled || !meetingId) return;
    if (fetchedRef.current) return; // already fetched — skip
    fetchedRef.current = true;
    fetch();
  }, [meetingId, enabled, fetch]);

  // refetch resets the guard so user can manually retry
  const refetch = useCallback(() => {
    fetchedRef.current = false;
    fetch();
  }, [fetch]);

  return { data, loading, error, notFound, refetch };
}