package com.style24.core.biz.service;

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.gagaframework.excel.env.GagaExcelConstants;
import com.gagaframework.excel.xssf.GagaExcelResultHandler;
import com.gagaframework.web.parameter.GagaMap;
import com.gagaframework.web.rest.server.GagaResponseStatus;
import com.style24.core.biz.dao.TscNaverPayDao;
import com.style24.core.biz.dao.TscOrderChangeDao;
import com.style24.core.biz.dao.TscOrderDao;
import com.style24.core.biz.dao.TscScmDao;
import com.style24.core.biz.thirdparty.SsgKakaoSender;
import com.style24.core.support.env.TscConstants;
import com.style24.core.support.env.TscConstants.OrderDetailStat;
import com.style24.core.support.message.TscMessageByLocale;
import com.style24.core.support.util.CryptoUtils;
import com.style24.persistence.domain.Order;
import com.style24.persistence.domain.OrderChange;
import com.style24.persistence.domain.Payment;
import com.style24.persistence.domain.Point;
import com.usafe.guarantee.InsuranceManager;

import lombok.extern.slf4j.Slf4j;

/**
 * 주문관리 Service
 *
 * @author jsh77b
 * @since 2020. 11. 16
 */
@Service
@Slf4j
public class TscOrderService {

	@Autowired
	private TscMessageByLocale message;

	@Autowired
	private Environment env;

	@Autowired
	private TscOrderDao orderDao;

	@Autowired
	private TscScmDao scmDao;
	
	@Autowired
	private TscOrderChangeDao orderChangeDao;

	@Autowired
	private TscOrderChangeService orderChangeService;
	
	@Autowired
	private TscPointService pointService;

	@Autowired
	private ObjectMapper mapper;
	
	@Autowired
	private TscKakaotalkService kakaotalkService;

	@Autowired
	private TscNaverPayService naverPayService;

	@Autowired
	private TscNaverPayDao naverPayDao;
	
	@Autowired
	private TscOrderRefundService orderRefundService;
	
	private static final String siteNm = "STYLE24";
	
	@Autowired
	private SsgKakaoSender kakaoSender;

	/**
	 * 주문목록 카운트
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public int getOrderListCount(Order order) {
		return orderDao.getOrderListCount(order);
	}

	/**
	 * 주문목록
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderList(Order order) {
		Collection<Order> orderList = orderDao.getOrderList(order);
		return orderList;
	}

	/**
	 * 주문기본정보
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderInfoList(Order order) {
		return orderDao.getOrderInfoList(order);
	}

	/**
	 * 주문상품정보 목록
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderDetailList(Order order) {
		return orderDao.getOrderDetailList(order);
	}

	/**
	 * 사은품목록
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderFreeGiftList(Order order) {
		return orderDao.getOrderFreeGiftList(order);
	}

	/**
	 * 배송정보
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getDeliveryAddrList(Order order) {
		return orderDao.getDeliveryAddrList(order);
	}

	/**
	 * 결제정보
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderPaymentBasicInfoList(Order order) {
		return orderDao.getOrderPaymentBasicInfoList(order);
	}

	/**
	 * 배송비정보
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getDeliveryFeeList(Order order) {
		return orderDao.getDeliveryFeeList(order);
	}

	/**
	 * 취소/반품/교환 요청 정보
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderChangeList(Order order) {
		return orderDao.getOrderChangeList(order);
	}

	/**
	 * 환불정보
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderRefundInfo(Order order) {
		return orderDao.getOrderRefundInfo(order);
	}

	/**
	 * 상담내역
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderCounselInfo(Order order) {
		return orderDao.getOrderCounselInfo(order);
	}

	/**
	 * 주문요청 관리자 메모 목록 조회
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 18
	 */
	public Collection<Order> getOrderMemoList(Order order) {
		order.setDelYn("N");
		return orderDao.getOrderMemoList(order);
	}

	/**
	 * 입점업체미발주 주문목록
	 * @param Order
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 30
	 */
	public int getOrderSellerUnorderListCount(Order order) {
		return scmDao.getOrderSellerUnorderListCount(order);
	}

	/**
	 * 입점업체미발주 주문목록
	 * @param Order
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2020. 11. 30
	 */
	public Collection<Order> getOrderSellerUnorderList(Order order) {
		return scmDao.getOrderSellerUnorderList(order);
	}

	/**
	 * 입점업체미발주목록 - 엑셀다운로드시 주문상태값 변경(상품준비중)
	 *
	 * @param orderList - 주문 정보
	 * @author jsh77b
	 * @since 2020. 11. 30
	 */
	@Transactional("shopTxnManager")
	public void saveUnorderStatus(Collection<Order> orderList, int userNo) {

		// 1. 임시테이블 삭제
		Order deleteOrder = new Order();
		deleteOrder.setRegNo(userNo);

		for (Order oneData : orderList) {

			Order updateData = new Order();

			updateData.setOrdNo(oneData.getOrdNo());
			updateData.setOrdDtlNo(oneData.getOrdDtlNo());
			updateData.setBrandCd(oneData.getBrandCd());
			updateData.setSupplyCompCd(oneData.getSupplyCompCd());
			updateData.setRegNo(userNo);
			updateData.setUpdNo(userNo);

			// 2. 주문상세상태값 변경
			int result = 0;
			// 20200521 상품준비중, 배송준비중일 경우 엑셀 업로드시에 상품준비중으로 상태 변경 되지 않도록 변경 - xodud1202
			if(TscConstants.OrderDetailStat.PAYMENT_COMPLETE.value().equals(oneData.getOrdDtlStat())) {
				// 2021.05.20
				updateData.setOrdDtlStat(TscConstants.OrderDetailStat.GOODS_PREPARE.value());

				result = scmDao.updateOrderDetailStat(updateData);
				if (result > 0) {
					// 3. 주문상세상태 변경 이력생성
					orderDao.createOrderDetailHst(updateData);

					// 202010419 xodud1202 주문상품상세 상태 변경
					updateData.setOrdDtlStat(TscConstants.OrderDetailStat.GOODS_PREPARE.value());
					scmDao.updateOrderDetailItemStat(updateData);
				}
			}
		}
	}

	/**
	 * 입점업체미발주목록 엑셀다운로드
	 *
	 * @param order - 주문정보
	 * @param excelFilenameWithPath - 경로를 포함한 엑셀파일명
	 * @author jsh77b
	 * @since 2020. 11. 30
	 */
	public void geSellerUnorderExcelList(Order order, String excelFilenameWithPath) {

		// 헤더 title 설정 (27)
		String[] listTitles = {
			  "입점업체"
			, "브랜드"
			, "주문번호"
			, "주문상세번호"
			, "주문상세상태"
			, "주문자명"
			, "주문일시"
			, "결제수단"
			, "주문자휴대전화"
			, "수령자명"
			, "수령자휴대전화"
			, "수령자우편번호"
			, "수령자기본주소"
			, "수령자상세주소"
			, "업체상품코드"
			, "상품코드"
			, "상품명"
			, "사이즈"
			, "옵션"
			, "주문수량"
			, "취소수량"
			, "주문금액"
			, "취소금액"
			, "할인금액"
			, "실결제금액"
			, "배송비"
			, "배송업체코드"
			, "송장번호"
			, "배송메모"
		};

		// DB 처리 시 사용되는 파라미터명(셀명) 설정 (27)
		String[] cellNames = {
			  "supplyCompNm"
			, "brandKnm"
			, "ordNo"
			, "ordDtlNo"
			, "ordDtlStatNm"
			, "ordNm"
			, "ordDt"
			, "payMeansNm"
			, "ordPhnno"
			, "recipNm"
			, "recipPhnno"
			, "recipZipcode"
			, "recipBaseAddr"
			, "recipDtlAddr"
			, "supplyGoodsCd"
			, "goodsCd"
			, "goodsNm"
			, "optCd2"
			, "opt"
			, "ordQty"
			, "cnclRtnQty"
			, "ordAmt"
			, "cnclRtnAmt"
			, "totDcAmt"
			, "realOrdAmt"
			, "realDelvAmt"
			, "shipCompCd"
			, "invoiceNo"
			, "delvMemo"
		};

		String[] cellTypes = {
			  GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
			, GagaExcelConstants.CellType.CHAR_CENTER.name()
		};

		GagaExcelResultHandler<Order> handler = new GagaExcelResultHandler<>(excelFilenameWithPath, "출고배송목록(입점)", listTitles, cellNames, cellTypes);

		scmDao.getSellerUnorderList(order, handler);

		handler.close();
	}

	/**
	 * 입점업체미발주목록 - 송장번호 입력(출고완료)
	 *
	 * @param orderList - 주문 정보
	 * @return String - 결과메시지
	 * @author jsh77b
	 * @since 2020. 11. 30
	 */
	@Transactional("shopTxnManager")
	public String saveUnorderInvoice(Collection<Order> orderList, int userNo) {
		String resultMsg;
		int totalCount 			= 0;	// 전체 카운트
		int failedCount 		= 0;	// 몰 실패 카운트
		int successCount 		= 0;	// 몰 성공 카운트
		String failedGoodCdStr 	= "";	// 실패 상품 리스트

		// 1. 송장번호 등록 대상 목록 처리
		for (Order oneData : orderList) {

			// 2. 송장번호, 업체코드 체크
			if (!StringUtils.isEmpty(oneData.getInvoiceNo()) && !StringUtils.isEmpty(oneData.getShipCompCd())) {
				totalCount++;

				Order updateData = new Order();
				updateData.setOrdNo(oneData.getOrdNo());
				updateData.setOrdDtlNo(oneData.getOrdDtlNo());
				updateData.setBrandCd(oneData.getBrandCd());
				updateData.setSupplyCompCd(oneData.getSupplyCompCd());
				updateData.setRegNo(userNo);
				updateData.setUpdNo(userNo);
				updateData.setGoodsCd(oneData.getGoodsCd());
				updateData.setOptCd2(oneData.getOptCd2());
				updateData.setOrdQty(oneData.getOrdQty());
				updateData.setShipCompCd(oneData.getShipCompCd());
				updateData.setInvoiceNo(oneData.getInvoiceNo().replace("-", ""));

				// 3. 원주문 상세정보 조회
				// 2020.12.15 세트상품의 경우에는 2개 이상의 row 가 표시됨 (주문상세번호 + 상풐코드로 + 사이즈코드) 변경
				Order orgOrder = scmDao.getOrderDetailInfo(oneData);
				if (orgOrder == null) {
					failedGoodCdStr += updateData.getGoodsCd() + " /  " + updateData.getOptCd2() + "(Error1)\n"; // 상품정보 (상품명 + 칼라명) / 사이즈코드
					failedCount++;
					continue;
				}

				// 4. 상품코드, 사이즈, 주문수량 체크
				if (!orgOrder.getGoodsCd().equals(updateData.getGoodsCd()) || !orgOrder.getOptCd2().equals(updateData.getOptCd2()) || orgOrder.getOrdQty() - orgOrder.getCnclRtnQty() != updateData.getOrdQty()) {
					failedGoodCdStr += updateData.getGoodsCd() + " /  " + updateData.getOptCd2() + "(Error2)\n";
					failedCount++;
					continue;
				}

				// 20200521 입점 발주 확정(결품취소, 배송중처리 완료 상품) 체크 > 발주 확정 전 데이터만 송장번호 변경 가능 - xodud1202
				if(TscConstants.OrderDetailStat.SHIPPING.value().equals(orgOrder.getOrdDtlStat())) {
					failedGoodCdStr += updateData.getGoodsCd() + " /  " + updateData.getOptCd2() + "(발주확정상품)\n";
					failedCount++;
					continue;
				}

				// 5. 업체코드, 상태값 설정
				updateData.setOrdDtlStat(TscConstants.OrderDetailStat.DELIVERY_PREPARE.value());
				updateData.setSupplyCompCd(orgOrder.getSupplyCompCd());

				// 6. 송장번호등록
				int result = scmDao.updateOrderDetailInvoice(updateData);

				// 7. 주문상세상태 변경 이력 등록
				if (result > 0) {
					successCount++;
					updateData.setOrdDtlStat(TscConstants.OrderDetailStat.DELIVERY_PREPARE.value());
					scmDao.updateOrderDetailItemStat(updateData);
					orderDao.createOrderDetailHst(updateData);
				} else {
					failedGoodCdStr += updateData.getGoodsCd() + " /  " + updateData.getOptCd2() + "(Error3)\n";
					failedCount++;
				}
			}
		}

		resultMsg = "배송준비중 : " + totalCount + "건 / 실패 : " + failedCount + "건 / 성공 : " + successCount + "건 \n" + "실패 목록 : " + failedGoodCdStr;

		return resultMsg;
	}

	/**
	 * 주문상세 > 주문요청 관리자 메모 > 메모정보조회
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	public Order getOrderMemoInfo(Order order) {
		return orderDao.getOrderMemoInfo(order);
	}

	/**
	 * 주문상세 > 주문요청 관리자 메모 > 메모등록
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	@Transactional("shopTxnManager")
	public void createOrderMemo(Order order) {
		orderDao.createOrderMemo(order);
	}

	/**
	 * 주문상세 > 주문요청 관리자 메모 > 메모수정
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	public void updateOrderMemo(Order order) {
		orderDao.updateOrderMemo(order);
	}

	/**
	 * 주문상세 > 주문요청 관리자 메모 > 메모삭제
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	@Transactional("shopTxnManager")
	public void deleteOrderMemo(Order order) {
		orderDao.deleteOrderMemo(order);
	}

	/**
	 * 주문상품 상세 변경 이력 화면
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	public Collection<Order> getOrderDetailHistoryList(Order order) {
		return orderDao.getOrderDetailHistoryList(order);
	}

	/**
	 * 쿠폰사용 내역 팝업 화면
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	public Collection<Order> getOrderDiscountCouponList(Order order) {
		return orderDao.getOrderDiscountCouponList(order);
	}

	/**
	 * 포인트사용 내역 팝업 화면
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	public Collection<Order> getOrderDiscountPointList(Order order) {
		return orderDao.getOrderDiscountPointList(order);
	}

	/**
	 * 상품권사용 내역 팝업 화면
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	public Collection<Order> getOrderGiftcardHstList(Order order) {
		return orderDao.getOrderGiftcardHstList(order);
	}

	/**
	 * 다다익선적용 내역 팝업 화면
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	public Collection<Order> getOrderTmtbHstList(Order order) {
		return orderDao.getOrderTmtbHstList(order);
	}

	/**
	 * 주문상세상태를 변경
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2020. 12. 16
	 */
	@Transactional("shopTxnManager")
	public void changedOrdDtlStat(Order order) {
		
		// 1. 주문상세상태변경
		int resultInt = orderDao.changedOrdDtlStat(order);
		
		// 2. 주문상세상태변경 성공 후 주문상세 이력을 등록
		if (resultInt > 0) {
			orderDao.createOrderDetailHst(order);
		}
		
		resultInt = orderDao.changedOrdDtlStat2(order);
		
		// 2021.04.30 결제완료 일때 TB_PAYMENT 상태값 결제성공 업데이트
		if ("G013_20".equals(order.getOrdDtlStat())) {
			orderDao.changedPayStat(order);
		}
	}
	
	/**
	 * 배송 > 배송지 정보 수정
	 *
	 * @param Order - 배송지 정보
	 * @author jsh77b
	 * @since 2021. 01. 15
	 */
	@Transactional("shopTxnManager")
	public void updateOrderAddr(Order order) {
		orderDao.updateOrderAddr(order);
	}
	
	/**
	 * 반품/교환 > 회수지 정보 수정
	 *
	 * @param Order - 배송지 정보
	 * @author jsh77b
	 * @since 2021. 01. 18
	 */
	@Transactional("shopTxnManager")
	public void updateOrderChange(Order order) {
		orderDao.updateOrderChange(order);
	}

	/**
	 * 장바구니 상품 목록 조회 (업체별 배송단위)
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public Collection<Order> getCartGoodsList(Order order) {
		return orderDao.getCartGoodsList(order);
	}
	
	/**
	 * 고객정보 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public Order getCustemerInfo(Order order) {
		return orderDao.getCustemerInfo(order);
	}
	
	/**
	 * 회원 배송지목록 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public Collection<Order> getDeliveryAddrInfo(Order order) {
		return orderDao.getDeliveryAddrInfo(order);
	}
	
	/**
	 * 회원 배송지정보 수정
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	@Transactional("shopTxnManager")
	public void updateCustDeliveryAddr(Order order) {
		
		// 기본배송지로 설정되면 기존의 기본배송지 정보는 N 처리
		if ("Y".equals(order.getDefaultYn())) {
			orderDao.updateCustDeliveryAddrDefaultYn(order);
		}
		
		// 배송지등록
		orderDao.updateCustDeliveryAddr(order);
	}
	
	/**
	 * 회원 배송지정보 등록
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	@Transactional("shopTxnManager")
	public void createCustDeliveryAddr(Order order) {
		
		// 기본배송지로 설정되면 기존의 기본배송지 정보는 N 처리
		if ("Y".equals(order.getDefaultYn())) {
			orderDao.updateCustDeliveryAddrDefaultYn(order);
		}
		
		// 배송지등록
		orderDao.createCustDeliveryAddr(order);
	}

	/**
	 * 포인트정보 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public int getCustPointInfo(Order order) {
		return orderDao.getCustPointInfo(order);
	}
	
	/**
	 * 상품권정보 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public int getGiftcardInfo(Order order) {
		return orderDao.getGiftcardInfo(order);
	}
	
	/**
	 * 포인트사용 기준정보 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 04. 29
	 */	
	public Order getPointUseEnvset() {
		return orderDao.getPointUseEnvset();
	}

