zhuoka/src/main/java/com/izouma/tcg/service/card/CardCaseService.java

package com.izouma.tcg.service.card;

import com.izouma.tcg.domain.BaseEntity;
import com.izouma.tcg.domain.User;
import com.izouma.tcg.domain.card.CardBox;
import com.izouma.tcg.domain.card.CardCase;
import com.izouma.tcg.domain.card.Collection;
import com.izouma.tcg.domain.customizeStore.Store;
import com.izouma.tcg.domain.orderInfo.OrderInfo;
import com.izouma.tcg.domain.orderInfo.OrderRefundApply;
import com.izouma.tcg.dto.CardBoxDTO;
import com.izouma.tcg.dto.GroupDTO;
import com.izouma.tcg.dto.PageQuery;
import com.izouma.tcg.dto.cardCase.CardCaseDTO;
import com.izouma.tcg.dto.cardCase.CardCaseInputDTO;
import com.izouma.tcg.enums.CaseStatus;
import com.izouma.tcg.enums.OrderStatus;
import com.izouma.tcg.exception.BusinessException;
import com.izouma.tcg.repo.card.CardBoxRepo;
import com.izouma.tcg.repo.card.CardCaseRepo;
import com.izouma.tcg.repo.card.CollectionRepo;
import com.izouma.tcg.repo.customizeStore.StoreRepo;
import com.izouma.tcg.repo.orderInfo.OrderInfoRepo;
import com.izouma.tcg.repo.orderInfo.OrderRefundApplyRepo;
import com.izouma.tcg.service.orderInfo.OrderRefundApplyService;
import com.izouma.tcg.utils.JpaUtils;
import com.izouma.tcg.utils.SecurityUtils;
import lombok.AllArgsConstructor;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import javax.persistence.criteria.Predicate;
import javax.transaction.Transactional;
import java.util.*;
import java.util.stream.Collectors;

import static com.izouma.tcg.utils.JpaUtils.*;

@Service
@AllArgsConstructor
public class CardCaseService {

    private final CardCaseRepo            cardCaseRepo;
    private final CollectionRepo          collectionRepo;
    private final CardBoxRepo             cardBoxRepo;
    private final StoreRepo               storeRepo;
    private final OrderRefundApplyService orderRefundApplyService;
    private final OrderInfoRepo           orderInfoRepo;
    private final OrderRefundApplyRepo    orderRefundApplyRepo;

    public Page<CardCase> all(PageQuery pageQuery) {
        return cardCaseRepo
                .findAll(JpaUtils.toSpecification(pageQuery, CardCase.class), JpaUtils.toPageRequest(pageQuery));
    }

    public List<GroupDTO> genNewCardCase(Integer group, Integer groupCount, boolean special) {
        List<GroupDTO> GroupDTOs = new ArrayList<>();
        for (int i = 0; i < group; i++) {
            int groupNo = i + 1;
            GroupDTO groupDTO = new GroupDTO();
            groupDTO.setTagTitle(groupNo + "组");
            if (special) {
                if (i == 0) {
                    groupDTO.setTagTitle("A");
                } else {
                    groupDTO.setTagTitle("B");
                }
            }
            List<CardBoxDTO> cardBoxDTOs = new ArrayList<>();
            for (int j = 0; j < groupCount; j++) {
                int boxNo = j + 1;

                CardBoxDTO cardBoxDTO = new CardBoxDTO();
                cardBoxDTO.setName(boxNo + "号");
                cardBoxDTO.setSold(false);
                cardBoxDTOs.add(cardBoxDTO);
                groupDTO.setDynamicTags(cardBoxDTOs);
            }
            GroupDTOs.add(groupDTO);
        }
        return GroupDTOs;
    }

