'use client';

import { useState, useEffect, useRef, useCallback } from 'react';
import {
  collection,
  query,
  where,
  orderBy,
  limit,
  onSnapshot,
} from 'firebase/firestore';
import { db } from '@/lib/firebase';
import type { DocumentStatus } from '@/types/firestore';
import type { Timestamp } from 'firebase/firestore';

export interface ReviewQueueItem {
  id: string;
  docId: string;
  title: string;
  status: DocumentStatus;
  riskLevel?: 'low' | 'high';
  updatedAt: Timestamp;
  authorName: string;
  category?: string;
  expert?: string;
  sourceDate?: string;
  insightEntryId?: string;
  question?: string;
  answer?: string;
}

export interface UseReviewQueueListenerReturn {
  items: ReviewQueueItem[];
  loading: boolean;
  error: Error | null;
  retry: () => void;
}

export function useReviewQueueListener(enabled: boolean): UseReviewQueueListenerReturn {
  const [items, setItems] = useState<ReviewQueueItem[]>([]);
  const [loading, setLoading] = useState<boolean>(false);
  const [error, setError] = useState<Error | null>(null);
  const [retryTrigger, setRetryTrigger] = useState<number>(0);

  const unsubscribeRef = useRef<(() => void) | null>(null);

  const retry = useCallback(() => {
    setError(null);
    setRetryTrigger((prev) => prev + 1);
  }, []);

  useEffect(() => {
    if (!enabled) return;

    const connect = () => {
      // 기존 리스너 정리
      if (unsubscribeRef.current) {
        unsubscribeRef.current();
        unsubscribeRef.current = null;
      }

      setError(null);
      setLoading(true);

      const q = query(
        collection(db, 'documents'),
        where('sourceType', '==', 'dashboard_insight'),
        where('status', '==', 'pending'),
        orderBy('updatedAt', 'desc'),
        limit(500)
      );

      const unsubscribe = onSnapshot(
        q,
        (snapshot) => {
          const queueItems: ReviewQueueItem[] = snapshot.docs.map((docSnap) => {
            const data = docSnap.data();
            return {
              id: docSnap.id,
              docId: data.docId as string,
              title: data.title as string,
              status: data.status as DocumentStatus,
              riskLevel: data.riskLevel as 'low' | 'high' | undefined,
              updatedAt: data.updatedAt as Timestamp,
              authorName: data.authorName as string,
              category: data.category as string | undefined,
              expert: (data.sourceMeta?.expertName ?? '') as string | undefined,
              sourceDate: (data.sourceMeta?.collectedAt ?? '') as string | undefined,
              insightEntryId: data.insightEntryId as string | undefined,
              question: data.question as string | undefined,
              answer: data.answer as string | undefined,
            };
          });
          setItems(queueItems);
          setLoading(false);
        },
        (err) => {
          setError(err);
          setLoading(false);
        }
      );

      unsubscribeRef.current = unsubscribe;
    };

    const disconnect = () => {
      if (unsubscribeRef.current) {
        unsubscribeRef.current();
        unsubscribeRef.current = null;
      }
    };

    // visibilitychange 핸들러
    const handleVisibilityChange = () => {
      if (document.visibilityState === 'hidden') {
        disconnect();
      } else {
        connect();
      }
    };

    // iOS Safari 폴백: pagehide/pageshow
    const handlePageHide = () => {
      disconnect();
    };

    const handlePageShow = () => {
      connect();
    };

    document.addEventListener('visibilitychange', handleVisibilityChange);
    document.addEventListener('pagehide', handlePageHide);
    document.addEventListener('pageshow', handlePageShow);

    // 초기 연결
    connect();

    return () => {
      disconnect();
      document.removeEventListener('visibilitychange', handleVisibilityChange);
      document.removeEventListener('pagehide', handlePageHide);
      document.removeEventListener('pageshow', handlePageShow);
    };
  }, [enabled, retryTrigger]);

  return { items, loading, error, retry };
}