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

import cn.dev33.satoken.stp.StpUtil;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.EnabledMark;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.module.evaluate.dto.AddEvaluateExecuterDto;
import com.xjrsoft.module.evaluate.dto.AddEvaluateObjectDto;
import com.xjrsoft.module.evaluate.dto.EvaluateObjectListDto;
import com.xjrsoft.module.evaluate.dto.SaveEvaluateObjectDto;
import com.xjrsoft.module.evaluate.entity.EvaluateExecuter;
import com.xjrsoft.module.evaluate.entity.EvaluateManage;
import com.xjrsoft.module.evaluate.entity.EvaluateObject;
import com.xjrsoft.module.evaluate.mapper.EvaluateExecuterMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateManageMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateObjectMapper;
import com.xjrsoft.module.evaluate.service.IEvaluateObjectService;
import com.xjrsoft.module.evaluate.vo.EvaluateExecuterVo;
import com.xjrsoft.module.evaluate.vo.EvaluateObjectListVo;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;

/**
* @title: 评价管理
* @Author dzx
* @Date: 2024-01-16
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class EvaluateObjectServiceImpl extends MPJBaseServiceImpl<EvaluateObjectMapper, EvaluateObject> implements IEvaluateObjectService {
    private final EvaluateManageMapper evaluateManageMapper;

    private final EvaluateObjectMapper evaluateObjectMapper;
    private final EvaluateExecuterMapper evaluateExecuterMapper;


    @Override
    public List<EvaluateObjectListVo> getObjectList(Long id) {
        List<EvaluateObjectListVo> objectList = evaluateObjectMapper.getObjectList(id);
        List<EvaluateExecuterVo> allExecuterList = evaluateObjectMapper.getExecuterList(id);
        for (EvaluateObjectListVo objectVo : objectList) {
            List<EvaluateExecuterVo> executerList = new ArrayList<>();
            for (EvaluateExecuterVo executerVo : allExecuterList) {
                if(objectVo.getId().equals(executerVo.getEvaluateObjectId())){
                    executerList.add(executerVo);
                }
            }

            objectVo.setExecuterCount(executerList.size());
            objectVo.setExecuterList(executerList);
        }
        return objectList;
    }

    @Override
    public Boolean save(SaveEvaluateObjectDto dto) {
        EvaluateManage manage = evaluateManageMapper.selectById(dto.getEvaluateManageId());
        if(manage == null){
           throw new MyException("未查询到信息，evaluateManageId不正确");
        }
        Date createDate = new Date();
        long createUserId = StpUtil.getLoginIdAsLong();
        for (AddEvaluateObjectDto objectDto : dto.getObjectList()) {
            EvaluateObject evaluateObject = new EvaluateObject();
            evaluateObject.setObjectId(Long.parseLong(objectDto.getObjectId()));
            evaluateObject.setEvaluateManageId(Long.parseLong(dto.getEvaluateManageId()));
            evaluateObject.setDeleteMark(DeleteMark.NODELETE.getCode());
            evaluateObject.setCreateDate(createDate);
            evaluateObject.setCreateUserId(createUserId);
            evaluateObject.setEnabledMark(EnabledMark.ENABLED.getCode());
            evaluateObject.setBaseGradeId(Long.parseLong(objectDto.getGradeId()));
            evaluateObjectMapper.insert(evaluateObject);

            for (AddEvaluateExecuterDto executerDto : objectDto.getExecuterList()) {
                EvaluateExecuter executer = new EvaluateExecuter();
                executer.setCreateDate(createDate);
                executer.setCreateUserId(createUserId);
                executer.setEvaluateManageId(Long.parseLong(dto.getEvaluateManageId()));
                executer.setEvaluateObjectId(evaluateObject.getId());
                executer.setUserId(Long.parseLong(executerDto.getExecuterId()));
                executer.setStatus(0);
                evaluateExecuterMapper.insert(executer);
            }
        }
        return true;
    }

    @Override
    public List<EvaluateObjectListVo> getNewObjectList(EvaluateObjectListDto dto) {
        List<EvaluateObjectListVo> newObjectList = evaluateObjectMapper.getNewObjectList(dto);
        List<EvaluateExecuterVo> newExecuterList = evaluateObjectMapper.getNewExecuterList(dto);

        for (EvaluateObjectListVo objectListVo : newObjectList) {
            List<EvaluateExecuterVo> dataList = new ArrayList<>();
            for (EvaluateExecuterVo executerVo : newExecuterList) {
                if(!executerVo.getClassId().equals(objectListVo.getClassId())){
                    continue;
                }
                dataList.add(executerVo);
            }
            List<EvaluateExecuterVo> executerList = new ArrayList<>();
            if("random15".equals(dto.getExecuterCount()) && dataList.size() > 0){
                List<Integer> randomList = new ArrayList<>();
                Random random = new Random();
                while(randomList.size() < 15){
                    int nextInt = random.nextInt(dataList.size());
                    if(!randomList.contains(nextInt) && nextInt >= 0){
                        randomList.add(nextInt);
                    }
                }
                for (Integer i : randomList) {
                    executerList.add(dataList.get(i));
                }
            }else{
                executerList.addAll(dataList);
            }
            objectListVo.setExecuterList(executerList);
        }
        return newObjectList;
    }
}