package com.sckj.iron.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.eventbus.AsyncEventBus;
import com.sckj.common.core.PageResult;
import com.sckj.common.validate.commons.PageValidate;
import com.sckj.iron.entity.TIronStep;
import com.sckj.iron.mapper.TIronStepMapper;
import com.sckj.iron.validate.TIronStepCreateValidate;
import com.sckj.iron.validate.TIronStepSearchValidate;
import com.sckj.iron.validate.TIronStepUpdateValidate;
import com.sckj.iron.vo.IronStepVO;
import com.sckj.iron.vo.TIronStepDetailVo;
import com.sckj.iron.vo.TIronStepListedVo;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;

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

/**
 * 出铁步骤配置实现类
 *
 * @author LikeAdmin
 */
@Service
public class TIronStepServiceImpl extends ServiceImpl<TIronStepMapper, TIronStep> {

    @Resource
    TIronStepMapper tIronStepMapper;

    @Resource
    private AsyncEventBus asyncEventBus;

    /***
     * 获取步骤及其子步骤
     * @return
     */
    public List<IronStepVO> getTreeSteps() {
        QueryWrapper<TIronStep> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(TIronStep::getStatus, "1").orderByAsc(TIronStep::getSort);
        List<TIronStep> stepList = list(queryWrapper);
        //按照 StepId 长度排序
        stepList = stepList.stream()
                .sorted((d1, d2) -> d1.getStepId().length() - d2.getStepId().length())
                .collect(Collectors.toList());

        Map<String, IronStepVO> stepMap = new HashMap<>();
        List<IronStepVO> stepDTOList = new ArrayList<>();
        // 将所有部门存入 Map 中
        for (TIronStep step : stepList) {
            IronStepVO stepVO = new IronStepVO();
            BeanUtils.copyProperties(step, stepVO);
            stepMap.put(step.getStepId(), stepVO);
        }

        for (TIronStep step : stepList) {
            String stepId = step.getStepId();
            IronStepVO currentDto = stepMap.get(stepId);
            if (stepId.length() == 3) {
                stepDTOList.add(currentDto);
            } else {
                String parentId = stepId.substring(0, stepId.length() - 3);
                IronStepVO parent = stepMap.get(parentId);
                if (parent != null) {
                    parent.addChilds(currentDto);
                }
            }
        }
        return stepDTOList;
    }


    public void refreshTreeSteps() {
        asyncEventBus.post("1");
    }


    public void refreshParams() {
        asyncEventBus.post("2");
    }

    public void refreshModals() {
        asyncEventBus.post("3");
    }

    public void refreshAudios() {
        asyncEventBus.post("4");
    }


    /**
     * 出铁步骤配置列表
     *
     * @author LikeAdmin
     * @param pageValidate 分页参数
     * @param searchValidate 搜索参数
     * @return PageResult<TIronStepListedVo>
     */
    
    public PageResult<TIronStepListedVo> list(PageValidate pageValidate, TIronStepSearchValidate searchValidate) {
        Integer page  = pageValidate.getPageNo();
        Integer limit = pageValidate.getPageSize();

        QueryWrapper<TIronStep> queryWrapper = new QueryWrapper<>();

        if(ObjectUtils.isNotEmpty(searchValidate.getStepId())){
            queryWrapper.lambda().eq(TIronStep::getStepId, searchValidate.getStepId());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getRequired())){
            queryWrapper.lambda().eq(TIronStep::getRequired, searchValidate.getRequired());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getIdentifier())){
            queryWrapper.lambda().like(TIronStep::getIdentifier, searchValidate.getIdentifier());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getStepName())){
            queryWrapper.lambda().like(TIronStep::getStepName, searchValidate.getStepName());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getStepNameExpression())){
            queryWrapper.lambda().like(TIronStep::getStepNameExpression, searchValidate.getStepNameExpression());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getStepCondition())){
            queryWrapper.lambda().like(TIronStep::getStepCondition, searchValidate.getStepCondition());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getSort())){
            queryWrapper.lambda().eq(TIronStep::getSort, searchValidate.getSort());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getNodeType())){
            queryWrapper.lambda().eq(TIronStep::getNodeType, searchValidate.getNodeType());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getStatus())){
            queryWrapper.lambda().eq(TIronStep::getStatus, searchValidate.getStatus());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getConfirmMode())){
            queryWrapper.lambda().eq(TIronStep::getConfirmMode, searchValidate.getConfirmMode());
        }
        if(ObjectUtils.isNotEmpty(searchValidate.getPointName())){
            queryWrapper.lambda().like(TIronStep::getPointName, searchValidate.getPointName());
        }

        queryWrapper.orderByAsc(Arrays.asList("sort"));

