shoptime/com.twin.app.shoptime/src/reducers/mockCartReducer.js

import { MOCK_CART_TYPES } from '../actions/mockCartActions';
import { createDebugHelpers } from '../utils/debug';

// 디버그 헬퍼 설정
const DEBUG_MODE = false;
const { dlog, dwarn, derror } = createDebugHelpers(DEBUG_MODE);

// 브라우저 환경 확인
const isBrowser = typeof window !== 'undefined' && typeof window.localStorage !== 'undefined';

/**
 * Mock Cart Reducer 초기 상태
 * 실제 cartReducer와 유사한 구조 유지
 */
const initialState = {
  // Mock 장바구니 목록
  cartInfo: [],
  // 선택된 상품들
  selectedItems: [],
  // 마지막 실행된 액션 정보
  lastAction: null,
  // 에러 정보
  error: null,
  // 총 상품 수량
  totalQuantity: 0,
  // 총 가격
  totalPrice: 0,
  // 마지막 업데이트 시간
  lastUpdated: null,
};

// localStorage 관련 유틸리티
const MOCK_CART_STORAGE_KEY = 'mockCartData';

/**
 * Mock 장바구니 데이터를 localStorage에 저장
 */
const saveToLocalStorage = (state) => {
  if (!isBrowser) return;

  try {
    const dataToSave = {
      cartInfo: state.cartInfo,
      selectedItems: state.selectedItems,
      totalQuantity: state.totalQuantity,
      totalPrice: state.totalPrice,
      lastUpdated: state.lastUpdated,
    };
    window.localStorage.setItem(MOCK_CART_STORAGE_KEY, JSON.stringify(dataToSave));
  } catch (error) {
    derror('[MockCartReducer] localStorage 저장 실패:', error);
  }
};

/**
 * localStorage에서 Mock 장바구니 데이터 불러오기
 */
const loadFromLocalStorage = () => {
  if (!isBrowser) return initialState;

  try {
    const savedData = window.localStorage.getItem(MOCK_CART_STORAGE_KEY);
    if (savedData) {
      const parsedData = JSON.parse(savedData);
      return {
        ...initialState,
        cartInfo: parsedData.cartInfo || [],
        selectedItems: parsedData.selectedItems || [],
        totalQuantity: parsedData.totalQuantity || 0,
        totalPrice: parsedData.totalPrice || 0,
        lastUpdated: parsedData.lastUpdated || Date.now(),
      };
    }
  } catch (error) {
    derror('[MockCartReducer] localStorage 로드 실패:', error);
  }
  return initialState;
};

/**
 * 장바구니 아이템 중복 확인
 * @param {Array} cartItems - 현재 장바구니 아이템 목록
 * @param {Object} newItem - 추가할 상품
 * @returns {Object} 중복 여부와 기존 아이템 인덱스
 */
const findDuplicateItem = (cartItems, newItem) => {
  const index = cartItems.findIndex(
    (item) => item.prdtId === newItem.prdtId && item.optNm === newItem.optNm
  );
  return {
    isDuplicate: index !== -1,
    index,
  };
};

/**
 * 총 수량 및 총 가격 계산
 * @param {Array} cartItems - 장바구니 아이템 목록
 * @returns {Object} 총 수량과 총 가격
 */
const calculateTotals = (cartItems) => {
  const totalQuantity = cartItems.reduce((sum, item) => sum + (item.prodQty || 1), 0);
  const totalPrice = cartItems.reduce((sum, item) => {
    const itemPrice = parseFloat(item.price3 || item.price2 || 0);
    const optionPrice = parseFloat(item.price5 || 0);
    const shippingPrice = parseFloat(item.shippingCharge || 0);
    return sum + ((itemPrice + optionPrice) * (item.prodQty || 1) + shippingPrice);
  }, 0);

  return {
    totalQuantity,
    totalPrice: parseFloat(totalPrice.toFixed(2)),
  };
};

/**
 * Mock Cart Reducer
 * Mock Mode에서 장바구니 데이터를 관리합니다.
 */