	/**
	 * 쿠폰정보 조회
	 *
	 * @param Order
	 * @author card007
	 * @since 2021. 02. 09
	 */
	public int getCouponInfo(Order order) {
		return orderDao.getCouponInfo(order);
	}
	
	/**
	 * 상품쿠폰, 장바구니쿠폰 적용 상품 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public GagaMap getGoodsCartCpnApplyGoodsList(Order order) {
		
		GagaMap resultMap = new GagaMap();
		
		Collection<Order> goodsCartCpnApplyList = orderDao.getGoodsCartCpnApplyGoodsList(order);
		
		Collection<Order> goodsCpnList 	= new ArrayList<Order>();
		Collection<Order> cartCpnList 	= new ArrayList<Order>();
		Collection<Order> cartCpnIdList	= new ArrayList<Order>();
		
		if (goodsCartCpnApplyList.size() > 0) {
			for (Order goodsCartCpnApply : goodsCartCpnApplyList) {
				// 상품쿠폰목록
				if ("G230_11".equals(goodsCartCpnApply.getCpnType())) {
					goodsCpnList.add(goodsCartCpnApply);
				}
				// 장바구니쿠폰목록
				else if ("G230_20".equals(goodsCartCpnApply.getCpnType())) {
					// 2021.03.20 장바구니쿠폰 결제가능수단목록조회
					order.setCpnId(goodsCartCpnApply.getCpnId());
					String[] payTypeArr = orderDao.getCartCpnPaytypeList(order);
					goodsCartCpnApply.setPayTypeArr(payTypeArr);
					
					// 쿠폰시퀀스가 중복 없을때 적용
					cartCpnList.add(goodsCartCpnApply);
					
					Boolean temp = true;
					
					// 2021.09.03 중복쿠폰제거하고 장바구니쿠폰 목록만 만들기
					if (cartCpnIdList.size() > 0) {
						for (Order cartCpn : cartCpnIdList) {
							if (goodsCartCpnApply.getCpnId().equals(cartCpn.getCpnId())) {
								temp = false;
							}
						}
					}
					
					if (temp) {
						cartCpnIdList.add(goodsCartCpnApply);
					}
				}
			}
		}
		
		resultMap.set("goodsCpnList"	, goodsCpnList);
		resultMap.set("cartCpnList"		, cartCpnList);
		resultMap.set("cartCpnIdList"	, cartCpnIdList);
		
		return resultMap;
	}
	
	/**
	 * 배송비쿠폰 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public Collection<Order> getDelvCpnList(Order order) {
		return orderDao.getDelvCpnList(order);
	}
	
	/**
	 * 상품단위 상품쿠폰 등록 
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */
	public Collection<Order> getGoodsCpnApplyList(Collection<Order> tmtbGoodsApplyList, Collection<Order> goodsCpnAllList) {
		Collection<Order> goodsApplyCpnList = new ArrayList<Order>();
		
		Boolean temp = true;
		int cpnDcAmt = 0;
		
		// 1. 쿠폰대상이 있는 상품만 정리
		for (Order tmtbGoods : tmtbGoodsApplyList) {
			List<Order> goodsCpnList = new ArrayList<Order>();
			
			for (Order goodsCpnAll : goodsCpnAllList) {
				// 2. 적용상풒 전체(A) or 상품코드 같을때 담기
				if ("A".equals(goodsCpnAll.getApplyScope()) || tmtbGoods.getGoodsCd().equals(goodsCpnAll.getGoodsCd())) {
					temp = true;
					
					// 3. 상품쿠폰목록에 담긴 상풐은 제외
					for (Order goodsCpnApply : goodsCpnList) {
						/*
						if (goodsCpnAll.getCpnId().equals(goodsCpnApply.getCpnId())) {
							temp = false;
						}
						*/
						
						// 2021.09.03 중복쿠폰 CPN_ID 제거 대신 회원보유쿠폰 시퀀스 중복 체크로 변경
						if (goodsCpnAll.getCustCpnSq().equals(goodsCpnApply.getCustCpnSq())) {
							temp = false;
						}
					}
					
					// 4. 상품쿠폰목록에 담기 가능 상품 담기
					if (temp) {
						Order goodsCpn = new Order();
						goodsCpn.setCpnId(goodsCpnAll.getCpnId());
						goodsCpn.setGoodsCd(tmtbGoods.getGoodsCd());
						goodsCpn.setCpnNm(goodsCpnAll.getCpnNm());
						goodsCpn.setCustCpnSq(goodsCpnAll.getCustCpnSq());
						goodsCpn.setMaxDcAmt(goodsCpnAll.getMaxDcAmt());
						goodsCpn.setMinOrdAmt(goodsCpnAll.getMinOrdAmt());
						goodsCpn.setBuyLimitAmt(goodsCpnAll.getBuyLimitAmt());
						goodsCpn.setDcWay(goodsCpnAll.getDcWay());
						goodsCpn.setDcVal(goodsCpnAll.getDcVal());
						
						// 5. 할인방식 금액, 율 판단 
						// 할인금액 (G240_10)
						if ("G240_10".equals(goodsCpnAll.getDcWay())) {
							goodsCpn.setCpnDcAmt(goodsCpnAll.getDcVal());
						}
						// 할인율 (G240_11)
						else {
							// 6. 할인율 일때 최대금액 판단으로 할인금액 등록
							if (tmtbGoods.getTmtbDcAmt() > 0) {
								cpnDcAmt = (tmtbGoods.getTmtbDcAmt() * goodsCpnAll.getDcVal()) / 100;
							} else {
								cpnDcAmt = (((tmtbGoods.getCurrPrice() + tmtbGoods.getOptAddPrice()) * tmtbGoods.getGoodsQty()) * goodsCpnAll.getDcVal()) / 100;
							}
							
							// 7. 할인금액 최대값보다 작으면 적용 or getMaxDcAmt( == 0 이면 무제한
							if (goodsCpnAll.getMaxDcAmt() > cpnDcAmt || goodsCpnAll.getMaxDcAmt() == 0) {
								goodsCpn.setCpnDcAmt(cpnDcAmt);
							} else {
								goodsCpn.setCpnDcAmt(goodsCpnAll.getMaxDcAmt());
							}
						}
						
						// 2021.05.11 오류수정 수량계산
						int ordAmt = 0;
						
						// 오류수정 수량계산
						if (tmtbGoods.getTmtbDcAmt() > 0) {
							ordAmt = tmtbGoods.getTmtbDcAmt();
						} else {
							ordAmt = (tmtbGoods.getCurrPrice() + tmtbGoods.getOptAddPrice()) * tmtbGoods.getGoodsQty();
						}

						// 8. 주문최소주문금액 보다 크면 쿠폰 적용
						if (ordAmt > goodsCpn.getBuyLimitAmt()) {
							goodsCpnList.add(goodsCpn);
						}
					}
				}
			}
			
			// 쿠폰할인금액이 높은순으로 정렬 함수 
			goodsCpnList = getListSort(goodsCpnList);
			
			tmtbGoods.setGoodsCpnList(goodsCpnList);
			
			// 상품쿠폰이 있으면 상품담기
			if (goodsCpnList.size() > 0) {
				goodsApplyCpnList.add(tmtbGoods);
			}
		}
		
		return goodsApplyCpnList;
	}
	
	/**
	 * 장바구니쿠폰단위 상품 등록 
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */
	public Collection<Order> getCartCpnApplyList(Collection<Order> tmtbGoodsApplyList, Collection<Order> cartCpnAllList
			, Collection<Order> cartCpnIdList) {
		
		List<Order> cartApplyCpnList = new ArrayList<Order>();
		
		// 1. 쿠폰대상이 있는 상품만 정리
		
		// 1. 장바구니쿠폰 ID 목록
		for (Order cartCpnId : cartCpnIdList) {
			int cpnDcAmt 			= 0;
			int ordAmtSum  			= 0;
			List<Integer> result 	= new ArrayList<>();
			List<Integer> dataList 	= new ArrayList<>();
			Boolean temp			= true;
			
			// 2. 장바구니쿠폰 상품 연결 확인 목록
			for (Order cartCpn : cartCpnAllList) {
				// 3. 쿠폰 ID 기준으로 데이타 체크
				if (cartCpnId.getCpnId().equals(cartCpn.getCpnId())) {
				//if (cartCpnId.getCustCpnSq().equals(cartCpn.getCustCpnSq())) {
					
					for (Order tmtbGoods : tmtbGoodsApplyList) {
						if ("A".equals(cartCpn.getApplyScope()) || tmtbGoods.getGoodsCd().equals(cartCpn.getGoodsCd())) {
							
							// 2021.09.07 장바구니쿠폰 오류 수정 
							if (tmtbGoods.getCartSq() > 0) {
								dataList.add(tmtbGoods.getCartSq());
							}
							
							// 3.1 최소주문금액을 체크를 위한 해당 상품 주문금액 합계
							if (tmtbGoods.getTmtbDcAmt() > 0) {
								ordAmtSum = ordAmtSum + tmtbGoods.getTmtbDcAmt();
							} else {
								ordAmtSum = ordAmtSum + ((tmtbGoods.getCurrPrice() + tmtbGoods.getOptAddPrice()) * tmtbGoods.getGoodsQty());
							}

							// 3.2 할인율 일때 최대금액 판단으로 할인금액 등록
							if ("G240_11".equals(cartCpn.getDcWay())) {
								if (tmtbGoods.getTmtbDcAmt() > 0) {
									cpnDcAmt = cpnDcAmt + (tmtbGoods.getTmtbDcAmt() * cartCpn.getDcVal()) / 100;
								} else {
									cpnDcAmt = cpnDcAmt + (((tmtbGoods.getCurrPrice() + tmtbGoods.getOptAddPrice()) * tmtbGoods.getGoodsQty()) * cartCpn.getDcVal()) / 100;
								}
							}
						}
					}
					
					if ("G240_10".equals(cartCpn.getDcWay())) {
						cpnDcAmt = cartCpn.getDcVal();
					}
				}
			}
			
			// 7. 할인금액 최대값보다 작으면 적용 or getMaxDcAmt( == 0 이면 무제한
			if (cartCpnId.getMaxDcAmt() > cpnDcAmt || cartCpnId.getMaxDcAmt() == 0) {
				cartCpnId.setCpnDcAmt(cpnDcAmt);
			} else {
				cartCpnId.setCpnDcAmt(cartCpnId.getMaxDcAmt());
			}
			
			// 최소금액주문이상일때 쿠폰사용불가
			if (cartCpnId.getBuyLimitAmt() > ordAmtSum) {
				cartCpnId.setCartCpnCartSqArr(null);
			} else {
				// 2021.09.07 장바구니쿠폰 오류 수정 
				result 						= dataList.stream().distinct().collect(Collectors.toList());
				int [] cartCpnCartSqArr 	= result.stream().mapToInt(Integer::intValue).toArray();

				cartCpnId.setCartCpnCartSqArr(cartCpnCartSqArr);
				
				temp = true;
				// 2021.05.16 중복쿠폰제거
				for (int j=0 ; j<cartApplyCpnList.size() ; j++) {
					Order cartCpn1 = cartApplyCpnList.get(j);
					if (cartCpn1.getCustCpnSq().equals(cartCpnId.getCustCpnSq())) {
						temp = false;
					}
				}
				if (temp) {
					cartApplyCpnList.add(cartCpnId);
				}
			}
		}
		
		// 쿠폰할인금액이 높은순으로 정렬 함수 
		cartApplyCpnList = getListSort(cartApplyCpnList);
		
		return cartApplyCpnList;
	}
	
	/**
	 * 배송비쿠폰단위 상품 등록 
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */
	public Collection<Order> getDelvCpnApplyList(Collection<Order> delvFeeCdList, Collection<Order> delvCpnAllList) {
		
		List<Order> delvApplyCpnList = new ArrayList<Order>();
		
		// 배송비가 있으면 배송업체코드, 배송비 배송비쿠폰에 설정
		for (Order delvCpn : delvCpnAllList) {
			for (Order delvFeeCd : delvFeeCdList) {
				if (delvFeeCd.getDelvFee() > 0) {
					delvCpn.setDelvFee(delvFeeCd.getDelvFee());
					delvCpn.setDelvFeeCd(delvFeeCd.getDelvFeeCd());
					
					int delvCpnDcAmt 	= delvCpn.getDcVal();
					int delvFee 		= delvFeeCd.getDelvFee();
					int cpnDcAmt		= 0;
					
					// 배송비가 배송비쿠폰할인금액보다 클경우 배송비 - 배송비쿠폰할인금액을 적용
					if (delvFee > delvCpnDcAmt) {
						cpnDcAmt = delvCpnDcAmt;
					} else {
						cpnDcAmt = delvFee;
					}
					
					delvCpn.setCpnDcAmt(cpnDcAmt);
				}
			}
			
			if (delvCpn.getCpnDcAmt() > 0) {
				delvApplyCpnList.add(delvCpn);
			}
		}
		
		// 쿠폰할인금액이 높은순으로 정렬 함수 
		delvApplyCpnList = getListSort(delvApplyCpnList);
		
		return delvApplyCpnList;
	}
	
	// 쿠폰할인금액이 높은순으로 정렬 함수
	private List<Order> getListSort(List<Order> goodsCpnList) {
		int cnt 			= 0;
		int sameCnt 		= 0;
		
		List<Order> goodsCpnSortList = new ArrayList<Order>();
		goodsCpnSortList.addAll(goodsCpnList);
		
		// 1. 쿠폰할인금액 순으로 정렬
		for (int i=0 ; i<goodsCpnList.size() ; i++) {
			Order tempCpn1 = goodsCpnList.get(i);
			
			cnt 	= 0;
			sameCnt = 0;
			
			// 2. 몇번째로 큰 할인금액 인지 판단
			for (int j=0 ; j<goodsCpnList.size() ; j++) {
				Order tempCpn2 = goodsCpnList.get(j);
				
				if (tempCpn1.getCpnDcAmt() == tempCpn2.getCpnDcAmt() && i <= j) {
					sameCnt++;
				}
				
				if (tempCpn1.getCpnDcAmt() < tempCpn2.getCpnDcAmt()) {
					cnt++;
				}
			}
			
			if (sameCnt > 0) {
				cnt = cnt + (sameCnt - 1);
			}
			
			goodsCpnSortList.set(cnt, tempCpn1);
		}
		
		return goodsCpnSortList;
	}
	