//        tIronStepMapper.setSearch(queryWrapper, searchValidate, new String[]{
//                "=:stepId@step_id:str",
//                "=:required:str",
//                "like:identifier@identifier:str",
//                "like:stepName@step_name:str",
//                "like:stepNameExpression@step_name_expression:str",
//                "like:stepCondition@step_condition:str",
//                "=:sort:int",
//                "=:nodeType@node_type:str",
//                "=:status:str",
//                "=:confirmMode@confirm_mode:str",
//                "like:pointName@point_name:str",
//        });
//


        IPage<TIronStep> iPage = tIronStepMapper.selectPage(new Page<>(page, limit), queryWrapper);

        List<TIronStepListedVo> list = new LinkedList<>();
        for(TIronStep item : iPage.getRecords()) {
            TIronStepListedVo vo = new TIronStepListedVo();
            BeanUtils.copyProperties(item, vo);
            list.add(vo);
        }

        return PageResult.iPageHandle(iPage.getTotal(), iPage.getCurrent(), iPage.getSize(), list);
    }

    /**
     * 出铁步骤配置详情
     *
     * @author LikeAdmin
     * @param id 主键参数
     * @return TIronStep
     */
    
    public TIronStepDetailVo detail(String id) {
        TIronStep model = tIronStepMapper.selectOne(
                new QueryWrapper<TIronStep>()
                        .eq("step_id", id)
                        .last("limit 1"));

        Assert.notNull(model, "数据不存在");

        TIronStepDetailVo vo = new TIronStepDetailVo();
        BeanUtils.copyProperties(model, vo);
        return vo;
    }

    /**
     * 出铁步骤配置新增
     *
     * @author LikeAdmin
     * @param createValidate 参数
     */
    
    public void add(TIronStepCreateValidate createValidate) {
        TIronStep model = new TIronStep();
        model.setStepId(createValidate.getStepId());
        model.setIdentifier(createValidate.getIdentifier());
        model.setRequired(createValidate.getRequired());
        model.setStepName(createValidate.getStepName());
        model.setStepNameExpression(createValidate.getStepNameExpression());
        model.setStepCondition(createValidate.getStepCondition());
        model.setSort(createValidate.getSort());
        model.setNodeType(createValidate.getNodeType());
        model.setStatus(createValidate.getStatus());
        model.setConfirmMode(createValidate.getConfirmMode());
        model.setPointName(createValidate.getPointName());
        tIronStepMapper.insert(model);
    }

    /**
     * 出铁步骤配置编辑
     *
     * @author LikeAdmin
     * @param updateValidate 参数
     */
    
    public void edit(TIronStepUpdateValidate updateValidate) {
        TIronStep model = tIronStepMapper.selectOne(
                new QueryWrapper<TIronStep>()
                        .eq("step_id",  updateValidate.getStepId())
                        .last("limit 1"));

        Assert.notNull(model, "数据不存在!");

        model.setStepId(updateValidate.getStepId());
        model.setRequired(updateValidate.getRequired());
        model.setIdentifier(updateValidate.getIdentifier());
        model.setStepName(updateValidate.getStepName());
        model.setStepNameExpression(updateValidate.getStepNameExpression());
        model.setStepCondition(updateValidate.getStepCondition());
        model.setSort(updateValidate.getSort());
        model.setNodeType(updateValidate.getNodeType());
        model.setStatus(updateValidate.getStatus());
        model.setConfirmMode(updateValidate.getConfirmMode());
        model.setPointName(updateValidate.getPointName());
        tIronStepMapper.updateById(model);
    }

    /**
     * 出铁步骤配置删除
     *
     * @author LikeAdmin
     * @param id 主键ID
     */
    
    public void del(String id) {
        TIronStep model = tIronStepMapper.selectOne(
                new QueryWrapper<TIronStep>()
                        .eq("step_id", id)
                        .last("limit 1"));

        Assert.notNull(model, "数据不存在!");

        tIronStepMapper.delete(new QueryWrapper<TIronStep>().eq("identifier", id));
    }

}