
import { Transaction } from '@/components/TransactionCard';
import { supabase } from '@/lib/supabase';
import { isSyncEnabled } from '@/utils/syncUtils';
import { formatISO } from 'date-fns';

// ISO 형식으로 날짜 변환 (Supabase 저장용)
const convertDateToISO = (dateStr: string): string => {
  try {
    // 이미 ISO 형식인 경우 그대로 반환
    if (dateStr.match(/^\d{4}-\d{2}-\d{2}T/)) {
      return dateStr;
    }

    // "오늘, 시간" 형식 처리
    if (dateStr.includes('오늘')) {
      const today = new Date();
      
      // 시간 추출 시도
      const timeMatch = dateStr.match(/(\d{1,2}):(\d{2})/);
      if (timeMatch) {
        const hours = parseInt(timeMatch[1], 10);
        const minutes = parseInt(timeMatch[2], 10);
        today.setHours(hours, minutes, 0, 0);
      }
      
      return formatISO(today);
    }
    
    // 일반 날짜 문자열은 그대로 Date 객체로 변환 시도
    const date = new Date(dateStr);
    if (!isNaN(date.getTime())) {
      return formatISO(date);
    }
    
    // 변환 실패 시 현재 시간 반환
    console.warn(`날짜 변환 오류: "${dateStr}"를 ISO 형식으로 변환할 수 없습니다.`);
    return formatISO(new Date());
  } catch (error) {
    console.error(`날짜 변환 오류: "${dateStr}"`, error);
    return formatISO(new Date());
  }
};

// Supabase와 트랜잭션 동기화 - Cloud 최적화 버전
export const syncTransactionsWithSupabase = async (user: any, transactions: Transaction[]): Promise<Transaction[]> => {
  if (!user || !isSyncEnabled()) return transactions;
  
  try {
    const { data, error } = await supabase
      .from('transactions')
      .select('*')
      .eq('user_id', user.id);
      
    if (error) {
      console.error('Supabase 데이터 조회 오류:', error);
      return transactions;
    }
    
    if (data && data.length > 0) {
      // Supabase 데이터 로컬 형식으로 변환
      const supabaseTransactions = data.map(t => ({
        id: t.transaction_id || t.id,
        title: t.title,
        amount: t.amount,
        date: t.date,
        category: t.category,
        type: t.type
      }));
      
      // 로컬 데이터와 병합 (중복 ID 제거)
      const mergedTransactions = [...transactions];
      
      supabaseTransactions.forEach(newTx => {
        const existingIndex = mergedTransactions.findIndex(t => t.id === newTx.id);
        if (existingIndex >= 0) {
          mergedTransactions[existingIndex] = newTx;
        } else {
          mergedTransactions.push(newTx);
        }
      });
      
      return mergedTransactions;
    }
  } catch (err) {
    console.error('Supabase 동기화 오류:', err);
  }
  
  return transactions;
};

// Supabase에 트랜잭션 업데이트 - Cloud 최적화 버전
export const updateTransactionInSupabase = async (user: any, transaction: Transaction): Promise<void> => {
  if (!user || !isSyncEnabled()) return;
  
  try {
    // 날짜를 ISO 형식으로 변환
    const isoDate = convertDateToISO(transaction.date);
    
    const { error } = await supabase.from('transactions')
      .upsert({
        user_id: user.id,
        title: transaction.title,
        amount: transaction.amount,
        date: isoDate, // ISO 형식 사용
        category: transaction.category,
        type: transaction.type,
        transaction_id: transaction.id
      });
      
    if (error) {
      console.error('트랜잭션 업데이트 오류:', error);
    } else {
      console.log('Supabase 트랜잭션 업데이트 성공:', transaction.id);
    }
  } catch (error) {
    console.error('Supabase 업데이트 오류:', error);
  }
};

// Supabase에서 트랜잭션 삭제 - Cloud 최적화 버전
export const deleteTransactionFromSupabase = async (user: any, transactionId: string): Promise<void> => {
  if (!user || !isSyncEnabled()) return;
  
  try {
    const { error } = await supabase.from('transactions')
      .delete()
      .eq('transaction_id', transactionId);
      
    if (error) {
      console.error('트랜잭션 삭제 오류:', error);
    } else {
      console.log('Supabase 트랜잭션 삭제 성공:', transactionId);
    }
  } catch (error) {
    console.error('Supabase 삭제 오류:', error);
  }
};