	/**
	 * 배송단위별 장바구니 상품 건수 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public GagaMap getGoodsDcAmt(Collection<Order> tmtbGoodsApplyList) {
		
		GagaMap resultMap = new GagaMap();
		
		int listSumAmt		= 0;
		int orgGoodsSumAmt	= 0;
		int goodsDcSumAmt	= 0;
		int currGoodsSumAmt	= 0;
		int tmtbDcSumAmt 	= 0;
		int cpn1DcSumAmt	= 0;
		int prePntDcAmt 	= 0;
		int savePntSumAmt 	= 0;

		// 상품금액, 배송비, 할인금액, 다다익선할인금액, 쿠폰할인금액, 선포인트사용, 포인트사용, 상품권사용
		for (Order tmtbGoodsApply : tmtbGoodsApplyList) {
			listSumAmt			= listSumAmt + ((tmtbGoodsApply.getListPrice() + tmtbGoodsApply.getOptAddPrice()) * tmtbGoodsApply.getGoodsQty());			// 상품가(정상가)
			orgGoodsSumAmt 		= orgGoodsSumAmt + ((tmtbGoodsApply.getOrgCurrPrice() + tmtbGoodsApply.getOptAddPrice()) * tmtbGoodsApply.getGoodsQty());	// 상품가
			currGoodsSumAmt 	= currGoodsSumAmt + ((tmtbGoodsApply.getCurrPrice() + tmtbGoodsApply.getOptAddPrice()) * tmtbGoodsApply.getGoodsQty());		// 즉시할인상품가			
			savePntSumAmt		= savePntSumAmt + tmtbGoodsApply.getSavePntAmt();																			// 적립에정포인트

			// 다다익선 할인금액이 있을때 적용
			if (tmtbGoodsApply.getTmtbDcAmt() > 0) {
				tmtbDcSumAmt = tmtbDcSumAmt + (((tmtbGoodsApply.getCurrPrice() + tmtbGoodsApply.getOptAddPrice()) * tmtbGoodsApply.getGoodsQty()) - tmtbGoodsApply.getTmtbDcAmt());
			}
			
			// 선포인트 사용가능 금액
			prePntDcAmt 		= prePntDcAmt + tmtbGoodsApply.getPrePntDcAmt();
		}
		
		goodsDcSumAmt		= listSumAmt - orgGoodsSumAmt;																									// 즉시할인금액
		cpn1DcSumAmt		= orgGoodsSumAmt - currGoodsSumAmt;																									// 즉시할인금액
		
		resultMap.set("listSumAmt"			, listSumAmt);
		resultMap.set("orgGoodsSumAmt"		, orgGoodsSumAmt);
		resultMap.set("goodsDcSumAmt"		, goodsDcSumAmt);
		resultMap.set("cpn1DcSumAmt"		, cpn1DcSumAmt);
		resultMap.set("tmtbDcSumAmt"		, tmtbDcSumAmt);
		resultMap.set("prePntDcAmt"			, prePntDcAmt);
		resultMap.set("savePntSumAmt"		, savePntSumAmt);
		
		return resultMap;
	}
	
	/**
	 * 배송단위별 장바구니 상품 건수 조회
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public GagaMap getCartDelvGoodsCntList(Collection<Order> cartGoodsList, Order orderInfo) {
		
		// 1. 장바구니 상품 배송단위별 건수 체크 로직 (자사:총알배송, 자사:일반배송, 입점업체, 예약배송)
		GagaMap resultMap = new GagaMap();
		
		int shotCnt				= 0; // 자사총알배송 건수
		int wmsCnt 				= 0; // 자사일반배송 건수
		int shotWmsCnt 			= 0; // 자사총알,일반배송 건수
		int resCnt 				= 0; // 자사예약배송 건수
		int delvCnt 			= 0; // 업체직배송 건수
		int delvFeeCdCnt 		= 0; // 배송정책단위 총 건수
		int goodsTotCnt			= 0; // 상품 총 건수
		
		String foreignBuyYn 	= "N"; // 해외구매대행여부
		String orderMadeYn 		= "N"; // 주문제작상품여부
		
		Collection<Order> shotCartList 						= (Collection<Order>)new ArrayList();					// 자사 총알배송
		Collection<Order> wmsCartList 						= (Collection<Order>)new ArrayList();					// 자사 일반배송
		Collection<Order> shotWmsCartList 					= (Collection<Order>)new ArrayList();					// 자사 총알,일반배송
		Collection<Order> resCartList 						= (Collection<Order>)new ArrayList();					// 자사 예약배송
		Collection<Order> delvCartList 						= (Collection<Order>)new ArrayList();					// 입점 일반배송
		Collection<Collection<Order>> delvAllCartList 		= (Collection<Collection<Order>>)new ArrayList();		// 배송전체목록
		
		List<Order> delvFeeCdList 		= (ArrayList<Order>)new ArrayList();										// 배송업체단위목록
		int ordAmt 						= 0; // 주문금액
		int sumOrdAmt 					= 0; // 배송단위 주문합계금액
		int sumDelvFee					= 0; // 전체배송금액
		
		for (Order order : cartGoodsList) {
			// 1.1 세트상품 옵션별 배열로 담기
			if (order.getItemNm().contains("!@!")) {
				order.setItemNmArr(order.getItemNm().split("!@!"));
				order.setOptCdArr(order.getOptCd().split(","));
				order.setItemQtyArr(order.getItemQtyr().split(","));
				order.setOptCd1Arr(order.getOptCd1().split(","));
				order.setOptCd2Arr(order.getOptCd2().split(","));
				order.setColorNmArr(order.getColorNm().split(","));
			} else {
				String[] arr = {order.getItemNm()}, arr2 = {order.getOptCd1()}, arr3 = {order.getOptCd2()}, arr4 = {order.getItemQtyr()}, arr5 = {order.getColorNm()};
				order.setItemNmArr(arr);
				order.setOptCd1Arr(arr2);
				order.setOptCd2Arr(arr3);
				order.setItemQtyArr(arr4);
				order.setColorNmArr(arr5);
			}
			
			// 1.2 즉시할인 적용가 * 주문수량(장바구니수량)
			
			// 1.3 배송정책별 상품 구분
			// 1.3.1 자사총알배송
			if ("SHOT".equals(order.getResDelvFeeCd())) {
				shotCartList.add(order);
				shotCnt++;
			}
			// 1.3.2 자사일반배송
			else if ("WMS".equals(order.getResDelvFeeCd())) {
				wmsCartList.add(order);
				wmsCnt++;
			} 
			// 1.3.2 자사예약배송
			else if ("RES".equals(order.getResDelvFeeCd())) {
				resCartList.add(order);
				
				// 2021.05.26 예약배송 상품코드기준으로 묶기
				int cnt = 0;
				if (resCartList.size() > 0) {
					for (Order resCart : resCartList) {
						if (order.getGoodsCd().equals(resCart.getGoodsCd())) {
							cnt++;
						}
					}
				}
				
				if (cnt < 2) {
					resCnt++;
				}
			} 
			// 1.3.3 입점업체일반배송
			else {
				delvCartList.add(order);
				delvCnt++;
			}
			
			goodsTotCnt++;
			
			// 1.4 배송단위별 배송비 설정
			// 1.4.1 즉시할인쿠폰금액 2021.05.16
			ordAmt = ((order.getCurrPrice() + order.getOptAddPrice()) * order.getGoodsQty());
			order.setOrdAmt(ordAmt);

			Boolean temp = true;

			// 1.4.1 업체별 배송비 합계
			if (delvFeeCdList.size() > 0) {
				for (int i=0 ; i<delvFeeCdList.size() ; i++) {
					Order delvFeeCdObj = delvFeeCdList.get(i);
					
					// 1.4.2 업체코드가 같으면 SUM
					if (delvFeeCdObj.getDelvFeeCd().equals(order.getDelvFeeCd())) {
						sumOrdAmt = delvFeeCdObj.getSumOrdAmt() + ordAmt;
						delvFeeCdObj.setSumOrdAmt(sumOrdAmt);
						temp = false;
					}
				}
				
				if (temp) {
					order.setSumOrdAmt(ordAmt);
					delvFeeCdList.add(order);
				}
			}
			// 1.4.2 최초등록이면 ADD
			else {
				order.setSumOrdAmt(ordAmt);
				delvFeeCdList.add(order);
			}
			
			// 1.5 해외구매대행여부체크
			if ("Y".equals(order.getForeignBuyYn())) {
				foreignBuyYn = "Y";
			}
			
			// 1.6 주문제작여부체크
			if ("Y".equals(order.getOrderMadeYn())) {
				orderMadeYn = "Y";
			}
		}
		
		delvCnt = 0;
		
		// 배송비
		for (int i=0 ; i<delvFeeCdList.size() ; i++) {
			Order delvFeeCdObj = delvFeeCdList.get(i);
			
			// 배송정책별 무료배송비 체크
			if (delvFeeCdObj.getSumOrdAmt() >= delvFeeCdObj.getMinOrdAmt() ) {
				delvFeeCdObj.setDelvFee(0);
			} else {
				delvFeeCdObj.setDelvFee(delvFeeCdObj.getDelvFee());
				sumDelvFee += delvFeeCdObj.getDelvFee();
			}
			
			if (!"WMS".equals(delvFeeCdObj.getDelvFeeCd())) {
				delvCnt++;
			}
		}
		
		// 입점업체건수 적용
		delvFeeCdCnt = delvCnt + resCnt;
		
		if ("Y".equals(orderInfo.getShotDelvYn())) {
			// 자사총알배송건수 추가
			if (shotCnt > 0) {
				delvFeeCdCnt++;
			}
			
			// 자사일반배송건수 1추가
			if (wmsCnt > 0) {
				delvFeeCdCnt++;
			}
		} else {
			// 자사총알배송건수 추가 || 자사일반배송건수 1추가
			if (shotCnt > 0 || wmsCnt > 0) {
				delvFeeCdCnt++;
			}
		}
		
		// 자사예약배송건수 1추가
		//if (resCnt > 0) {
			//delvFeeCdCnt++;
		//}
		
		shotWmsCnt = shotCnt + wmsCnt;
		
		// 총알배송, 일반배송 
		shotWmsCartList.addAll(shotCartList);
		shotWmsCartList.addAll(wmsCartList);
		
		// 전체배송정보
		// 총알배송일때 배송정보 목록 분기처리
		if ("Y".equals(orderInfo.getShotDelvYn())) {
			delvAllCartList.add(shotCartList);						// index 0
			delvAllCartList.add(wmsCartList);						// index 1
		} else {
			// 배송카운트(총알배송 + 일반배송)
			shotCnt 		= 0;
			wmsCnt 			= shotWmsCnt;
			
			delvAllCartList.add(null);								// index 0
			delvAllCartList.add(shotWmsCartList);					// index 1
		}
		
		delvAllCartList.add(delvCartList);							// index 4
		delvAllCartList.add(resCartList);							// index 5
		
		// 2021.04.29 자사일반배송, 자사총알배송 1건씩표현
		if (shotCnt > 0) {
			shotCnt = 1;
		}
		
		if (wmsCnt > 0) {
			wmsCnt = 1;
		}
		
		resultMap.set("delvFeeCdCnt"		, delvFeeCdCnt);		// 배송타입건수
		resultMap.set("shotCnt"				, shotCnt);				// 자사몰 총알배송건수
		resultMap.set("wmsCnt"				, wmsCnt);				// 자사몰 일반배송건수(총알배송불가)
		resultMap.set("shotWmsCnt"			, shotWmsCnt);			// 자사몰 총알,일반배송건수(총알배송불가)
		resultMap.set("resCnt"				, resCnt);				// 자사몰 예약배송건수
		resultMap.set("delvCnt"				, delvCnt);				// 입점업체 배송건수
		
		resultMap.set("goodsTotCnt"			, goodsTotCnt);			// 전체상품건수
		resultMap.set("delvAllCartList"		, delvAllCartList);		// 전체배송단위목록 sort
		
		resultMap.set("sumDelvFee"			, sumDelvFee);			// 배송비합계
		resultMap.set("delvFeeCdList"		, delvFeeCdList);		// 배송업체목록
		
		resultMap.set("foreignBuyYn"		, foreignBuyYn);		// 해외구매대행여부
		resultMap.set("orderMadeYn"			, orderMadeYn);			// 주문제작여부
		
		return resultMap;
	}
	
	/**
	 * 총알배송가능 지역, 총알배송 가능 시간 체크
	 *
	 * @param Order
	 * @author jsh77b
	 * @since 2021. 02. 02
	 */	
	public int getDailyDeliveryCheck(Order order) {
		
		int rtn = 0;
		
		// 1. 총알배송 가능 시간 체크
		if (orderDao.getDailyDeliveryTimeInfo() > 0) {
			// 2. 총알배송 가능 지역 제크
			if (StringUtils.isEmpty(order.getRecipZipcode())) {
				rtn = 1;
			} else {
				if (orderDao.getDailyDeliveryZoneInfo(order) > 0) {
					rtn = 1;
				}
			}
		} 
		
		return rtn;
	}

	/**
	 * 구매확정 처리
	 * 
	 * @param Order
	 * @result GagaMap
	 * @author card007
	 * @since 2021. 02. 17
	 */
	@Transactional("shopTxnManager")
	public GagaMap decideOrder(Order order) {
		GagaMap result = new GagaMap();

		Integer custNo 		= order.getCustNo();
		Integer ordNo 		= order.getOrdNo();
		Integer reviewSq 	= order.getReviewSq();
		Integer regNo 		= order.getRegNo();
		Integer updNo 		= order.getUpdNo();
		int gvPointAmt 		= 0;
		
		try {
			for (Integer ordDtlNo : order.getOrdDtlNoArr()) {
				// 구매확정 포인트 적립
				Point point = new Point();
				point.setCustNo(custNo);
				point.setOrdNo(ordNo);
				point.setOrdDtlNo(ordDtlNo);
				point.setReviewSq(reviewSq);
				point.setRegNo(regNo);
				point.setUpdNo(updNo);

				if (pointService.getOrderDecisionPointHstCount(point) > 0) {
					gvPointAmt += pointService.createOrderDecisionPoint(point);
				}

				// 주문상세 상태값 변경
				order.setOrdDtlStat(TscConstants.OrderDetailStat.PURCHASE_CONFIRM.value());
				order.setOrdDtlNo(ordDtlNo);
				this.saveOrdDtlStat(order);
			}
			
			result.set("message", NumberFormat.getInstance().format(gvPointAmt) + "P가 적립되었습니다.");
			result.set("status", GagaResponseStatus.SUCCESS.getCode());
		} catch(Exception e) {
			throw new IllegalStateException(message.getMessage("FAIL_1003"));
		}
		
		return result;
	}

	/**
	 * 장바구니 쿠폰 적용 상품 리스트 조회
	 * @param Order
	 * @return Order
	 * @author xodud1202
	 * @since 2021. 02. 17
	 */
	public Collection<Order> getSerialCpnApplyGoodsList(Order order) {
		return orderDao.getGoodsCartCpnApplyGoodsList(order);
	}
	