    //    public List<CardCaseDTO> showStoreViewCases(CaseStatus caseStatus, List<String> sortStrings) {
//        List<CardCase> cardCases = new ArrayList<>();
//        Set<Long> collectionIds = new HashSet<>();
//        if (StringUtils.isNotBlank(search)) {
//            collectionIds = collectionRepo.findAllByNameLike("%" + search + "%").stream().map(Collection::getId)
//                    .collect(Collectors.toSet());
//            cardCases = cardCaseRepo
//                    .findAllByCaseStatusAndCollectionIdInAndSeriesId(caseStatus, collectionIds, seriesId);
//        }
//        if (collectionId != null) {
//            collectionIds.add(collectionId);
//            cardCases = cardCaseRepo
//                    .findAllByCaseStatusAndCollectionIdInAndSeriesId(caseStatus, collectionIds, seriesId);
//        }
//        if (collectionId == null & StringUtils.isBlank(search)) {
//            cardCases = cardCaseRepo.findAllByCaseStatusAndSeriesId(caseStatus, seriesId);
//        }
//        List<CardCaseDTO> result = new ArrayList<>();
//        cardCases.removeIf(CardCase::isDel);
//        cardCases.forEach(cardCase -> {
//            CardCaseDTO cardCaseDTO = new CardCaseDTO();
//            cardCaseDTO.setCardCaseId(cardCase.getId());
//            cardCaseDTO
//                    .setCaseName(Optional.ofNullable(cardCase.getCollection()).orElseThrow(new BusinessException("暂无"))
//                            .getName() + cardCase.getCode());
//            cardCaseDTO.setImage(cardCase.getCollection().getImages().get(0));
//            cardCaseDTO.setEndTime(cardCase.getStartTime());
//            cardCaseDTO.setPrice(cardCase.getBoxPrice());
//            cardCaseDTO.setTotal(cardCase.getCardBoxList().size());
//            cardCaseDTO.setCaseStatus(cardCase.getCaseStatus().toString());
//            Integer preorderCount = cardBoxRepo.countAllByCardCaseIdAndUserIdNotNull(cardCase.getId());
//            cardCaseDTO.setPreorder(preorderCount);
//            result.add(cardCaseDTO);
//        });
//        return result;
//    }

    public List<CardCaseDTO> showStoreCasesMA(PageQuery pageQuery) {
        List<CardCase> cardCases = cardCaseRepo
                .findAll((Specification<CardCase>) (root, criteriaQuery, criteriaBuilder) ->
                        criteriaBuilder.and(criteriaBuilder.and(
                                criteriaBuilder.equal(root.get("storeId"), pageQuery.getQuery().get("storeId")),
                                root.get("caseStatus").in(pageQuery.getQuery().get("caseStatus")),
                                criteriaBuilder.equal(root.get("del"), false))), toPageRequest(pageQuery)).getContent();
        return getCardCaseDTOS(cardCases);
    }

    private List<CardCaseDTO> getCardCaseDTOS(List<CardCase> cardCases) {
        List<CardCaseDTO> result = new ArrayList<>();
        cardCases.forEach(cardCase -> {
            CardCaseDTO cardCaseDTO = new CardCaseDTO();
            cardCaseDTO.setCardCaseId(cardCase.getId());
            cardCaseDTO
                    .setCaseName(Optional.ofNullable(cardCase.getCollection()).orElseThrow(new BusinessException("暂无"))
                            .getName() + cardCase.getCode());
            if (cardCase.getImages().size() == 0) {
                cardCaseDTO.setImage(cardCase.getCollection().getImages().get(0));
            } else {
                cardCaseDTO.setImage(cardCase.getImages().get(0));
            }
            cardCaseDTO.setEndTime(cardCase.getStartTime());
            cardCaseDTO.setCaseStatus(cardCase.getCaseStatus().toString());
            cardCaseDTO.setDescription(cardCase.getDescription());
            Integer preorderCount = cardBoxRepo.countAllByCardCaseIdAndUserIdNotNull(cardCase.getId());
            Integer otherPreorderCount = cardBoxRepo.countAllByCardCaseIdAndBindNameNotNull(cardCase.getId());
            preorderCount = preorderCount + otherPreorderCount;
            Store store = storeRepo.findById(cardCase.getStoreId()).orElse(null);
            if (store != null) {
                cardCaseDTO.setStoreId(store.getId());
                cardCaseDTO.setStoreName(store.getStoreName());
                cardCaseDTO.setStoreLogo(store.getLogo());
            }
            cardCaseDTO.setPrice(cardCase.getBoxPrice());
            if (cardCase.isSpecial()) {
                cardCaseDTO.setTotal(cardCase.getCardBoxList().size() / 2);
                cardCaseDTO.setPreorder(preorderCount / 2);
            } else {
                cardCaseDTO.setPreorder(preorderCount);
                cardCaseDTO.setTotal(cardCase.getCardBoxList().size());
            }

            result.add(cardCaseDTO);
        });
        return result;
    }


