package kr.wisestone.owl.service.impl;


import kr.wisestone.owl.constant.Constants;
import kr.wisestone.owl.constant.MsgConstants;
import kr.wisestone.owl.domain.*;
import kr.wisestone.owl.domain.enumType.EmailType;
import kr.wisestone.owl.exception.OwlRuntimeException;
import kr.wisestone.owl.repository.PaymentRepository;
import kr.wisestone.owl.service.*;
import kr.wisestone.owl.util.CommonUtil;
import kr.wisestone.owl.util.ConvertUtil;
import kr.wisestone.owl.util.DateUtil;
import kr.wisestone.owl.util.MapUtil;
import kr.wisestone.owl.vo.PaymentHistoryVo;
import kr.wisestone.owl.vo.PaymentVo;
import kr.wisestone.owl.vo.UserVo;
import kr.wisestone.owl.web.form.PaymentForm;
import org.apache.commons.text.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class PaymentServiceImpl extends AbstractServiceImpl<Payment, Long, JpaRepository<Payment, Long>> implements PaymentService {

    private static final Logger log = LoggerFactory.getLogger(PaymentServiceImpl.class);

    @Autowired
    private PaymentRepository paymentRepository;

    @Autowired
    private WorkspaceService workspaceService;

    @Autowired
    private UserWorkspaceService userWorkspaceService;

    @Autowired
    private ReservationDisableUserService reservationDisableUserService;

    @Autowired
    private UserService userService;

    @Autowired
    private SystemEmailService systemEmailService;

    @Autowired
    private PaymentHistoryService paymentHistoryService;

    @Value("${saas.usdkrw}")
    private Integer usdKrw;

    @Value("${payment.cancel.manager.email}")
    private String paymentCancelManagerEmail;

    private static final String IAMPORT_SERVER_URL = "https://api.iamport.kr";
    private static final String ACCESS_TOKEN_REQUEST_URL = "/users/getToken";
    private static final String IMP_KEY = "4101736461182334";
    private static final String IMP_SECRET = "HjTiwAyYJD8r0NRDY0wcmQG989bsOTGvczOJamIT0Rl0FdEDdaQz1wJ9GUCuNj00TOK3btWclic0vREI";
    private static final String SUBSCRIBE_PAYMENTS_ONETIME = "/subscribe/payments/onetime";  //  최초 결제할때
    private static final String SUBSCRIBE_PAYMENTS_AGAIN = "/subscribe/payments/again";  //  정기 결제할때
    private static final String PAYMENTS_CANCEL_URL = "/payments/cancel";    //  취소할때
    private static final int DEFAULT_BILLING_AMOUNT = 9;
    private static final int BILLING_AMOUNT = 6;

    @Override
    protected JpaRepository<Payment, Long> getRepository() {
        return this.paymentRepository;
    }

    //  즉시 결제
    @Override
    @Transactional
    public void immediateAddUser(PaymentForm paymentForm) {
        Workspace workspace = this.workspaceService.findOne(paymentForm.getWorkspaceId());
        //  서버에서 결재 금액을 다시 계산한다.
        int definiteAmount = this.calculateDailyAmount(paymentForm.getBuyUser(), workspace.getExpireDate());
        paymentForm.setPaymentAmount(definiteAmount);

        //  결재 실행
        RestClientResultObject resultObject = this.executePayment(paymentForm, workspace);
        //  히스토리 생성
        PaymentHistory paymentHistory = this.paymentHistoryService.addPaymentHistory(resultObject, paymentForm, workspace);
        //  결재 결과 처리
        this.paymentResultProcess(paymentHistory, workspace, paymentForm, true);
    }

    private int calculateDailyAmount(int buyUser, Date expireDate) {

        int expireDateTerm = DateUtil.getDateDiff(new Date(), expireDate) + 1;

        //  사용자가 1명이 안될 때는 오류 발생
        if (buyUser < 1) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_BUY_USER_MUST_BE_GREATER_THAN_ZERO));
        }

        if (expireDateTerm > 29) {
            //  기본 사용자(10명)을 초과한 결제를 진행했을 때 결제 금액을 계산한다.
            return this.calculateAmountDefaultUserOver(buyUser);
        }
        else {
            int totalAmount = (BILLING_AMOUNT * this.usdKrw * buyUser);
            int dayAmount = (totalAmount / 30); //  30일 기준으로 가격을 나눈다.
            double sale = buyUser * 0.01;
            double discount = 0;

            //  100명 이상 결제시 할인 적용
            if (buyUser > 99) {
                discount = (totalAmount * (sale / 100));
            }

            return (int) Math.round((dayAmount * expireDateTerm) - discount);
        }
    }

    //  기본 사용자(10명)을 초과한 결제를 진행했을 때 결제 금액을 계산한다.
    private int calculateAmountDefaultUserOver(int buyUser) {
        //   100프로
        int totalAmount = (BILLING_AMOUNT * this.usdKrw * buyUser);
        double sale = buyUser * 0.01;
        double discount = 0;

        //  100명 이상 결제시 할인 적용
        if (buyUser > 99) {
            discount = (totalAmount * (sale / 100));
        }

        return (int) Math.floor((totalAmount - discount));
    }

    //  정기 결제
    @Override
    @Transactional
    public void paymentOneTime(PaymentForm paymentForm) {
        Workspace workspace = this.workspaceService.getWorkspace(paymentForm.getWorkspaceId());
        //  결제하려는 사용자가 업무 공간의 관리자인지 확인한다.
        this.checkWorkspaceManager(workspace);
        //  구매 사용자 수 체크
        this.verifyBuyUser(paymentForm);
        //  결제 유형 체크
        this.verifyPaymentType(paymentForm.getType());

        //  서버에서 결제 금액을 다시 계산한다.
        int definiteAmount = this.calculateAmount(paymentForm.getBuyUser());
        paymentForm.setPaymentAmount(definiteAmount);
        //  결제 실행
        RestClientResultObject resultObject = this.executePayment(paymentForm, workspace);
        //  히스토리 생성
        PaymentHistory paymentHistory = this.paymentHistoryService.addPaymentHistory(resultObject, paymentForm, workspace);
        //  결제 결과 처리
        this.paymentResultProcess(paymentHistory, workspace, paymentForm, false);

        //  결제 정보를 map 으로 만들어준다. - 이메일 발송에 사용
        Map<String, Object> paymentMap = this.makePaymentMap(workspace, this.webAppUtil.getLoginUser().getName(), paymentForm.getBuyUser(), definiteAmount, null);

        //  결제 성공 메일 발송
        this.systemEmailService.directEmail(new String[]{this.webAppUtil.getLoginUser().getAccount()}, EmailType.REGULAR_PAYMENT, paymentMap, this.webAppUtil.getLoginUser().getAccount());
    }

    //  결제 정보를 map 으로 만들어준다. - 이메일 발송에 사용
    private Map<String, Object> makePaymentMap(Workspace workspace, String userName, Integer buyUser, Integer price, String email) {
        Map<String, Object> paymentMap = new HashMap<>();
        paymentMap.put("userName", userName);
        paymentMap.put("workspaceName", workspace.getName());
        paymentMap.put("storageSize", workspace.getStorageSize() / 1024 / 1024 / 1024);
        paymentMap.put("buyUser", buyUser);
        paymentMap.put("price", CommonUtil.getDecimalFormat(price));
        paymentMap.put("registerDate", DateUtil.convertDateToStr(new Date()));
        paymentMap.put("nextPaymentDay", DateUtil.convertDateToYYYYMMDD(DateUtil.addDays(workspace.getExpireDate(), 1)));
        paymentMap.put("startDate", DateUtil.convertDateToYYYYMMDD(workspace.getStartDate()));
        paymentMap.put("expireDate", DateUtil.convertDateToYYYYMMDD(workspace.getExpireDate()));
        paymentMap.put("email", email);

        return paymentMap;
    }

    //  결제하려는 사용자가 업무 공간의 관리자인지 확인한다.
    private void checkWorkspaceManager(Workspace workspace) {
        UserWorkspace userWorkspace = this.userWorkspaceService.findByUserIdAndWorkspaceId(this.webAppUtil.getLoginId(), workspace.getId());

        if (!userWorkspace.getManagerYn()) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_EXECUTE_ONLY_WORKSPACE_MANAGER));
        }
    }

    //  스케쥴러로 한번 결제한 정보를 토대로 자동 결제를 실행한다.
    @Override
    @Transactional
    public void subscribeImmediate(Workspace workspace) {
        Payment payment = workspace.getPayment();

        if (payment == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_NOT_EXIST));
        }

        User workspaceManager = this.userService.findByWorkspaceIdAndManagerYn(workspace);

        if (workspaceManager == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.USER_WORKSPACE_MANAGER_NOT_EXIST));
        }

        PaymentForm paymentForm = ConvertUtil.copyProperties(payment, PaymentForm.class);
        paymentForm.setCustomerUid(workspace.makeCustomerUid(workspaceManager.getAccount()));
        paymentForm.setMerchantUid(workspaceManager.getAccount() + new Date().getTime());
        paymentForm.setPaymentAmount(payment.getPrice());   //  히스토리 생성할 때 사용

        HttpHeaders headers = new HttpHeaders();
        headers.add("Authorization", this.getAccessToken());

        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));

        MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
        parameters.add("customer_uid", paymentForm.getCustomerUid());
        parameters.add("merchant_uid", paymentForm.getMerchantUid());
        parameters.add("amount", paymentForm.getPaymentAmount().toString());

        RestClientResultObject resultObject = this.postRequest(this.makeIamportRequestUrl(SUBSCRIBE_PAYMENTS_AGAIN), new HttpEntity<>(parameters, headers));
        //  히스토리 생성
        PaymentHistory paymentHistory = this.paymentHistoryService.addPaymentHistory(resultObject, paymentForm, workspace);
        //  결제 결과 처리
        this.paymentResultProcess(paymentHistory, workspace, paymentForm, false);
        //  비활성화 사용자 처리
        this.checkPaymentByUserCount(paymentHistory, payment, paymentForm, workspace);

        List<UserWorkspace> userWorkspaces = this.userWorkspaceService.findByWorkspaceIdAndManagerYn(workspace.getId(), true);
        //  업무 공간 담당자 이름
        String workspaceManagerName = "";

        if (userWorkspaces.size() > 0) {
            workspaceManagerName = userWorkspaces.get(0).getUser().getName();
        }

        //  결제 정보를 map 으로 만들어준다. - 이메일 발송에 사용
        Map<String, Object> paymentMap = this.makePaymentMap(workspace, workspaceManagerName, payment.getBuyUser(), payment.getPrice(), null);

        //  결제 성공 메일 발송
        this.systemEmailService.directEmail(new String[]{workspaceManager.getAccount()}, EmailType.REGULAR_PAYMENT, paymentMap, null);
    }

    //  결제된 사용자 수를 체크한다.
    private void checkPaymentByUserCount(PaymentHistory paymentHistory, Payment payment, PaymentForm paymentForm, Workspace workspace) {
        try {
            //  결제가 성공했을 때 참여 사용자와 결제된 사용자 수를 비교한다.
            if (paymentHistory.getPaymentResult().equals(PaymentHistory.PAYMENT_RESULT_SUCCESS)) {
                Integer activeUserCount = this.userWorkspaceService.countByWorkspaceIdAndUseYn(workspace.getId(), true);

                //  결제한 사용자보다 참여중인 사용자가 많을 경우
                if (workspace.getMaxUser() < activeUserCount) {
                    this.executeWorkspaceStandbyUser(workspace, payment, activeUserCount);
                }
            }
        } catch (Exception e) {
            this.cancelPayment(paymentForm.getMerchantUid(), "");
            this.paymentHistoryService.cancelPaymentHistory(paymentForm, workspace, "결제 완료후 비활성화로 예정된 사용자 처리 과정에서 오류가 발생하였습니다.");
        }
    }

    //  업무 공간에 참여하는 사용자 참여 대기 상태로 변경하기 - 결제 인원 수를 제외한 인원들
    private void executeWorkspaceStandbyUser(Workspace workspace, Payment payment, Integer activeUserCount) {
        int disableUserCount = activeUserCount - workspace.getMaxUser();
        //  참여 대기로 예약된 사용자부터 참여 대기로 상태를 변경
        ReservationDisableUser reservationDisableUser = payment.getReservationDisableUser();

        if (reservationDisableUser != null) {
            String[] userIds = reservationDisableUser.getUserIds().split(",");

            for (String userId : userIds) {
                if (!StringUtils.isEmpty(userId)) {
                    if (disableUserCount < 1) {
                        break;
                    }

                    User user = this.userService.getUser(Long.valueOf(userId));
                    //  해당 업무 공간에서 사용자를 비활성화한다.
                    this.userWorkspaceService.disabledUserWorkspace(user, workspace);
                    //  사용자를 해당 업무 공간에서 참여 대기 상태로 변경했으면 카운터를 내린다.
                    disableUserCount--;
                }
            }

            payment.setReservationDisableUser(null);
            this.paymentRepository.saveAndFlush(payment);
        }

        //  해당 업무 공간에 참여하는 사용자 중 번호가 높은 순서대로 참여 대기 상태로 변경한다.
        List<UserWorkspace> userWorkspaces = this.userWorkspaceService.findByWorkspaceIdAndUseYn(workspace.getId(), true);

        for (UserWorkspace userWorkspace : userWorkspaces) {
            //  관리자는 항상 참여 상태여야 한다.
            if (userWorkspace.getManagerYn()) {
                continue;
            }

            if (disableUserCount < 1) {
                break;
            }

            //  해당 업무 공간에서 사용자를 비활성화한다.
            this.userWorkspaceService.disabledUserWorkspace(userWorkspace.getUser(), workspace);
            //  사용자를 해당 업무 공간에서 참여 대기 상태로 변경했으면 카운터를 내린다.
            disableUserCount--;
        }
    }

    //  서버에서 결제 금액을 다시 계산한다.
    private int calculateAmount(int buyUser) {
        //  사용자가 1명이 안될 때는 오류 발생
        if (buyUser < 1) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_BUY_USER_MUST_BE_GREATER_THAN_ZERO));
        }

        if (buyUser < 11) {
            return (DEFAULT_BILLING_AMOUNT * this.usdKrw);
        }
        else {
            //  기본 사용자(10명)을 초과한 결제를 진행했을 때 결제 금액을 계산한다.
            return this.calculateAmountDefaultUserOver(buyUser);
        }
    }

    //  결제를 실행한다.
    private RestClientResultObject executePayment(PaymentForm paymentForm, Workspace workspace) {
        UserVo workspaceManager = this.webAppUtil.getLoginUser();
        paymentForm.setCustomerUid(workspace.makeCustomerUid(workspaceManager.getAccount()));
        paymentForm.setMerchantUid(workspaceManager.getAccount() + new Date().getTime());
        //  HttpHeader 를 생성한다.
        HttpHeaders headers = this.makeHttpHeader();

        MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
        parameters.add("merchant_uid", paymentForm.getMerchantUid());
        parameters.add("amount", paymentForm.getPaymentAmount().toString());
        parameters.add("card_number", CommonUtil.decryptAES128(paymentForm.getCardNumber1()) + "-" + CommonUtil.decryptAES128(paymentForm.getCardNumber2())
                + "-" + CommonUtil.decryptAES128(paymentForm.getCardNumber3()) + "-" + CommonUtil.decryptAES128(paymentForm.getCardNumber4()));
        parameters.add("expiry", CommonUtil.decryptAES128(paymentForm.getExpireYear()) + "-" + CommonUtil.decryptAES128(paymentForm.getExpireMonth()));
        parameters.add("birth", CommonUtil.decryptAES128(paymentForm.getBirth()));
        parameters.add("pwd_2digit", CommonUtil.decryptAES128(paymentForm.getCardPwd()));
        parameters.add("customer_uid", paymentForm.getCustomerUid());
        parameters.add("buyer_name", workspaceManager.getName());
        parameters.add("buyer_email", workspaceManager.getAccount());

        return this.postRequest(this.makeIamportRequestUrl(SUBSCRIBE_PAYMENTS_ONETIME), new HttpEntity<>(parameters, headers));
    }

    //  결제 결과를 처리한다.
    private PaymentHistoryVo paymentResultProcess(PaymentHistory paymentHistory, Workspace workspace, PaymentForm paymentForm, Boolean immediate) {
        if (paymentHistory.getPaymentResult().equals(PaymentHistory.PAYMENT_RESULT_SUCCESS)) {
            try {
                //  추가 결제
                if (immediate) {
                    Payment payment = workspace.getPayment();
                    //  인원 추가
                    payment.setBuyUser(payment.getBuyUser() + paymentForm.getBuyUser());
                    //  추가 결제로 인한 사용금액 변경
                    payment.setPrice(this.calculateAmountDefaultUserOver(payment.getBuyUser()));
                    this.paymentRepository.saveAndFlush(payment);
                    //  추가 결제 완료 후 최대 사용자 수, 저장 공간을 업데이트한다.
                    this.workspaceService.updateWorkspaceByImmediatePayment(workspace, payment.getBuyUser());
                }
                else {
                    //  정기 결제로 결제를 진행한 경우
                    Payment payment = this.executePaymentOneTime(workspace, paymentForm);

                    if (payment != null) {
                        //  비활성화 사용자 처리
                        this.checkPaymentByUserCount(paymentHistory, payment, paymentForm, workspace);
                    }
                }
            } catch (Exception e) {
                this.cancelPayment(paymentForm.getMerchantUid(), "");
                PaymentHistory cancelPaymentHistory = this.paymentHistoryService.cancelPaymentHistory(paymentForm, workspace, "결제 과정에서 오류가 발생하였습니다. 다시 시도해 주세요.");
                return ConvertUtil.copyProperties(cancelPaymentHistory, PaymentHistoryVo.class);
            }
        }
        else {
            throw new OwlRuntimeException(this.messageAccessor.getMessage(paymentHistory.getPaymentResponse()));
        }

        return ConvertUtil.copyProperties(paymentHistory, PaymentHistoryVo.class);
    }

    //  정기 결제로 결제를 진행한 경우
    private Payment executePaymentOneTime(Workspace workspace, PaymentForm paymentForm) {
        //  다음 결제일 지정 및 업무 공간에 결제한 신규 데이터 적용
        this.workspaceService.updateWorkspace(workspace, paymentForm);

        if (workspace.getPayment() == null) {
            //  결제가 완료되고 결제 정보가 업무 공간에 업데이트가 되면 정기 결제를 위해 결제 정보를 생성한다.
            Payment payment = ConvertUtil.copyProperties(paymentForm, Payment.class);
            payment.setPrice(paymentForm.getPaymentAmount());
            payment.setWorkspace(workspace);
            return this.paymentRepository.saveAndFlush(payment);
        }

        return null;
    }

    //  결제 진행중 발생한 오류로 인한 결제 취소 요청
    private String cancelPayment(String merchantUid, String reason) {
        //  HttpHeader 를 생성한다.
        HttpHeaders headers = this.makeHttpHeader();
        //  RestTemplate 를 생성한다.
        RestTemplate restTemplate = this.makeRestTemplate();

        MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
        parameters.add("merchant_uid", merchantUid);
        parameters.add("reason", reason);

        URI targetUrl = UriComponentsBuilder.fromUriString(IAMPORT_SERVER_URL)
                .path(PAYMENTS_CANCEL_URL)
                .build()
                .toUri();

        String url = null;

        try {
            url = URLDecoder.decode(targetUrl.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        ResponseEntity<String> result = restTemplate.postForEntity(url, new HttpEntity<>(parameters, headers), String.class);
        Map<String, Object> resultMap = ConvertUtil.convertJsonToMap(result.getBody());
        return StringEscapeUtils.unescapeJava(MapUtil.getString(resultMap, "response"));
    }

    //  HttpHeader 를 생성한다.
    private HttpHeaders makeHttpHeader() {
        HttpHeaders headers = new HttpHeaders();
        headers.add("Authorization", this.getAccessToken());

        return headers;
    }

    //  RestTemplate 를 생성한다.
    private RestTemplate makeRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters()
                .add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));

        return restTemplate;
    }

    //  정기 결제 취소하기
    @Override
    @Transactional
    public void cancelNextPayment(PaymentForm paymentForm) {
        Workspace workspace = this.workspaceService.getWorkspace(paymentForm.getWorkspaceId());
        //  결제 취소하려는 사용자가 업무 공간의 관리자인지 확인한다.
        this.checkWorkspaceManager(workspace);

        Payment payment = workspace.getPayment();

        if (payment == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_NOT_EXIST));
        }
        //  업무 공간 정기 결제 취소 - 정기 결제 정보 삭제
        this.workspaceService.cancelWorkspacePayment(workspace);

        //  결제 정보를 map 으로 만들어준다. - 이메일 발송에 사용
        Map<String, Object> paymentMap = this.makePaymentMap(workspace, this.webAppUtil.getLoginUser().getName(), 0, 0, CommonUtil.decryptAES128(this.webAppUtil.getLoginUser().getAccount()));
        paymentMap.put("maxUser", workspace.getMaxUser());

        try {
            //  오늘 결제한 업무 공간을 사용자가 취소했는지 확인한다.
            PaymentHistory paymentHistory = this.paymentHistoryService.findByWorkspaceLastPaymentHistory(workspace);

            //  당일 결제 취소일 경우
            if (paymentHistory.getRegisterDate().compareTo(new Date()) == 0) {
                paymentMap.put("refundPrice", CommonUtil.getDecimalFormat(paymentHistory.getPrice())); //  환불 금액
                //  회계 담당자 이메일 주소 암호화
                String encryptAccountingManager = CommonUtil.encryptAES128(this.paymentCancelManagerEmail);
                //  회계 담당자에게 결제 취소 알림 메일
                this.systemEmailService.directEmail(new String[]{encryptAccountingManager}, EmailType.REGULAR_PAYMENT_CANCEL_BY_ACCOUNTING_MANAGER, paymentMap, encryptAccountingManager);
            }

        } catch (Exception e) {
            log.debug("환불 알림 메일 오류 발생" + e.getMessage());
        }

        //  정기 결제 취소 알림 메일
        this.systemEmailService.directEmail(new String[]{this.webAppUtil.getLoginUser().getAccount()}, EmailType.REGULAR_PAYMENT_CANCEL, paymentMap, this.webAppUtil.getLoginUser().getAccount());
    }

    @Override
    public String getAccessToken() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters()
                .add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));

        MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
        parameters.add("imp_key", IMP_KEY);
        parameters.add("imp_secret", IMP_SECRET);

        URI targetUrl = UriComponentsBuilder.fromUriString(IAMPORT_SERVER_URL)
                .path(ACCESS_TOKEN_REQUEST_URL)
                .build()
                .toUri();

        String url = "";

        try {
            url = URLDecoder.decode(targetUrl.toString(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        String result = restTemplate.postForObject(url, parameters, String.class);
        Map<String, Object> resultMap = ConvertUtil.convertJsonToMap(result);
        Map<String, Object> tokenMap = (Map<String, Object>) resultMap.get("response");
        return MapUtil.getString(tokenMap, "access_token");
    }

    //  결제 상세 정보를 조회한다.
    @Override
    @Transactional(readOnly = true)
    public void detailPayment(Map<String, Object> resJsonData, PaymentForm paymentForm) {
        Workspace workspace = this.workspaceService.findOne(paymentForm.getWorkspaceId());
        Payment payment = workspace.getPayment();

        if (payment != null) {
            resJsonData.put(Constants.RES_KEY_CONTENTS, ConvertUtil.copyProperties(payment, PaymentVo.class));
        }
    }

    //  결제 정보를 수정한다.
    @Override
    @Transactional
    public PaymentVo modifyPayment(PaymentForm paymentForm) {
        Workspace workspace = this.workspaceService.findOne(paymentForm.getWorkspaceId());
        //  결제하려는 사용자가 업무 공간의 관리자인지 확인한다.
        this.checkWorkspaceManager(workspace);

        Payment payment = workspace.getPayment();

        Map<String, Object> paymentMap = new HashMap<>();
        paymentMap.put("beforeMaxUser", payment.getBuyUser());    //  이전 최대 사용자 수
        paymentMap.put("beforePrice", CommonUtil.getDecimalFormat(payment.getPrice()));  //  이전 가격

        //  결제 사용자 수 체크
        this.verifyBuyUser(paymentForm);

        //  결제 유형 체크
        this.verifyPaymentType(paymentForm.getType());
        payment.setBuyUser(paymentForm.getBuyUser());
        payment.setType(paymentForm.getType());

        //  서버에서 결제 금액을 다시 계산한다.
        int definiteAmount = this.calculateAmount(paymentForm.getBuyUser());
        payment.setPrice(definiteAmount);

        if (payment.getReservationDisableUser() != null) {
            payment.setReservationDisableUser(null);
        }

        this.paymentRepository.saveAndFlush(payment);
        this.reservationDisableUserService.add(paymentForm, payment);

        paymentMap.put("userName", this.webAppUtil.getLoginUser().getName());
        paymentMap.put("workspaceName", workspace.getName());
        paymentMap.put("maxUser", paymentForm.getBuyUser());
        paymentMap.put("price", CommonUtil.getDecimalFormat(definiteAmount));
        paymentMap.put("nextPaymentDay", DateUtil.convertDateToYYYYMMDD(DateUtil.addDays(workspace.getExpireDate(), 1)));

        //  정기 결제 변경 알림 메일
        this.systemEmailService.directEmail(new String[]{this.webAppUtil.getLoginUser().getAccount()}, EmailType.REGULAR_PAYMENT_MODIFY, paymentMap, this.webAppUtil.getLoginUser().getAccount());

        return ConvertUtil.copyProperties(payment, PaymentVo.class);
    }

    //  결제 사용자 수 체크
    private void verifyBuyUser(PaymentForm paymentForm) {
        if (paymentForm.getBuyUser() == null || paymentForm.getBuyUser() < 1) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_BUY_USER_MUST_BE_GREATER_THAN_ZERO));
        }

        //  1명으로 구입해도 10인까지 사용 가능하도록 변경
        if (paymentForm.getBuyUser() < 10) {
            paymentForm.setBuyUser(10);
        }
    }

    //  결제 유형 체크
    private void verifyPaymentType(String type) {
        if (StringUtils.isEmpty(type)) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_NO_TYPE));
        }
    }

    //  결제 아이디로 결제를 조회한다.
    @Override
    @Transactional(readOnly = true)
    public Payment getPayment(Long id) {
        if (id == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_NOT_EXIST));
        }

        Payment payment = this.findOne(id);

        if (payment == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.PAYMENT_NOT_EXIST));
        }

        return payment;
    }

    //  결제 금액에 환율 정보를 업데이트한다.
    @Override
    @Transactional
    public void updateExchangeRatePayment() {
        List<Payment> payments = this.paymentRepository.findAll();

        for (Payment payment : payments) {
            //  서버에서 결제 금액을 다시 계산한다.
            int definiteAmount = this.calculateAmount(payment.getBuyUser());
            payment.setPrice(definiteAmount);
        }

        this.paymentRepository.saveAll(payments);
    }

    private URI makeIamportRequestUrl(String requestPath) {
        return UriComponentsBuilder.fromUriString(IAMPORT_SERVER_URL)
                .path(requestPath)
                .build()
                .toUri();
    }

    private RestClientResultObject postRequest(URI targetUrl, HttpEntity<MultiValueMap<String, String>> request) {
        RestClientResultObject restResult = new RestClientResultObject();
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));

        try {
            String url = URLDecoder.decode(targetUrl.toString(), "UTF-8");
            ResponseEntity<String> result = restTemplate.postForEntity(url, request, String.class);
            Map<String, Object> resultMap = ConvertUtil.convertJsonToMap(result.getBody());

            restResult.setHttpStatus(result.getStatusCode());
            restResult.setCode(MapUtil.getString(resultMap, "code"));

            if (resultMap.containsKey("message")) {
                restResult.setMessage(StringEscapeUtils.unescapeJava(MapUtil.getString(resultMap, "message")));
            }

            if (resultMap.containsKey("response")) {
                Map<String, Object> response = (Map<String, Object>) resultMap.get("response");
                restResult.setResponse(response);

                String responseStatus = MapUtil.getString(response, "status");
                String failReason = MapUtil.getString(response, "fail_reason");

                restResult.setIamportStatus(responseStatus);

                Boolean isNotPaidResult = !"paid".equals(responseStatus);

                if (isNotPaidResult) {
                    restResult.setIamportFailReason(failReason);
                }
            }

        } catch (HttpClientErrorException e) {

            restResult.setMessage(e.getMessage());
            restResult.setCode(e.getStatusCode().toString());
            restResult.setHttpStatus(e.getStatusCode());

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        return restResult;
    }

    public static class RestClientResultObject {
        private static final String CODE_RESULT_SUCCESS = "0";
        private static final String CODE_RESULT_FAILED = "-1";
        private static final String IAMPORT_STATUS_PAID = "paid";


        private HttpStatus httpStatus;
        private String code;
        private String message;
        private Map<String, Object> response;
        private String iamportStatus;
        private String iamportFailReason;

        public Boolean isValidResult() {
            if (isHttpRequestFailed() || isIamportResultFailed() || isIamportPaymentFailed()) {
                return Boolean.FALSE;
            }

            return Boolean.TRUE;
        }

        public Boolean isHttpRequestFailed() {
            return !HttpStatus.OK.equals(this.getHttpStatus());
        }

        public Boolean isIamportResultFailed() {
            return CODE_RESULT_FAILED.equals(this.getCode());
        }

        public Boolean isIamportPaymentFailed() {
            return !IAMPORT_STATUS_PAID.equals(this.getIamportStatus());
        }

        public HttpStatus getHttpStatus() {
            return httpStatus;
        }

        public void setHttpStatus(HttpStatus httpStatus) {
            this.httpStatus = httpStatus;
        }

        public String getCode() {
            return code;
        }

        public void setCode(String code) {
            this.code = code;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

        public Map<String, Object> getResponse() {
            return response;
        }

        public void setResponse(Map<String, Object> response) {
            this.response = response;
        }

        public String getIamportStatus() {
            return iamportStatus;
        }

        public void setIamportStatus(String iamportStatus) {
            this.iamportStatus = iamportStatus;
        }

        public String getIamportFailReason() {
            return iamportFailReason;
        }

        public void setIamportFailReason(String iamportFailReason) {
            this.iamportFailReason = iamportFailReason;
        }
    }
}