	/**
	 * 주문정보등록(사전등록)
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 03. 09
	 */
	@Transactional("shopTxnManager")
	public void createPreOrder(Order order) {
		
		// 1. 주문기본정보등록
		orderDao.createOrder(order);
		
		// 2. 주문배송정보등록
		orderDao.createDeliveryAddr(order);
		
		// 3. 주문배송비정보등록
		Collection<Order> delvFeeCdList = order.getDelvFeeCdList();
		for (Order delvFeeCd : delvFeeCdList) {
			
			delvFeeCd.setOrdNo(order.getOrdNo());
			delvFeeCd.setCustNo(order.getCustNo());
			delvFeeCd.setDelvFeeGb(TscConstants.DeliveryFeeGb.ORIGIN_DELIVERY_FEE.value());
			
			// 2021.07.19 배송비에 상품권 사용금액 적용
			// 실제배송비 = 배송비 - 쿠폰사용금액 - 상품권사용금액
			int realDelvAmt = delvFeeCd.getDelvFee() - delvFeeCd.getDelvCpnDcAmt() - delvFeeCd.getDelvGfcdUseAmt();
			delvFeeCd.setRealDelvAmt(realDelvAmt);
			
			/*
			// TODO 보유쿠폰존재여부체크
			// 배송비쿠폰할인금액이 존재한다면 실결제배송비용에 쿠폰할인금액을 적용
			if (delvFeeCd.getDelvCpnDcAmt() > 0) {
				// 배송비 > 쿠폰할인금액
				if (delvFeeCd.getDelvFee() > delvFeeCd.getDelvCpnDcAmt()) {
					int realDelvAmt = delvFeeCd.getDelvFee() - delvFeeCd.getDelvCpnDcAmt();
					delvFeeCd.setRealDelvAmt(realDelvAmt);
				} else {
					delvFeeCd.setRealDelvAmt(0);
				}
			} else {
				delvFeeCd.setRealDelvAmt(delvFeeCd.getDelvFee());
			}
			*/
			
			orderDao.createDeliveryFee(delvFeeCd); // 주문배송비정보등록
		}
		
		// 4. 주문상세정보등록
		Collection<Order> orderDetailList = order.getOrderDetailList();
		
		for (Order orderDetail : orderDetailList) {
			orderDetail.setOrdNo(order.getOrdNo());
			orderDetail.setOrdExchGb("O");
			orderDetail.setCustNo(order.getCustNo());
			orderDetail.setRegNo(order.getCustNo());
			orderDetail.setOrdDtlStat(TscConstants.OrderDetailStat.ORDER_RECEIPT.value());
			orderDetail.setDelvAddrSq(order.getDelvAddrSq());
			
			// 2021.03.29 즉시할인금액 수량만큼 넣어야함
			orderDetail.setCpn1DcAmt(orderDetail.getCpn1DcAmt() * orderDetail.getGoodsQty());
			
			// 선포인트사용여부에 따라서 적립포인트 0원 설정
			if ("Y".equals(order.getPrePntDcAmtYn())) {
				if (orderDetail.getPrePntDcAmt() > 0) {
					orderDetail.setSavePntAmt(0);
				}
			} else {
				orderDetail.setPrePntDcAmt(0);
			}
			
			// 2021.04.28 비회원 포인트 적립금 없음
			if (order.getCustNo() == 0) {
				orderDetail.setSavePntAmt(0);
			}

			// 총알배송가능이면 총알배송 상품은 총알배송가능으로 설정
			if ("N".equals(order.getShotDelvYn())) {
				orderDetail.setShotDelvYn("N");
			}
			
			// TODO 총알배송, 구매대행상품여부 체크
			orderDao.createOrderDetail(orderDetail); // 주문상세정보등록
			
			orderDao.createOrderDetailHst(orderDetail); // 주문상세이력정보등록
			
			Collection<Order> orderDetailItemList = orderDao.getOrderDetailItem(orderDetail); // 주문상세단품정보조회
			
			// 주문상세단품단위 금액 등록
			int length				= orderDetailItemList.size();
			int index				= 1;
			int leftOrdAmt 			= orderDetail.getOrdAmt();
			int leftCpn1DcAmt 		= orderDetail.getCpn1DcAmt();
			int leftTmtb1DcAmt 		= orderDetail.getTmtb1DcAmt();
			int leftTmtb2DcAmt 		= orderDetail.getTmtb2DcAmt();
			int leftGoodsCpnDcAmt 	= orderDetail.getGoodsCpnDcAmt();
			int leftCartCpnDcAmt 	= orderDetail.getCartCpnDcAmt();
			int leftPntDcAmt 		= orderDetail.getPntDcAmt();
			int leftPrePntDcAmt 	= orderDetail.getPrePntDcAmt();
			int leftSavePntAmt 		= orderDetail.getSavePntAmt();
			int leftRealOrdAmt 		= orderDetail.getRealOrdAmt();
			int leftGfcdUseAmt 		= orderDetail.getGfcdUseAmt();
			
			// 2021.05.25
			// 세트상품 단품단위 비율배분을 위한 주문금액 구하기
			double currPrice = 0;
			for (Order orderDetailItem : orderDetailItemList) {
				currPrice += ((orderDetailItem.getItemPrice() + orderDetailItem.getOptAddPrice()) * orderDetailItem.getItemQty());
			}
			
			for (Order orderDetailItem : orderDetailItemList) {
				int itemPrice 		= orderDetailItem.getItemPrice();
				int optAddPrice 	= orderDetailItem.getOptAddPrice();
				int itemQty 		= orderDetailItem.getItemQty();
				double itemOrdAmt	= (itemPrice + optAddPrice) * itemQty;
				double tempDivD		= (itemOrdAmt / currPrice) * 100;
				int tempDiv 		= Integer.parseInt(String.valueOf(Math.round(tempDivD)));
				
				if (index == length) {
					orderDetailItem.setOrdAmt(leftOrdAmt);
					orderDetailItem.setCpn1DcAmt(leftCpn1DcAmt);
					orderDetailItem.setTmtb1DcAmt(leftTmtb1DcAmt);
					orderDetailItem.setTmtb2DcAmt(leftTmtb2DcAmt);
					orderDetailItem.setGoodsCpnDcAmt(leftGoodsCpnDcAmt);
					orderDetailItem.setCartCpnDcAmt(leftCartCpnDcAmt);
					orderDetailItem.setPntDcAmt(leftPntDcAmt);
					orderDetailItem.setPrePntDcAmt(leftPrePntDcAmt);
					orderDetailItem.setSavePntAmt(leftSavePntAmt);
					orderDetailItem.setRealOrdAmt(leftRealOrdAmt);
					orderDetailItem.setGfcdUseAmt(leftGfcdUseAmt);
				} else {
					orderDetailItem.setOrdAmt((orderDetail.getOrdAmt() * tempDiv) / 100);
					orderDetailItem.setCpn1DcAmt((orderDetail.getCpn1DcAmt() * tempDiv) / 100);
					orderDetailItem.setTmtb1DcAmt((orderDetail.getTmtb1DcAmt() * tempDiv) / 100);
					orderDetailItem.setTmtb2DcAmt((orderDetail.getTmtb2DcAmt() * tempDiv) / 100);
					orderDetailItem.setGoodsCpnDcAmt((orderDetail.getGoodsCpnDcAmt() * tempDiv) / 100);
					orderDetailItem.setCartCpnDcAmt((orderDetail.getCartCpnDcAmt() * tempDiv) / 100);
					orderDetailItem.setPntDcAmt((orderDetail.getPntDcAmt() * tempDiv) / 100);
					orderDetailItem.setPrePntDcAmt((orderDetail.getPrePntDcAmt() * tempDiv) / 100);
					orderDetailItem.setSavePntAmt((orderDetail.getSavePntAmt() * tempDiv) / 100);
					orderDetailItem.setRealOrdAmt((orderDetail.getRealOrdAmt() * tempDiv) / 100);
					orderDetailItem.setGfcdUseAmt((orderDetail.getGfcdUseAmt() * tempDiv) / 100);
										
					leftOrdAmt 			= leftOrdAmt 			- ((orderDetail.getOrdAmt() * tempDiv) / 100);
					leftCpn1DcAmt 		= leftCpn1DcAmt 		- ((orderDetail.getCpn1DcAmt() * tempDiv) / 100);
					leftTmtb1DcAmt 		= leftTmtb1DcAmt 		- ((orderDetail.getTmtb1DcAmt() * tempDiv) / 100);
					leftTmtb2DcAmt 		= leftTmtb2DcAmt 		- ((orderDetail.getTmtb2DcAmt() * tempDiv) / 100);
					leftGoodsCpnDcAmt 	= leftGoodsCpnDcAmt 	- ((orderDetail.getGoodsCpnDcAmt() * tempDiv) / 100);
					leftCartCpnDcAmt 	= leftCartCpnDcAmt 		- ((orderDetail.getCartCpnDcAmt() * tempDiv) / 100);
					leftPntDcAmt 		= leftPntDcAmt 			- ((orderDetail.getPntDcAmt() * tempDiv) / 100);
					leftPrePntDcAmt 	= leftPrePntDcAmt 		- ((orderDetail.getPrePntDcAmt() * tempDiv) / 100);
					leftSavePntAmt 		= leftSavePntAmt 		- ((orderDetail.getSavePntAmt() * tempDiv) / 100);
					leftRealOrdAmt 		= leftRealOrdAmt 		- ((orderDetail.getRealOrdAmt() * tempDiv) / 100);
					leftGfcdUseAmt 		= leftGfcdUseAmt 		- ((orderDetail.getGfcdUseAmt() * tempDiv) / 100);
				}
				
				// 2021.05.06 옵션금액 단품 추가
				orderDetailItem.setOptAddPrice(optAddPrice);
				orderDetailItem.setCustNo(order.getCustNo());

				orderDao.createOrderDetailItem(orderDetailItem); // 주문상세단품정보등록
				
				index++;
			}
		}
		
		// 5. 주문사은품정보등록
		order.setOrdDtlStat(TscConstants.OrderDetailStat.ORDER_RECEIPT.value());
		if(order.getFreegiftValArr() != null && order.getFreegiftValArr().length > 0) {
			orderDao.createOrdFreegift(order);

			// 6. 주문사은품 상품 정보 등록
			orderDao.createOrdFreegiftVal(order);

			// 7. 주문사은품 주문상세정보 등록
			for(int i = 0 ; i < order.getFreegiftGoodsArr().length ; i++) {
				order.setFreegiftSq(order.getFreegiftSqArr()[i]);
				order.setGoodsCd(order.getFreegiftGoodsArr()[i]);

				orderDao.createOrdFreegiftDtl(order);
			}
		}
		
		// 8. 2021.04.25 보증보험신청정보등록 (무통장결제, 실시간계좌이체)
		if (TscConstants.PayMeans.ACCOUNT_TRANSFER.value().equals(order.getPayMeans()) || TscConstants.PayMeans.BANK_DEPOSIT.value().equals(order.getPayMeans())) {
			if ("Y".equals(order.getInsuranceYn())) {
				
				//G007_F : 여성
				//G007_M : 남성
				//G007_X : 알수없음
				//G007_Z : 공통
				
				if ("G007_F".equals(order.getSexGb())) {
					order.setSexGb("2");
				} else {
					order.setSexGb("1");
				}
				
				// 2021.05.07 생년월일 + 성별구분
				String birthYmd = order.getBirthYmd() + order.getSexGb();
				order.setBirthYmd(birthYmd);
				orderDao.createInsurance(order);
			}
		}
	}

	/**
	 * 주문정보(결제완료)
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 03. 09
	 */
	@Transactional("shopTxnManager")
	public void updateOrderInfo(Order order) {
		
		// 2021.10.01 세션유실시 CUST_NO 주문정보에 있는 CUST_NO로 방어 설정
		if (order.getCustNo() < 1) {
			int custNo = 0;
			Collection<Order> orderInfo = orderDao.getOrderInfoList(order);
			if (orderInfo != null) {
				if (orderInfo.size() > 0) {
					custNo = orderInfo.iterator().next().getCustNo();
				}
			}
			order.setCustNo(custNo);
		}
		
		// 1.1 무통장입금시 입금대기 
		if (TscConstants.PayMeans.BANK_DEPOSIT.value().equals(order.getPayMeans())) {
			order.setOrdDtlStat(TscConstants.OrderDetailStat.DEPOSIT_WAIT.value());
			// 2. 주문 결제시간 업데이트 (무통장 입금 대기시 PAY_DT를 NULL로 변경)
			orderDao.updateOrderPayDtNull(order);
		}
		// 1.2 그외는 결제완료 표기
		else {
			order.setOrdDtlStat(TscConstants.OrderDetailStat.PAYMENT_COMPLETE.value());
			// 2. 주문 결제시간 업데이트
			orderDao.updateOrder(order);
		}
		
		// 3. 주문상세 결제완료 상태 업데이트
		orderDao.updateOrderDetail(order);
		
		// 3.1 주문상세이력정보 전체 등록
		orderDao.createOrderDetailAllHst(order);
		
		// 4. 주문상세단품 결제완료 상태 업데이트
		orderDao.updateOrderDetailItem(order);
		
		// 4.1 주문상세단품 이력정보 전체 등록
		// 2021.06.25 결제완료 (정산구분값추가)
		// 2021.09.06 무통장입금처리시 정산데이타 적재안함 처리
		if (!TscConstants.PayMeans.BANK_DEPOSIT.value().equals(order.getPayMeans())) {
			order.setOrdDtlStat(TscConstants.OrdDtlItemStat.SALE_PAYMENT_COMPLETE.value());
			orderDao.createOrderDetailItemAllHst(order);
		}

		// 5. 상품재고처리
		orderDao.createSellQty(order);
		
		// 6. 주문상세할인정보조회 (상품쿠폰, 장바구니쿠폰, 배송비쿠폰, 주문사용포인트, 주문상품권사용, 적립에정포인트, 주문사은품사용포인트, 주문배송상품권사용)
		Collection<Order> orderDetailDcList = orderDao.getOrderDetailDcInfo(order);
		
		// 7. 회원포인트목록정보조회
		Collection<Order> custPointInfoList = orderDao.getCustPointInfoList(order);
		
		// 8. 포인트사용처리
		int pntDcAmt	= 0;
		int rmPntAmt	= 0;
		int usPntAmt	= 0;
		
		for (Order orderDetail : orderDetailDcList) {
			pntDcAmt	= orderDetail.getPntDcAmt();
			
			for (Order custPointInfo : custPointInfoList) {
				// 포인트사용금액 있으면 실행
				if (pntDcAmt > 0) {
					rmPntAmt = custPointInfo.getRmPntAmt();
					
					// 남은포인트 > 사용포인트보다 크면 실행
					if (rmPntAmt > pntDcAmt) {
						rmPntAmt = rmPntAmt - pntDcAmt;
						usPntAmt = pntDcAmt;
						pntDcAmt = 0;
					} else {
						pntDcAmt = pntDcAmt - rmPntAmt;
						usPntAmt = rmPntAmt;
						rmPntAmt = 0;
					}
					
					// 2021.05.10 0원이상일때 동작 (소원씨찾음)
					if (usPntAmt > 0) {
						// 8.1 포인트정보변경
						custPointInfo.setUsPntAmt(usPntAmt);
						custPointInfo.setRmPntAmt(rmPntAmt);
						custPointInfo.setCustNo(order.getCustNo());
						orderDao.updateCustPoint(custPointInfo);
						
						// 주문사용포인트
						if (orderDetail.getOrdDtlNo() > 0) {
							custPointInfo.setOccurGb(TscConstants.PointOccurGb.ORD_USE_POINT.value());
							custPointInfo.setOccurDtlDesc("구매포인트사용");
						}
						// 사은품사용포인트
						else {
							custPointInfo.setOccurGb(TscConstants.PointOccurGb.FREEGIFT_USE_POINT.value());
							custPointInfo.setOccurDtlDesc("사은품포인트사용");
						}
						
						custPointInfo.setPntAmt(usPntAmt * -1);
						custPointInfo.setOrdNo(orderDetail.getOrdNo());
						custPointInfo.setOrdDtlNo(orderDetail.getOrdDtlNo());
						custPointInfo.setPntUploadStat(TscConstants.PntUploadStat.APPLY_COMPLETE.value());
						
						// 8.2 포인트이력정보등록
						orderDao.createCustPointHst(custPointInfo);
					}
				}
			}
		}
		
		// 9. 회원상품권목록정보조회
		Collection<Order> custGiftcardInfoList = orderDao.getCustGiftcardInfoList(order);
		
		// 10. 상품권사용처리
		int gfcdUseAmt		= 0;
		int rmGfcdAmt		= 0;
		int usGfcdAmt		= 0;
		String temp			= "";
		
		for (Order orderDetail : orderDetailDcList) {
			// 상픔권 사용금액 초기화
			gfcdUseAmt		= 0;
			temp			= "";
			
			// 2021.07.19 [상품상세] 상품권사용금액 존재하면 상품상세상품권금액적용
			if (orderDetail.getGfcdUseAmt() > 0) {
				gfcdUseAmt	= orderDetail.getGfcdUseAmt();
				temp		= "orderDetail";
			} 
			// [배송비] 상품권사용금액 존재하면 배송비상품권금액적용
			else if (orderDetail.getDelvGfcdUseAmt() > 0) {
				gfcdUseAmt	= orderDetail.getDelvGfcdUseAmt();
				temp		= "deliveryFee";
			}
			
			for (Order custGiftcardInfo : custGiftcardInfoList) {
				
				// 상품권사용금액 있으면 실행
				if (gfcdUseAmt > 0) {
					rmGfcdAmt = custGiftcardInfo.getRmGfcdAmt();
					
					// 남은상품권금액 > 사용상품권금액보다 크면 실행
					if (rmGfcdAmt > gfcdUseAmt) {
						rmGfcdAmt = rmGfcdAmt - gfcdUseAmt;
						usGfcdAmt = gfcdUseAmt;
						gfcdUseAmt = 0;
					} else {
						gfcdUseAmt = gfcdUseAmt - rmGfcdAmt;
						usGfcdAmt = rmGfcdAmt;
						rmGfcdAmt = 0;
					}
					
					// 2021.05.10 0원이상일때 동작 (소원씨찾음)
					if (usGfcdAmt > 0) {
						// 10.1 포인트정보변경
						custGiftcardInfo.setUsGfcdAmt(usGfcdAmt);
						custGiftcardInfo.setRmGfcdAmt(rmGfcdAmt);
						custGiftcardInfo.setCustNo(order.getCustNo());
						orderDao.updateCustGiftcard(custGiftcardInfo);
					
						custGiftcardInfo.setOccurGb("G074_12");
						custGiftcardInfo.setOccurDtlDesc("상품권사용");
						custGiftcardInfo.setGfcdAmt(usGfcdAmt * -1);
						custGiftcardInfo.setOrdNo(orderDetail.getOrdNo());
						
						if ("orderDetail".equals(temp)) {
							custGiftcardInfo.setOrdDtlNo(orderDetail.getOrdDtlNo());
							custGiftcardInfo.setDelvFeeSq(0);
						} else if ("deliveryFee".equals(temp)){
							custGiftcardInfo.setOrdDtlNo(0);
							custGiftcardInfo.setDelvFeeSq(orderDetail.getOrdDtlNo());
						}

						// 10.2 포인트이력정보등록
						orderDao.createCustGiftcardHst(custGiftcardInfo);
					}
				}
			}
		}
		
		// 11. 쿠폰사용처리 (상품쿠폰, 장바구니쿠폰, 배송비쿠폰)
		for (Order orderDetail : orderDetailDcList) {
			// 11.1 상품쿠폰
			if (orderDetail.getGoodsCpnSq() > 0) {
				orderDetail.setCustNo(order.getCustNo());
				orderDetail.setCustCpnSq(orderDetail.getGoodsCpnSq());
				orderDao.updateCustCouponUsedDt(orderDetail);
			}
			
			// 11.2 장바구니쿠폰
			if (orderDetail.getCartCpnSq() > 0) {
				orderDetail.setCustNo(order.getCustNo());
				orderDetail.setCustCpnSq(orderDetail.getCartCpnSq());
				orderDao.updateCustCouponUsedDt(orderDetail);
			}
			
			// 11.3 배송비쿠폰
			if (orderDetail.getDelvCpnSq() > 0) {
				orderDetail.setCustNo(order.getCustNo());
				orderDetail.setCustCpnSq(orderDetail.getDelvCpnSq());
				orderDao.updateCustCouponUsedDt(orderDetail);
			}
		}
		
		// 12. 예정포인트적립처리
		for (Order orderDetail : orderDetailDcList) {
			// 12.1 적립에정포인트 존재하면 실행
			if (orderDetail.getSavePntAmt() > 0) {
				orderDetail.setCustNo(order.getCustNo());
				orderDetail.setOccurGb(TscConstants.PointOccurGb.EXPECT_POINT.value());
				orderDetail.setOccurDtlDesc("예정포인트적립");
				orderDetail.setPntAmt(orderDetail.getSavePntAmt());
				orderDetail.setPntUploadStat(TscConstants.PntUploadStat.APPLY_EXPECT.value());
				
				// 12.2 포인트이력정보등록
				orderDao.createCustPointHst(orderDetail);
			}
		}
		
		// 13. 사은품 상태값 수정
		orderDao.updateOrdFreegiftValOrdDtlStat(order);
		
		// 14. 사은품 수량 차감 로직 TB_FREEGIFT_VAL LEFT_QTY
		orderDao.updateFreegiftValLeftQty(order);
	}
	