    public List<CardCaseDTO> showCardCasesMA(CaseStatus caseStatus, Long collectionId, String search, Long seriesId) {
        List<CardCase> cardCases = new ArrayList<>();
        Set<Long> collectionIds = new HashSet<>();
        if (StringUtils.isNotBlank(search)) {
            collectionIds = collectionRepo.findAllByNameLike("%" + search + "%").stream().map(Collection::getId)
                    .collect(Collectors.toSet());
            cardCases = cardCaseRepo
                    .findAllByCaseStatusAndCollectionIdInAndSeriesId(caseStatus, collectionIds, seriesId);
        }
        if (collectionId != null) {
            collectionIds.add(collectionId);
            cardCases = cardCaseRepo
                    .findAllByCaseStatusAndCollectionIdInAndSeriesId(caseStatus, collectionIds, seriesId);
        }
        if (collectionId == null & StringUtils.isBlank(search)) {
            cardCases = cardCaseRepo.findAllByCaseStatusAndSeriesId(caseStatus, seriesId);
        }
        cardCases.removeIf(BaseEntity::isDel);
        return getCardCaseDTOS(cardCases);
    }

    public Map<String, Object> showCaseInfoMA(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        List<CardBox> caseBoxList = cardCase.getCardBoxList();
        Map<String, List<CardBox>> groupBoxMap = caseBoxList.stream()
                .collect(Collectors.groupingBy(CardBox::getGroupCode));
        Map<String, Object> result = new HashMap<>();
        CardCaseDTO cardCaseDTO = new CardCaseDTO();
        cardCaseDTO.setCardCaseId(cardCase.getId());
        cardCaseDTO
                .setCaseName(Optional.ofNullable(cardCase.getCollection()).orElseThrow(new BusinessException("暂无"))
                        .getName() + cardCase.getCode());
        cardCaseDTO.setDescription(cardCase.getDescription());
        cardCaseDTO.setImage(cardCase.getCollection().getImages().get(0));
        cardCaseDTO.setEndTime(cardCase.getStartTime());
        cardCaseDTO.setPrice(cardCase.getBoxPrice());
        cardCaseDTO.setCaseStatus(cardCase.getCaseStatus().toString());
        cardCaseDTO.setSpecial(cardCase.isSpecial());
        cardCaseDTO.setDescription(cardCase.getDescription());
        Integer preorderCount = cardBoxRepo.countAllByCardCaseIdAndUserIdNotNull(cardCase.getId());
        Integer otherPreorderCount = cardBoxRepo.countAllByCardCaseIdAndBindNameNotNull(cardCase.getId());
        preorderCount = preorderCount + otherPreorderCount;
        Store store = storeRepo.findById(cardCase.getStoreId()).orElse(null);
        if (store != null) {
            cardCaseDTO.setStoreId(store.getId());
            cardCaseDTO.setStoreName(store.getStoreName());
            cardCaseDTO.setStoreLogo(store.getStoreName());
        }
        if (cardCase.isSpecial()) {
            cardCaseDTO.setTotal(cardCase.getCardBoxList().size() / 2);
            cardCaseDTO.setPreorder(preorderCount / 2);
        } else {
            cardCaseDTO.setTotal(cardCase.getCardBoxList().size());
            cardCaseDTO.setPreorder(preorderCount);
        }
        result.put("cardCaseInfo", cardCaseDTO);
        result.put("groupBoxMap", groupBoxMap);
        return result;
    }


