package com.doumee.service.business.impl;

import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.DeclareScoreMapper;
import com.doumee.dao.business.DeclaresMapper;
import com.doumee.dao.business.MultifileMapper;
import com.doumee.dao.business.ProjectScoreMapper;
import com.doumee.dao.business.model.DeclareScore;
import com.doumee.dao.business.model.Declares;
import com.doumee.dao.business.model.Multifile;
import com.doumee.dao.business.model.ProjectScore;
import com.doumee.dao.system.dto.MultiFileDTO;
import com.doumee.service.business.DeclareScoreService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.service.business.DeclaresService;
import com.doumee.service.business.MultifileService;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import com.doumee.core.utils.Constants.*;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 项目申报评分记录表Service实现
 * @author 江蹄蹄
 * @date 2023/05/29 10:50
 */
@Service
public class DeclareScoreServiceImpl implements DeclareScoreService {

    @Autowired
    private DeclareScoreMapper declareScoreMapper;

    @Autowired
    private ProjectScoreMapper projectScoreMapper;

    @Autowired
    private DeclaresMapper declaresMapper;

    @Autowired
    private MultifileService multifileService;

    @Autowired
    SystemDictDataBiz systemDictDataBiz;

    @Transactional(rollbackFor = {Exception.class,BusinessException.class})
    @Override
    public Integer create(DeclareScore declareScore) {

        LoginUserInfo principal = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Declares declares = declaresMapper.selectById(declareScore.getDeclareId());

        Integer projectId = Optional.ofNullable(declares)
                .map(s -> s.getProjectId())
                .orElseThrow(() -> new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "企业项目报名信息不存在"));

        QueryWrapper<ProjectScore> wrapper = new QueryWrapper<>();
        wrapper.lambda()
                .eq(ProjectScore::getRoleType,declareScore.getRoleType())
                .eq(ProjectScore::getProjectId,projectId);
        ProjectScore projectScore = projectScoreMapper.selectOne(wrapper);
        if (Objects.isNull(projectScore)){
            return null;
        }
        QueryWrapper<DeclareScore> wrapper1 = new QueryWrapper<>();
        wrapper1.lambda().eq(DeclareScore::getDeclareId,declareScore.getDeclareId())
                            .eq(DeclareScore::getRoleType,declareScore.getRoleType())
                            .last("limit 1");
        DeclareScore declareScore1 = declareScoreMapper.selectOne(wrapper1);
        if (Objects.nonNull(declareScore1)){
            throw new BusinessException(ResponseStatus.DATA_EXISTS.getCode(),"评分记录已存在");
        }

        DeclareScore insert = new DeclareScore();
        insert.setCreator(principal.getId());
        insert.setCreateDate(new Date());
        insert.setEditor(principal.getId());
        insert.setEditDate(new Date());
        insert.setRoleType(declareScore.getRoleType());
        insert.setStatus(declareScore.getStatus());
        insert.setDeclareId(declareScore.getDeclareId());
        insert.setScore(declareScore.getScore());
        insert.setScoreDate(new Date());
        insert.setType(projectScore.getType());
        declareScoreMapper.insert(insert);