	/**
	 * 주문정보(결제완료)
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 03. 09
	 */
	@Transactional("shopTxnManager")
	public void updateOrderInfoVBank(Order order) {
		
		// 1. 무통장입금시 입금 결제완료
		order.setOrdDtlStat(TscConstants.OrderDetailStat.PAYMENT_COMPLETE.value());
		order.setPayStat(TscConstants.PaymentStat.PAYMENT_COMPLETE.value());

		// 1.5 TB_ORDER DATA PAY_DT UPDATE >> 김성욱차장님 요청으로 추가 : 20210624 - xodud1202
		orderDao.updateOrder(order);
		
		// 2. 주문상세 결제완료 상태 업데이트
		orderDao.updateOrderDetail(order);
		
		// 2.1 주문상세이력정보 전체 등록
		orderDao.createOrderDetailAllHst(order);
		
		// 3. 주문상세단품 결제완료 상태 업데이트
		orderDao.updateOrderDetailItem(order);
		
		// 3.1 주문상세단품 이력정보 전체 등록
		order.setOrdDtlStat(TscConstants.OrdDtlItemStat.SALE_PAYMENT_COMPLETE.value());
		orderDao.createOrderDetailItemAllHst(order);
		
		// 4. 사은품 상태값 수정
		order.setOrdDtlStat(TscConstants.OrderDetailStat.PAYMENT_COMPLETE.value());
		orderDao.updateOrdFreegiftValOrdDtlStat(order);

		// 5. PAYMENT 수정
		orderDao.updatePaymentStat(order);
	}
	
	/**
	 * 주문정보(결제완료)
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 03. 09
	 */
	@SuppressWarnings("rawtypes")
	public GagaMap getOrderCompleteInfo(Order order) {
		GagaMap resultMap = new GagaMap();
		
		order.setDelYn("N");
		
		// 1. 주문기본정보조회
		Collection<Order> orderInfoList = getOrderInfoList(order); 
		int index = 0;
		for (Order orderInfo : orderInfoList) {
			if (index == 0) {
				order.setCardNm(orderInfo.getCardNm());
				order.setVaBank(orderInfo.getVaBank());
				order.setVaDeadline(orderInfo.getVaDeadline());
				order.setOrdNm(orderInfo.getOrdNm());
				order.setOrdEmail(orderInfo.getOrdEmail());
				order.setOrdPhnno(orderInfo.getOrdPhnno());
				order.setVaNo(orderInfo.getVaNo());
				order.setCustNo(orderInfo.getCustNo());
				order.setPgGb(orderInfo.getPgGb());
				order.setCustId(orderInfo.getCustId());
				
				order.setGiftPackCloseYn(orderInfo.getGiftPackCloseYn());
				order.setGiftPackCloseDt(orderInfo.getGiftPackCloseDt());
				order.setOrdDt(orderInfo.getOrdDt());
			}
			index++;
		}
		
		// 2. 주문배송정보조회
		Collection<Order> deliveryAddrInfoList = getDeliveryAddrList(order); 
		index = 0;
		for (Order deliveryAddrInfo : deliveryAddrInfoList) {
			if (index == 0) {
				order.setRecipNm(deliveryAddrInfo.getRecipNm());
				order.setRecipZipcode(deliveryAddrInfo.getRecipZipcode());
				order.setRecipBaseAddr(deliveryAddrInfo.getRecipBaseAddr());
				order.setRecipDtlAddr(deliveryAddrInfo.getRecipDtlAddr());
				order.setRecipPhnno(deliveryAddrInfo.getRecipPhnno());
				order.setDelvMemo(deliveryAddrInfo.getDelvMemo());
				order.setGiftMsg(deliveryAddrInfo.getGiftMsg());
				order.setDelvAddrSq(deliveryAddrInfo.getDelvAddrSq());
				order.setRecipAddr(deliveryAddrInfo.getRecipBaseAddr() + " " + deliveryAddrInfo.getRecipDtlAddr());
			}
			index++;
		}
		
		// 3. 상품정보조회
		Collection<Order> orderDetailList 			= orderDao.getOrderDetailOrdAmtList(order);
		//Collection<Order> orderDetailDelvFeeCdGrp 	= orderDao.getOrderDetailDelvFeeCdGrp(order);
		
		int listSumAmt 			= 0; // 상품금액합계(정상가)
		int goodsSumAmt 		= 0; // 상품금액합계(판매가)
		int goodsDcSumAmt		= 0; // 상품할인금액(정상가 - 판매가)
		int delvFeeSumAmt 		= 0; // 배송비합계
		int realDelvSumAmt		= 0; // 실제배송비합계
		int cpn11DcSumAmt 		= 0; // 즉시할인합계(실결제금액계산용)
		int tmtbSumAmt 			= 0; // 다다익선합계
		int cpnDcSumAmt 		= 0; // 쿠폰할인합계
		int prePntDcSumAmt 		= 0; // 선포인트할인합계
		int pntDcSumAmt 		= 0; // 포인트사용합계
		int gfcdUseSumAmt 		= 0; // 상품권사용합계
		int mileageDcAmt 		= 0; // 마일리지사용합계
		int allianceDcAmt 		= 0; // 제휴할인합계
		int savePntSumAmt 		= 0; // 적립예정포인트합계
		int delvAddrSq			= 0; // 배송지번호
		String goodsNm			= ""; // 상품명
		int goodsCnt			= 0; // 상품건수
		index					= 0;
		
		String giftPackYn		= "N"; // 선물여부

		for (Order orderDetail : orderDetailList) {
			listSumAmt 			= listSumAmt 		+ ((orderDetail.getListPrice() + orderDetail.getOptAddPrice()) * orderDetail.getOrdQty());
			goodsSumAmt 		= goodsSumAmt 		+ ((orderDetail.getCurrPrice() + orderDetail.getOptAddPrice()) * orderDetail.getOrdQty());
			cpn11DcSumAmt 		= cpn11DcSumAmt 	+ orderDetail.getCpn1DcAmt();
			tmtbSumAmt 			= tmtbSumAmt 		+ (orderDetail.getTmtb1DcAmt() + orderDetail.getTmtb2DcAmt());
			cpnDcSumAmt			= cpnDcSumAmt 		+ (orderDetail.getGoodsCpnDcAmt() + orderDetail.getCartCpnDcAmt());
			prePntDcSumAmt		= prePntDcSumAmt 	+ orderDetail.getPrePntDcAmt();
			pntDcSumAmt			= pntDcSumAmt 		+ orderDetail.getPntDcAmt();
			gfcdUseSumAmt		= gfcdUseSumAmt 	+ orderDetail.getGfcdUseAmt();
			savePntSumAmt		= savePntSumAmt		+ orderDetail.getSavePntAmt();
			
			if (index == 0) {
				delvAddrSq		= orderDetail.getDelvAddrSq();
				goodsNm			= orderDetail.getGoodsNm();
			}
			index++;
			
			if ("Y".equals(orderDetail.getGiftPackYn())) {
				giftPackYn		= "Y"; 
			}
		}
		
		// 2021.04.25 금액표기수정
		goodsDcSumAmt	= listSumAmt - goodsSumAmt;
		goodsCnt 		= orderDetailList.size() - 1; 
		
		// 선물여부
		order.setGiftPackYn(giftPackYn);
		
		// 4. 결제정보조회
		Collection<Order> orderPaymentList = getOrderPaymentBasicInfoList(order);
		index = 0;
		String payType = "";
		for (Order orderPayment : orderPaymentList) {
			if (index == 0) {
				if (orderPayment.getPgGb().equals("PAYCO")) {
					payType = "페이코";
				} else if (orderPayment.getPgGb().equals("NAVER")) {
					payType = "네이버페이";
				} else if (orderPayment.getPgGb().equals("KAKAO")) {
					payType = "카카오페이";
				} else if (orderPayment.getPgGb().equals("KCP")) {
					payType = orderPayment.getPayMeansNm();
				}
				
				order.setPayMeans(orderPayment.getPayMeans());
				order.setPayMeansNm(orderPayment.getPayMeansNm());
				order.setCardNm(orderPayment.getCardNm());
				order.setPayType(payType);
				order.setPgGb(orderPayment.getPgGb());
				order.setVaNo(orderPayment.getVaNo());
				order.setVaDeadline(orderPayment.getVaDeadline());
				
				// 2021.05.07 현금영수증정보
				order.setCashAuthNo(orderPayment.getCashAuthNo());
				order.setCashTradeNo(orderPayment.getCashTradeNo());
				
				
				if (orderPayment.getCardMips() != null && !"".equals(orderPayment.getCardMips())) {
					if ("00".equals(orderPayment.getCardMips())) {
						order.setCardMips("일시불");
					} else {
						int cardMips = Integer.parseInt(orderPayment.getCardMips());
						order.setCardMips(cardMips + "개월 할부");
					}
				}
				
				// 체크카드 Y, 신용카드 N
				order.setCardType(orderPayment.getCardType());
			}
			index++;
		}
		
		// 5. 배송정보조회
		Collection<Order> deliveryFeeList = getDeliveryFeeList(order);
		for (Order deliveryFee : deliveryFeeList) {
			delvFeeSumAmt 		= delvFeeSumAmt 	+ deliveryFee.getDelvFee();
			realDelvSumAmt 		= realDelvSumAmt 	+ deliveryFee.getRealDelvAmt();
			//cpnDcSumAmt			= cpnDcSumAmt 		+ deliveryFee.getDelvCpnDcAmt();
		}
		
		int ordSumAmt 		= goodsSumAmt + realDelvSumAmt;
		int dcSumAmt 		= cpn11DcSumAmt + tmtbSumAmt + cpnDcSumAmt + prePntDcSumAmt + pntDcSumAmt + gfcdUseSumAmt + mileageDcAmt + allianceDcAmt;
		int realOrdSumAmt 	= ordSumAmt - dcSumAmt;
		
		// 결제금액
		order.setPayAmt(realOrdSumAmt);
		
		// 6. 화면전송변수설정
		resultMap.set("orderInfo"			, order);				// 주문기본정보
		resultMap.set("ordSumAmt"			, ordSumAmt);			// 주문금액합계
		resultMap.set("dcSumAmt"			, dcSumAmt);			// 할인금액합계
		resultMap.set("realOrdSumAmt"		, realOrdSumAmt);		// 결제금액합계
		resultMap.set("listSumAmt"			, listSumAmt);			// 상품금액합계(정상가)
		resultMap.set("goodsSumAmt"			, goodsSumAmt);			// 상품금액합계(판매가)
		resultMap.set("goodsDcSumAmt"		, goodsDcSumAmt);		// 상품금액합계(정상가 - 판매가)
		resultMap.set("delvFeeSumAmt"		, delvFeeSumAmt);		// 배송비합계
		resultMap.set("realDelvSumAmt"		, realDelvSumAmt);		// 실제배송비합계
		resultMap.set("cpn1DcSumAmt"		, cpn11DcSumAmt);		// 즉시할인합계
		resultMap.set("tmtbSumAmt"			, tmtbSumAmt);			// 다다익선합계
		resultMap.set("cpnDcSumAmt"			, cpnDcSumAmt);			// 쿠폰할인합계
		resultMap.set("prePntDcSumAmt"		, prePntDcSumAmt);		// 선포인트할인합계
		resultMap.set("pntDcSumAmt"			, pntDcSumAmt);			// 포인트사용합계
		resultMap.set("gfcdUseSumAmt"		, gfcdUseSumAmt);		// 상품권사용합계
		resultMap.set("savePntSumAmt"		, savePntSumAmt);		// 적립예정포인트합계
		resultMap.set("mileageDcAmt"		, mileageDcAmt);		// 마일리지사용합계
		resultMap.set("allianceDcAmt"		, allianceDcAmt);		// 제휴할인합계
		resultMap.set("delvAddrSq"			, delvAddrSq);			// 배송지번호
		resultMap.set("orderDetailList"		, orderDetailList);		// 주문목록
		resultMap.set("goodsNm"				, goodsNm);				// 상품명
		resultMap.set("goodsCnt"			, goodsCnt);			// 상품건수
		
		// 2021.06.23 주문완료 메일정보 추가
		resultMap.set("ordNm"				, order.getOrdNm());			// 주문자명
		resultMap.set("ordNo"				, order.getOrdNo());			// 주문번호
		resultMap.set("ordDt"				, order.getOrdDt());			// 주문일자
		resultMap.set("recipNm"				, order.getRecipNm());			// 받는사람
		resultMap.set("recipPhnno"			, order.getRecipPhnno());		// 받는사람핸드폰번호
		resultMap.set("recipZipcode"		, order.getRecipZipcode());		// 받는사람우편번호
		resultMap.set("recipBaseAddr"		, order.getRecipBaseAddr());	// 받는사람기본주소
		resultMap.set("recipDtlAddr"		, order.getRecipDtlAddr());		// 받는사람상세주소
		resultMap.set("delvMemo"			, order.getDelvMemo());			// 받는사람배송메모
		
		String pgGbNm = payType;
		
		if (TscConstants.PayMeans.BANK_DEPOSIT.value().equals( order.getPayMeans())) {
			pgGbNm = "";
		}
		
		resultMap.set("pgGbNm"				, payType);						// 결제방법
		
		// 취소 상세 정보 조회
		Collection<OrderChange> cancelList = new ArrayList();
		
		for (Order orderDetail : orderDetailList) {
			OrderChange orderChange = new OrderChange();
			orderChange.setGoodsCd(orderDetail.getGoodsCd());
			orderChange.setGoodsNm(orderDetail.getGoodsNm());
			orderChange.setBrandNm(orderDetail.getBrandGroupNm());
			orderChange.setShotDelvYn(orderDetail.getShotDelvYn());
			orderChange.setSelfGoodsYn(orderDetail.getSelfGoodsYn());
			orderChange.setItemNm(orderDetail.getItemNm());
			orderChange.setColorNm(orderDetail.getColorNm());
			orderChange.setOptCd1(orderDetail.getOptCd1());
			orderChange.setOptCd2(orderDetail.getOptCd2());
			orderChange.setGoodsType(orderDetail.getGoodsType());
			orderChange.setSysImgNm(orderDetail.getSysImgNm());
			orderChange.setSupplyCompNm(orderDetail.getSupplyCompNm());
			orderChange.setDelvFeeCd(orderDetail.getDelvFeeCd());
			orderChange.setOrdNo(order.getOrdNo());
			orderChange.setChgQty(orderDetail.getOrdQty());
			orderChange.setListPrice(orderDetail.getOrdAmt());
			orderChange.setOrdAmt(orderDetail.getRealOrdAmt() + orderDetail.getPntDcAmt() + orderDetail.getGfcdUseAmt());
			cancelList.add(orderChange);
		}

		// 상픔 정보 조회
		String cancelInfo = orderChangeService.getMailOrderCancelInfo(cancelList);
		resultMap.set("orderListInfo"		, cancelInfo);				// 주문목록
		
		// 사은품목록
		OrderChange oc = new OrderChange();
		oc.setOrdNo(order.getOrdNo());
		oc.setDelYn("N");	
		String freeGiftInfo = orderChangeService.getMailFreeGiftCancelInfo(oc);
		resultMap.set("orderFreegiftInfo"	, freeGiftInfo);			// 사은품목록

		return resultMap;
	}
	
