shoptime/com.twin.app.shoptime/src/actions/mockCartActions.js

import { BUYNOW_CONFIG } from '../utils/BuyNowConfig';
import {
  createMockCartListData,
  createMockCartData,
  addMockCartItem,
  removeMockCartItem,
  updateMockCartItemQuantity,
} from '../utils/BuyNowDataManipulator';
import { createDebugHelpers } from '../utils/debug';

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

// Mock Cart Action Types
export const MOCK_CART_TYPES = {
  INIT_MOCK_CART: 'mockCart/INIT_MOCK_CART',
  ADD_TO_MOCK_CART: 'mockCart/ADD_TO_MOCK_CART',
  REMOVE_FROM_MOCK_CART: 'mockCart/REMOVE_FROM_MOCK_CART',
  UPDATE_MOCK_CART_ITEM: 'mockCart/UPDATE_MOCK_CART_ITEM',
  CLEAR_MOCK_CART: 'mockCart/CLEAR_MOCK_CART',
  SET_MOCK_CART_QUANTITY: 'mockCart/SET_MOCK_CART_QUANTITY',
  UPDATE_SELECTED_ITEMS: 'mockCart/UPDATE_SELECTED_ITEMS',
};

/**
 * Mock 장바구니 초기화
 * BuyOption에서 ADD TO CART 시 호출 - 기존 장바구니에 상품 추가
 */
export const initializeMockCart =
  (productData, optionInfo = {}, quantity = 1) =>
  (dispatch, getState) => {
    if (!BUYNOW_CONFIG.isMockMode()) {
      return;
    }

    dlog('[MockCartActions] initializeMockCart - productData:', productData);

    // 기존 장바구니 데이터 확인
    const currentCart = getState().mockCart.cartInfo || [];
    dlog('[MockCartActions] initializeMockCart - current cart items:', currentCart.length);

    // 새 상품 데이터 생성
    const newCartItem = createMockCartData(productData, optionInfo, quantity);

    if (newCartItem) {
      // addToMockCart를 사용하여 기존 장바구니에 상품 추가 (덮어쓰기 방지)
      dispatch(addToMockCart(productData, optionInfo, quantity));
    } else {
      dlog('[MockCartActions] initializeMockCart - Failed to create cart item');
    }
  };

/**
 * Mock 장바구니에 상품 추가
 * @param {Object} productData - 상품 데이터
 * @param {Object} optionInfo - 옵션 정보
 * @param {number} quantity - 수량
 */
export const addToMockCart =
  (productData, optionInfo = {}, quantity = 1) =>
  (dispatch, getState) => {
    if (!BUYNOW_CONFIG.isMockMode()) {
      return;
    }

    dlog('[MockCartActions] addToMockCart - productData:', productData);

    // Mock 장바구니 데이터 생성
    const newCartItem = addMockCartItem(productData, optionInfo, quantity);

    dispatch({
      type: MOCK_CART_TYPES.ADD_TO_MOCK_CART,
      payload: {
        item: newCartItem,
        lastAction: {
          type: 'add',
          data: newCartItem,
          timestamp: Date.now(),
        },
      },
    });
  };

/**
 * Mock 장바구니에서 상품 제거
 * @param {string} prodSno - 상품 고유번호
 */
export const removeFromMockCart = (prodSno) => (dispatch, getState) => {
  if (!BUYNOW_CONFIG.isMockMode()) {
    return;
  }

  dlog('[MockCartActions] removeFromMockCart - prodSno:', prodSno);

  dispatch({
    type: MOCK_CART_TYPES.REMOVE_FROM_MOCK_CART,
    payload: {
      prodSno,
      lastAction: {
        type: 'remove',
        data: { prodSno },
        timestamp: Date.now(),
      },
    },
  });
};

/**
 * Mock 장바구니 상품 수량 업데이트
 * @param {string} prodSno - 상품 고유번호
 * @param {number} quantity - 새로운 수량
 */
export const updateMockCartItem = (prodSno, quantity) => (dispatch, getState) => {
  if (!BUYNOW_CONFIG.isMockMode()) {
    return;
  }

  dlog('[MockCartActions] updateMockCartItem - prodSno:', prodSno, 'quantity:', quantity);

  const updatedItem = updateMockCartItemQuantity(prodSno, quantity);

  dispatch({
    type: MOCK_CART_TYPES.UPDATE_MOCK_CART_ITEM,
    payload: {
      item: updatedItem,
      prodSno,
      quantity,
      lastAction: {
        type: 'update',
        data: { prodSno, quantity },
        timestamp: Date.now(),
      },
    },
  });
};

/**
 * Mock 장바구니 상품 수량 직접 설정
 * @param {string} prodSno - 상품 고유번호
 * @param {number} quantity - 설정할 수량
 */
export const setMockCartItemQuantity = (prodSno, quantity) => (dispatch, getState) => {
  if (!BUYNOW_CONFIG.isMockMode()) {
    return;
  }

  if (quantity <= 0) {
    // 수량이 0이면 상품 제거
    dispatch(removeFromMockCart(prodSno));
    return;
  }

  dlog('[MockCartActions] setMockCartItemQuantity - prodSno:', prodSno, 'quantity:', quantity);

  const updatedItem = updateMockCartItemQuantity(prodSno, quantity);

  dispatch({
    type: MOCK_CART_TYPES.SET_MOCK_CART_QUANTITY,
    payload: {
      item: updatedItem,
      prodSno,
      quantity,
      lastAction: {
        type: 'set_quantity',
        data: { prodSno, quantity },
        timestamp: Date.now(),
      },
    },
  });
};

/**
 * Mock 장바구니 전체 비우기
 */
export const clearMockCart = () => (dispatch, getState) => {
  if (!BUYNOW_CONFIG.isMockMode()) {
    return;
  }

  dlog('[MockCartActions] clearMockCart');

  dispatch({
    type: MOCK_CART_TYPES.CLEAR_MOCK_CART,
    payload: {
      lastAction: {
        type: 'clear',
        timestamp: Date.now(),
      },
    },
  });
};

/**
 * Mock 장바구니 데이터 재설정 (빈 장바구니로 복원)
 */
export const resetMockCart = () => (dispatch, getState) => {
  if (!BUYNOW_CONFIG.isMockMode()) {
    return;
  }

  dlog('[MockCartActions] resetMockCart - Clearing cart to empty');

  // 빈 장바구니로 재설정 (기본 Mock 상품 없음)
  dispatch({
    type: MOCK_CART_TYPES.INIT_MOCK_CART,
    payload: {
      items: [], // 빈 배열로 재설정
      lastAction: {
        type: 'reset',
        timestamp: Date.now(),
      },
    },
  });
};

/**
 * 선택된 상품들 업데이트
 * @param {Array} selectedItems - 선택된 상품들의 prodSno 배열
 */
export const updateSelectedItems = (selectedItems) => (dispatch, getState) => {
  if (!BUYNOW_CONFIG.isMockMode()) {
    return;
  }

  dlog('[MockCartActions] updateSelectedItems - selectedItems:', selectedItems);

  dispatch({
    type: MOCK_CART_TYPES.UPDATE_SELECTED_ITEMS,
    payload: {
      selectedItems,
      lastAction: {
        type: 'update_selected',
        timestamp: Date.now(),
      },
    },
  });
};