package kr.wisestone.owl.service.impl;

import kr.wisestone.owl.constant.Constants;
import kr.wisestone.owl.constant.ElasticSearchConstants;
import kr.wisestone.owl.constant.MsgConstants;
import kr.wisestone.owl.domain.Issue;
import kr.wisestone.owl.domain.IssueReservation;
import kr.wisestone.owl.domain.enumType.IssueReservationType;
import kr.wisestone.owl.exception.OwlRuntimeException;
import kr.wisestone.owl.repository.IssueReservationRepository;
import kr.wisestone.owl.service.IssueReservationService;
import kr.wisestone.owl.service.IssueService;
import kr.wisestone.owl.service.WorkspaceService;
import kr.wisestone.owl.util.ConvertUtil;
import kr.wisestone.owl.util.ElasticSearchUtil;
import kr.wisestone.owl.vo.IssueReservationVo;
import kr.wisestone.owl.web.condition.IssueReservationCondition;
import kr.wisestone.owl.web.form.IssueReservationForm;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;

@Service
public class IssueReservationServiceImpl extends AbstractServiceImpl<IssueReservation, Long, JpaRepository<IssueReservation, Long>> implements IssueReservationService {

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

    @Autowired
    private WorkspaceService workspaceService;

    @Autowired
    private IssueService issueService;

    @Autowired
    private IssueReservationRepository issueReservationRepository;

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

    //  이슈 발생 예약 상세 정보를 조회한다.
    @Override
    @Transactional(readOnly = true)
    public void detailIssueReservation(Map<String, Object> resJsonData, IssueReservationCondition issueReservationCondition) {
        IssueReservationVo issueReservationVo = new IssueReservationVo();

        if (issueReservationCondition.getIssueId() != null) {
            Issue issue = this.issueService.getIssue(issueReservationCondition.getIssueId());
            IssueReservation issueReservation = issue.getIssueReservation();

            if (issueReservation != null) {
                issueReservationVo = ConvertUtil.copyProperties(issueReservation, IssueReservationVo.class, "issueReservationType");

                if (issueReservation.getIssueReservationType() != null) {
                    issueReservationVo.setIssueReservationType(issueReservation.getIssueReservationType().toString());
                }
            }
        }

        resJsonData.put(Constants.RES_KEY_CONTENTS, issueReservationVo);
    }

    //  이슈 발생 이력 아이디로 이슈 발생 이력을 조회한다.
    @Override
    @Transactional(readOnly = true)
    public IssueReservation getIssueReservation(Long id) {
        if (id == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_NOT_EXIST));
        }

        IssueReservation issueReservation = this.findOne(id);

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

        return issueReservation;
    }

    //  이슈 발생 이력 정보를 수정한다.
    @Override
    @Transactional
    public void modifyIssueReservation(Map<String, Object> resJsonData, IssueReservationForm issueReservationForm) {
        //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
        this.workspaceService.checkUseWorkspace();

        IssueReservation issueReservation;

        //  수정
        if (issueReservationForm.getId() != null) {
            issueReservation = this.getIssueReservation(issueReservationForm.getId());
            ConvertUtil.copyProperties(issueReservationForm, issueReservation, "id", "issueReservationType");

            if (!StringUtils.isEmpty(issueReservationForm.getIssueReservationType())) {
                issueReservation.setIssueReservationType(IssueReservationType.valueOf(issueReservationForm.getIssueReservationType()));
                //  이슈 발생 예약일 체크
                this.verifyReservation(issueReservation.getIssueReservationType(), issueReservation.getReservation());
            }
            else {
                issueReservation.setIssueReservationType(null);
                issueReservation.setReservation(null);
            }
        }
        else {
            Issue issue = this.issueService.getIssue(issueReservationForm.getIssueId());
            //  생성
            issueReservation = ConvertUtil.copyProperties(issueReservationForm, IssueReservation.class, "issueReservationType");
            issueReservation.setIssue(issue);
            issueReservation.setWorkspace(issue.getProject().getWorkspace());

            if (!StringUtils.isEmpty(issueReservationForm.getIssueReservationType())) {
                issueReservation.setIssueReservationType(IssueReservationType.valueOf(issueReservationForm.getIssueReservationType()));
            }
        }

        this.issueReservationRepository.saveAndFlush(issueReservation);

        resJsonData.put(Constants.RES_KEY_CONTENTS, ConvertUtil.copyProperties(issueReservation, IssueReservationVo.class));

        //  사용자 시스템 기능 사용 정보 수집
        log.info(ElasticSearchUtil.makeUserActiveHistoryMessage(this.webAppUtil.getLoginUser(), ElasticSearchConstants.ISSUE_RESERVATION));
    }

    //  이슈 발생 예약일 체크
    private void verifyReservation(IssueReservationType issueReservationType, String reservation) {
        switch (issueReservationType) {
            case DAY:
                if (!StringUtils.isEmpty(reservation)) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                break;
            case WEEK:
                if (StringUtils.isEmpty(reservation)) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                boolean pass = false;

                //  일 단위 예약
                switch (reservation) {
                    case "1":
                    case "2":
                    case "3":
                    case "4":
                    case "5":
                    case "6":
                    case "7":
                        pass = true;
                        break;
                }

                if (!pass) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                break;
            case MONTH:
                if (StringUtils.isEmpty(reservation)) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                if (!reservation.matches("^[0-9]*$")) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                if (Integer.parseInt(reservation) > 31) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                break;
            case YEAR:
                if (StringUtils.isEmpty(reservation)) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                if (!reservation.matches("^[0-9]+-[0-9]+$")) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                String[] date = reservation.split("-");

                if (date.length < 2) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                if (Integer.parseInt(date[0]) > 12 || Integer.parseInt(date[0]) < 1) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                if (Integer.parseInt(date[1]) > 31 || Integer.parseInt(date[1]) < 1) {
                    throw new OwlRuntimeException(
                            this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                }

                switch (Integer.parseInt(date[0])) {
                    case 2:
                        if (Integer.parseInt(date[1]) > 29) {
                            throw new OwlRuntimeException(
                                    this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                        }
                        break;
                    case 4:
                    case 6:
                    case 9:
                    case 11:
                        if (Integer.parseInt(date[1]) > 30) {
                            throw new OwlRuntimeException(
                                    this.messageAccessor.getMessage(MsgConstants.ISSUE_RESERVATION_VALUE_INVALID));
                        }
                        break;
                }

                break;
        }
    }

    //  이슈 발생 이력 정보가 저장되어 있는 항목을 조회한다.
    @Override
    @Transactional(readOnly = true)
    public List<IssueReservation> findByIssueReservationTypeNotNull() {
        return this.issueReservationRepository.findByIssueReservationTypeNotNull();
    }
}