package jnpf.flowable.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import jnpf.base.ActionResult;
import jnpf.constant.MsgCode;
import jnpf.constant.PermissionConst;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.WorkFlowApi;
import jnpf.flowable.entity.*;
import jnpf.flowable.enums.NodeEnum;
import jnpf.flowable.enums.OperatorStateEnum;
import jnpf.flowable.mapper.*;
import jnpf.flowable.model.task.FileModel;
import jnpf.flowable.model.templatenode.nodejson.FileConfig;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.util.FlowNature;
import jnpf.flowable.util.VisuladeUtil;
import jnpf.util.DateUtil;
import jnpf.util.JsonUtil;
import jnpf.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/workFlow")
public class WorkFlowApiController implements WorkFlowApi {

    @Autowired
    private TaskMapper taskMapper;
    @Autowired
    private TemplateNodeMapper templateNodeMapper;
    @Autowired
    private TemplateJsonMapper templateJsonMapper;
    @Autowired
    private TemplateMapper templateMapper;
    @Autowired
    private RecordMapper recordMapper;
    @Autowired
    private LaunchUserMapper launchUserMapper;
    @Autowired
    private OperatorMapper operatorMapper;
    @Autowired
    private VisuladeUtil visuladeUtil;

    // 获取归档信息
    @Override
    @GetMapping("/getFileModel")
    public FileModel getFileModel(@RequestParam("taskId") String taskId) {
        TaskEntity taskEntity = taskMapper.selectById(taskId);
        if (null == taskEntity) {
            return new FileModel();
        }
        FileModel model = new FileModel();

        List<TemplateNodeEntity> nodeEntityList = templateNodeMapper.getList(taskEntity.getFlowId());
        TemplateNodeEntity globalEntity = nodeEntityList.stream().filter(e -> StringUtil.equals(NodeEnum.global.getType(), e.getNodeType())).findFirst().orElse(new TemplateNodeEntity());
        NodeModel global = JsonUtil.getJsonToBean(globalEntity.getNodeJson(), NodeModel.class);
        if (null != global) {
            FileConfig fileConfig = global.getFileConfig();
            // 归档路径
            model.setParentId(fileConfig.getParentId());

            String userId = taskEntity.getCreatorUserId();
            if (fileConfig.getPermissionType().equals(FlowNature.FlowAll)) {
                // 创建人
                model.setUserId(userId);
                // 分享人
                List<String> list = visuladeUtil.getListOfFile(taskId);
                List<String> userList = new ArrayList<>();
                for (String id : list){
                    if (!id.equals(userId)) {
                        userList.add(id + "--"+ PermissionConst.USER);
                    }
                }
                model.setUserList(userList);
            } else if (fileConfig.getPermissionType().equals(FlowNature.FlowLast)) {
                // 最后节点审批人
                List<String> list = visuladeUtil.getListOfLast(taskId);
                if (CollectionUtil.isNotEmpty(list)) {
                    model.setUserId(list.get(0));
                    list.remove(0);
                    if (CollectionUtil.isNotEmpty(list)) {
                        List<String> userList = new ArrayList<>();
                        for (String id : list){
                            userList.add(id + "--"+ PermissionConst.USER);
                        }
                        model.setUserList(userList);
                    }
                } else {
                    model.setUserId(userId);
                }
            } else {
                // 创建人
                model.setUserId(userId);
            }
        }

        // 文件名称
        String filename = taskEntity.getFullName();
        String datetime;
        if (null != taskEntity.getEndTime()) {
            datetime = DateUtil.dateToString(taskEntity.getEndTime(), "yyyyMMddHHmmss");
        } else {
            datetime = DateUtil.dateToString(new Date(), "yyyyMMddHHmmss");
        }
        filename += "-" + datetime;
        model.setFilename(filename + ".pdf");

        return model;
    }

    @Override
    @GetMapping("/getInfoSubmitById")
    public TaskEntity getInfoSubmit(@RequestParam("id") String id) {
        return taskMapper.getInfoSubmit(id,
                TaskEntity::getId,
                TaskEntity::getParentId,
                TaskEntity::getTemplateId,
                TaskEntity::getFullName,
                TaskEntity::getStatus,
                TaskEntity::getEndTime);
    }

    @Override
    @PostMapping("/getInfoSubmitByIds")
    public List<TaskEntity> getInfosSubmit(@RequestBody String[] ids) {
        return taskMapper.getInfosSubmit(ids, TaskEntity::getStatus, TaskEntity::getId);
    }

    @Override
    @PostMapping("/delete")
    public ActionResult delete(@RequestBody TaskEntity taskEntity) {
        try {
            visuladeUtil.delete(taskEntity.getId());
        } catch (Exception e) {
            return ActionResult.fail(e.getMessage());
        }
        return ActionResult.success();
    }

