package com.vci.web.dao.impl;

import com.vci.dto.VciFileDocClassifyDTO;
import com.vci.dto.VciFileDocClassifyDTOList;
import com.vci.model.VciFileDocClassifyDO;
import com.vci.pagemodel.VciFileDocClassifyVO;
import com.vci.starter.revision.service.RevisionModelUtil;
import com.vci.starter.web.annotation.bus.VciChangeDocument;
import com.vci.starter.web.enumpck.VciChangeDocumentTypeEnum;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.BaseResult;
import com.vci.starter.web.pagemodel.DataGrid;
import com.vci.starter.web.pagemodel.KeyValue;
import com.vci.starter.web.pagemodel.PageHelper;
import com.vci.starter.web.util.BeanUtilForVCI;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.web.dao.VciFileDocClassifyDaoI;
import com.vci.web.service.VciFileDocClassifyServiceI;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

import static com.vci.constant.FrameWorkLangCodeConstant.*;

/**
 * 文档的类型服务
 *
 * @author weidy
 * @date 2020-08-04
 */
@Service
@VciChangeDocument(btmType = "fileDocClassify")
public class VciFileDocClassifyServiceImpl implements VciFileDocClassifyServiceI {

    /**
    * 日志
    */
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
    * 数据操作层
    */
    @Resource
    private VciFileDocClassifyDaoI vciFileDocClassifyMapper;

    /**
    * 版本和数据对象工具类
    */
    @Autowired
    private RevisionModelUtil revisionModelUtil;

