package com.xjrsoft.module.textbook.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.EasyExcel;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.WarehouseModeEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.page.ConventPage;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseCourseSubject;
import com.xjrsoft.module.base.entity.BaseGrade;
import com.xjrsoft.module.base.entity.BaseSemester;
import com.xjrsoft.module.student.entity.BaseClassMajorSet;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.textbook.dto.*;
import com.xjrsoft.module.textbook.entity.*;
import com.xjrsoft.module.textbook.mapper.*;
import com.xjrsoft.module.textbook.service.ITextbookSubscriptionService;
import com.xjrsoft.module.textbook.vo.*;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.InputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @title: 教材教辅征订记录表
 * @Author dzx
 * @Date: 2024-12-16
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class TextbookSubscriptionServiceImpl extends MPJBaseServiceImpl<TextbookSubscriptionMapper, TextbookSubscription> implements ITextbookSubscriptionService {

    private final TextbookSubscriptionMapper textbookSubscriptionTextbookSubscriptionMapper;

    private final TextbookSubscriptionItemMapper textbookSubscriptionTextbookSubscriptionItemMapper;

    private final TextbookSubscriptionClassMapper textbookSubscriptionClassMapper;

    private final TextbookSubscriptionItemClassMapper textbookSubscriptionItemClassMapper;

    private final TextbookWarehouseRecordMapper textbookWarehouseRecordMapper;

    private final TextbookSubscriptionItemHistoryMapper textbookSubscriptionItemHistoryMapper;

    @Override
    public IPage<TextbookSubscriptionPageVo> pageRubAndHand(TextbookSubscriptionPageDto dto) {
        MPJLambdaWrapper<TextbookSubscription> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .select(TextbookSubscription::getId)
                .selectAs(BaseSemester::getName, TextbookSubscriptionPageVo::getBaseSemesterIdCn)
                .select(TextbookSubscription.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionPageVo.class).contains(x.getProperty()))
                .leftJoin(BaseSemester.class, BaseSemester::getId, TextbookSubscription::getBaseSemesterId)
                .eq(dto.getBaseSemesterId() != null && dto.getBaseSemesterId() > 0, TextbookSubscription::getBaseSemesterId, dto.getBaseSemesterId())
                .eq(dto.getSubscriptionMethod() != null && dto.getSubscriptionMethod() > 0, TextbookSubscription::getSubscriptionMethod, dto.getSubscriptionMethod())
                .eq(StringUtils.isNotBlank(dto.getId()), TextbookSubscription::getId, dto.getId())
                .orderByDesc(TextbookSubscription::getCreateDate)
        ;
        IPage<TextbookSubscriptionPageVo> page = this.selectJoinListPage(ConventPage.getPage(dto), TextbookSubscriptionPageVo.class, queryWrapper);
        return page;
    }

    @Override
    public List<TextbookInstockroomListVo> instockroomList(TextbookInstockroomListDto dto) {
        MPJLambdaWrapper<TextbookSubscriptionItem> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .selectAs(TextbookSubscriptionItem::getId, TextbookInstockroomListVo::getTextbookSubscriptionItemId)
                .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(TextbookInstockroomListVo.class).contains(x.getProperty()))
                .select(TextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookInstockroomListVo.class).contains(x.getProperty()))
                .selectAs(TextbookSubscriptionItem::getStudentNum, TextbookInstockroomListVo::getStudentSubscriptionNumber)
                .selectAs(TextbookSubscriptionItem::getTeacherNum, TextbookInstockroomListVo::getTeacherSubscriptionNumber)
                .selectAs(TextbookSubscriptionItem::getPrice, TextbookInstockroomListVo::getActualPrice)
                .selectAs(TextbookSubscriptionItem::getDiscount, TextbookInstockroomListVo::getDiscount)
                .leftJoin(Textbook.class, Textbook::getId, TextbookSubscriptionItem::getTextbookId)

                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId,
                        wrapper -> wrapper
                                .selectAs(BaseCourseSubject::getName, TextbookInstockroomListVo::getCourseName)
                )
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, TextbookInstockroomListVo::getTextbookTypeCn)
                )

                .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, dto.getTextbookSubscriptionId())
                .orderByAsc(TextbookSubscriptionItem::getInStockNum)
        ;

        return textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinList(TextbookInstockroomListVo.class, queryWrapper);
    }

    @Override
    public List<TextbookInstockroomOnceListVo> everyInstockroomList(TextbookInstockroomOnceListDto dto) {
        MPJLambdaWrapper<TextbookWarehouseRecord> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .select(TextbookSubscriptionItem::getId)
                .selectAs(TextbookWarehouseRecord::getWarehouseNumber, TextbookInstockroomOnceListVo::getOnceInStockNum)
                .selectAs(TextbookWarehouseRecord::getCreateDate, TextbookInstockroomOnceListVo::getCreateDate)
                .selectAs(TextbookWarehouseRecord::getCreateUserId, TextbookInstockroomOnceListVo::getCreateUserId)
                .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(TextbookInstockroomOnceListVo.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, TextbookSubscriptionItem::getTextbookId)
                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId,
                        wrapper -> wrapper
                                .selectAs(BaseCourseSubject::getName, TextbookInstockroomOnceListVo::getCourseName)
                )
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, TextbookInstockroomOnceListVo::getTextbookTypeCn)
                )
                .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, dto.getTextbookSubscriptionId())
                .orderByAsc(TextbookSubscriptionItem::getInStockNum)
        ;

        return textbookWarehouseRecordMapper.selectJoinList(TextbookInstockroomOnceListVo.class, queryWrapper);
    }

    @Override
    public TextbookSubscriptionVo infoRubAndHand(Long id) {
        TextbookSubscription textbookSubscription = this.getById(id);
        TextbookSubscriptionVo textbookSubscriptionVo = BeanUtil.toBean(textbookSubscription, TextbookSubscriptionVo.class);

        MPJLambdaWrapper<TextbookSubscriptionItem> textbookSubscriptionItemMPJLambdaWrapper = new MPJLambdaWrapper<>();
        textbookSubscriptionItemMPJLambdaWrapper
                .select(TextbookSubscriptionItem::getId)
                .select(TextbookSubscriptionItem.class,x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionItemVo.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, TextbookSubscriptionItem::getTextbookId,
                        wrapper -> wrapper
                                .select(Textbook.class,x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionItemVo.class).contains(x.getProperty()))
                                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId,
                                        wp -> wp
                                                .selectAs(BaseCourseSubject::getName, TextbookSubscriptionItemVo::getCourseSubjectIdCn)
                                )
                                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                                        wp -> wp
                                                .selectAs(DictionaryDetail::getName, TextbookSubscriptionItemVo::getTextbookTypeCn)
                                )
                )
                .selectAs(TextbookSubscriptionItem::getPrice, TextbookSubscriptionItemVo::getPricing)
                .selectAs(Textbook::getPrice, TextbookSubscriptionItemVo::getPrice)
                .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, id)
        ;
        List<TextbookSubscriptionItemVo> list = textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinList(TextbookSubscriptionItemVo.class, textbookSubscriptionItemMPJLambdaWrapper);

        textbookSubscriptionVo.setTextbookSubscriptionItemList(list);
        return textbookSubscriptionVo;
    }

    @Override
    public TextbookSubscriptionDetailVo detail(Long id) {
        TextbookSubscription textbookSubscription = this.getById(id);
        if (ObjectUtils.isEmpty(textbookSubscription)) {
            throw new MyException("证订记录被修改，请刷新重试");
        }

        // 获取所有的证订项目
        LambdaQueryWrapper<TextbookSubscriptionItem> subscriptionItemLambdaQueryWrapper = new LambdaQueryWrapper<>();
        subscriptionItemLambdaQueryWrapper
                .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, id)
                .eq(TextbookSubscriptionItem::getDeleteMark, DeleteMark.NODELETE.getCode())
        ;
        List<TextbookSubscriptionItem> textbookSubscriptionItemList = textbookSubscriptionTextbookSubscriptionItemMapper.selectList(subscriptionItemLambdaQueryWrapper);
        int stuNum = 0;
        int teaNum = 0;
        BigDecimal totalPrice = BigDecimal.valueOf(0);
        BigDecimal currentPrice;
        BigDecimal currentTotalPrice;
        for (TextbookSubscriptionItem textbookSubscriptionItem : textbookSubscriptionItemList) {
            stuNum += textbookSubscriptionItem.getStudentNum();
            teaNum += textbookSubscriptionItem.getTeacherNum();

            BigDecimal discount = BigDecimal.valueOf(textbookSubscriptionItem.getDiscount()).divide(BigDecimal.valueOf(10), 2, RoundingMode.DOWN);

            currentPrice = textbookSubscriptionItem.getPrice().multiply(discount);

            currentTotalPrice = currentPrice.multiply(BigDecimal.valueOf(textbookSubscriptionItem.getTeacherNum() + textbookSubscriptionItem.getStudentNum()));

            totalPrice = totalPrice.add(currentTotalPrice);
        }
        TextbookSubscriptionDetailVo textbookSubscriptionDetailVo = new TextbookSubscriptionDetailVo();
        textbookSubscriptionDetailVo.setId(String.valueOf(id));
        textbookSubscriptionDetailVo.setStudentTatolNum(stuNum);
        textbookSubscriptionDetailVo.setTeacherTatolNum(teaNum);
        textbookSubscriptionDetailVo.setSum(stuNum + teaNum);
        textbookSubscriptionDetailVo.setSumPrice(totalPrice);
        return textbookSubscriptionDetailVo;
    }

    @Override
    public IPage<TextbookSubscriptionItemPageVo> itemPage(TextbookSubscriptionItemPageDto dto) {
        MPJLambdaWrapper<TextbookSubscriptionItem> textbookSubscriptionItemMPJLambdaWrapper = new MPJLambdaWrapper<>();
        textbookSubscriptionItemMPJLambdaWrapper
                .select(TextbookSubscriptionItem::getId)
                .select(TextbookSubscriptionItem.class,x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionItemPageVo.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, TextbookSubscriptionItem::getTextbookId,
                        wrapper -> wrapper
                                .select(Textbook.class,x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionItemPageVo.class).contains(x.getProperty()))
                                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId,
                                        wp -> wp
                                                .selectAs(BaseCourseSubject::getName, TextbookSubscriptionItemPageVo::getCourseSubjectIdCn)
                                                .like(StringUtils.isNotBlank(dto.getCourseSubjectIdCn()), BaseCourseSubject::getName, dto.getCourseSubjectIdCn())
                                )
                                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                                        wp -> wp
                                                .selectAs(DictionaryDetail::getName, TextbookSubscriptionItemPageVo::getTextbookTypeCn)
                                )
                                .like(StringUtils.isNotBlank(dto.getBookName()), Textbook::getBookName, dto.getBookName())
                                .eq(StringUtils.isNotBlank(dto.getTextbookType()), Textbook::getTextbookType, dto.getTextbookType())
                        )
                .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, dto.getTextbookSubscriptionId())
                ;
        IPage<TextbookSubscriptionItemPageVo> page = textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinPage(ConventPage.getPage(dto), TextbookSubscriptionItemPageVo.class, textbookSubscriptionItemMPJLambdaWrapper);
        return page;
    }

    @Override
    public IPage<BaseclassPageVo> baseclassPage(BaseclassPageDto dto) {
        // 查询征订记录总的征订班级
        MPJLambdaWrapper<TextbookSubscriptionItem> baseClassMPJLambdaWrapper = new MPJLambdaWrapper<>();
        baseClassMPJLambdaWrapper
                .disableSubLogicDel()
                .distinct()
                .selectAs(BaseGrade::getName, BaseclassPageVo::getGradeIdCn)
                .selectAs(XjrUser::getName, BaseclassPageVo::getTeacherIdCn)
                .select(" (select" +
                        "         count(a.id)" +
                        "     from base_student_school_roll a" +
                        "         where a.class_id = t1.base_class_id" +
                        "         and a.archives_status = 'FB2901'" +
                        "         and a.delete_mark = 0" +
                        "    ) as total_student")
                .select(BaseClass.class, x -> VoToColumnUtil.fieldsToColumns(BaseclassPageVo.class).contains(x.getProperty()))

                .innerJoin(TextbookSubscriptionItemClass.class, TextbookSubscriptionItemClass::getTextbookSubscriptionItemId, TextbookSubscriptionItem::getId)

                .leftJoin(BaseClass.class, BaseClass::getId, TextbookSubscriptionItemClass::getBaseClassId)
                .leftJoin(BaseGrade.class, BaseGrade::getId, BaseClass::getGradeId)
                .leftJoin(XjrUser.class, XjrUser::getId, BaseClass::getTeacherId)

                .eq(ObjectUtils.isNotEmpty(dto.getId()), TextbookSubscriptionItem::getTextbookSubscriptionId, dto.getId())
                .eq(ObjectUtils.isNotEmpty(dto.getTextbookSubscriptionItemId()), TextbookSubscriptionItem::getId, dto.getTextbookSubscriptionItemId())
                .eq(TextbookSubscriptionClass::getDeleteMark, DeleteMark.NODELETE.getCode())
        ;

        return textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinPage(ConventPage.getPage(dto), BaseclassPageVo.class, baseClassMPJLambdaWrapper);
    }

    @Override
    public List<SubscriptionItemListDistributeVo> itemListConfirmDistribute(SubscriptionItemListDistributeDto dto) {
        MPJLambdaWrapper<TextbookSubscriptionItem> textbookSubscriptionItemMPJLambdaWrapper = new MPJLambdaWrapper<>();
        textbookSubscriptionItemMPJLambdaWrapper
                .select(TextbookSubscriptionItem::getId)
                .selectAs(TextbookSubscriptionItem::getPrice, SubscriptionItemListDistributeVo::getActulPrice)
                .select(TextbookSubscriptionItem.class,x -> VoToColumnUtil.fieldsToColumns(SubscriptionItemListDistributeVo.class).contains(x.getProperty()))
                .innerJoin(TextbookSubscription.class, TextbookSubscription::getId, TextbookSubscriptionItem::getTextbookSubscriptionId)
                .eq(TextbookSubscriptionItem::getTextbookId, dto.getTextbookId())
                .gt(TextbookSubscriptionItem::getInStockNum, TextbookSubscriptionItem::getOutStockNum)
                .orderByAsc(TextbookSubscriptionItem::getCreateDate)
        ;
        return textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinList(SubscriptionItemListDistributeVo.class, textbookSubscriptionItemMPJLambdaWrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(TextbookSubscription textbookSubscription) {
        // 处理征订表
        int sum = 0;
        for (TextbookSubscriptionItem textbookSubscriptionItem : textbookSubscription.getTextbookSubscriptionItemList()) {
            textbookSubscriptionItem.setStudentNum(ObjectUtils.isEmpty(textbookSubscriptionItem.getStudentNum()) ? 0 : textbookSubscriptionItem.getStudentNum());
            textbookSubscriptionItem.setTeacherNum(ObjectUtils.isEmpty(textbookSubscriptionItem.getTeacherNum()) ? 0 : textbookSubscriptionItem.getTeacherNum());

            sum += textbookSubscriptionItem.getStudentNum() + textbookSubscriptionItem.getTeacherNum();
        }
        textbookSubscription.setSum(sum);
        textbookSubscription.setCreateDate(new Date());
        textbookSubscriptionTextbookSubscriptionMapper.insert(textbookSubscription);

//        // 处理征订和班级关联表
//        if (ObjectUtils.isNotEmpty(textbookSubscription.getSubscriptionMethod())
//                && textbookSubscription.getSubscriptionMethod() == 1
//                && StringUtils.isNotBlank(textbookSubscription.getBaseClassIds())
//        ) {
//            String[] classIdArr = textbookSubscription.getBaseClassIds().split(",");
//            TextbookSubscriptionClass textbookSubscriptionClass;
//            for (String str : classIdArr) {
//                textbookSubscriptionClass = new TextbookSubscriptionClass();
//                textbookSubscriptionClass.setTextbookSubscriptionId(textbookSubscription.getId());
//                textbookSubscriptionClass.setBaseClassId(Long.parseLong(str));
//                textbookSubscriptionClass.setCreateDate(new Date());
//                textbookSubscriptionClassMapper.insert(textbookSubscriptionClass);
//            }
//        }

        // 处理征订项
        TextbookSubscriptionItemClass textbookSubscriptionItemClass;
        for (TextbookSubscriptionItem textbookSubscriptionItem : textbookSubscription.getTextbookSubscriptionItemList()) {
            String[] classIdArr = new String[0];
            if (ObjectUtils.isNotEmpty(textbookSubscription.getSubscriptionMethod())
                    && textbookSubscription.getSubscriptionMethod() == 1
                    && ObjectUtils.isNotEmpty(textbookSubscriptionItem.getClassIds())
            ) {
                classIdArr = textbookSubscriptionItem.getClassIds().split(",");
            }

            textbookSubscriptionItem.setUseClassNum(classIdArr.length);
            textbookSubscriptionItem.setTextbookSubscriptionId(textbookSubscription.getId());
            textbookSubscriptionItem.setCreateDate(new Date());
            textbookSubscriptionTextbookSubscriptionItemMapper.insert(textbookSubscriptionItem);

            // 处理征订项和班级关联表
            for (String str : classIdArr) {
                textbookSubscriptionItemClass = new TextbookSubscriptionItemClass();
                textbookSubscriptionItemClass.setTextbookSubscriptionItemId(textbookSubscriptionItem.getId());
                textbookSubscriptionItemClass.setBaseClassId(Long.parseLong(str));
                textbookSubscriptionItemClass.setCreateDate(new Date());
                textbookSubscriptionItemClassMapper.insert(textbookSubscriptionItemClass);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean instockroom(List<TextbookInstockroomDto> dtos) {
        if (dtos.isEmpty()) {
            return false;
        }

        List<Long> textbookSubscriptionItemIds = new ArrayList<>();
        for (TextbookInstockroomDto dto : dtos) {
            if(ObjectUtils.isNotEmpty(dto.getTextbookSubscriptionItemId())){
                textbookSubscriptionItemIds.add(dto.getTextbookSubscriptionItemId());
            }
        }

        if (textbookSubscriptionItemIds.isEmpty()) {
            throw new MyException("请选择需要入库的教材");
        }

        //获取需要修改的list
        MPJLambdaWrapper<TextbookSubscriptionItem> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .select(TextbookSubscriptionItem::getId)
                .select(TextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionItem.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, TextbookSubscriptionItem::getTextbookId)
                .in(TextbookSubscriptionItem::getId, textbookSubscriptionItemIds)
                .eq(TextbookSubscriptionItem::getDeleteMark, DeleteMark.NODELETE.getCode())
        ;
        List<TextbookSubscriptionItem> textbookSubscriptionItemList = textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinList(TextbookSubscriptionItem.class, queryWrapper);

        if (textbookSubscriptionItemList.isEmpty()) {
            throw new MyException("证订信息已经修改，请刷新重试");
        }

        Map<Long, TextbookSubscriptionItem> itemByIdMap = new HashMap<>();
        for (TextbookSubscriptionItem el : textbookSubscriptionItemList) {
            if(ObjectUtils.isNotEmpty(el.getId()) && !itemByIdMap.containsKey(el.getId())){
                itemByIdMap.put(el.getId(), el);
            }
        }

        TextbookSubscriptionItem old = null;
        for (TextbookInstockroomDto dto : dtos) {
            if (ObjectUtils.isNotEmpty(dto.getTextbookSubscriptionItemId())) {
                old = itemByIdMap.get(dto.getTextbookSubscriptionItemId());
            }

            if (ObjectUtils.isEmpty(old)) {
                continue;
            }

            TextbookSubscriptionItem updateItem = new TextbookSubscriptionItem();
            updateItem.setId(old.getId());
            updateItem.setDiscount(dto.getDiscount());
            updateItem.setPrice(old.getPrice().multiply(BigDecimal.valueOf(dto.getDiscount() / 10)));
            updateItem.setInStockNum(old.getInStockNum() + dto.getInNum());
            updateItem.setModifyDate(new Date());
            updateItem.setModifyUserId(StpUtil.getLoginIdAsLong());
            textbookSubscriptionTextbookSubscriptionItemMapper.updateById(updateItem);

            //新增入库记录
            TextbookWarehouseRecord textbookWarehouseRecord = new TextbookWarehouseRecord();
            textbookWarehouseRecord.setTextbookId(old.getTextbookId());
            textbookWarehouseRecord.setDataId(dto.getTextbookSubscriptionId());
            textbookWarehouseRecord.setDataItemId(dto.getTextbookSubscriptionItemId());
            textbookWarehouseRecord.setWarehouseNumber(dto.getInNum());
            textbookWarehouseRecord.setPrice(old.getPrice());
            textbookWarehouseRecord.setDiscount(dto.getDiscount());
            textbookWarehouseRecord.setSubtotal(old.getPrice().multiply(BigDecimal.valueOf(dto.getDiscount() / 10)));
            textbookWarehouseRecord.setTotalPrice(textbookWarehouseRecord.getSubtotal().multiply(BigDecimal.valueOf(dto.getInNum())));
            textbookWarehouseRecord.setWarehouseMode(WarehouseModeEnum.WmManual.getCode());
            updateItem.setCreateDate(new Date());
            updateItem.setCreateUserId(StpUtil.getLoginIdAsLong());
            textbookWarehouseRecordMapper.insert(textbookWarehouseRecord);
        }

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String instockroomExcelImport(InputStream inputStream, Long textbookSubscriptionId) {
        AtomicReference<Map<String, Object>> atomicMap = new AtomicReference<>(new HashMap<>());
        List<Map<Integer, Object>> excalDataList = EasyExcel.read(inputStream).sheet().headRowNumber(1).doReadSync();
        String regex = "\\d+";
        Pattern pattern = Pattern.compile(regex);
        List<TextbookInstockroomImportDto> dataList = new ArrayList<>();
        for (Map<Integer, Object> integerObjectMap : excalDataList) {
            Matcher matcher = pattern.matcher(integerObjectMap.get(11).toString());
            int inNum = 0;
            if (matcher.find()) {
                inNum = Integer.parseInt(integerObjectMap.get(11).toString());
            }
            TextbookInstockroomImportDto importDto = new TextbookInstockroomImportDto();
            importDto.setInNum(inNum);
            importDto.setIssn(integerObjectMap.get(2).toString());
            dataList.add(importDto);
        }

        //获取需要修改的list
        MPJLambdaWrapper<TextbookSubscriptionItem> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .select(TextbookSubscriptionItem::getId)
                .selectAs(Textbook::getIssn, TextbookSubscriptionItemVo::getIssn)
                .select(TextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionItemVo.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, TextbookSubscriptionItem::getTextbookId)
                .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, textbookSubscriptionId)
                .eq(TextbookSubscriptionItem::getDeleteMark, DeleteMark.NODELETE.getCode())
        ;
        List<TextbookSubscriptionItemVo> textbookSubscriptionItemVos = textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinList(TextbookSubscriptionItemVo.class, queryWrapper);

        if (textbookSubscriptionItemVos.isEmpty()) {
            return null;
        }

        Map<String, TextbookSubscriptionItemVo> itemByIssnMap = new HashMap<>();
        for (TextbookSubscriptionItemVo el : textbookSubscriptionItemVos) {
            itemByIssnMap.put(el.getIssn(), el);
        }

        int successNum = 0;
        int instockroomNum = 0;
        for (TextbookInstockroomImportDto item : dataList) {
            if (StringUtils.isBlank(item.getIssn())) {
                continue;
            }
            TextbookSubscriptionItemVo old = itemByIssnMap.get(item.getIssn());
            if (old == null) {
                continue;
            }

            TextbookSubscriptionItem updateItem = new TextbookSubscriptionItem();
            updateItem.setId(old.getId());
            updateItem.setInStockNum(old.getInStockNum() + item.getInNum());
            textbookSubscriptionTextbookSubscriptionItemMapper.updateById(updateItem);

            //新增入库记录
            TextbookWarehouseRecord textbookWarehouseRecord = new TextbookWarehouseRecord();
            textbookWarehouseRecord.setTextbookId(old.getTextbookId());
            textbookWarehouseRecord.setDataId(textbookSubscriptionId);
            textbookWarehouseRecord.setDataItemId(old.getId());
            textbookWarehouseRecord.setWarehouseNumber(item.getInNum());
            textbookWarehouseRecord.setWarehouseMode(WarehouseModeEnum.WmManual.getCode());
            textbookWarehouseRecordMapper.insert(textbookWarehouseRecord);
            successNum++;
            successNum += item.getInNum();
        }
        return "成功入库" + successNum + "样，成功入库" + successNum + "本";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(TextbookSubscription textbookSubscription) {
        int sum = 0;
        //********************************* TextbookSubscriptionItem  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<TextbookSubscriptionItem> textbookSubscriptionItemList = textbookSubscriptionTextbookSubscriptionItemMapper.selectList(
                    Wrappers.lambdaQuery(TextbookSubscriptionItem.class)
                            .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, textbookSubscription.getId())
                            .select(TextbookSubscriptionItem::getId));
            List<Long> textbookSubscriptionItemIds = textbookSubscriptionItemList.stream()
                    .map(TextbookSubscriptionItem::getId)
                    .collect(Collectors.toList());
            // 原有子表单 没有被删除的主键
            List<Long> textbookSubscriptionItemOldIds = textbookSubscription.getTextbookSubscriptionItemList().stream()
                    .map(TextbookSubscriptionItem::getId)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList());
            // 找到需要删除的id
            List<Long> textbookSubscriptionItemRemoveIds = textbookSubscriptionItemIds.stream()
                    .filter(item -> !textbookSubscriptionItemOldIds.contains(item))
                    .collect(Collectors.toList());

            TextbookSubscriptionItemClass textbookSubscriptionItemClass;
            for (TextbookSubscriptionItem textbookSubscriptionItem : textbookSubscription.getTextbookSubscriptionItemList()) {
                // 如果不等于空则修改
                if (textbookSubscriptionItem.getId() != null) {
                    textbookSubscriptionTextbookSubscriptionItemMapper.updateById(textbookSubscriptionItem);
                } else {
                    // 如果等于空 则新增
                    // 新增的时候应该处理班级关联
                    String[] classIdArr = new String[0];
                    if (ObjectUtils.isNotEmpty(textbookSubscription.getSubscriptionMethod())
                            && textbookSubscription.getSubscriptionMethod() == 1
                            && ObjectUtils.isNotEmpty(textbookSubscriptionItem.getClassIds())
                    ) {
                        classIdArr = textbookSubscriptionItem.getClassIds().split(",");
                    }

                    textbookSubscriptionItem.setUseClassNum(classIdArr.length);
                    textbookSubscriptionItem.setTextbookSubscriptionId(textbookSubscription.getId());
                    textbookSubscriptionItem.setCreateDate(new Date());
                    textbookSubscriptionTextbookSubscriptionItemMapper.insert(textbookSubscriptionItem);

                    // 处理征订项和班级关联表
                    for (String str : classIdArr) {
                        textbookSubscriptionItemClass = new TextbookSubscriptionItemClass();
                        textbookSubscriptionItemClass.setTextbookSubscriptionItemId(textbookSubscriptionItem.getId());
                        textbookSubscriptionItemClass.setBaseClassId(Long.parseLong(str));
                        textbookSubscriptionItemClass.setCreateDate(new Date());
                        textbookSubscriptionItemClassMapper.insert(textbookSubscriptionItemClass);
                    }
                }
                textbookSubscriptionItem.setStudentNum(ObjectUtils.isEmpty(textbookSubscriptionItem.getStudentNum()) ? 0 : textbookSubscriptionItem.getStudentNum());
                textbookSubscriptionItem.setTeacherNum(ObjectUtils.isEmpty(textbookSubscriptionItem.getTeacherNum()) ? 0 : textbookSubscriptionItem.getTeacherNum());

                sum += textbookSubscriptionItem.getStudentNum() + textbookSubscriptionItem.getTeacherNum();
            }
            // 已经不存在的id 删除
            if (ObjectUtils.isNotEmpty(textbookSubscriptionItemRemoveIds.isEmpty())) {
                LambdaUpdateWrapper<TextbookSubscriptionItemClass> textbookSubscriptionItemClassLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
                textbookSubscriptionItemClassLambdaUpdateWrapper
                        .in(TextbookSubscriptionItemClass::getTextbookSubscriptionItemId, textbookSubscriptionItemRemoveIds)
                        .eq(TextbookSubscriptionItemClass::getDeleteMark, DeleteMark.NODELETE.getCode())
                        ;
                textbookSubscriptionItemClassMapper.delete(textbookSubscriptionItemClassLambdaUpdateWrapper);
                textbookSubscriptionTextbookSubscriptionItemMapper.deleteBatchIds(textbookSubscriptionItemRemoveIds);
            }
        }
        //********************************* TextbookSubscriptionItem  增删改  结束 *******************************************/

        //********************************* TextbookSubscriptionClass  增删改  开始 *******************************************/
//        LambdaUpdateWrapper<TextbookSubscriptionClass> textbookSubscriptionClassLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
//        textbookSubscriptionClassLambdaUpdateWrapper
//                .eq(TextbookSubscriptionClass::getTextbookSubscriptionId, textbookSubscription.getId())
//        ;
//        textbookSubscriptionClassMapper.delete(textbookSubscriptionClassLambdaUpdateWrapper);
//
//        if (ObjectUtils.isNotEmpty(textbookSubscription.getSubscriptionMethod())
//                && textbookSubscription.getSubscriptionMethod() == 1
//                && StringUtils.isNotBlank(textbookSubscription.getBaseClassIds())
//        ) {
//            String[] classIdArr = textbookSubscription.getBaseClassIds().split(",");
//            for (String str : classIdArr) {
//                TextbookSubscriptionClass textbookSubscriptionClass = new TextbookSubscriptionClass();
//                textbookSubscriptionClass.setTextbookSubscriptionId(textbookSubscription.getId());
//                textbookSubscriptionClass.setBaseClassId(Long.parseLong(str));
//                textbookSubscriptionClass.setCreateDate(new Date());
//                textbookSubscriptionClassMapper.insert(textbookSubscriptionClass);
//            }
//        }
        //********************************* TextbookSubscriptionClass  增删改  结束 *******************************************/

        textbookSubscription.setSum(sum);
        textbookSubscriptionTextbookSubscriptionMapper.updateById(textbookSubscription);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean alteration(UpdateTextbookSubscriptionItemDto dto) {
        TextbookSubscriptionItem old = textbookSubscriptionTextbookSubscriptionItemMapper.selectById(dto.getId());
        if(old == null){
            throw new MyException("征订项已经被修改，刷新重试");
        }

        MPJLambdaWrapper<TextbookSubscription> textbookSubscriptionMPJLambdaWrapper = new MPJLambdaWrapper<>();
        textbookSubscriptionMPJLambdaWrapper
                .select(TextbookSubscription.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscription.class).contains(x.getProperty()))
                .eq(TextbookSubscriptionItem::getId, dto.getId())
                .innerJoin(TextbookSubscriptionItem.class, TextbookSubscriptionItem::getTextbookSubscriptionId, TextbookSubscription::getId)
        ;

        TextbookSubscription textbookSubscription = this.selectJoinOne(TextbookSubscription.class, textbookSubscriptionMPJLambdaWrapper);

        // 判断变更状态
        int alterationType = 0;
        TextbookSubscription updateTotalNum = new TextbookSubscription();
        if(!old.getStudentNum().equals(dto.getStudentNum())
                || !old.getTeacherNum().equals(dto.getTeacherNum())
        ){
            alterationType = 1;
            if(ObjectUtils.isNotEmpty(textbookSubscription)){
                updateTotalNum.setId(textbookSubscription.getId());
                updateTotalNum.setSum(textbookSubscription.getSum() + (dto.getStudentNum() - old.getStudentNum()) + (dto.getTeacherNum() - old.getTeacherNum()));
                this.updateById(updateTotalNum);
            }
        }

        if(!old.getTextbookId().equals(dto.getTextbookId())){
            alterationType = 2;
            if(ObjectUtils.isNotEmpty(textbookSubscription)){
                updateTotalNum.setId(textbookSubscription.getId());
                updateTotalNum.setSum(textbookSubscription.getSum() - (old.getTeacherNum() + old.getStudentNum()) + (dto.getTeacherNum() + dto.getStudentNum()));
                this.updateById(updateTotalNum);
            }
        }

        // 将历史记录保存到历史变更记录表
        // 当前征订项的变更历史最后一次记录
        LambdaQueryWrapper<TextbookSubscriptionItemHistory> textbookSubscriptionItemHistoryLambdaQueryWrapper = new LambdaQueryWrapper<>();
        textbookSubscriptionItemHistoryLambdaQueryWrapper
                .eq(TextbookSubscriptionItemHistory::getTextbookSubscriptionItemId, old.getId())
                .orderByDesc(TextbookSubscriptionItemHistory::getHistoryVersion)
                .last("limit 1")
        ;
        TextbookSubscriptionItemHistory lastOne = textbookSubscriptionItemHistoryMapper.selectOne(textbookSubscriptionItemHistoryLambdaQueryWrapper);

        // 将变更前的数据记录在历史表中
        TextbookSubscriptionItemHistory textbookSubscriptionItemHistory = new TextbookSubscriptionItemHistory();
        // 变更前
        textbookSubscriptionItemHistory.setOldTextbookId(old.getTextbookId());
        textbookSubscriptionItemHistory.setOldStudentNum(old.getStudentNum());
        textbookSubscriptionItemHistory.setOldTeacherNum(old.getTeacherNum());
        textbookSubscriptionItemHistory.setOldDiscount(old.getDiscount());
        textbookSubscriptionItemHistory.setOldPrice(old.getPrice());
        textbookSubscriptionItemHistory.setOldInStockNum(old.getInStockNum());
        textbookSubscriptionItemHistory.setOldOutStockNum(old.getOutStockNum());

        // 变更后
        textbookSubscriptionItemHistory.setNewTextbookId(dto.getTextbookId());
        textbookSubscriptionItemHistory.setNewStudentNum(dto.getStudentNum());
        textbookSubscriptionItemHistory.setNewTeacherNum(dto.getTeacherNum());
        textbookSubscriptionItemHistory.setNewDiscount(dto.getDiscount());
        textbookSubscriptionItemHistory.setNewPrice(dto.getPrice());
        textbookSubscriptionItemHistory.setNewInStockNum(dto.getInStockNum());
        textbookSubscriptionItemHistory.setNewOutStockNum(dto.getOutStockNum());

        textbookSubscriptionItemHistory.setTextbookSubscriptionId(old.getTextbookSubscriptionId());
        textbookSubscriptionItemHistory.setTextbookSubscriptionItemId(old.getId());
        textbookSubscriptionItemHistory.setCreateDate(new Date());
        textbookSubscriptionItemHistory.setCreateUserId(StpUtil.getLoginIdAsLong());
        if(ObjectUtils.isNotEmpty(lastOne)){
            textbookSubscriptionItemHistory.setHistoryVersion(lastOne.getHistoryVersion() + 1);
        } else {
            textbookSubscriptionItemHistory.setHistoryVersion(1);
        }
        textbookSubscriptionItemHistory.setAlterationType(alterationType);
        textbookSubscriptionItemHistoryMapper.insert(textbookSubscriptionItemHistory);

        // 变更征订总数量


        //变更当前记录
        TextbookSubscriptionItem updateItem = new TextbookSubscriptionItem();
        BeanUtils.copyProperties(dto, updateItem);
        updateItem.setAlterationType(alterationType);
        textbookSubscriptionTextbookSubscriptionItemMapper.updateById(updateItem);

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean changeStatus(UpdateWfTextbookSubscriptionDto dto) {
        TextbookSubscription textbookSubscription = this.getById(dto.getId());
        if (textbookSubscription == null) {
            return false;
        }

        TextbookSubscription newT = new TextbookSubscription();
        newT.setId(textbookSubscription.getId());
        newT.setStatus(dto.getStatus());

        return this.updateById(newT);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        LambdaQueryWrapper<TextbookSubscriptionItem> textbookSubscriptionItemLambdaQueryWrapper = new LambdaQueryWrapper<>();
        textbookSubscriptionItemLambdaQueryWrapper
                .in(TextbookSubscriptionItem::getTextbookSubscriptionId, ids)
                ;
        List<TextbookSubscriptionItem> textbookSubscriptionItemList = textbookSubscriptionTextbookSubscriptionItemMapper.selectList(textbookSubscriptionItemLambdaQueryWrapper);

        List<Long> textbookSubscriptionItemIds = textbookSubscriptionItemList.stream()
                                .map(TextbookSubscriptionItem::getId)
                                .collect(Collectors.toList());

        if(ObjectUtils.isNotEmpty(textbookSubscriptionItemIds)){
            textbookSubscriptionItemClassMapper.delete(Wrappers.lambdaQuery(TextbookSubscriptionItemClass.class).in(TextbookSubscriptionItemClass::getTextbookSubscriptionItemId, textbookSubscriptionItemIds));
        }

        if(ObjectUtils.isNotEmpty(ids)) {
            textbookSubscriptionTextbookSubscriptionItemMapper.delete(Wrappers.lambdaQuery(TextbookSubscriptionItem.class).in(TextbookSubscriptionItem::getTextbookSubscriptionId, ids));
            textbookSubscriptionClassMapper.delete(Wrappers.lambdaQuery(TextbookSubscriptionClass.class).in(TextbookSubscriptionClass::getTextbookSubscriptionId, ids));
            textbookSubscriptionTextbookSubscriptionMapper.deleteBatchIds(ids);
        }
        return true;
    }

    @Override
    public List<TextbookSubscriptionExportQueryListVo> textbookSubscriptionExportQuery(TextbookSubscriptionExportQueryListDto dto) {
        TextbookSubscription textbookSubscription = this.getById(dto.getTextbookSubscriptionId());
        if (textbookSubscription == null) {
            return null;
        }

        MPJLambdaWrapper<TextbookSubscriptionItem> textbookSubscriptionItemMPJLambdaWrapper = new MPJLambdaWrapper<>();
        textbookSubscriptionItemMPJLambdaWrapper
                .selectAs(BaseCourseSubject::getName, TextbookSubscriptionExportQueryListVo::getCourseName)
                .selectAs(TextbookSubscriptionItem::getStudentNum, TextbookSubscriptionExportQueryListVo::getStudentSubscriptionNumber)
                .selectAs(TextbookSubscriptionItem::getTeacherNum, TextbookSubscriptionExportQueryListVo::getTeacherSubscriptionNumber)
                .selectAs(TextbookSubscriptionItem::getInStockNum, TextbookSubscriptionExportQueryListVo::getInStockroomNum)
                .selectAs(TextbookSubscription::getBaseClassIds, TextbookSubscriptionExportQueryListVo::getClassIds)
                .select("t.student_num + t.teacher_num as subscription_sum")
                .select(TextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionExportQueryListVo.class).contains(x.getProperty()))
                .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionExportQueryListVo.class).contains(x.getProperty()))
                .leftJoin(TextbookSubscription.class, TextbookSubscription::getId, TextbookSubscriptionItem::getTextbookSubscriptionId)
                .leftJoin(Textbook.class, Textbook::getId, TextbookSubscriptionItem::getTextbookId)
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                        ext -> ext.selectAs(DictionaryDetail::getName, TextbookSubscriptionExportQueryListVo::getTextbookTypeCn))
                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId)
                .eq(TextbookSubscriptionItem::getTextbookSubscriptionId, textbookSubscription.getId())
        ;
        List<TextbookSubscriptionExportQueryListVo> itemList = textbookSubscriptionTextbookSubscriptionItemMapper.selectJoinList(TextbookSubscriptionExportQueryListVo.class, textbookSubscriptionItemMPJLambdaWrapper);

        //处理班级
        String classIds = "";
        List<String> classIdList = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        if (!itemList.isEmpty() && itemList.get(0).getClassIds() != null && !itemList.get(0).getClassIds().equals("")) {
            classIds = itemList.get(0).getClassIds();
            String[] classIdArr = classIds.split(",");
            classIdList = Arrays.asList(classIdArr);
            /*if(!classIdList.isEmpty()){
                List<BaseClass> baseClassList = baseClassMapper.selectList(Wrappers.<BaseClass>query().lambda().in(BaseClass::getId, classIdList));
                Map<Long, BaseClass> baseClassMap = baseClassList.stream()
                        .collect(Collectors.toMap(BaseClass::getId, baseClass -> baseClass));

                for (String classId : classIdList){
                    BaseClass baseClass = baseClassMap.get(Long.parseLong(classId));
                    if(baseClass != null){
                        sb.append(baseClass.getName());
                        sb.append(",");
                    }
                }
                sb.deleteCharAt(sb.length() - 1);
            }*/
        }

        for (TextbookSubscriptionExportQueryListVo w : itemList) {
            w.setClassNum(classIdList.size());
        }

        return itemList;
    }
}