        List<Multifile> multiFileDTOList = declareScore.getMultiFileDTOList();
        if (!CollectionUtils.isEmpty(multiFileDTOList)){
            multiFileDTOList.forEach(s->{

                Multifile multifile = new Multifile();
                multifile.setCreator(principal.getId());
                multifile.setCreateDate(new Date());
                multifile.setEditor(principal.getId());
                multifile.setEditDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setName(s.getName());
                multifile.setInfo(s.getInfo());
                multifile.setObjId(insert.getId());
                multifile.setType(Constants.TWO);
                multifile.setObjType(getMultiFileObjType(declareScore.getRoleType()));
                multifile.setFileurl(s.getFileurl());
                multifileService.create(multifile);
            });
        }
        return insert.getId();
    }

    @Transactional(rollbackFor = {Exception.class,BusinessException.class})
    @Override
    public Integer createBatch(List<DeclareScore> declareScore) {
        declareScore.forEach(s-> {
            if (Objects.nonNull(s.getId())){
                this.updateById(s);
            }else {
                this.create(s);
            }
        });
        return null;
    }

    private Integer getMultiFileObjType(int roleType){

//        0企业 1县区 2服务机构 3综合服务单位 4专家 5市局
        Integer key = null;
        switch (roleType){

            case 0  : key = MultiFile.COMPANY_SCORE_REPORT.getKey(); break;

            case 5 : key = MultiFile.SJ_SCORE_REPORT.getKey();break;

            case 3 : key = MultiFile.SD_SCORE_REPORT.getKey();break;

            case 2 : key = MultiFile.SO_SCORE_REPORT.getKey();break;

            case 1 : key = MultiFile.AREA_SCORE_REPORT.getKey();break;

            case 4 : key = MultiFile.BUSINESS_EXPERT.getKey();break;

        }
        if (Objects.isNull(key)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"该角色无权操作");
        }
       return key;
    }

    @Override
    public BigDecimal getDeclareScore(Integer projectId,Integer declareId){

        ProjectScore ps = new ProjectScore();
        ps.setIsdeleted(Constants.ZERO);
        ps.setProjectId(projectId);
        //查询全部配置信息
        List<ProjectScore> psList = projectScoreMapper.selectList(new QueryWrapper<>(ps));
        if(psList !=null){
            DeclareScore ds = new DeclareScore();
            ds.setIsdeleted(Constants.ZERO);
            ds.setDeclareId(declareId);
            ds.setStatus(Constants.ONE);//提交数据
            //查询全部配置信息
            List<DeclareScore> dsList = declareScoreMapper.selectList(new QueryWrapper<>(ds));
            if(dsList!=null && dsList.size()>0){
                BigDecimal score = new BigDecimal(0);
                 for(ProjectScore p : psList){
                     //查询评分记录（无论
                     DeclareScore d = getFromListByRoleType(p,dsList);
                     if(d ==null){
                         continue;
                     }
                     score = score.add(Constants.formatBigdecimal4Float(d.getScore()).multiply(Constants.formatBigdecimal4Float(p.getRate()).divide(new BigDecimal(100))));
                 }
                return score;
            }
        }
        return null;
    }
    @Override
    public BigDecimal getDeclareScoreAll(Integer projectId,Integer declareId,List<DeclareScore> scoreList,List<ProjectScore> psList){
        BigDecimal score = null;

        if(psList !=null){
            List<DeclareScore> dsList = getFromListByDeclareId(declareId,scoreList);
            if(dsList!=null){
                 for(ProjectScore p : psList){
                     //查询评分记录（无论
                     DeclareScore d = getFromListByRoleType(p,dsList);
                     if(d ==null){
                         continue;
                     }
                     score = Constants.formatBigdecimal(score).add(Constants.formatBigdecimal4Float(d.getScore()).multiply(Constants.formatBigdecimal4Float(p.getRate()).divide(new BigDecimal(100))));
                 }
            }
        }
        return score;
    }

    private List<DeclareScore> getFromListByDeclareId(Integer declareId, List<DeclareScore> scoreList) {
        if(scoreList ==null){
            return  null;
        }
        List<DeclareScore> list = new ArrayList<>();
        for(DeclareScore d : scoreList){
            if(Constants.equalsInteger(declareId,d.getDeclareId())){
                list.add(d);
            }
        }
        return list;

    }

    @Override
    public BigDecimal getDeclareScoreByList(List<ProjectScore> psList, Integer declareId){

        if(psList !=null){

            DeclareScore ds = new DeclareScore();
            ds.setIsdeleted(Constants.ZERO);
            ds.setDeclareId(declareId);
            ds.setStatus(Constants.ONE);//提交数据
            //查询全部配置信息
            List<DeclareScore> dsList = declareScoreMapper.selectList(new QueryWrapper<>(ds));
            if(dsList!=null && dsList.size()>0){
                BigDecimal score = new BigDecimal(0);
                 for(ProjectScore p : psList){
                     //查询评分记录（无论
                     DeclareScore d = getFromListByRoleType(p,dsList);
                     if(d ==null){
                         continue;
                     }
                     score = score.add(Constants.formatBigdecimal4Float(d.getScore()).multiply(Constants.formatBigdecimal4Float(p.getRate()).divide(new BigDecimal(100))));
                 }
                 return  score;
            }
        }
        return null;
    }

    private DeclareScore getFromListByRoleType(ProjectScore p, List<DeclareScore> dsList) {
        for(DeclareScore d :dsList){
            if(Constants.equalsInteger(d.getRoleType(),p.getRoleType())){
                return d;
            }
        }
        return  null;
    }

    @Override
    public void deleteById(Integer id) {
        declareScoreMapper.deleteById(id);
    }

    @Override
    public void delete(DeclareScore declareScore) {
        UpdateWrapper<DeclareScore> deleteWrapper = new UpdateWrapper<>(declareScore);
        declareScoreMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        declareScoreMapper.deleteBatchIds(ids);
    }

    @Transactional(rollbackFor = {Exception.class,BusinessException.class})
    @Override
    public void updateById(DeclareScore declareScore) {


        LoginUserInfo principal = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Multifile query = new Multifile();
        query.setObjId(declareScore.getId());
        query.setObjType(getMultiFileObjType(declareScore.getRoleType()));
        multifileService.delete(query);
        List<Multifile> multiFileDTOList = declareScore.getMultiFileDTOList();
        if (!CollectionUtils.isEmpty(multiFileDTOList)){
            multiFileDTOList.forEach(s->{

                Multifile multifile = new Multifile();
                multifile.setCreator(principal.getId());
                multifile.setCreateDate(new Date());
                multifile.setEditor(principal.getId());
                multifile.setEditDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setName(s.getName());
                multifile.setInfo(s.getInfo());
                multifile.setObjId(declareScore.getId());
                multifile.setType(Constants.TWO);
                multifile.setObjType(getMultiFileObjType(declareScore.getRoleType()));
                multifile.setFileurl(s.getFileurl());
                multifileService.create(multifile);
            });
        }
        UpdateWrapper<DeclareScore> wrapper = new UpdateWrapper<>();
        wrapper.lambda().set(DeclareScore::getScore,declareScore.getScore())
                        .set(DeclareScore::getScoreDate,new Date())
                        .set(DeclareScore::getStatus,declareScore.getStatus())
                        .eq(DeclareScore::getId,declareScore.getId());
        declareScoreMapper.update(null,wrapper);
    }

    @Override
    public void updateByIdInBatch(List<DeclareScore> declareScores) {
        if (CollectionUtils.isEmpty(declareScores)) {
            return;
        }
        for (DeclareScore declareScore: declareScores) {
            if (Objects.nonNull(declareScore.getId())){
                this.updateById(declareScore);
            }else {
                this.create(declareScore);
            }

        }
    }

    @Override
    public DeclareScore findById(Integer id) {
        return declareScoreMapper.selectById(id);
    }

    @Override
    public DeclareScore findOne(DeclareScore declareScore) {

        LoginUserInfo principal = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        QueryWrapper<DeclareScore> wrapper = new QueryWrapper<>(declareScore);
        wrapper.lambda().last("limit 1");
        DeclareScore declareScore1 = declareScoreMapper.selectOne(wrapper);
        Multifile multifile = new Multifile();
        multifile.setObjId(declareScore1.getId());
        multifile.setType(getMultiFileObjType(principal.getType()));
        List<Multifile> list = multifileService.findList(multifile);

        String path =systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode();
        String projectFile = systemDictDataBiz.queryByCode(Constants.OSS, Constants.PROJECT_FILE).getCode();

        if (!CollectionUtils.isEmpty(list)){
            List<Multifile> collect = list.stream().map(s -> {
                Multifile multiFileDTO = new Multifile();
                multiFileDTO.setName(s.getName());
                multiFileDTO.setInfo(s.getInfo());
                multiFileDTO.setObjId(s.getObjId());
                multiFileDTO.setType(s.getType());
                multiFileDTO.setObjType(s.getObjType());
                multiFileDTO.setFileurl(s.getFileurl());
                multiFileDTO.setFileurlfull(path+projectFile+s.getFileurl());
                return multiFileDTO;
            }).collect(Collectors.toList());
            declareScore1.setMultiFileDTOList(collect);
        }

        return declareScore1;
    }

    @Override
    public List<DeclareScore> findList(DeclareScore declareScore) {
        QueryWrapper<DeclareScore> wrapper = new QueryWrapper<>(declareScore);
        List<DeclareScore> declareScores = declareScoreMapper.selectList(wrapper);

        declareScores.forEach(s->{

            Multifile multifile = new Multifile();
            multifile.setObjId(s.getId());
            multifile.setObjType(getMultiFileObjType(s.getRoleType()));
            List<Multifile> list = multifileService.findList(multifile);

            String path =systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode();
            String projectFile = systemDictDataBiz.queryByCode(Constants.OSS, Constants.PROJECT_FILE).getCode();

            if (!CollectionUtils.isEmpty(list)){
               list.forEach(m -> {
                    m.setFileurlfull(path+projectFile+m.getFileurl());
                });
                s.setMultiFileDTOList(list);
            }
        });
        return declareScores;
    }
  
    @Override
    public PageData<DeclareScore> findPage(PageWrap<DeclareScore> pageWrap) {
        IPage<DeclareScore> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<DeclareScore> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.lambda().eq(DeclareScore::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getCreator() != null) {
            queryWrapper.lambda().eq(DeclareScore::getCreator, pageWrap.getModel().getCreator());
        }
        if (pageWrap.getModel().getCreateDate() != null) {
            queryWrapper.lambda().ge(DeclareScore::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()));
            queryWrapper.lambda().le(DeclareScore::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()));
        }
        if (pageWrap.getModel().getEditor() != null) {
            queryWrapper.lambda().eq(DeclareScore::getEditor, pageWrap.getModel().getEditor());
        }
        if (pageWrap.getModel().getEditDate() != null) {
            queryWrapper.lambda().ge(DeclareScore::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()));
            queryWrapper.lambda().le(DeclareScore::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()));
        }
        if (pageWrap.getModel().getIsdeleted() != null) {
            queryWrapper.lambda().eq(DeclareScore::getIsdeleted, pageWrap.getModel().getIsdeleted());
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.lambda().eq(DeclareScore::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getRoleType() != null) {
            queryWrapper.lambda().eq(DeclareScore::getRoleType, pageWrap.getModel().getRoleType());
        }
        if (pageWrap.getModel().getDeclareId() != null) {
            queryWrapper.lambda().eq(DeclareScore::getDeclareId, pageWrap.getModel().getDeclareId());
        }
        if (pageWrap.getModel().getScore() != null) {
            queryWrapper.lambda().eq(DeclareScore::getScore, pageWrap.getModel().getScore());
        }
        if (pageWrap.getModel().getScoreDate() != null) {
            queryWrapper.lambda().ge(DeclareScore::getScoreDate, Utils.Date.getStart(pageWrap.getModel().getScoreDate()));
            queryWrapper.lambda().le(DeclareScore::getScoreDate, Utils.Date.getEnd(pageWrap.getModel().getScoreDate()));
        }
        if (pageWrap.getModel().getType() != null) {
            queryWrapper.lambda().eq(DeclareScore::getType, pageWrap.getModel().getType());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(declareScoreMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(DeclareScore declareScore) {
        QueryWrapper<DeclareScore> wrapper = new QueryWrapper<>(declareScore);
        return declareScoreMapper.selectCount(wrapper);
    }
}