    /**
     * 查询所有的文档的类型
     * @param conditionMap 查询条件
     * @param pageHelper 分页和排序
     * @return 执行结果
     * @throws VciBaseException 查询条件和分页出错的时候会抛出异常
     */
    @Override
    public DataGrid<VciFileDocClassifyVO> gridVciFileDocClassify(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);
        }
        VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(conditionMap,VciFileDocClassifyDO.class,pageHelper);
        List<VciFileDocClassifyDO> doList = vciFileDocClassifyMapper.selectByWrapper(queryWrapper);
        DataGrid<VciFileDocClassifyVO> dataGrid=new DataGrid<>();
        if (!CollectionUtils.isEmpty(doList)) {
            dataGrid.setData(vciFileDocClassifyDO2VOs(doList));
            queryWrapper.clearPage();
            dataGrid.setTotal(vciFileDocClassifyMapper.countByWrapper(queryWrapper));
        }
        return dataGrid;
    }

    /**
     * 批量数据对象转换为显示对象
     * @param vciFileDocClassifyDOs 数据对象列表
     * @return 显示对象
     * @throws VciBaseException 参数为空或者不存在的时候会抛出异常
     */
    @Override
    public List<VciFileDocClassifyVO> vciFileDocClassifyDO2VOs(Collection<VciFileDocClassifyDO>  vciFileDocClassifyDOs) throws VciBaseException {
        List<VciFileDocClassifyVO> voList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(vciFileDocClassifyDOs)){
            vciFileDocClassifyDOs.stream().forEach(s ->{
                    VciFileDocClassifyVO vo =  vciFileDocClassifyDO2VO(s);
                if(vo != null){
                    voList.add(vo);
                }
            });
        }
        return voList;
    }

    /**
     * 数据对象转换为显示对象
     * @param  vciFileDocClassifyDO 数据对象
     * @return 显示对象
     * @throws VciBaseException 拷贝属性出错的时候会抛出异常
     */
    @Override
    public VciFileDocClassifyVO vciFileDocClassifyDO2VO(VciFileDocClassifyDO vciFileDocClassifyDO) throws VciBaseException {
              VciFileDocClassifyVO vo = new VciFileDocClassifyVO();
        if(vciFileDocClassifyDO != null){
          BeanUtilForVCI.convert(vciFileDocClassifyDO,vo);
          //还需要处理枚举等其他的内容
        }
        return vo;
    }

    /**
     * 增加文档的类型
     * @param vciFileDocClassifyDTO 文档的类型数据传输对象
     * @return 执行结果
     * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
     */
    @Override
    @VciChangeDocument(changeType = VciChangeDocumentTypeEnum.ADD)
    public VciFileDocClassifyVO addSave(VciFileDocClassifyDTO vciFileDocClassifyDTO) throws VciBaseException {
        VciBaseUtil.alertNotNull(vciFileDocClassifyDTO,"需要添加的数据对象");
        //将DTO转换为DO
        VciFileDocClassifyDO vciFileDocClassifyDO = new VciFileDocClassifyDO();
        BeanUtilForVCI.convert(vciFileDocClassifyDTO,vciFileDocClassifyDO);

        revisionModelUtil.wrapperForAdd(vciFileDocClassifyDO);
        int insert = vciFileDocClassifyMapper.insert(vciFileDocClassifyDO);
        if(insert>0){
            return vciFileDocClassifyDO2VO(vciFileDocClassifyDO);
        }else{
            throw new VciBaseException(ADD_FAIL);
        }
    }

    /**
     * 修改文档的类型
     * @param vciFileDocClassifyDTO 文档的类型数据传输对象
     * @return 执行结果
     * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
     */
     @Override
     @VciChangeDocument(changeType = VciChangeDocumentTypeEnum.EDIT)
     public VciFileDocClassifyVO editSave(VciFileDocClassifyDTO vciFileDocClassifyDTO) throws VciBaseException {
         VciBaseUtil.alertNotNull(vciFileDocClassifyDTO,"数据对象",vciFileDocClassifyDTO.getOid(),"文档的类型主键");
         //将DTO转换为DO
         VciFileDocClassifyDO vciFileDocClassifyDO = selectByOid(vciFileDocClassifyDTO.getOid());
         revisionModelUtil.copyFromDTO(vciFileDocClassifyDTO,vciFileDocClassifyDO);
         revisionModelUtil.wrapperForEdit(vciFileDocClassifyDO);
         int update = vciFileDocClassifyMapper.updateByPrimaryKey(vciFileDocClassifyDO);
         if(update>0){
             return vciFileDocClassifyDO2VO(vciFileDocClassifyDO);
         }else{
             throw new VciBaseException(EDIT_FAIL);
         }
     }


    /**
     * 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
     * @param vciFileDocClassifyDTO 数据传输对象
     * @param vciFileDocClassifyDO 数据库中的数据对象
     * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
     */
    private BaseResult checkIsCanDeleteForDO(VciFileDocClassifyDTO vciFileDocClassifyDTO, VciFileDocClassifyDO vciFileDocClassifyDO) {
        revisionModelUtil.checkTs(vciFileDocClassifyDTO.getTs(),vciFileDocClassifyDO.getTs());
        if(!checkIsLinked(vciFileDocClassifyDO.getOid())) {
            return BaseResult.success();
        }else{
            return BaseResult.fail(DATA_LINKED_NOT_DELETE,new String[]{""});
        }
    }

    /**
    * 校验是否被引用
    * @param oid 主键
    * @throws VciBaseException 被引用的时候会抛出异常
    */
    private boolean checkIsLinked(String oid) throws VciBaseException {
        //TODO 添加需要校验引用的地方
        return false;
    }

    /**
     * 删除文档的类型
     * @param vciFileDocClassifyDTO 文档的类型数据传输对象，oid和ts需要传输
     * @return 删除结果反馈：：success：成功，fail：失败
     * @throws VciBaseException 参数为空，被引用时抛出异常
     */
    @Override
    @VciChangeDocument(changeType = VciChangeDocumentTypeEnum.DELETE)
    public BaseResult deleteVciFileDocClassify(VciFileDocClassifyDTO vciFileDocClassifyDTO) throws VciBaseException {
        VciBaseUtil.alertNotNull(vciFileDocClassifyDTO,"文档的类型数据对象",vciFileDocClassifyDTO.getOid(),"文档的类型的主键");
        VciFileDocClassifyDO vciFileDocClassifyDO = selectByOid(vciFileDocClassifyDTO.getOid());
        BaseResult baseResult = checkIsCanDeleteForDO(vciFileDocClassifyDTO,vciFileDocClassifyDO);
        if(baseResult.isSuccess()) {
                    }else{
            return baseResult;
        }
        //执行删除操作
        return (vciFileDocClassifyMapper.deleteByPrimaryKey(vciFileDocClassifyDO.getOid()) > 0)? BaseResult.successMsg(DELETE_SUCCESS): BaseResult.fail(DELETE_FAIL);
    }

    /**
    * 主键获取文档的类型
    * @param oid 主键
    * @return 文档的类型显示对象
    * @throws VciBaseException 参数为空，数据不存在时会抛出异常
    */
    @Override
    public VciFileDocClassifyVO getObjectByOid(String oid) throws VciBaseException {
        return vciFileDocClassifyDO2VO(selectByOid(oid));
    }

    /**
    * 主键查询数据对象
    * @param oid 主键
    * @return  数据对象
    * @throws VciBaseException 参数为空，并且数据不存在的时候会抛出异常
    */
    private VciFileDocClassifyDO selectByOid(String oid) throws VciBaseException {
        VciBaseUtil.alertNotNull(oid,"主键");
        VciFileDocClassifyDO vciFileDocClassifyDO = vciFileDocClassifyMapper.selectByPrimaryKey(oid.trim());
        if(vciFileDocClassifyDO == null || StringUtils.isBlank(vciFileDocClassifyDO.getOid())){
            throw new VciBaseException(DATA_OID_NOT_EXIST);
        }
        return vciFileDocClassifyDO;
    }

    /**
     * 主键批量获取文档的类型
     * @param oidCollections 主键集合，但是受性能影响，建议一次查询不超过10000个
     * @return 文档的类型显示对象
     * @throws VciBaseException 查询出现异常时会抛出
     */
    @Override
    public Collection<VciFileDocClassifyVO> listVciFileDocClassifyByOids(Collection<String> oidCollections) throws VciBaseException {
        VciBaseUtil.alertCollectionNotNull("数据对象主键集合",oidCollections);
        List<VciFileDocClassifyDO> vciFileDocClassifyDOList = listVciFileDocClassifyDOByOidCollections(oidCollections);
        return vciFileDocClassifyDO2VOs(vciFileDocClassifyDOList);
    }

    /**
    * 使用主键集合查询数据对象
    * @param oidCollections 主键的集合
    * @return 数据对象列表
    */
    private List<VciFileDocClassifyDO> listVciFileDocClassifyDOByOidCollections(Collection<String> oidCollections){
        List<VciFileDocClassifyDO> vciFileDocClassifyDOList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(oidCollections)){
            Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
            oidCollectionsList.stream().forEach(oids ->{
                List<VciFileDocClassifyDO> tempDOList =  vciFileDocClassifyMapper.selectByPrimaryKeyCollection(oids);
                if(!CollectionUtils.isEmpty(tempDOList)){
                    vciFileDocClassifyDOList.addAll(tempDOList);
                }
            });
        }
        return  vciFileDocClassifyDOList;
    }

    /**
     * 参照文档的类型列表
     * @param conditionMap 查询条件
     * @param pageHelper 分页和排序
     * @return 文档的类型显示对象列表，生效的内容
     * @throws VciBaseException 查询条件和分页出错的时候会抛出异常
     */
    @Override
    public DataGrid<VciFileDocClassifyVO> refDataGridVciFileDocClassify(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
        if(conditionMap == null){
            conditionMap = new HashMap<>();
        }
        return gridVciFileDocClassify(conditionMap,pageHelper);
    }

    /**
     * 校验编号是否存在
     *
     * @param idCollections 编号的集合
     * @return success为true表示存在,否则在data中获取不存在的内容
     */
    @Override
    public BaseResult checkClassifyIdsExist(Collection<String> idCollections) {
        VciBaseUtil.alertCollectionNotNull("文档类型编号",idCollections);
        Collection<Collection<String>> idCollectionss = VciBaseUtil.switchCollectionForOracleIn(idCollections);
        Set<String> existIdsSet = new HashSet<>();
        idCollectionss.stream().forEach(ids-> {
            List<VciFileDocClassifyDO> fileDocClassifyDOS = vciFileDocClassifyMapper.selectByIdCollection(ids);
            if(!CollectionUtils.isEmpty(fileDocClassifyDOS)){
                existIdsSet.addAll(fileDocClassifyDOS.stream().map(VciFileDocClassifyDO::getId).collect(Collectors.toSet()));
            }
        });
        if(existIdsSet.size() ==0){
            BaseResult baseResult = BaseResult.fail(DATA_ID_NOT_EXIST);
            baseResult.setData(idCollections);
            return baseResult;
        }
        Set<String> unExistIdSet = new HashSet<>();
        idCollections.stream().forEach(id ->{
            if(!existIdsSet.contains(id)){
                unExistIdSet.add(id);
            }
        });
        if(!CollectionUtils.isEmpty(unExistIdSet)){
            BaseResult baseResult = BaseResult.fail(DATA_ID_NOT_EXIST);
            baseResult.setData(unExistIdSet);
            return baseResult;
        }
        return BaseResult.success();
    }

    /**
     * 批量添加分类
     *
     * @param fileDocClassifyDTOList 分类的数据传输对象
     * @return success为true表示执行成功
     */
    @Override
    public BaseResult batchAddSave(VciFileDocClassifyDTOList fileDocClassifyDTOList) {
        VciBaseUtil.alertNotNull(fileDocClassifyDTOList,"文件类型的数据传输对象");
        List<VciFileDocClassifyDO> doList = new ArrayList<>();
        List<VciFileDocClassifyDTO> dtoList = fileDocClassifyDTOList.getDocClassifyDTOList();
        VciBaseUtil.alertCollectionNotNull("文件类型的数据传输对象",dtoList);
        //循环处理
        dtoList.stream().forEach(dto->{
            VciFileDocClassifyDO classifyDO = new VciFileDocClassifyDO();
            BeanUtilForVCI.convert(dto,classifyDO);
            VciBaseUtil.alertNotNull(classifyDO.getId(),"文件类型编号",classifyDO.getName(),"文件类型名称");
            doList.add(classifyDO);
        });
        revisionModelUtil.wrapperForBatchAdd(doList);
        doList.stream().forEach(classifyDO->{
            vciFileDocClassifyMapper.insert(classifyDO);
        });
        return BaseResult.success(ADD_SUCCESS);
    }

    /**
     * 使用编号查询对象
     * @param id 编号
     * @return 文档类型对象
     * @throws VciBaseException 参数为空和不存在的时候会抛出异常
     */
    private VciFileDocClassifyDO selectById(String id) throws VciBaseException {
        VciBaseUtil.alertNotNull(id,"文档类型编号");
        VciFileDocClassifyDO classifyDO = vciFileDocClassifyMapper.selectById(id.trim());
        if(classifyDO == null || StringUtils.isBlank(classifyDO.getOid())){
            throw new VciBaseException(DATA_ID_NOT_EXIST,new String[]{id});
        }
        return classifyDO;
    }

    /**
     * 使用编号获取对象
     *
     * @param id 编号
     * @return 显示对象
     * @throws VciBaseException 参数为空或者执行出错的时候会抛出异常
     */
    @Override
    public VciFileDocClassifyVO getObjectById(String id) throws VciBaseException {
        return vciFileDocClassifyDO2VO(selectById(id));
    }

    /**
     * 使用编号批量获取类型对象
     *
     * @param idCollection 编号集合
     * @return 显示对象
     * @throws VciBaseException 参数为空或者执行出错的时候会抛出异常
     */
    @Override
    public List<VciFileDocClassifyVO> listVciFileDocClassifyByIds(Collection<String> idCollection) throws VciBaseException {
        List<VciFileDocClassifyDO> classifyDOList = new ArrayList<>();
        VciBaseUtil.alertCollectionNotNull("编号集合",idCollection);
        Collection<Collection<String>> idCollections = VciBaseUtil.switchCollectionForOracleIn(idCollection);
        idCollections.stream().forEach(ids->{
            List<VciFileDocClassifyDO> classifyDOs = vciFileDocClassifyMapper.selectByIdCollection(ids);
            if(!CollectionUtils.isEmpty(classifyDOs)){
                classifyDOList.addAll(classifyDOs);
            }
        });
        return vciFileDocClassifyDO2VOs(classifyDOList);
    }

    /**
     * 文件类型的下拉菜单
     *
     * @return 下拉菜单的值
     */
    @Override
    public List<KeyValue> comboFileDocClassify() {
        VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(new HashMap<>(),VciFileDocClassifyDO.class);
        queryWrapper.neq("creator","sysAdmin");
        List<VciFileDocClassifyDO> doList = vciFileDocClassifyMapper.selectByWrapper(queryWrapper);
        List<KeyValue> keyValues = new ArrayList<>();
        if(!CollectionUtils.isEmpty(doList)){
            doList.stream().forEach(doc->{
                KeyValue keyValue = new KeyValue();
                keyValue.setKey(doc.getId());
                keyValue.setValue(doc.getName());
                keyValues.add(keyValue);
            });
        }
        return keyValues;
    }
}