    @Transactional
    public CardCase save(CardCaseInputDTO cardCaseInputDTO) {
        CardCase cardCase = new CardCase();
        if (cardCaseInputDTO.getId() != null) {
            CardCase orig = cardCaseRepo.findById(cardCaseInputDTO.getId()).orElse(null);
            if (orig != null) {
                cardCase = orig;
            }
        }
        User user = SecurityUtils.getAuthenticatedUser();
        Store store = storeRepo.findFirstByUserId(user.getId());
        if (store != null) {
            cardCase.setStoreId(store.getId());
        }
        Collection collection = collectionRepo.findById(cardCaseInputDTO.getCollectionId())
                .orElseThrow(new BusinessException("无系列信息"));
        cardCase.setSeriesId(collection.getSeriesId());
        cardCase.setCollectionId(collection.getId());
        cardCase.setCode(cardCaseInputDTO.getCode());
        cardCase.setDescription(cardCaseInputDTO.getDescription());
        if (cardCase.getCode() == null) {
            cardCase.setCode("");
        }

        cardCase.setCaseStatus(cardCaseInputDTO.getCaseStatus());
        cardCase.setStartTime(cardCaseInputDTO.getStartTime());
        cardCase.setBoxPrice(cardCaseInputDTO.getBoxPrice());
        if (cardCaseInputDTO.getImages() != null) {
            List<String> images = Arrays
                    .asList((String[]) ConvertUtils.convert(cardCaseInputDTO.getImages().split(","), String.class));
            cardCase.setImages(images);
        }
        cardCase.setPostage(cardCaseInputDTO.getPostage());
        cardCase.setBoxesCount(cardCaseInputDTO.getBoxesCount());
        cardCase.setSpecial(cardCaseInputDTO.isSpecial());
        CardCase result = cardCaseRepo.save(cardCase);
        //解析卡盒与组

        List<Long> newIds = new ArrayList<>();
        List<GroupDTO> groupDTOS = cardCaseInputDTO.getGroupDTOS();
        groupDTOS.forEach(groupDTO -> {
            String groupName = groupDTO.getTagTitle();
            List<CardBoxDTO> boxDTOs = groupDTO.getDynamicTags();
            boxDTOs.forEach(box -> {
                CardBox cardBox;
                if (box.getCardBoxId() != null) {
                    cardBox = cardBoxRepo.findById(box.getCardBoxId()).orElse(null);
                    if (cardBox != null) {
                        cardBox.setCardCaseId(result.getId());
                        cardBox.setBoxCode(box.getName());
                        cardBox.setGroupCode(groupName);
                        cardBox.setMoney(result.getBoxPrice());
                        cardBox.setCaseStatus(result.getCaseStatus());
                        cardBox.setBoxPrice(result.getBoxPrice());
                        cardBoxRepo.save(cardBox);
                        newIds.add(cardBox.getId());
                    }
                } else {
                    cardBox = new CardBox();
                    cardBox.setCardCaseId(result.getId());
                    cardBox.setBoxCode(box.getName());
                    cardBox.setGroupCode(groupName);
                    cardBox.setMoney(result.getBoxPrice());
                    cardBox.setCaseStatus(result.getCaseStatus());
                    cardBox.setBoxPrice(result.getBoxPrice());
                    cardBoxRepo.save(cardBox);
                }
            });
        });
        if (cardCase.getCardBoxList() != null) {
            List<Long> cardBoxIds = cardCase.getCardBoxList().stream().map(CardBox::getId).collect(Collectors.toList());
            if (cardBoxIds.size() > 0) {
                cardBoxIds.removeIf(newIds::contains);
                cardBoxRepo.deleteAllByIdIn(cardBoxIds);
            }
        }
        return result;
    }

