package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.constant.WorkflowEnum;
import com.whyc.constant.WorkflowProcessEnum;
import com.whyc.constant.WorkflowTypeEnum;
import com.whyc.dto.Response;
import com.whyc.mapper.WorkflowMainMapper;
import com.whyc.pojo.db_user.User;
import com.whyc.pojo.web_site.WorkflowDevice;
import com.whyc.pojo.web_site.WorkflowLink;
import com.whyc.pojo.web_site.WorkflowMain;
import com.whyc.util.ActionUtil;
import com.whyc.util.CommonUtil;
import com.whyc.util.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.ServletContext;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class WorkflowMainService {

    @Resource
    private WorkflowMainMapper mapper;

    @Autowired(required = false)
    private WorkflowLinkService linkService;

    @Autowired
    private WorkflowDeviceService deviceService;


    /**
     * 分派单号:
     * */
    public String getNextOrderId(String typeName) {
        ServletContext application = ActionUtil.getApplication();
        List<String> orderIdList = (List) application.getAttribute("orderIdList");
        if(orderIdList == null){
            orderIdList = new LinkedList<>();
        }
        String nextSequence = "";
        QueryWrapper<WorkflowMain> wrapper = Wrappers.query();

        String orderId = typeName+"-";
        String ymd = new SimpleDateFormat("yyyyMMdd").format(new Date());
        orderId = orderId+ymd+"-";
        //先查询是否缓存中是否存在前缀相同的单号,有的话存起来
        List<Integer> sequenceList = new LinkedList<>();
        sequenceList.add(0);
        for (String item : orderIdList) {
            if(item.startsWith(orderId)){
                String sequence = item.split("-")[3];
                sequenceList.add(Integer.parseInt(sequence));
            }
        }
        wrapper.likeRight("order_id",orderId).orderByDesc("order_id").last(" limit 1");
        WorkflowMain workflowMain = mapper.selectOne(wrapper);
        if(workflowMain != null){
            String sequence = workflowMain.getOrderId().split("-")[3];
            sequenceList.add(Integer.parseInt(sequence));
        }
        Integer maxSequence = sequenceList.stream().max(Comparator.comparing(Integer::intValue)).get();
        nextSequence = String.format("%05d", maxSequence+1);
        String nextOrderId = orderId + nextSequence;
        //加入缓存中
        orderIdList.add(nextOrderId);
        application.setAttribute("orderIdList",orderIdList);
        return nextOrderId;
    }

    public void add(WorkflowMain main) {
        mapper.insert(main);
    }

    public void addBatch(List<WorkflowMain> workflowMainList) {
        mapper.insertBatchSomeColumn(workflowMainList);
    }


    public WorkflowMain getBaseInfo(Integer mainId) {
        //根据mainId查询是哪种类型
        QueryWrapper<WorkflowMain> query = Wrappers.query();
        query.eq("id",mainId).last(" limit 1");
        WorkflowMain workflowMain = mapper.selectOne(query);
        Integer type = workflowMain.getType();
        if(type ==1){
            //List<BattDischargePlanTemp> tempList = tempService.getListByMainId(mainId);
            //workflowMain.setTempList(tempList);
        }
        List<WorkflowLink> linkList = linkService.getWorkflowInfo(mainId);
        workflowMain.setLinkList(linkList);

        return workflowMain;
    }

    public List<WorkflowLink> getAssignReply(Integer mainId) {
        QueryWrapper<WorkflowLink> wrapper = Wrappers.query();
        //wrapper.eq("main_id",mainId)
        //return linkMapper.
        return null;
    }

    public void updateById(WorkflowMain main) {
        mapper.updateById(main);
    }

    /**
     *
     * @param userId
     * @param type
     * @see WorkflowEnum
     *
     * @return
     */
    public Response<Map<Integer,Integer>> getOwnStatistics(int userId, int type) {
        Map<Integer,Integer> statistics = new HashMap<>();
        statistics.put(1,0);
        statistics.put(2,0);
        statistics.put(3,0);
        QueryWrapper<WorkflowMain> query = Wrappers.query();
        query.eq("create_user_id",userId).eq("type",type);
        List<WorkflowMain> mains = mapper.selectList(query);
        Map<Integer, List<WorkflowMain>> statusListMap = mains.stream().collect(Collectors.groupingBy(WorkflowMain::getStatus));
        Set<Integer> statusSet = statusListMap.keySet();
        for (Integer status : statusSet) {
            statistics.put(status,statusListMap.get(status).size());
        }
        return new Response<Map<Integer,Integer>>().set(1,statistics);
    }

    /**
     * 二次核容和故障隐患的统计
     *
     * 增加了全部 key=0
     * @param type ={0,2,3} 0代表二次核容和故障隐患一起
     * @see WorkflowEnum
     *
     * @return
     */
    public Response<Map<Integer,Integer>> getOwnStatistics2(int userId, int type) {
        Map<Integer,Integer> statistics = new HashMap<>();
        statistics.put(0,0);
        statistics.put(1,0);
        statistics.put(2,0);
        statistics.put(3,0);
        QueryWrapper<WorkflowMain> query = Wrappers.query();
        query.eq("create_user_id", userId);
        if(type == 0){
            query.in("type",2,3);
        }else {
            query.eq("type", type);
        }
        List<WorkflowMain> mains = mapper.selectList(query);
        Map<Integer, List<WorkflowMain>> statusListMap = mains.stream().collect(Collectors.groupingBy(WorkflowMain::getStatus));
        Set<Integer> statusSet = statusListMap.keySet();
        int sum = 0;
        for (Integer status : statusSet) {
            int size = statusListMap.get(status).size();
            statistics.put(status, size);
            sum+=size;
        }
        statistics.put(0,sum);
        return new Response<Map<Integer,Integer>>().set(1,statistics);
    }

    public Response<PageInfo<WorkflowMain>> ownListPage(int userId, int type, int status, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        List<WorkflowMain> mains = getOwnListByUserAndType(userId,type,status);
        if(type == 1) {
            for (WorkflowMain main : mains) {
                Integer id = main.getId();
                //List<BattDischargePlanTemp> tempList = tempService.getListByMainId(id);
                //main.setTempList(tempList);
            }
        }
        PageInfo<WorkflowMain> pageInfo = new PageInfo<>(mains);
        return new Response<PageInfo<WorkflowMain>>().set(1,pageInfo);
    }

    private List<WorkflowMain> getOwnListByUserAndType(int userId, int type, int status) {
        QueryWrapper<WorkflowMain> query = Wrappers.query();
        if(status == 0){
            query.eq("create_user_id",userId).eq("type",type).orderByDesc("id");
        }else {
            query.eq("create_user_id", userId).eq("type", type).eq("status", status).orderByDesc("id");
        }
        return mapper.selectList(query);
    }

    public Response<Map<Integer,Integer>> getReceivedStatistics(int type, User user) {
        Map<Integer,Integer> statisticsMap = linkService.getReceivedStatistics(type,user);
        return new Response<Map<Integer,Integer>>().set(1,statisticsMap);
    }

    public Response<PageInfo<WorkflowMain>> getReceivedListPage(int type, int status, User user, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        List<WorkflowMain> mains = getReceivedListByUserAndType(user,type,status);
        if (type == 1) {
            for (WorkflowMain main : mains) {
                Integer id = main.getId();
                //List<BattDischargePlanTemp> tempList = tempService.getListByMainId(id);
                //main.setTempList(tempList);
            }
        }
        PageInfo<WorkflowMain> pageInfo = new PageInfo<>(mains);
        return new Response<PageInfo<WorkflowMain>>().set(1, pageInfo);
    }

    private List<WorkflowMain> getReceivedListByUserAndType(User user, int type, int status) {
        return mapper.getReceivedListByUserAndType(user, type, status);
    }

    public WorkflowMain getById(Integer mainId) {
        return mapper.selectById(mainId);
    }

    //查询表单编号
    public int getMaxId() {
        Integer id = mapper.getMaxId();
        if (id == null) {
            id = 1;
        } else {
            id = id + 1;
        }
        return id;
    }

    /**
     * 通用提交方法,提交给角色-角色层
     * 如果related_id不为空,则需要特殊处理. 证明会影响到关联单据
     *
     * 涉及到新的问题需要解决,现场故障后,设备维修申请 或 报废申请 是多个,并存入工单设备表中. 并不只是单纯的数量. TODO ?自动化处理怎么更新
     */

    @Transactional
    public Response submit(WorkflowMain main){
        //1.提交到单据审批流程
        //如果存在关联单据id,首先校验提交的数量
        Date now = new Date();
        List<WorkflowDevice>  deviceListRelatedInDB = deviceService.getByMainId(main.getRelatedId());
        List<WorkflowDevice> deviceList = main.getDeviceList();
        if(main.getRelatedId() != null) {
            //遍历deviceList,如果deviceList内的对象的quantity值大于 deviceListRelatedInDB内对象列表中的对象所有字段相同的记录的quantityUnprocessed值,则返回错误
            for (int i = 0; i < deviceList.size(); i++) {
                WorkflowDevice device = deviceList.get(i);
                for (int j = 0; j < deviceListRelatedInDB.size(); j++) {
                    WorkflowDevice deviceInDB = deviceListRelatedInDB.get(j);
                    if (device.getName().equals(deviceInDB.getName())
                            && device.getModel().equals(deviceInDB.getModel())
                            && device.getVersion().equals(deviceInDB.getVersion())
                            && device.getBrand().equals(deviceInDB.getBrand())
                            && device.getType().equals(deviceInDB.getType())
                            && device.getSupplier().equals(deviceInDB.getSupplier())
                    ) {
                        if (device.getQuantity() > deviceInDB.getQuantityUnprocessed()) {
                            return new Response().setII(1, "入库数量不能大于维修申请关联单据的未处理数量");
                        }else{
                            //当前设备的校验结束,进入下一个设备校验
                            break;
                        }
                    }

                }
            }
        }
        //主表插入
        //初始化相关字段
        WorkflowTypeEnum typeEnum = WorkflowTypeEnum.getByType(main.getType());
        String name = typeEnum.getName();
        String namingPrefix = typeEnum.getNamingPrefix();
        String orderId = getNextOrderId(namingPrefix);
        //String title = mainTypeCN+"审批单-"+ DateUtil.YYYY_MM_DD_HH_MM_SS.format(now);

        String title = name + ThreadLocalUtil.format(ThreadLocalUtil.TIME_YYYY_MM_DD_HH_MM_SS, now);
        Integer mainStatus = WorkflowEnum.MAIN_STATUS_DEALING.getValue();
        User user = CommonUtil.getUser();
        WorkflowProcessEnum process = getProcessLevel(main.getType(),user.getRole());
        main.setOrderId(orderId);
        main.setTitle(title);
        main.setCreateUserId(user.getId());
        main.setCreateUserName(user.getName());
        main.setCreateTime(now);
        main.setBeginTime(now);
        main.setStatus(mainStatus);
        main.setProcessStage(process.getStage());
        if(main.getType() == WorkflowTypeEnum.DEVICE_REPAIR.getType().intValue()){ //维修申请单,需填入
            for (int i = 0; i < deviceList.size(); i++) {
                deviceList.get(i).setQuantityUnprocessed(deviceList.get(i).getQuantity());
            }
        }
        add(main);
        //主表关联的物料插入
        for (WorkflowDevice device : deviceList) {
            device.setMainId(main.getId());
        }
        deviceService.addBatch(deviceList);

        //内存中去除已插入数据库的单号
        ServletContext application = ActionUtil.getApplication();
        List<String> orderIdList = (List<String>) application.getAttribute("orderIdList");
        //校验是否去除
        boolean remove = orderIdList.remove(orderId);
        if(!remove){
            System.err.println("没有去除掉!!!!!!!!!!!!!");
        }
        application.setAttribute("orderIdList",orderIdList);

        //节点表插入
        WorkflowLink link = new WorkflowLink();
        link.setMainId(main.getId());
        link.setParentId(0);
        link.setProcessStage(process.getStage());
        link.setProcessName(process.getName());
        link.setCreateTime(now);
        link.setDealRoleId(getNextDealRoleId(process.getName()));
        link.setDealType(WorkflowEnum.TYPE_DELIVER.getValue());
        link.setDealDesc(main.getTaskDesc());
        link.setStatus(WorkflowEnum.LINK_STATUS_TAKING.getValue());

        linkService.add(link);

        //如果存在关联单据id,处理关联单据及自动生成新单据
        checkRelatedAndDone(main, now, deviceListRelatedInDB, user);
        return new Response().setII(1,"提交完成");
    }

    private void checkRelatedAndDone(WorkflowMain main, Date now, List<WorkflowDevice> deviceListRelatedInDB, User user) {
        if(main.getRelatedId() != null){
            //申请的数量<关联单据的未处理数量,则说明有剩余. 需要自动生成对立工单
            List<WorkflowDevice> deviceList = main.getDeviceList();
            //计算deviceListn内quantity属性值的和
            int sumQuantity = 0;
            for (WorkflowDevice device : deviceList) {
                sumQuantity += device.getQuantity();
            }
            //计算deviceListRelatedInDBn内quantityUnprocessed属性值的和
            int sumQuantityUnprocessedInDB = 0;
            for (WorkflowDevice device : deviceListRelatedInDB) {
                sumQuantityUnprocessedInDB += device.getQuantityUnprocessed();
            }
            if (sumQuantity < sumQuantityUnprocessedInDB){ //说明需要自动生成入库或者报废单据
                //需要自动生成报废的申请
                WorkflowMain mainAuto = new WorkflowMain();
                WorkflowTypeEnum typeEnumAuto;

                Integer statusAuto = WorkflowEnum.MAIN_STATUS_DEALING.getValue();
                WorkflowProcessEnum processAuto = WorkflowProcessEnum.PROCESS_MANAGER1SIGN;
                mainAuto.setCreateUserId(user.getId());
                mainAuto.setCreateTime(now);
                mainAuto.setBeginTime(now);
                mainAuto.setProcessStage(processAuto.getStage());
                mainAuto.setStatus(statusAuto);
                mainAuto.setRelatedId(main.getRelatedId());
                //整理主表的设备附表
                List<WorkflowDevice> deviceListAuto = new ArrayList<>();
                //遍历deviceListRelatedInDB,减去deviceList中申请的数量
                for (WorkflowDevice deviceInDB : deviceListRelatedInDB) {
                    boolean deviceExists = false;
                    for (WorkflowDevice device : deviceList) {
                        if (device.getName().equals(deviceInDB.getName())
                                && device.getModel().equals(deviceInDB.getModel())
                                && device.getVersion().equals(deviceInDB.getVersion())
                                && device.getBrand().equals(deviceInDB.getBrand())
                                && device.getType().equals(deviceInDB.getType())
                                && device.getSupplier().equals(deviceInDB.getSupplier())
                        ){
                            deviceExists = true;
                            if (deviceInDB.getQuantityUnprocessed()-device.getQuantity() > 0){
                                WorkflowDevice deviceAuto = new WorkflowDevice();
                                deviceAuto.setName(deviceInDB.getName());
                                deviceAuto.setModel(deviceInDB.getModel());
                                deviceAuto.setVersion(deviceInDB.getVersion());
                                deviceAuto.setQuantity(deviceInDB.getQuantityUnprocessed()-device.getQuantity());
                                deviceAuto.setBrand(deviceInDB.getBrand());
                                deviceAuto.setType(deviceInDB.getType());
                                deviceAuto.setSupplier(deviceInDB.getSupplier());

                                deviceListAuto.add(deviceAuto);
                            }else{
                                break;
                            }
                        }
                    }
                    if (!deviceExists){
                        WorkflowDevice deviceAuto = new WorkflowDevice();
                        deviceAuto.setName(deviceInDB.getName());
                        deviceAuto.setModel(deviceInDB.getModel());
                        deviceAuto.setVersion(deviceInDB.getVersion());
                        deviceAuto.setQuantity(deviceInDB.getQuantityUnprocessed());
                        deviceAuto.setBrand(deviceInDB.getBrand());
                        deviceAuto.setType(deviceInDB.getType());
                        deviceAuto.setSupplier(deviceInDB.getSupplier());

                        deviceListAuto.add(deviceAuto);
                    }
                }

                if(main.getType() == WorkflowTypeEnum.DEVICE_IN.getType().intValue()) { //申请的入库
                    mainAuto.setTaskDesc("提交了维修后的入库申请,系统自动生成剩余数量的报废申请");
                    typeEnumAuto = WorkflowTypeEnum.DEVICE_SCRAP;
                }else { //申请的报废
                    mainAuto.setTaskDesc("提交了维修后的报废申请,系统自动生成剩余数量的入库申请");
                    typeEnumAuto = WorkflowTypeEnum.DEVICE_IN;
                }
                mainAuto.setOrderId(getNextOrderId(typeEnumAuto.getNamingPrefix()));
                String titleAuto = typeEnumAuto.getName() + ThreadLocalUtil.format(ThreadLocalUtil.TIME_YYYY_MM_DD_HH_MM_SS, now);
                mainAuto.setTitle(titleAuto);
                mainAuto.setType(typeEnumAuto.getType());
                add(mainAuto);
                deviceListAuto.forEach(device -> {
                    device.setMainId(mainAuto.getId());
                });
                //插入主表的设备附表
                deviceService.addBatch(deviceListAuto);

                //自动节点生成
                WorkflowLink linkAuto = new WorkflowLink();
                linkAuto.setParentId(0);
                linkAuto.setProcessStage(processAuto.getStage());
                linkAuto.setProcessName(processAuto.getName());
                linkAuto.setCreateTime(now);
                linkAuto.setDealRoleId(getNextDealRoleId(processAuto.getName()));
                linkAuto.setDealType(WorkflowEnum.TYPE_DELIVER.getValue());
                linkAuto.setStatus(WorkflowEnum.LINK_STATUS_TAKING.getValue());
                linkAuto.setMainId(mainAuto.getId());
                linkAuto.setDealDesc(mainAuto.getTaskDesc());
                linkService.add(linkAuto);

            }
            //关闭关联单据的状态
            WorkflowMain relatedMain = new WorkflowMain();
            relatedMain.setId(main.getRelatedId());
            relatedMain.setStatus(WorkflowEnum.MAIN_STATUS_END_DEALT.getValue());
            relatedMain.setEndTime(now);
            if(main.getType() == WorkflowTypeEnum.DEVICE_IN.getType().intValue()) {
                relatedMain.setEndReason("用户提交维修申请后的入库申请,维修流程结束");
            }else{
                relatedMain.setEndReason("用户提交维修申请后的报废申请,维修流程结束");
            }
            updateById(relatedMain);
            //更新关联单据的设备剩余未处理数量为0
            deviceService.setQuantityUnprocessedZero(main.getRelatedId());
        }
    }

    /**
     * TODO 每次新增流程时,需要持续维护
     * 如果后续存在会签,则需要追加一个多type类型的同名方法
     * @param processLevelName 流程阶段名
     * @return 流程处理的下一个角色
     */
    private Integer getNextDealRoleId(String processLevelName) {
        WorkflowProcessEnum processEnum = WorkflowProcessEnum.getByName(processLevelName);
        switch (processEnum){
            //角色:1普通用户，2管理层，3领导层，4运维班组
            case PROCESS_MANAGER1SIGN:
                return 2;
            default:
                return 2;
        }
    }

    /**
     * TODO 每次新增流程时,需要持续维护
     * @param type 流程的类型
     * @param roleId 现在的角色
     * @return 流程处理的下一个角色
     */
    private WorkflowProcessEnum getProcessLevel(Integer type,Integer roleId) {
        WorkflowTypeEnum typeEnum = WorkflowTypeEnum.getByType(type);
        String name = typeEnum.getName();
        //角色:1普通用户，2管理层，3领导层，4运维班组
        switch (name){
            //审批顺序为 普通用户->管理员 ->普通用户(进行完结)
            case "设备维修申请单":
            case "设备入库申请单":
            case "设备报废申请单":
            case "设备出库申请单":
                if (roleId == 1) {
                    return WorkflowProcessEnum.PROCESS_MANAGER1SIGN;
                }
            default:
                return WorkflowProcessEnum.PROCESS_SPECIALIST;
        }
    }

    public void updateProcessLevel(String processLevel, Integer mainId) {
        UpdateWrapper<WorkflowMain> update = Wrappers.update();
        update.set("process_level",processLevel).eq("id",mainId);
        mapper.update((WorkflowMain) ActionUtil.objeNull,update);
    }

    public void resetRepairStatus(Integer relatedId) {
        UpdateWrapper<WorkflowMain> update = Wrappers.update();
        update.set("status",WorkflowEnum.MAIN_STATUS_WAIT_FOR_DEALING.getValue())
                .set("end_time",null)
                .set("end_reason",null)
                .eq("id",relatedId);
        mapper.update((WorkflowMain) ActionUtil.objeNull,update);
    }
}