export const mockCartReducer = (state = loadFromLocalStorage(), action) => {
  switch (action.type) {
    case MOCK_CART_TYPES.INIT_MOCK_CART: {
      const { items = [] } = action.payload;
      const newState = {
        ...state,
        cartInfo: items,
        lastAction: action.payload.lastAction,
        error: null,
        lastUpdated: Date.now(),
        ...calculateTotals(items),
      };

      // localStorage에 저장
      saveToLocalStorage(newState);
      return newState;
    }

    case MOCK_CART_TYPES.ADD_TO_MOCK_CART: {
      const { item } = action.payload;
      const currentItems = [...state.cartInfo];

      // 중복 상품 확인
      const { isDuplicate, index } = findDuplicateItem(currentItems, item);

      let updatedItems;
      if (isDuplicate) {
        // 중복 상품이면 수량 증가 (BuyOption에서 전달된 수량 존중)
        updatedItems = [...currentItems];
        const currentQty = updatedItems[index].prodQty || updatedItems[index].qty || 1;
        const newQty = item.prodQty || item.qty || 1;

        dlog('[MockCartReducer] Quantity update - Current:', currentQty, 'Adding:', newQty);

        updatedItems[index] = {
          ...updatedItems[index],
          prodQty: currentQty + newQty,
          qty: currentQty + newQty, // qty 필드도 동기화
        };
      } else {
        // 새 상품 추가
        updatedItems = [...currentItems, item];
      }

      const newState = {
        ...state,
        cartInfo: updatedItems,
        lastAction: action.payload.lastAction,
        error: null,
        lastUpdated: Date.now(),
        ...calculateTotals(updatedItems),
      };

      // localStorage에 저장
      saveToLocalStorage(newState);
      return newState;
    }

    case MOCK_CART_TYPES.REMOVE_FROM_MOCK_CART: {
      const { prodSno } = action.payload;
      const updatedItems = state.cartInfo.filter((item) => item.prodSno !== prodSno);

      const newState = {
        ...state,
        cartInfo: updatedItems,
        lastAction: action.payload.lastAction,
        error: null,
        lastUpdated: Date.now(),
        ...calculateTotals(updatedItems),
      };

      // localStorage에 저장
      saveToLocalStorage(newState);
      return newState;
    }

    case MOCK_CART_TYPES.UPDATE_MOCK_CART_ITEM: {
      const { prodSno, quantity } = action.payload;
      const updatedItems = state.cartInfo.map((item) => {
        if (item.prodSno === prodSno) {
          return {
            ...item,
            prodQty: Math.max(1, quantity), // 최소 1개 보장
          };
        }
        return item;
      });

      const newState = {
        ...state,
        cartInfo: updatedItems,
        lastAction: action.payload.lastAction,
        error: null,
        lastUpdated: Date.now(),
        ...calculateTotals(updatedItems),
      };

      // localStorage에 저장
      saveToLocalStorage(newState);
      return newState;
    }

    case MOCK_CART_TYPES.SET_MOCK_CART_QUANTITY: {
      const { prodSno, quantity } = action.payload;

      if (quantity <= 0) {
        // 수량이 0이면 상품 제거
        const updatedItems = state.cartInfo.filter((item) => item.prodSno !== prodSno);

        const newState = {
          ...state,
          cartInfo: updatedItems,
          lastAction: action.payload.lastAction,
          error: null,
          lastUpdated: Date.now(),
          ...calculateTotals(updatedItems),
        };

        // localStorage에 저장
        saveToLocalStorage(newState);
        return newState;
      }

      const updatedItems = state.cartInfo.map((item) => {
        if (item.prodSno === prodSno) {
          return {
            ...item,
            prodQty: quantity,
          };
        }
        return item;
      });

      const newState = {
        ...state,
        cartInfo: updatedItems,
        lastAction: action.payload.lastAction,
        error: null,
        lastUpdated: Date.now(),
        ...calculateTotals(updatedItems),
      };

      // localStorage에 저장
      saveToLocalStorage(newState);
      return newState;
    }

    case MOCK_CART_TYPES.CLEAR_MOCK_CART: {
      const newState = {
        ...state,
        cartInfo: [],
        selectedItems: [], // 선택된 상품들도 초기화
        lastAction: action.payload.lastAction,
        error: null,
        lastUpdated: Date.now(),
        totalQuantity: 0,
        totalPrice: 0,
      };

      // localStorage에 저장
      saveToLocalStorage(newState);
      return newState;
    }

    case MOCK_CART_TYPES.UPDATE_SELECTED_ITEMS: {
      const { selectedItems } = action.payload;

      const newState = {
        ...state,
        selectedItems,
        lastAction: action.payload.lastAction,
        lastUpdated: Date.now(),
      };

      // localStorage에 저장
      saveToLocalStorage(newState);
      return newState;
    }

    default:
      return state;
  }
};