	/**
	 * 선물받기 주문정보(결제완료)
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 04. 15
	 */
	public GagaMap getOrderGiftCompleteInfo(Order order) {
		GagaMap resultMap = new GagaMap();
		
		order.setDelYn("N");
		
		// 1. 주문기본정보조회
		Collection<Order> orderInfoList = getOrderInfoList(order); 
		int index = 0;
		for (Order orderInfo : orderInfoList) {
			if (index == 0) {
				order.setCardNm(orderInfo.getCardNm());
				order.setVaBank(orderInfo.getVaBank());
				order.setVaDeadline(orderInfo.getVaDeadline());
				order.setOrdNm(orderInfo.getOrdNm());
				order.setOrdEmail(orderInfo.getOrdEmail());
				order.setOrdPhnno(orderInfo.getOrdPhnno());
				order.setVaNo(orderInfo.getVaNo());
				order.setCustNo(orderInfo.getCustNo());
				order.setGiftPackCloseYn(orderInfo.getGiftPackCloseYn());
				order.setGiftPackCloseDt(orderInfo.getGiftPackCloseDt());
			}
			index++;
		}
		
		// 2. 주문배송정보조회
		Collection<Order> deliveryAddrInfoList = getDeliveryAddrList(order); 
		index = 0;
		for (Order deliveryAddrInfo : deliveryAddrInfoList) {
			if (index == 0) {
				order.setRecipNm(deliveryAddrInfo.getRecipNm());
				order.setRecipBaseAddr(deliveryAddrInfo.getRecipBaseAddr());
				order.setRecipDtlAddr(deliveryAddrInfo.getRecipDtlAddr());
				order.setRecipPhnno(deliveryAddrInfo.getRecipPhnno());
				order.setRecipZipcode(deliveryAddrInfo.getRecipZipcode());
				order.setDelvMemo(deliveryAddrInfo.getDelvMemo());
				order.setGiftMsg(deliveryAddrInfo.getGiftMsg());
				order.setDelvAddrSq(deliveryAddrInfo.getDelvAddrSq());
			}
			index++;
		}
		
		// 3. 주문목록 조회
		Collection<Order> orderList = getOrderGiftGoodsList(order);
		String giftAddrInpYn 	= "N";
		String goodsNm 			= "";
		int goodsCnt			= orderList.size() - 1;
		
		for (Order orderDetail : orderList) {
			if (index == 0) {
				giftAddrInpYn 	= orderDetail.getGiftAddrInpYn();
				goodsNm			= orderDetail.getGoodsNm();
			}
			
			// 1.1 세트상품 옵션별 배열로 담기
			if (orderDetail.getItemNm().contains("!@!")) {
				orderDetail.setItemNmArr(orderDetail.getItemNm().split("!@!"));
				orderDetail.setOptCdArr(orderDetail.getOptCd().split(","));
				orderDetail.setItemQtyArr(orderDetail.getItemQtyr().split(","));
				orderDetail.setOptCd1Arr(orderDetail.getOptCd1().split(","));
				orderDetail.setOptCd2Arr(orderDetail.getOptCd2().split(","));
				orderDetail.setColorNmArr(orderDetail.getColorNm().split(","));
			} else {
				String[] arr = {orderDetail.getItemNm()}, arr2 = {orderDetail.getOptCd1()}, arr3 = {orderDetail.getOptCd2()}, arr4 = {orderDetail.getItemQtyr()}, arr5 = {orderDetail.getColorNm()};
				orderDetail.setItemNmArr(arr);
				orderDetail.setOptCd1Arr(arr2);
				orderDetail.setOptCd2Arr(arr3);
				orderDetail.setItemQtyArr(arr4);
				orderDetail.setColorNmArr(arr5);
			}
			index++;
		}

		String delvRegYn = "Y";
		if (order.getRecipZipcode() == null || "".equals(order.getRecipZipcode())) {
			delvRegYn = "N";
		}

		// 4. 화면전송변수설정
		resultMap.set("orderInfo"			, order);				// 주문기본정보
		resultMap.set("orderList"			, orderList);			// 주문목록정보
		resultMap.set("orderListCnt"		, orderList.size());	// 주문목록갯수
		resultMap.set("giftAddrInpYn"		, giftAddrInpYn);		// 선물받기배송지등록여부
		resultMap.set("delvRegYn"			, delvRegYn);			// 배송지등록여부
		resultMap.set("goodsNm"				, goodsNm);				// 상품명
		resultMap.set("goodsCnt"			, goodsCnt);			// 상품수
		
		return resultMap;
	}
	
	/**
	 * 선물주문배송신청완료
	 *
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 04. 15
	 */
	@Transactional("shopTxnManager")
	public int updateOrderDetailGiftAddrInpYn(Order order) {
		
		order.setCustNo(0);

		// 선물주문배송신청완료
		
		int rtn = orderDao.updateOrderDetailGiftAddrInpYn(order);
		
		// 주문상세 이력 등록
		rtn = orderDao.createOrderDetailAllHst(order);
		
		return rtn;
	}


	/**
	 * 주문 상태 별 수량 조회
	 *
	 * @param Order
	 * @return Order
	 * @author card007
	 * @since 2021. 02. 08
	 */
	public Order getOrderStatCount(Order order) { return orderDao.getOrderStatCount(order); }
	
	/**
	 * 장바구니 구분의 선물하기 여부 판단
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2021. 04. 13
	 */
	public int getGiftOrderCheck(Order order) {
		return orderDao.getGiftOrderCheck(order);
	}
	
	/**
	 * 선물받기 주문상품 목록 조회
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2021. 04. 15
	 */
	public Collection<Order> getOrderGiftGoodsList(Order order) {
		return orderDao.getOrderGiftGoodsList(order);
	}
	
	
	/**
	 * 추가결제 취소,반품,교환 대상 상품목록 조회
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2021. 04. 15
	 */
	public GagaMap getAddPayOrderListInfo(Order order) {
		GagaMap resultMap = new GagaMap();
		
		Collection<Order> orderAddPayGoodsList = orderDao.getAddPayGoodsList(order);
		
		int ordNo			= 0;
		int refundAmt 		= 0;
		int addPayCost 		= 0;
		int ordChgSq		= 0;
		
		String chgGb		= "";
		String chgerNm		= "";
		String chgerPhnno	= "";
		String goodsNm		= "";
		String ordNm		= "";
		String ordPhnno		= "";
		
		int index = 0;
		for (Order orderInfo : orderAddPayGoodsList) {
			if (index == 0) {
				ordNo		= orderInfo.getOrdNo();
				refundAmt 	= orderInfo.getRefundAmt();
				addPayCost 	= orderInfo.getAddPayCost();
				ordChgSq	= orderInfo.getOrdChgSq();
				
				chgGb		= orderInfo.getChgGb();
				chgerNm		= orderInfo.getChgerNm();
				chgerPhnno	= orderInfo.getChgerPhnno();
				goodsNm		= orderInfo.getGoodsNm();
				ordNm		= orderInfo.getOrdNm();
				ordPhnno	= orderInfo.getOrdPhnno();
			}
			
			// 1.1 세트상품 옵션별 배열로 담기
			if (orderInfo.getItemNm().contains("!@!")) {
				orderInfo.setItemNmArr(orderInfo.getItemNm().split("!@!"));
				orderInfo.setOptCdArr(orderInfo.getOptCd().split(","));
				orderInfo.setItemQtyArr(orderInfo.getItemQtyr().split(","));
				orderInfo.setOptCd1Arr(orderInfo.getOptCd1().split(","));
				orderInfo.setOptCd2Arr(orderInfo.getOptCd2().split(","));
				orderInfo.setColorNmArr(orderInfo.getColorNm().split(","));
			} else {
				String[] arr = {orderInfo.getItemNm()}, arr2 = {orderInfo.getOptCd1()}, arr3 = {orderInfo.getOptCd2()}, arr4 = {orderInfo.getItemQtyr()}, arr5 = {orderInfo.getColorNm()};
				orderInfo.setItemNmArr(arr);
				orderInfo.setOptCd1Arr(arr2);
				orderInfo.setOptCd2Arr(arr3);
				orderInfo.setItemQtyArr(arr4);
				orderInfo.setColorNmArr(arr5);
			}
						
			index++;
		}
		
		// 추가결제시 업체명 목록 조회
		Collection<Order> delvFeeCdList =  orderDao.getDelvFeeCdSupplyCompNmList(order);
		
		// 2021.07.05 결제타입 가져오기
		String payMeansNm = "";
		
		if (ordChgSq > 0) {
			order.setOrdChgSq(ordChgSq);
			Order paymentInfo = orderDao.getAddPaymentInfo(order);
			if (paymentInfo != null) {
				if (TscConstants.PayMeans.CELL_PHONE.value().equals(paymentInfo.getPayMeans())) {
					payMeansNm = "휴대전화";
				} else {
					payMeansNm = "신용카드";
				}
			}
		}
		
		resultMap.set("orderAddPayGoodsList"	, orderAddPayGoodsList);	// 주문목록정보
		resultMap.set("ordNo"					, ordNo);					// 주문번호
		resultMap.set("refundAmt"				, refundAmt);				// 상품환불금액
		resultMap.set("addPayCost"				, addPayCost);				// 추가결제금액
		resultMap.set("ordChgSq"				, ordChgSq);				// 주문취소신청번호
		
		resultMap.set("chgGb"					, chgGb);					// 변경구분
		resultMap.set("chgerNm"					, chgerNm);					// 변경신청인
		resultMap.set("chgerPhnno"				, chgerPhnno);				// 변경신청핸드폰번호
		resultMap.set("goodsNm"					, goodsNm);					// 상품명
		resultMap.set("ordNm"					, ordNm);					// 주문자
		resultMap.set("ordPhnno"				, ordPhnno);				// 주문자핸드폰번호
		resultMap.set("delvCnt"					, delvFeeCdList.size());	// 업체명카운트
		resultMap.set("delvFeeCdList"			, delvFeeCdList);			// 추가결제시 업체명 목록 조회
		resultMap.set("payMeansNm"				, payMeansNm);				// 결제타입명
		
		return resultMap;
	}
	
	/**
	 * 주문정보(결제완료)
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 03. 09
	 */
	@Transactional("shopTxnManager")
	public void updateOrderChangeDetail(Order order) {
		
		// 1. 추가결제 반품,교환 상태값 업데이트
		orderDao.updateOrderChangeDetailChgStat(order);
		// 2. 추가결제 반품,교환 변경 이력 생성
		orderDao.createOrderChangeDetailHstChgStat(order);
		// 3 주문상세이력정보 전체 등록
		orderDao.createOrderDetailAllHst(order);
		
	}

	/**
	 * 입점 발주 최종 처리
	 * @param Order
	 * @return List<Order>
	 * @author xodud1202
	 * @since 2021. 04. 21
	 */
	@Transactional("shopTxnManager")
	public Collection<OrderChange> getCancelDataList(Collection<Order> params, int userNo) {
		
		// 주문번호별 상세번호, 취소수량 및 주문정보 세팅
		List<OrderChange> cancelDataList = new ArrayList<OrderChange>();
		
		for(Order param : params) {
			
			log.info("param.getCancelQty() ::: {} ", param.getCancelQty());
			log.info("param.getDelvFeeCd() ::: {} ", param.getDelvFeeCd());
			log.info("param.getOrdChgSq() ::: {} ", param.getOrdChgSq());
			
			// 품절취소 수량이 존재하면 취소대상목록에 추가등록
			if (param.getCancelQty() > 0) {
				
				boolean chkOrd = true;
				
				// TODO 2021.07.14 교환일때 교환변경번호가 한번에 출고되는 상황인지 체크
				// 취소대상목록에 주문번호 존재하면 취소상세번호, 취소수량만 배열에 추가
				for(OrderChange cancelData : cancelDataList) {
					// 2021.07.15 정책단위 체크
					// 2021.09.06 결제건은일반출고 
					if (cancelData.getOrdChgSq() != null && cancelData.getOrdChgSq() > 0) {
						if (param.getOrdNo().equals(cancelData.getOrdNo()) && param.getDelvFeeCd().equals(cancelData.getDelvFeeCd()) 
								&& param.getOrdChgSq().equals(cancelData.getOrdChgSq())) {
							chkOrd = false;
							cancelData.getOrdDtlNoList().add(param.getOrdDtlNo());
							cancelData.getCnclRtnReqQtyList().add(param.getCancelQty());
						}
					}
				}
				
				// 취소대상목록에 존재하지 않으면 신규등록
				if (chkOrd) {
					OrderChange change = new OrderChange();
					change.setOrdNo(param.getOrdNo());
					change.setCustNo(param.getCustNo());
					change.setOrderNm(param.getOrdNm());
					change.setOrdNm(param.getOrdNm());
					change.setOrdPhnno(param.getOrdPhnno());
					change.setUserNo(userNo);
					change.setPgGb(param.getPgGb());
					change.setPayMeans(param.getPayMeans());
					change.setBankCd(param.getBankCd());
					change.setAccountNm(param.getAccountNm());
					change.setAccountNo(CryptoUtils.decryptAES(param.getAccountNo()));
					change.getOrdDtlNoList().add(param.getOrdDtlNo());
					change.getCnclRtnReqQtyList().add(param.getCancelQty());
					change.setChgReason(TscConstants.OrderCancelReason.SOLDOUT_CANCEL.value());
					change.setChgReasonNm("품절취소");
					change.setDelvFeeCd(param.getDelvFeeCd());
					change.setOrdChgSq(param.getOrdChgSq());
					cancelDataList.add(change);
				}
			}
		}
		
		
		return cancelDataList;
	}