    public CardCaseInputDTO getCardCaseInputDTO(Long id) {
        CardCase cardCase = cardCaseRepo.findById(id).orElseThrow(new BusinessException("无信息"));
        CardCaseInputDTO cardCaseInputDTO = new CardCaseInputDTO();
        cardCaseInputDTO.setCaseStatus(cardCase.getCaseStatus());
        cardCaseInputDTO.setBoxPrice(cardCase.getBoxPrice());
        cardCaseInputDTO.setCode(cardCase.getCode());
        cardCaseInputDTO.setId(cardCase.getId());
        cardCaseInputDTO.setBoxesCount(cardCase.getBoxesCount());
        cardCaseInputDTO.setCollectionId(cardCase.getCollectionId());
        cardCaseInputDTO.setSeriesId(cardCase.getSeriesId());
        cardCaseInputDTO.setStartTime(cardCase.getStartTime());
        cardCaseInputDTO.setDescription(cardCase.getDescription());
        cardCaseInputDTO.setSpecial(cardCase.isSpecial());
        String imagesList = cardCase.getImages().toString();
        cardCaseInputDTO.setImages(imagesList);
//
//        cardCaseInputDTO.setImages(images);
        cardCaseInputDTO.setPostage(cardCase.getPostage());
        Map<String, List<CardBox>> groupMap = cardCase.getCardBoxList().stream()
                .collect(Collectors.groupingBy(CardBox::getGroupCode));
        List<GroupDTO> groupDTOS = new ArrayList<>();
        groupMap.forEach((groupCode, cardBoxList) -> {
            GroupDTO groupDTO = new GroupDTO();
            groupDTO.setTagTitle(groupCode);
            List<CardBoxDTO> dtos = new ArrayList<>();
            cardBoxList.forEach(cardBox -> {
                CardBoxDTO cardBoxDTO = new CardBoxDTO();
                cardBoxDTO.setCardBoxId(cardBox.getId());
                cardBoxDTO.setName(cardBox.getBoxCode());
                cardBoxDTO.setSold(cardBox.isSold());
                dtos.add(cardBoxDTO);
            });
            groupDTO.setDynamicTags(dtos);
            groupDTOS.add(groupDTO);
        });
        cardCaseInputDTO.setGroupDTOS(groupDTOS);
        return cardCaseInputDTO;
    }

    public void softDelete(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        cardCase.setCaseStatus(CaseStatus.UNDO);
        cardCaseRepo.save(cardCase);
    }

    public void revive(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        cardCase.setCaseStatus(CaseStatus.PROGRESS);
        cardCase.getCardBoxList().forEach(cardBox -> {
            cardBox.setCaseStatus(CaseStatus.PROGRESS);
            cardBoxRepo.save(cardBox);
        });
        cardCaseRepo.save(cardCase);
    }

    public void multipleDelete(String caseList) {
        List<Long> boxIds = Arrays.asList((Long[]) ConvertUtils.convert(caseList.split(","), Long.class));
        boxIds.forEach(cardCaseRepo::softDelete);
    }

    public void cancel(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("报错咯，无卡箱信息"));
        cardCase.getCardBoxList().forEach(cardBox -> {
            cardBox.setCaseStatus(CaseStatus.FINISH);
            cardBoxRepo.save(cardBox);
        });
        cardCase.setCaseStatus(CaseStatus.FINISH);
        cardCaseRepo.save(cardCase);
        List<OrderStatus> orderStatuses = new ArrayList<>();
        orderStatuses.add(OrderStatus.REFUND);
        orderStatuses.add(OrderStatus.PAYED);
        List<OrderInfo> orderInfos = orderInfoRepo.findAllByCaseIdAndOrderStatusIn(caseId, orderStatuses);
        List<OrderRefundApply> orderRefundApplies = new ArrayList<>();
        orderInfos.forEach(orderInfo -> {
            if (orderInfo.getOrderStatus().equals(OrderStatus.REFUND)) {
                orderRefundApplies.add(orderRefundApplyRepo.findById(orderInfo.getRefundId()).orElse(null));
            } else {
                orderRefundApplies.add(orderRefundApplyService.apply(orderInfo.getId(), "拼箱失败，自动发起退款"));
            }
        });
        orderRefundApplies.forEach(orderRefundApply -> {
            orderRefundApplyService.audit(orderRefundApply.getId());
        });
    }
}