    @Override
    @PostMapping("/updateIsFile")
    public void updateIsFile(@RequestParam("taskId") String taskId) {
        TaskEntity taskEntity = taskMapper.selectById(taskId);
        if (null != taskEntity) {
            taskEntity.setIsFile(1);
            taskMapper.updateById(taskEntity);
        }
    }

    @Override
    @GetMapping("/getRecordList")
    public List<RecordEntity> getRecordList(@RequestParam("taskId") String taskId) {
        return recordMapper.getList(taskId);
    }


    @Override
    @GetMapping("/getFlowIdsByTemplateId")
    public List<String> getFlowIdsByTemplateId(@RequestParam("templateId") String templateId) {
        List<TemplateJsonEntity> list = templateJsonMapper.getList(templateId);
        return list.stream().map(TemplateJsonEntity::getId).distinct().collect(Collectors.toList());
    }

    @Override
    @GetMapping("/getTemplateByVersionId")
    public String getTemplateByVersionId(@RequestParam("flowId") String flowId) {
        String templateId = "";
        TemplateJsonEntity byId = templateJsonMapper.selectById(flowId);
        if (byId != null) {
            templateId = byId.getTemplateId();
        }
        return templateId;
    }


    @Override
    @GetMapping("/getFlowIdsByTemplate")
    public List<TemplateJsonEntity> getFlowIdsByTemplate(@RequestParam("templateId")String templateId) {
        return templateJsonMapper.getList(templateId);
    }

    @Override
    @GetMapping("/getFormList")
    public List<String> getFormList() {
        List<String> resList = new ArrayList<>();
        List<TemplateJsonEntity> list = templateJsonMapper.getListOfEnable();
        if (CollectionUtil.isNotEmpty(list)) {
            List<String> flowIds = list.stream().map(TemplateJsonEntity::getId).distinct().collect(Collectors.toList());
            List<TemplateNodeEntity> startNodeList = templateNodeMapper.getList(flowIds, NodeEnum.start.getType());
            resList = startNodeList.stream().map(TemplateNodeEntity::getFormId).distinct().collect(Collectors.toList());
        }
        return resList;
    }

    @Override
    @GetMapping("/getStepList")
    public List<String> getStepList() {
        QueryWrapper<LaunchUserEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(LaunchUserEntity::getType,FlowNature.StepInitiation);
        List<LaunchUserEntity> list = launchUserMapper.selectList(queryWrapper);
        List<String> stepList = new ArrayList<>();
        for (LaunchUserEntity entity : list){
            String organizeId = entity.getOrganizeId();
            if (StringUtil.isNotEmpty(organizeId)){
                stepList.addAll(Arrays.asList(organizeId.split(",")));
            }
            String positionId = entity.getPositionId();
            if (StringUtil.isNotEmpty(positionId)){
                stepList.addAll(Arrays.asList(positionId.split(",")));
            }
        }
        return stepList;
    }

    @Override
    @GetMapping("/getFlowFormMap")
    public Map<String, String> getFlowFormMap() {
        Map<String, String> map = new HashMap<>();
        List<TemplateJsonEntity> listOfEnable = templateJsonMapper.getListOfEnable();
        List<TemplateNodeEntity> listStart = templateNodeMapper.getListStart(listOfEnable);
        List<String> collect = listStart.stream().map(TemplateNodeEntity::getFlowId).collect(Collectors.toList());
        if (ObjectUtil.isNotEmpty(collect)) {
            QueryWrapper<TemplateEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().select(TemplateEntity::getId, TemplateEntity::getFlowId);
            queryWrapper.lambda().in(TemplateEntity::getFlowId, collect);
            Map<String, String> flowTempMap = templateMapper.selectList(queryWrapper).stream().collect(Collectors.toMap(TemplateEntity::getFlowId, TemplateEntity::getId));
            for (TemplateNodeEntity templateNodeEntity : listStart) {
                if (ObjectUtil.isNotEmpty(flowTempMap.get(templateNodeEntity.getFlowId()))) {
                    map.put(flowTempMap.get(templateNodeEntity.getFlowId()), templateNodeEntity.getFormId());
                }
            }
        }
        return map;
    }


    @Override
    @GetMapping("/checkTodo")
    public Boolean checkSign() {
        QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OperatorEntity::getCompletion, FlowNature.Normal)
                .ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode())
                .isNull(OperatorEntity::getSignTime);
        long count = operatorMapper.selectCount(queryWrapper);
        return count > 0;
    }

    @Override
    @GetMapping("/checkSign")
    public Boolean checkTodo() {
        QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OperatorEntity::getCompletion, FlowNature.Normal)
                .ne(OperatorEntity::getStatus, OperatorStateEnum.Futility.getCode())
                .isNotNull(OperatorEntity::getSignTime).isNull(OperatorEntity::getStartHandleTime);
        long count = operatorMapper.selectCount(queryWrapper);
        return count > 0;
    }
}