	/**
	 * 입점 발주 최종 처리
	 * @param Order
	 * @return List<Order>
	 * @author xodud1202
	 * @since 2021. 04. 21
	 */
	public String updateSellerDelvStart(Collection<Order> params, Collection<OrderChange> cancelDataList, int userNo) {
		// 배송중 주문 목록 (알림톡 송부 위함)
		List<Order> delvStartList = new ArrayList<Order>();

		// 네이버페이 주문형 일반 배송중 주문 목록
		List<Order> delvStartDtlList = new ArrayList<Order>();

		int exchangeDelvFailCnt = 0;
		int cnt = 0;
		int idx = 0;
		List<Integer> ordNoList = new ArrayList<>();
		List<String> messageList = new ArrayList<>();

		try {
			// 결품 취소 후 수량이 남은 경우 배송중처리
			for(Order param : params) {
	
				// TODO 2021.07.14 교환일때 교환변경번호가 한번에 출고되는 상황인지 체크
				Boolean temp = true;
	
				// 2021.07.15 교환출고중에 혹시 ORD_CHG_SQ 번호로 묶인 상품중 품절취소건이 있으면 출고 대기
				if (param.getOrdChgSq() != null && param.getOrdChgSq() > 0) {
					for(OrderChange cancelData : cancelDataList) {
						if (param.getOrdChgSq().equals(cancelData.getOrdChgSq())) {
							temp = false;
						}
					}
				}
	
				// 결품 취소 후 수량이 남은 경우 배송중 변경 처리
				if (temp) {
					// 변경번호 ORD_CHG_SQ 로 출고대상목록 조회 후 한번에 출고되는지 체크
					// 한번에 출고되지 않으면 결제완료로 변경
					if (param.getOrdQty() - param.getCnclRtnQty() - param.getCancelQty() > 0) {
						GagaMap map = new GagaMap();
						Order tmp = naverPayDao.getOrderDetailInfoFromOrdDtlNo(param);
						String result = "SUCESS";
						if(TscConstants.PgGb.NAVER_ORDER.value().equals(tmp.getPgGb())) {
							if ("E".equals(tmp.getOrdExchGb())) {
								// 네이버페이 교환 배송중 데이터 송부
								if("scm".equals(env.getProperty("server.site.name"))) {
									map = naverPayService.sendNaverPayExchangeReDelivery(param, userNo);    // 교환재배송
									result = map.getString("status");
								} else {
									// naverPayService.sendNaverPayExchangeReDelivery(change, userNo);    // 교환재배송
									String addUrl = "/naverpay/send/exchange/delivery?ordDtlNo=" + param.getOrdDtlNo() + "&userNo=" + userNo;
									result = naverPayService.sendScmServerForNaverpay(addUrl);						// 교환재배송

									if (!"SUCCESS".equals(result)) {
										map.setString("message", result);
									}
								}
							} else if ("O".equals(tmp.getOrdExchGb())) {
								// 네이버페이 원주문 배송중 데이터 송부
								if("scm".equals(env.getProperty("server.site.name"))) {
									map = naverPayService.sendNaverPayDeliveryStartOrder(tmp, "SHIPPING", userNo);    // 배송중
									result = map.getString("status");
								} else {
									// naverPayService.sendNaverPayDeliveryStartOrder(tmp, "SHIPPING", userNo);    // 배송중
									String addUrl = "/naverpay/send/order/delivery/start?ordDtlNo=" + param.getOrdDtlNo() + "&userNo=" + userNo;
									result = naverPayService.sendScmServerForNaverpay(addUrl);						// 배송중
									
									if (!"SUCCESS".equals(result)) {
										map.setString("message", result);
									}
								}
							}
						}

						if ("SUCCESS".equals(result)) {
							// 주문 상세 (TB_ORDER_DETAIL) 배송중으로 변경
							param.setOrdDtlStat(TscConstants.OrderDetailStat.SHIPPING.value());
							param.setRegNo(userNo);
							param.setUpdNo(userNo);
							orderDao.changedOrdDtlStatDelvStart(param);

							// 주문 상품 상세 (TB_ORDER_DETAIL_ITEM) 배송중으로 변경
							scmDao.updateOrderDetailItemStat(param);

							// 주문 상세 송장번호 등록
							scmDao.createOrderDetailInvoice(param);

							// 주문 변경 이력 저장
							orderDao.createOrderDetailHst(param);

							// 주문 상세 아이템 이력 저장
							// 2021.08.06 card007 TB_ORDER_DETAIL_ITEM_HST.ORD_DTL_STAT G013 -> G720으로 변경
							// 뒷로직에서 G013으로 사용하는지 확인 후 안쓰면 하기 G013으로 변경 로직 제거 필요
							String ordDtlStat = param.getOrdDtlStat();
							param.setOrdDtlStat(TscConstants.OrdDtlItemStat.SALE_SHIPPING.value());
							orderDao.createOrderDetailItemHstFromDtlNo(param);
							param.setOrdDtlStat(ordDtlStat);

							boolean isOther = true;
							for (Order delv : delvStartList) {
								if (delv.getOrdNo().equals(param.getOrdNo())) {
									delv.setGoodsCnt(String.valueOf(Integer.parseInt(delv.getGoodsCnt()) + 1));
									isOther = false;
								}
							}

							if (isOther) {
								Order delv = new Order();
								delv.setOrdNo(param.getOrdNo());
								delv.setOrdNm(param.getOrdNm());
								delv.setGoodsNm(param.getGoodsNm());
								delv.setOrdPhnno(param.getOrdPhnno());
								delv.setCustNo(param.getCustNo());
								delv.setOrdDtlNo(param.getOrdDtlNo());
								delv.setGoodsCnt("0");        // 첫 상품은 외 0건

								delvStartList.add(delv);
								if ("O".equals(tmp.getOrdExchGb())) {
									delvStartDtlList.add(delv);
								}
							}

							cnt++;
						} else {
							ordNoList.add(param.getOrdNo());
							messageList.add(map.getString("message"));
						}

						idx++;
					}
				}
				// 2021.07.22 교환상품 출고예외등록
				else {
					// 2021
					OrderChange delvFailVo = new OrderChange();
					delvFailVo.setOrdNo(param.getOrdNo());
					delvFailVo.setOrdDtlNo(param.getOrdDtlNo());
					delvFailVo.setOrdChgSq(param.getOrdChgSq());
					delvFailVo.setOrdQty(param.getOrdQty() - param.getCnclRtnQty());
					delvFailVo.setChgQty(param.getCancelQty());
					delvFailVo.setRegNo(userNo);
	
					// 교환상품 출고예외등록
					orderChangeDao.insertTbExchangeDelvFail(delvFailVo);
	
					exchangeDelvFailCnt++;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new IllegalArgumentException(e);
		}

		log.info("exchangeDelvFailCnt ::: {}", exchangeDelvFailCnt);

		try {
			// 2021.06.08 알림톡전송 배송중 주문 알림톡 송부
			for(Order kakaoSend : delvStartList) {
				if (StringUtils.isNotBlank(kakaoSend.getOrdPhnno())) {
					try {
						kakaotalkService.sendDeliveryStart(kakaoSend, userNo);
					} catch (Exception e) {
						e.printStackTrace();
						// Do nothing
					}
				}
			}
		} catch (Exception e) {
			// 카카오 발송 에러시에는 그냥 진행되어야함
			e.printStackTrace();
		}

		// alert 처리
		String alert;
		if (cnt == idx) {
			alert = message.getMessage("SUCC_0004");
		} else {
			StringBuilder sb = new StringBuilder();
			sb.append("총 ");
			sb.append(idx);
			sb.append("건 중 ");
			sb.append(cnt);
			sb.append("건 처리되었습니다.<br/>");
			sb.append("(");
			for (int i=0; i < ordNoList.size(); i++) {
				sb.append(ordNoList.get(i));
				sb.append(" : ");
				sb.append(messageList.get(i));
				if (i < ordNoList.size() - 1) {
					sb.append("<br/>");
				}
			}
			sb.append(")");

			alert = sb.toString();
		}

		return alert;
	}

	/**
	 * 주문상세상태 변경 및 이력 생성
	 * @param order - 고객번호, 주문번호, 주문상세번호
	 * @author jsshin
	 * @since 2021. 04. 21
	 */
	@Transactional("shopTxnManager")
	public void saveOrdDtlStat(Order order) {
		// 주문상세 상태 변경
		orderDao.changedOrdDtlStat(order);
		// 주문상세 이력 저장
		orderDao.createOrderDetailHst(order);
		// 주문상세단품 상태 변경
		orderDao.updateOrderDetailItemStat(order);
 	}

	/**
	 * USAFE 보증보험 입금전 취소 (입금 확인 후 취소 안됨 주의)
	 * temp.setOrdNo(111);			// 주문번호
	 * @param param
	 * @author xodud1202
	 * @since 2021. 04. 30
	 */
	public String uSafeGuaranteePayedBeforeCancel(Order param) {
		// 보증보험 정보 조회
		Order insurance = orderDao.getInsuranceInfo(param);

		// 보증보험 신청 이력이 없으면 완료안됨
		if(insurance != null) {
			// 보증보험 입금 완료 정보 송부
			InsuranceManager manager = new InsuranceManager(env.getProperty("usafe.guarantee.send.url"), null);
			String result = manager.cancelInsurance(env.getProperty("usafe.guarantee.mall.id"), String.valueOf(param.getOrdNo()), insurance.getInsNo());

			// 송부 결과
			String rtnResult[]	= result.split("[\u007C]");
			param.setResultCd(rtnResult[0]);
			param.setResultMsg(rtnResult[1]);

			if("0".equals(param.getResultCd())) {
				param.setIfYn("C");
			} else {
				param.setIfYn("F");
			}

			orderDao.updateInsuranceInfo(param);
		}

		return "SUCCESS";
	}

	public String simpleDecode(String strVal) {
		String result = strVal;
		result = result.replaceAll("%3D", "=");
		result = result.replaceAll("%26", "&");
		result = result.replaceAll("%25", "%");
		result = result.replaceAll("%20", " ");
		return result;
	}
	
	/**
	 * 입점클레임목록건수(교환,반품접수)
	 * @param Order
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2021. 05. 17
	 */
	public int getOrderSellerClaimCount(Order order) {
		return scmDao.getOrderSellerClaimCount(order);
	}
	
	/**
	 * 입점클레임목록조회(교환,반품접수)
	 * @param Order
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2021. 05. 17
	 */
	public List<Order> getOrderSellerClaimList(Order order) {
		return scmDao.getOrderSellerClaimList(order);
	}
	
	/**
	 * 입점업체미발주목록 - 송장번호 입력(출고완료)
	 *
	 * @param orderList - 주문 정보
	 * @return String - 결과메시지
	 * @author jsh77b
	 * @since 2020. 11. 30
	 */
	@Transactional("shopTxnManager")
	public String saveClaimChgStat31(Collection<Order> orderList, int userNo) {
		
		// 1. 입점클레임목록 입고확인 처리
		for (Order oneData : orderList) {
			Order vo = new Order();
			vo.setOrdChgSq(oneData.getOrdChgSq());
			vo.setOrdDtlNo(oneData.getOrdDtlNo());
			vo.setChgStat(TscConstants.OrderChangeStat.WITHDRAW_GOODS_CHECK.value());
			vo.setRegNo(userNo);
			vo.setUpdNo(userNo);
			
			// 상품검수중 상태값 변경
			orderChangeDao.updateOrderChangeDtlForSeller(vo);
			
			OrderChange po = new OrderChange();
			po.setOrdChgSq(oneData.getOrdChgSq());
			po.setOrdDtlNo(oneData.getOrdDtlNo());
			po.setChgStat(TscConstants.OrderChangeStat.WITHDRAW_GOODS_CHECK.value());
			po.setRegNo(userNo);
			po.setUpdNo(userNo);
			
			// 상품검수중 상태값 변경 이력등록
			orderChangeDao.createOrderChangeDetailHst(po);
		}
		
		return "성공";
	}
	
	/**
	 * 회수컨펌
	 *
	 * @param order - 주문 정보
	 * @return String - 결과메시지
	 * @author jsh77b
	 * @since 2021. 05. 20
	 */
	@SuppressWarnings("unchecked")
	@Transactional("shopTxnManager")
	public String withdrawConfirm(Order order, int userNo) {
		
		Boolean temp = false;
		
		// 0. 주문변경 요청메모 수정
		order.setUpdNo(userNo);
		orderChangeDao.updateOrderChangeMemo(order);
		
		// 1. 기존사유에서 변경 여부 체크 (회사 ---> 고객)
		// 고객사유일때 사유체크
		if (order.getIsCustomer()) {
			// 사유변경여부체크 (회사 ---> 고객)
			int resultCnt = scmDao.getChgReasonCheck(order);
			
			if (resultCnt < 1) {
			
				// 주문변경정보목록
				Collection<Order> withdrawInfoForSeller = orderChangeDao.getWithdrawInfoForSeller(order);

				int delvFee 		= withdrawInfoForSeller.iterator().next().getDelvFee();
				int rtnDelvFee 		= withdrawInfoForSeller.iterator().next().getRtnDelvFee();
				int refundAmt		= withdrawInfoForSeller.iterator().next().getRefundAmt();
				
				// 교환일때실행
				if (TscConstants.OrderChangeGb.EXCHANGE.value().equals(order.getChgGb())) {
					// TB_ORDER_CHANGE_DETAIL 			결제대기 (G685_32)
					// TB_ORDER_CHANGE_DETAIL_HST 		등록
					// TB_ORDER_CHANGE ADD_PAY_COST 	교환배송비 업데이트
					Collection<Order> withdrawConfirmList = order.getWithdrawConfirmList();
					
					for (Order vo : withdrawConfirmList) {
						// 주문변경정보수정
						vo.setChgStat(TscConstants.OrderChangeStat.WITHDRAW_WAIT.value());	// 결제대기
						vo.setUpdNo(userNo);
						orderChangeDao.updateOrderChangeDtlForSeller(vo);
						
						// 주문변경이력정보등록
						OrderChange po = new OrderChange();
						po.setChgStat(TscConstants.OrderChangeStat.WITHDRAW_WAIT.value());
						po.setUpdNo(userNo);
						po.setRegNo(userNo);
						po.setOrdChgSq(vo.getOrdChgSq());
						po.setOrdDtlNo(vo.getOrdDtlNo());
						
						orderChangeDao.createOrderChangeDetailHst(po);
					}
					
					// 입점업체 클레임 주문변경요청정보변경
					order.setAddPayCost(delvFee + rtnDelvFee);
					orderChangeDao.updateOrderChangeForSeller(order);
					
				} else {
					// 반품
					// 환불금액이 반품배송비보다 작으면 결제대기 그렇지 않으면 진행 (TB_REFUND.REFUND_AMT 판단)
					// TODO 환불금액 계산 로직 수정
					if (refundAmt < rtnDelvFee) {
						// TB_ORDER_CHANGE_DETAIL 			결제대기 (G685_32)
						// TB_ORDER_CHANGE_DETAIL_HST 		등록
						// TB_ORDER_CHANGE ADD_PAY_COST 	반품배송비 업데이트
						
						Collection<Order> withdrawConfirmList = order.getWithdrawConfirmList();
						
						for (Order vo : withdrawConfirmList) {
							// 주문변경정보수정
							vo.setChgStat(TscConstants.OrderChangeStat.WITHDRAW_WAIT.value());	// 결제대기
							vo.setUpdNo(userNo);
							vo.setRegNo(userNo);
							orderChangeDao.updateOrderChangeDtlForSeller(vo);
							
							// 주문변경이력정보등록
							OrderChange po = new OrderChange();
							po.setChgStat(TscConstants.OrderChangeStat.WITHDRAW_WAIT.value());
							po.setUpdNo(userNo);
							po.setRegNo(userNo);
							po.setOrdChgSq(vo.getOrdChgSq());
							po.setOrdDtlNo(vo.getOrdDtlNo());
							
							orderChangeDao.createOrderChangeDetailHst(po);
							
							// TB_WITHDRAW
							orderChangeDao.insertTbWithdraw(vo);
							
							// TB_WITHDRAW_DETAIL
							orderChangeDao.insertTbWithdrawDetail(vo);
						}
						
						// 입점업체 클레임 주문변경요청정보변경
						order.setAddPayCost(rtnDelvFee);
						orderChangeDao.updateOrderChangeForSeller(order);
					} else {
						temp = true;
					}
				}
			} else {
				temp = true;
			}
		} else {
			temp = true;
		}
		
		Collection<Order> withdrawConfirmList = order.getWithdrawConfirmList();

		// 2.2 기존의 사유를 계속 유지시 회수컨펌을 진행
		// 교환일때 교환완료
		// 반품일때 반품진행중 ---> 환불컨펌대상
		if (temp) {
			// 교환
			// TB_ORDER_CHANGE_DETAIL 		교환완료 업데이트 (EXCHANGE_COMPLETE)
			// TB_ORDER_CHANGE_DETAIL_HST 	주문변경이력테이블 등록
			// TB_ORDER_DETAIL 				교환대상 결제완료 변경
			// TB_ORDER_DETAIL_HST 			주문상세이력테이블 등록
			if (TscConstants.OrderChangeGb.EXCHANGE.value().equals(order.getChgGb())) {
				
				int[] ordDtlNoArr 		= new int[withdrawConfirmList.size()];
				int[] cnclRtnReqQtyArr 	= new int[withdrawConfirmList.size()];
				int idx					= 0;
				
				int ordChgSq 			= withdrawConfirmList.iterator().next().getOrdChgSq();
				int ordNo 				= withdrawConfirmList.iterator().next().getOrdNo();
				String ordNm 			= withdrawConfirmList.iterator().next().getOrdNm();
				String ordPhnno 		= withdrawConfirmList.iterator().next().getOrdPhnno();
				
				for (Order vo : withdrawConfirmList) {
					// 주문변경정보수정
					vo.setChgStat(TscConstants.OrderChangeStat.EXCHANGE_COMPLETE.value());	// 교환완료
					vo.setUpdNo(userNo);
					vo.setRegNo(userNo);
					orderChangeDao.updateOrderChangeDtlForSeller(vo);
					
					// 주문변경이력정보등록
					OrderChange po = new OrderChange();
					po.setChgStat(TscConstants.OrderChangeStat.EXCHANGE_COMPLETE.value()); // 교환완료
					po.setUpdNo(userNo);
					po.setRegNo(userNo);
					po.setOrdChgSq(vo.getOrdChgSq());
					po.setOrdDtlNo(vo.getOrdDtlNo());
					orderChangeDao.createOrderChangeDetailHst(po);
					
					// 2021.07.20 교환결제완료 환불 정보 처리
					ordDtlNoArr[idx] 		= vo.getOrdDtlNo();
					cnclRtnReqQtyArr[idx] 	= vo.getChgQty();
					idx++;

					try {
						// 2021.09.11 태영아 이소스는 뭘까? 알려주삼
						// 네이버페이 주문형 정보일때 사용하는것으로 판단됨
						if ("scm".equals(env.getProperty("server.site.name"))) {
							naverPayService.sendNaverPayExchangeCollectComplete(vo, userNo);		// 교환재배송
						} else {
							// naverPayService.sendNaverPayExchangeReDelivery(change, userNo);    	// 교환재배송
							String addUrl = "/naverpay/send/exchange/collect/complete?ordDtlNo=" + vo.getOrdDtlNo() + "&userNo=" + userNo;
							naverPayService.sendScmServerForNaverpay(addUrl);						// 교환 반려
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				
				OrderChange orderChange = new OrderChange();
				orderChange.setOrdChgSq(ordChgSq);
				orderChange.setOrdNo(ordNo);
				orderChange.setOrdNm(ordNm);
				orderChange.setOrdPhnno(ordPhnno);
				orderChange.setOrdDtlNoArr(ordDtlNoArr);
				orderChange.setCnclRtnReqQtyArr(cnclRtnReqQtyArr);
				
				// 환불사전정보조회
				GagaMap refundPreInfo = orderChangeService.getRefundPreInfo(orderChange);
				List<Order> cnclReqList = (List<Order>)refundPreInfo.get("cnclReqList");
				
				// 환불금액정보조회
				GagaMap info = orderRefundService.cnclRtnRefundAmt(cnclReqList);
				List<Order> cancelOrderRefundList = (List<Order>) info.get("cancelOrderRefundList");
				
				for (Order withdrawVo : withdrawConfirmList) {
					for (Order vo : cancelOrderRefundList) {
						
						// 회수컨펌상세번호 == 취소상세번호가 같을때 동작
						if (withdrawVo.getOrdDtlNo().equals(vo.getOrdDtlNo())) {
							vo.setRegNo(userNo);
							vo.setUpdNo(userNo);
							vo.setOrdDtlStat(OrderDetailStat.PAYMENT_AFTER_CANCEL.value());
							
							// 원주문 주문상세정보 수정
							orderChangeDao.updateOrderDetail(vo);
							
							// 원주문 주문상세이력 등록
							orderDao.createOrderDetailHst(vo);
							
							// 원주문 주문상세단품 데이타 등록
							insertOrderDetailItem(vo, userNo, ordChgSq);
							
							// 교환주문 주문상세정보 등록
							// 교환주문 상세 수정
							vo.setOrdDtlStat(OrderDetailStat.PAYMENT_COMPLETE.value()); // 교환주문상세 결제완료
							vo.setOrdDtlNo(withdrawVo.getExchangeOrdDtlNo());
							vo.setWdBfSendYn("N");
							orderChangeDao.updateChgOrderDetailTemp(vo);
							
							// 교환주문 주문상세이력 등록
							orderDao.createOrderDetailHst(vo);
							
							// 교환주문 주문상세단품 데이타 등록
							insertOrderDetailItem(vo, userNo, ordChgSq);
						}
					}
				}
			}
			// 반품
			// TB_ORDER_CHANGE_DETAIL 		반품진행중 업데이트 (G685_33)
			// TB_ORDER_CHANGE_DETAIL_HST 	주문변경이력테이블 등록
			else {				
				for (Order vo : withdrawConfirmList) {
					// 주문변경정보수정
					vo.setChgStat(TscConstants.OrderChangeStat.RETURN_ING.value());	// 반품진행중
					vo.setUpdNo(userNo);
					vo.setRegNo(userNo);
					orderChangeDao.updateOrderChangeDtlForSeller(vo);
					
					// 주문변경이력정보등록
					OrderChange po = new OrderChange();
					po.setChgStat(TscConstants.OrderChangeStat.RETURN_ING.value()); // 반품진행중
					po.setUpdNo(userNo);
					po.setRegNo(userNo);
					po.setOrdChgSq(vo.getOrdChgSq());
					po.setOrdDtlNo(vo.getOrdDtlNo());
					orderChangeDao.createOrderChangeDetailHst(po);
					
					// TB_WITHDRAW
					orderChangeDao.insertTbWithdraw(vo);
					
					// TB_WITHDRAW_DETAIL
					orderChangeDao.insertTbWithdrawDetail(vo);
				}
			}
		}
		
		return "성공";
	}
	
	// 주문상세단품 데이타 등록
	private void insertOrderDetailItem(Order vo, int userNo, int ordChgSq) {
		
		// 주문상세단품정보조회
		Collection<Order> orderDetailItemList = orderChangeDao.getOrderDetailItemForCnclRtn(vo);
		
		int ordDtlOrdAmt 			= orderDetailItemList.iterator().next().getOrdAmt();
		int ordDtlCnclRtnAmt	 	= orderDetailItemList.iterator().next().getCnclRtnAmt();
		int ordDtlCpn1DcAmt 		= orderDetailItemList.iterator().next().getCpn1DcAmt();
		int ordDtlTmtb1DcAmt 		= orderDetailItemList.iterator().next().getTmtb1DcAmt();
		int ordDtlTmtb2DcAmt 		= orderDetailItemList.iterator().next().getTmtb2DcAmt();
		int ordDtlGoodsCpnDcAmt 	= orderDetailItemList.iterator().next().getGoodsCpnDcAmt();
		int ordDtlCartCpnDcAmt 		= orderDetailItemList.iterator().next().getCartCpnDcAmt();
		int ordDtlPntDcAmt 			= orderDetailItemList.iterator().next().getPntDcAmt();
		int ordDtlPrePntDcAmt 		= orderDetailItemList.iterator().next().getPrePntDcAmt();
		int ordDtlSavePntAmt 		= orderDetailItemList.iterator().next().getSavePntAmt();
		int ordDtlRealOrdAmt 		= orderDetailItemList.iterator().next().getRealOrdAmt();
		int ordDtlGfcdUseAmt 		= orderDetailItemList.iterator().next().getGfcdUseAmt();

		// 주문상세단품단위 금액 등록
		int length					= orderDetailItemList.size();
		int index					= 1;
		int leftOrdAmt 				= ordDtlOrdAmt;
		int leftCnclRtnAmt			= ordDtlCnclRtnAmt;
		int leftCpn1DcAmt 			= ordDtlCpn1DcAmt;
		int leftTmtb1DcAmt 			= ordDtlTmtb1DcAmt;
		int leftTmtb2DcAmt 			= ordDtlTmtb2DcAmt;
		int leftGoodsCpnDcAmt 		= ordDtlGoodsCpnDcAmt;
		int leftCartCpnDcAmt 		= ordDtlCartCpnDcAmt;
		int leftPntDcAmt 			= ordDtlPntDcAmt;
		int leftPrePntDcAmt 		= ordDtlPrePntDcAmt;
		int leftSavePntAmt 			= ordDtlSavePntAmt;
		int leftRealOrdAmt 			= ordDtlRealOrdAmt;
		int leftGfcdUseAmt 			= ordDtlGfcdUseAmt;
		
		for (Order orderDetailItem : orderDetailItemList) {
			double dtlOrdAmt		= orderDetailItem.getDtlOrdAmt();
			double dtlItemOrdAmt	= orderDetailItem.getDtlItemOrdAmt();
			double tempDivD			= (dtlItemOrdAmt / dtlOrdAmt) * 100;
			
			int tempDiv				= Integer.parseInt(String.valueOf(Math.round(tempDivD)));

			if (index == length) {
				orderDetailItem.setOrdAmt(leftOrdAmt);
				orderDetailItem.setCnclRtnAmt(leftCnclRtnAmt);
				orderDetailItem.setCpn1DcAmt(leftCpn1DcAmt);
				orderDetailItem.setTmtb1DcAmt(leftTmtb1DcAmt);
				orderDetailItem.setTmtb2DcAmt(leftTmtb2DcAmt);
				orderDetailItem.setGoodsCpnDcAmt(leftGoodsCpnDcAmt);
				orderDetailItem.setCartCpnDcAmt(leftCartCpnDcAmt);
				orderDetailItem.setPrePntDcAmt(leftPrePntDcAmt);
				orderDetailItem.setPntDcAmt(leftPntDcAmt);
				orderDetailItem.setGfcdUseAmt(leftGfcdUseAmt);
				orderDetailItem.setRealOrdAmt(leftRealOrdAmt);
				orderDetailItem.setSavePntAmt(leftSavePntAmt);
			} else {
				orderDetailItem.setOrdAmt((ordDtlOrdAmt 				* tempDiv) / 100);
				orderDetailItem.setCnclRtnAmt((ordDtlCnclRtnAmt 		* tempDiv) / 100);
				orderDetailItem.setCpn1DcAmt((ordDtlCpn1DcAmt 			* tempDiv) / 100);
				orderDetailItem.setTmtb1DcAmt((ordDtlTmtb1DcAmt 		* tempDiv) / 100);
				orderDetailItem.setTmtb2DcAmt((ordDtlTmtb2DcAmt 		* tempDiv) / 100);
				orderDetailItem.setGoodsCpnDcAmt((ordDtlGoodsCpnDcAmt 	* tempDiv) / 100);
				orderDetailItem.setCartCpnDcAmt((ordDtlCartCpnDcAmt 	* tempDiv) / 100);
				orderDetailItem.setPrePntDcAmt((ordDtlPrePntDcAmt 		* tempDiv) / 100);
				orderDetailItem.setPntDcAmt((ordDtlPntDcAmt 			* tempDiv) / 100);
				orderDetailItem.setGfcdUseAmt((ordDtlGfcdUseAmt 		* tempDiv) / 100);
				orderDetailItem.setRealOrdAmt((ordDtlRealOrdAmt 		* tempDiv) / 100);
				orderDetailItem.setSavePntAmt((ordDtlSavePntAmt 		* tempDiv) / 100);
				
				leftOrdAmt			-= ((ordDtlOrdAmt 					* tempDiv) / 100);
				leftCnclRtnAmt		-= ((ordDtlCnclRtnAmt 				* tempDiv) / 100);
				leftCpn1DcAmt 		-= ((ordDtlCpn1DcAmt 				* tempDiv) / 100);
				leftTmtb1DcAmt 		-= ((ordDtlTmtb1DcAmt 				* tempDiv) / 100);
				leftTmtb2DcAmt 		-= ((ordDtlTmtb2DcAmt 				* tempDiv) / 100);
				leftGoodsCpnDcAmt 	-= ((ordDtlGoodsCpnDcAmt 			* tempDiv) / 100);
				leftCartCpnDcAmt 	-= ((ordDtlCartCpnDcAmt 			* tempDiv) / 100);
				leftPrePntDcAmt 	-= ((ordDtlPrePntDcAmt 				* tempDiv) / 100);
				leftPntDcAmt 		-= ((ordDtlPntDcAmt 				* tempDiv) / 100);
				leftGfcdUseAmt 		-= ((ordDtlGfcdUseAmt 				* tempDiv) / 100);
				leftRealOrdAmt 		-= ((ordDtlRealOrdAmt 				* tempDiv) / 100);
				leftSavePntAmt 		-= ((ordDtlSavePntAmt 				* tempDiv) / 100);
			}

			orderDetailItem.setRegNo(userNo);
			orderDetailItem.setUpdNo(userNo);
			orderDetailItem.setOrdDtlStat(vo.getOrdDtlStat());
			
			// 2021.06.25 WMS 회수정보 수집 (교환완료) (정산구분값추가)
			if (OrderDetailStat.PAYMENT_AFTER_CANCEL.value().equals(vo.getOrdDtlStat())) {
				orderDetailItem.setOrdDtlStat(TscConstants.OrdDtlItemStat.SALE_RETURN_EXCHANGE_COMPLETE.value());
				orderDetailItem.setCnclRtnQty(vo.getOrdCanChgQty());  
				orderDetailItem.setOrdChgSq(ordChgSq);
				
				orderChangeDao.createOrderDetailItemHst(orderDetailItem);
				orderChangeDao.updateOrderDetailItem(orderDetailItem);
			} else {
				orderDetailItem.setOrdDtlStat(TscConstants.OrdDtlItemStat.SALE_PAYMENT_COMPLETE.value());
				orderDetailItem.setExchangeOrdDtlItemSq(orderDetailItem.getOrdDtlItemSq());
				
				// 2021.08.20 교환완료시 결제완료 item 정보 수정
				orderChangeDao.updateOrderDetailItemExchPay(orderDetailItem);
				orderChangeDao.createOrderDetailItemHstForExchange(orderDetailItem);
			}
			
			index++;
		}
	}
	
	
	/**
	 * 회수컨펌목록
	 *
	 * @param order - 주문 정보
	 * @return String - 결과메시지
	 * @author jsh77b
	 * @since 2021. 05. 20
	 */
	@Transactional("shopTxnManager")
	public String withdrawConfirmList(Collection<Order> withdrawConfirmList, int userNo) {
		
		// 주문변경상세단위로 반복문처리
		for (Order vo : withdrawConfirmList) {
			// 교환
			// TB_ORDER_CHANGE_DETAIL 		교환완료 업데이트 (EXCHANGE_COMPLETE)
			// TB_ORDER_CHANGE_DETAIL_HST 	주문변경이력테이블 등록
			// TB_ORDER_DETAIL 				교환대상 결제완료 변경'
			// TB_ORDER_DETAIL_HST 			주문상세이력테이블 등록
			if (TscConstants.OrderChangeGb.EXCHANGE.value().equals(vo.getChgGb())) {
				// 주문변경정보수정
				vo.setChgStat(TscConstants.OrderChangeStat.EXCHANGE_COMPLETE.value());	// 교환완료
				vo.setUpdNo(userNo);
				vo.setRegNo(userNo);
				orderChangeDao.updateOrderChangeDtlForSeller(vo);
				
				// 주문변경이력정보등록
				OrderChange po = new OrderChange();
				po.setChgStat(TscConstants.OrderChangeStat.EXCHANGE_COMPLETE.value()); // 교환완료
				po.setUpdNo(userNo);
				po.setRegNo(userNo);
				po.setOrdChgSq(vo.getOrdChgSq());
				po.setOrdDtlNo(vo.getOrdDtlNo());
				orderChangeDao.createOrderChangeDetailHst(po);
				
				// 2. 주문상세상태값 변경
				vo.setOrdDtlStat(TscConstants.OrderDetailStat.PAYMENT_COMPLETE.value()); // 결제완료
				scmDao.updateOrderDetailStat(vo);
				
				// 3. 주문상세상태 변경 이력생성
				orderDao.createOrderDetailHst(vo);
			} 
			// 반품
			// TB_ORDER_CHANGE_DETAIL 		반품진행중 업데이트 (G685_33)
			// TB_ORDER_CHANGE_DETAIL_HST 	주문변경이력테이블 등록
			else {
				// 주문변경정보수정
				vo.setChgStat(TscConstants.OrderChangeStat.RETURN_ING.value());	// 반품진행중
				vo.setUpdNo(userNo);
				vo.setRegNo(userNo);
				orderChangeDao.updateOrderChangeDtlForSeller(vo);
				
				// 주문변경이력정보등록
				OrderChange po = new OrderChange();
				po.setChgStat(TscConstants.OrderChangeStat.RETURN_ING.value()); // 반품진행중
				po.setUpdNo(userNo);
				po.setRegNo(userNo);
				po.setOrdChgSq(vo.getOrdChgSq());
				po.setOrdDtlNo(vo.getOrdDtlNo());
				orderChangeDao.createOrderChangeDetailHst(po);
				
				// TB_WITHDRAW
				orderChangeDao.insertTbWithdraw(vo);
				
				// TB_WITHDRAW_DETAIL
				orderChangeDao.insertTbWithdrawDetail(vo);
			}
		}
		
		return "성공";
	}
	
	/**
	 * 최근사용한결제수단
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2021. 05. 26
	 */
	public Order getCustPaymeans(Order order) {
		return orderDao.getCustPaymeans(order);
	}
	
	/**
	 * 스윗트래커 정보 조회
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2021. 06. 17
	 */
	public Collection<Order> getSweetTrackerDeliveryInfo(Order order) {
		return orderDao.getSweetTrackerDeliveryInfo(order);
	}

	/**
	 * 배송비 테이블 결제시퀀스 등록
	 * 
	 * @param Payment
	 * @author card007
	 * @since 2021. 06. 17
	 */
	@Transactional("shopTxnManager")
	public void updateDeliveryFeePaySq(Payment payment) {
		orderDao.updateDeliveryFeePaySq(payment);
	}
	
	/**
	 * 선물받기 옵션변경
	 * @param Order
	 * @return Order
	 * @author jsh77b
	 * @since 2021. 06. 18
	 */
	@Transactional("shopTxnManager")
	public void updateOrderDetailItemOpt2(Order order) {
		
		// 1. 추가결제 반품,교환 상태값 업데이트
		orderDao.updateOrderDetailItemOpt2(order);
	}
	
	

	/**
	 * 추가배송비 결제금액 환불배송비 수정 처리
	 *
	 * @param Payment
	 * @return int
	 * @author card007
	 * @since 2021. 06. 18
	 */
	@Transactional("shopTxnManager")
	public int updateRefundDeliveryFee(Payment payment) {
		return orderDao.updateRefundDeliveryFee(payment);
	}
	
	/**
	 * 개인통관부호 정보 가져오기
	 * @param Order
	 * @return
	 * @author jsh77b
	 * @since 2021. 07. 05
	 */
	public Order getEntryNo(Order order) {
		return orderDao.getEntryNo(order);
	}
	
	/**
	 * 자동품절취소실패목록
	 *
	 * @param order - 주문 정보
	 * @return Collection<Order>
	 * @author jsh77b
	 * @since 2021. 09. 11
	 */
	public Collection<Order> getSoldOutCnclFailList(Order order) {
		return orderDao.getSoldOutCnclFailList(order);
	}
}



