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

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.evaluate.dto.AddEvaluateItemDto;
import com.xjrsoft.module.evaluate.dto.MakeEvaluateItemDto;
import com.xjrsoft.module.evaluate.entity.EvaluateItem;
import com.xjrsoft.module.evaluate.entity.EvaluateTemplate;
import com.xjrsoft.module.evaluate.mapper.EvaluateItemMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateTemplateMapper;
import com.xjrsoft.module.evaluate.service.IEvaluateItemService;
import com.xjrsoft.module.evaluate.vo.EvaluateItemGroupByTopicVo;
import com.xjrsoft.module.evaluate.vo.EvaluateItemVo;
import com.xjrsoft.module.evaluate.vo.MakeEvaluateItemVo;
import com.xjrsoft.module.organization.entity.Department;
import com.xjrsoft.module.organization.mapper.DepartmentMapper;
import com.xjrsoft.module.system.entity.DictionaryDetail;
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-01-15
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class EvaluateItemServiceImpl extends MPJBaseServiceImpl<EvaluateItemMapper, EvaluateItem> implements IEvaluateItemService {

    private EvaluateItemMapper evaluateItemMapper;

    private EvaluateTemplateMapper evaluateTemplateMapper;

    private DepartmentMapper departmentMapper;
    @Override
    public MakeEvaluateItemVo getMakeEvaluateItem(MakeEvaluateItemDto dto){
        //获取模板基本信息
        MPJLambdaWrapper<EvaluateTemplate> evaluateTemplateMPJLambdaWrapper = new MPJLambdaWrapper<>();
        evaluateTemplateMPJLambdaWrapper
                .select(EvaluateTemplate::getId)
                .selectAs(DictionaryDetail::getName, MakeEvaluateItemVo::getEvaluateTypeCN)
                .select(EvaluateTemplate.class, x -> VoToColumnUtil.fieldsToColumns(MakeEvaluateItemVo.class).contains(x.getProperty()))
                .eq(EvaluateTemplate::getId, dto.getEvaluateTemplateId())
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, EvaluateTemplate::getEvaluateType);
        MakeEvaluateItemVo makeEvaluateItemVo = evaluateTemplateMapper.selectJoinOne(MakeEvaluateItemVo.class,evaluateTemplateMPJLambdaWrapper);

        //如何没有找到模板，返回null
        if(makeEvaluateItemVo == null){
            return makeEvaluateItemVo;
        }

        List<String> deptIdList = new ArrayList<>();
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            deptIdList = objectMapper.readValue(makeEvaluateItemVo.getDeptIds(), new TypeReference<List<String>>() {});
        }catch (Exception e){
        }
        if(deptIdList != null && deptIdList.size() > 0 && !deptIdList.get(0).equals("0")){
            String deptIdStr = String.join(",", deptIdList);
            LambdaQueryWrapper<Department> departmentLambdaQueryWrapper = new LambdaQueryWrapper<>();
            departmentLambdaQueryWrapper
                    .in(Department::getId, deptIdList);
            List<Department> departmentList = departmentMapper.selectList(departmentLambdaQueryWrapper);
            StringBuilder deptStr = new StringBuilder();

            for (int i = 0; i < departmentList.size(); i++) {
                deptStr.append(departmentList.get(i).getName());
                if(i < departmentList.size() - 1){
                    deptStr.append("，");
                }
            }
            makeEvaluateItemVo.setDeptIds("[" + deptIdStr +"]");
            makeEvaluateItemVo.setDeptIdsCN(deptStr.toString());
        }

        if(deptIdList != null && deptIdList.size() > 0 && deptIdList.get(0).equals("0")){
            makeEvaluateItemVo.setDeptIdsCN("通用");
        }

        //获取模板下的所有评价子项集合
        MPJLambdaWrapper<EvaluateItem> evaluateItemWrapper = new MPJLambdaWrapper<>();
        evaluateItemWrapper
                .select(EvaluateItem::getId)
                .select(EvaluateItem.class, x -> VoToColumnUtil.fieldsToColumns(EvaluateItemVo.class).contains(x.getProperty()))
                .eq(EvaluateItem::getEvaluateTemplateId, dto.getEvaluateTemplateId());

        List<EvaluateItemVo> evaluateItemVoList = this.selectJoinList(EvaluateItemVo.class, evaluateItemWrapper);

//        Map<String, List<EvaluateItemVo>> groupedEvaluateItemVo = evaluateItemVoList.stream()
//                .collect(Collectors.groupingBy(EvaluateItemVo::getTopic));

        //需要按照存入数据库的顺序返回，所以只有自己写map，
        Map<String, List<EvaluateItemVo>> groupedEvaluateItemVo = evaluateItemVoList.stream()
                .collect(Collectors.groupingBy(EvaluateItemVo::getTopic, LinkedHashMap::new, Collectors.toList()));

        List<EvaluateItemGroupByTopicVo> evaluateItemGroupByTopicVoList = new ArrayList<>();
        groupedEvaluateItemVo.forEach((topic, group) -> {
            evaluateItemGroupByTopicVoList.add(new EvaluateItemGroupByTopicVo(){{
                setTopic(topic);
                setEvaluateItemVoList(group);
            }});
        });

        makeEvaluateItemVo.setEvaluateItemGroupByTopicVoList(evaluateItemGroupByTopicVoList);

        return makeEvaluateItemVo;
    }

    @Override
    @Transactional
    public Boolean addEvaluateItem(List<AddEvaluateItemDto> dto) {
        //获取模板
        Long evaluateTemplateId = dto.get(0).getEvaluateTemplateId();
        EvaluateTemplate evaluateTemplate = evaluateTemplateMapper.selectById(evaluateTemplateId);
        if(evaluateTemplate == null) {
            throw new MyException("没有找到对应模板！");
        }
        //先物理删除数据库中该模板下的所有评价项
        evaluateItemMapper.physicalDeleteEvaluateItem(dto.get(0).getEvaluateTemplateId());
        //获取sortCode的最大数量
        QueryWrapper<EvaluateItem> queryWrapperSortcode = new QueryWrapper<>();
        queryWrapperSortcode.select("IFNULL(MAX(sort_code),0) as sortCode");
        EvaluateItem e = this.getOne(queryWrapperSortcode);
        int sortCode = e.getSortCode() + 1;

        List<EvaluateItem> evaluateItemList = new ArrayList<>();
        int sumScore = 0;
        for (AddEvaluateItemDto addEvaluateItemDto : dto) {
            addEvaluateItemDto.setSortCode(sortCode++);
            EvaluateItem evaluateItem = BeanUtil.toBean(addEvaluateItemDto, EvaluateItem.class);
            evaluateItem.setCreateDate(new Date());
            evaluateItemList.add(evaluateItem);
            sumScore += evaluateItem.getScore();
        }
        if(sumScore > evaluateTemplate.getTotal()) {
            throw new MyException("题目总分超出模板设置的总分！");
        }
        return this.saveBatch(evaluateItemList);
    }
}
