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

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseCourseSubject;
import com.xjrsoft.module.base.mapper.BaseClassMapper;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.textbook.dto.*;
import com.xjrsoft.module.textbook.entity.Textbook;
import com.xjrsoft.module.textbook.entity.TextbookSubscriptionRecord;
import com.xjrsoft.module.textbook.entity.WfTextbookSubscription;
import com.xjrsoft.module.textbook.entity.WfTextbookSubscriptionItem;
import com.xjrsoft.module.textbook.mapper.TextbookSubscriptionRecordMapper;
import com.xjrsoft.module.textbook.mapper.WfTextbookSubscriptionItemMapper;
import com.xjrsoft.module.textbook.mapper.WfTextbookSubscriptionMapper;
import com.xjrsoft.module.textbook.service.ITextbookService;
import com.xjrsoft.module.textbook.service.IWfTextbookSubscriptionService;
import com.xjrsoft.module.textbook.vo.TextbookInstockroomListVo;
import com.xjrsoft.module.textbook.vo.TextbookSubscriptionExportQueryListVo;
import com.xjrsoft.module.textbook.vo.WfTextbookSubscriptionItemVo;
import com.xjrsoft.module.textbook.vo.WfTextbookSubscriptionVo;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @title: 教材教辅征订
 * @Author szs
 * @Date: 2024-06-04
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class WfTextbookSubscriptionServiceImpl extends MPJBaseServiceImpl<WfTextbookSubscriptionMapper, WfTextbookSubscription> implements IWfTextbookSubscriptionService {
    private final WfTextbookSubscriptionMapper wfTextbookSubscriptionWfTextbookSubscriptionMapper;

    private final WfTextbookSubscriptionItemMapper wfTextbookSubscriptionWfTextbookSubscriptionItemMapper;

    private final TextbookSubscriptionRecordMapper textbookTextbookSubscriptionRecordMapper;

    private final ITextbookService textbookService;

    private final BaseClassMapper baseClassMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(WfTextbookSubscription wfTextbookSubscription) {
        wfTextbookSubscription.setApplicantUserId(StpUtil.getLoginIdAsLong());
        wfTextbookSubscription.setStatus(1);
        wfTextbookSubscription.setCreateDate(new Date());
        wfTextbookSubscriptionWfTextbookSubscriptionMapper.insert(wfTextbookSubscription);
        for (WfTextbookSubscriptionItem wfTextbookSubscriptionItem : wfTextbookSubscription.getWfTextbookSubscriptionItemList()) {
            wfTextbookSubscriptionItem.setWfTextbookSubscriptionId(wfTextbookSubscription.getId());
            wfTextbookSubscriptionItem.setCreateDate(new Date());
            wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.insert(wfTextbookSubscriptionItem);
        }

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(WfTextbookSubscription wfTextbookSubscription) {
        wfTextbookSubscriptionWfTextbookSubscriptionMapper.updateById(wfTextbookSubscription);
        //********************************* WfTextbookSubscriptionItem  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<WfTextbookSubscriptionItem> wfTextbookSubscriptionItemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectList(Wrappers.lambdaQuery(WfTextbookSubscriptionItem.class).eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, wfTextbookSubscription.getId()).select(WfTextbookSubscriptionItem::getId));
            List<Long> wfTextbookSubscriptionItemIds = wfTextbookSubscriptionItemList.stream().map(WfTextbookSubscriptionItem::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> wfTextbookSubscriptionItemOldIds = wfTextbookSubscription.getWfTextbookSubscriptionItemList().stream().map(WfTextbookSubscriptionItem::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> wfTextbookSubscriptionItemRemoveIds = wfTextbookSubscriptionItemIds.stream().filter(item -> !wfTextbookSubscriptionItemOldIds.contains(item)).collect(Collectors.toList());

            for (WfTextbookSubscriptionItem wfTextbookSubscriptionItem : wfTextbookSubscription.getWfTextbookSubscriptionItemList()) {
                //如果不等于空则修改
                if (wfTextbookSubscriptionItem.getId() != null) {
                    wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.updateById(wfTextbookSubscriptionItem);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    wfTextbookSubscriptionItem.setWfTextbookSubscriptionId(wfTextbookSubscription.getId());
                    wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.insert(wfTextbookSubscriptionItem);
                }
            }
            //已经不存在的id 删除
            if (wfTextbookSubscriptionItemRemoveIds.size() > 0) {
                wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.deleteBatchIds(wfTextbookSubscriptionItemRemoveIds);
            }
        }
        //********************************* WfTextbookSubscriptionItem  增删改  结束 *******************************************/

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        wfTextbookSubscriptionWfTextbookSubscriptionMapper.deleteBatchIds(ids);
        wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.delete(Wrappers.lambdaQuery(WfTextbookSubscriptionItem.class).in(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, ids));

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean changeStatus(UpdateWfTextbookSubscriptionDto dto) {
        WfTextbookSubscription wfTextbookSubscription = this.getById(dto.getId());
        if (wfTextbookSubscription == null) {
            return false;
        }
        //点击发起征订
        if (wfTextbookSubscription.getStatus() == 1 && dto.getStatus() == 2) {
            WfTextbookSubscription newW = BeanUtil.toBean(dto, WfTextbookSubscription.class);
            //添加征订记录
            List<WfTextbookSubscriptionItem> wfTextbookSubscriptionItemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectList(Wrappers.<WfTextbookSubscriptionItem>query().lambda().eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, wfTextbookSubscription.getId()));
            for (WfTextbookSubscriptionItem w : wfTextbookSubscriptionItemList) {
                textbookTextbookSubscriptionRecordMapper.insert(new TextbookSubscriptionRecord() {{
                    setCreateDate(new Date());
                    setTextbookId(w.getTextbookId());
                    setWfTextbookSubscriptionId(wfTextbookSubscription.getId());
                    setWfTextbookSubscriptionItemId(w.getId());//该字段存入征订项的id，征订项中有所属征订记录
                }});
            }
            return this.updateById(newW);
        }


        //点击完成征订
        if (wfTextbookSubscription.getStatus() == 3 && dto.getStatus() == 4) {
            WfTextbookSubscription newW = BeanUtil.toBean(dto, WfTextbookSubscription.class);
            return this.updateById(newW);
        }
        return false;
    }

    @Override
    public WfTextbookSubscriptionVo getInfo(Long id) {
        WfTextbookSubscription wfTextbookSubscription = this.getById(id);
        if (wfTextbookSubscription == null) {
            return null;
        }
        WfTextbookSubscriptionVo wfTextbookSubscriptionVo = BeanUtil.toBean(wfTextbookSubscription, WfTextbookSubscriptionVo.class);

        MPJLambdaWrapper<WfTextbookSubscriptionItem> mpjLambdaWrapper = new MPJLambdaWrapper<>();
        mpjLambdaWrapper
                .selectAs(BaseCourseSubject::getName, WfTextbookSubscriptionItemVo::getCourseSubjectIdCn)
                .select(WfTextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(WfTextbookSubscriptionItemVo.class).contains(x.getProperty()))
                .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(WfTextbookSubscriptionItemVo.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, WfTextbookSubscriptionItem::getTextbookId)
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                        ext -> ext.selectAs(DictionaryDetail::getName, WfTextbookSubscriptionItemVo::getTextbookTypeCn))
                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId)
                .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, wfTextbookSubscription.getId())
        ;
        List<WfTextbookSubscriptionItemVo> itemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectJoinList(WfTextbookSubscriptionItemVo.class, mpjLambdaWrapper);

        //处理班级
        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);
            }
        }

        //遍历处理所有项
        int stuSum = 0;
        int teaSum = 0;
        for (WfTextbookSubscriptionItemVo w : itemList) {
            if (!classIdList.isEmpty()) {
                w.setClassNum(classIdList.size());
            }
            if (w.getStudentSubscriptionNumber() != null) {
                stuSum += w.getStudentSubscriptionNumber();
            }
            if (w.getTeacherSubscriptionNumber() != null) {
                teaSum += w.getTeacherSubscriptionNumber();
            }
        }

        wfTextbookSubscriptionVo.setClassIdsCn(sb.toString());
        wfTextbookSubscriptionVo.setClassIds(classIds);
        wfTextbookSubscriptionVo.setStudentSubscriptionNumberSum(stuSum);
        wfTextbookSubscriptionVo.setTeacherSubscriptionNumberSum(teaSum);
        wfTextbookSubscriptionVo.setSum(stuSum + teaSum);
        wfTextbookSubscriptionVo.setWfTextbookSubscriptionItemList(itemList);

        return wfTextbookSubscriptionVo;
    }

    @Override
    public List<TextbookSubscriptionExportQueryListVo> textbookSubscriptionExportQuery(TextbookSubscriptionExportQueryListDto dto) {
        WfTextbookSubscription wfTextbookSubscription = this.getById(dto.getWfTextbookSubscriptionId());
        if (wfTextbookSubscription == null) {
            return null;
        }

        MPJLambdaWrapper<WfTextbookSubscriptionItem> mpjLambdaWrapper = new MPJLambdaWrapper<>();
        mpjLambdaWrapper
                .selectAs(BaseCourseSubject::getName, TextbookSubscriptionExportQueryListVo::getCourseName)
                .select(WfTextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionExportQueryListVo.class).contains(x.getProperty()))
                .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionExportQueryListVo.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, WfTextbookSubscriptionItem::getTextbookId)
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                        ext -> ext.selectAs(DictionaryDetail::getName, TextbookSubscriptionExportQueryListVo::getTextbookTypeCn))
                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId)
                .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, wfTextbookSubscription.getId())
        ;
        List<TextbookSubscriptionExportQueryListVo> itemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectJoinList(TextbookSubscriptionExportQueryListVo.class, mpjLambdaWrapper);

        //处理班级
        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;
    }

    @Override
    public List<TextbookInstockroomListVo> instockroomList(TextbookInstockroomListDto dto) {
        MPJLambdaWrapper<WfTextbookSubscriptionItem> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .select(WfTextbookSubscriptionItem::getId)
                .selectAs(BaseCourseSubject::getName, TextbookInstockroomListVo::getCourseSubjectIdCn)
                .selectAs(DictionaryDetail::getName, TextbookInstockroomListVo::getTextbookTypeCn)
                .select("(t.student_subscription_number + t.teacher_subscription_number) as subscriptionNumber")
                .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(TextbookInstockroomListVo.class).contains(x.getProperty()))
                .select(WfTextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookInstockroomListVo.class).contains(x.getProperty()))
                .leftJoin(Textbook.class, Textbook::getId, WfTextbookSubscriptionItem::getTextbookId)
                .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId)
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType)
                .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, dto.getWfTextbookSubscriptionId())
                .orderByAsc(WfTextbookSubscriptionItem::getInstockroomNum)
        ;
        List<TextbookInstockroomListVo> list = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectJoinList(TextbookInstockroomListVo.class, queryWrapper);

        return list;
    }

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

        //获取需要修改的list
        LambdaQueryWrapper<WfTextbookSubscriptionItem> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper
                .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, dtos.get(0).getWfTextbookSubscriptionId())
                .eq(WfTextbookSubscriptionItem::getDeleteMark, DeleteMark.NODELETE.getCode())
        ;
        List<WfTextbookSubscriptionItem> wfTextbookSubscriptionItemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectList(queryWrapper);

        if (wfTextbookSubscriptionItemList.isEmpty()) {
            return false;
        }

        Map<Long, WfTextbookSubscriptionItem> itemMap = wfTextbookSubscriptionItemList
                .stream()
                .collect(Collectors.toMap(
                        WfTextbookSubscriptionItem::getId,
                        item -> item
                ));

        Date now = new Date();
        Long loginId = StpUtil.getLoginIdAsLong();
        for (TextbookInstockroomDto dto : dtos) {
            WfTextbookSubscriptionItem old = itemMap.get(dto.getId());
            WfTextbookSubscriptionItem updateItem = new WfTextbookSubscriptionItem();
            updateItem.setId(old.getId());
            updateItem.setInstockroomNum(old.getInstockroomNum() + dto.getInNum());
            updateItem.setModifyDate(now);
            updateItem.setModifyUserId(loginId);
            wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.updateById(updateItem);

            //新增入库记录
            textbookService.deliverWarehouse(new AddTextbookWarehouseRecordDto() {{
                setTextbookId(old.getTextbookId());
                setWarehouseNumber(dto.getInNum());
                setSource("wm_manual");
            }});
        }
        return true;
    }
}