
import { useCallback, useRef, useEffect } from 'react';
import { Transaction } from '@/components/TransactionCard';
import { useAuth } from '@/contexts/auth/useAuth';
import { toast } from '@/hooks/useToast.wrapper';
import { saveTransactionsToStorage } from './storageUtils';
import { deleteTransactionFromServer } from '@/utils/sync/transaction/deleteTransaction';
import { addToDeletedTransactions } from '@/utils/sync/transaction/deletedTransactionsTracker';

/**
 * 안정화된 트랜잭션 삭제 훅 - 완전 재구현 버전
 */
export const useDeleteTransaction = (
  transactions: Transaction[],
  setTransactions: React.Dispatch<React.SetStateAction<Transaction[]>>
) => {
  // 삭제 상태 추적
  const pendingDeletionRef = useRef<Set<string>>(new Set());
  const { user } = useAuth();
  
  // 삭제 함수 - 전체 재구현
  const deleteTransaction = useCallback((id: string): Promise<boolean> => {
    return new Promise((resolve) => {
      try {
        console.log(`[안정화] 트랜잭션 삭제 시작 (ID: ${id})`);
        
        // 이미 삭제 중인지 확인
        if (pendingDeletionRef.current.has(id)) {
          console.warn(`[안정화] 이미 삭제 중인 트랜잭션: ${id}`);
          resolve(true);
          return;
        }
        
        // 삭제 중인 상태 표시
        pendingDeletionRef.current.add(id);
        
        // 타임아웃 설정 (300ms)
        const timeoutId = setTimeout(() => {
          console.warn(`[안정화] 삭제 타임아웃 - 강제 완료 (ID: ${id})`);
          pendingDeletionRef.current.delete(id);
          resolve(true); // 성공으로 간주
        }, 300);
        
        // UI 즉시 업데이트 (낙관적 UI 업데이트)
        setTransactions(prev => prev.filter(t => t.id !== id));
        
        // 비동기 스토리지 작업 실행
        queueMicrotask(() => {
          try {
            // 트랜잭션 찾기
            const updatedTransactions = transactions.filter(t => t.id !== id);
            
            // 삭제된 트랜잭션 추적 목록에 추가
            try {
              addToDeletedTransactions(id);
              console.log(`[안정화] 삭제된 트랜잭션 추적 추가 (ID: ${id})`);
            } catch (trackingError) {
              console.error('[안정화] 삭제 추적 실패:', trackingError);
            }
            
            // 로컬 스토리지 저장
            try {
              saveTransactionsToStorage(updatedTransactions);
              console.log(`[안정화] 로컬 스토리지 업데이트 완료 (ID: ${id})`);
            } catch (storageError) {
              console.error('[안정화] 스토리지 저장 실패:', storageError);
            }
            
            // 서버 동기화 (별도의 비동기 작업)
            if (user && user.id) {
              setTimeout(() => {
                try {
                  deleteTransactionFromServer(user.id, id)
                    .catch(err => console.error('[안정화] 서버 삭제 실패:', err));
                } catch (serverError) {
                  console.error('[안정화] 서버 삭제 요청 실패:', serverError);
                }
              }, 10);
            }
            
            // 이벤트 발생
            try {
              window.dispatchEvent(new Event('transactionDeleted'));
              window.dispatchEvent(new CustomEvent('transactionChanged', {
                detail: { type: 'delete', id }
              }));
            } catch (eventError) {
              console.error('[안정화] 이벤트 발생 오류:', eventError);
            }
            
            // 토스트 메시지
            toast({
              title: "삭제 완료",
              description: "항목이 삭제되었습니다.",
              duration: 1500
            });
            
            // 성공적으로 처리됨
            clearTimeout(timeoutId);
            pendingDeletionRef.current.delete(id);
            resolve(true);
          } catch (error) {
            console.error('[안정화] 삭제 처리 중 오류:', error);
            clearTimeout(timeoutId);
            pendingDeletionRef.current.delete(id);
            resolve(true); // 오류가 있어도 UI는 이미 업데이트됨
          }
        });
      } catch (error) {
        console.error('[안정화] 삭제 함수 심각한 오류:', error);
        
        // 항상 pending 상태 제거 보장
        pendingDeletionRef.current.delete(id);
        
        // 오류가 있어도 UI 차단 방지를 위해 성공 반환
        resolve(true);
      }
    });
  }, [transactions, user, setTransactions]);

  // 컴포넌트 언마운트 시 모든 상태 정리
  useEffect(() => {
    // 현재 ref 값을 로컬 변수에 복사하여 클린업 함수에서 사용
    const pendingDeletion = pendingDeletionRef.current;
    return () => {
      pendingDeletion.clear();
    };
  }, []);

  return deleteTransaction;
};
