package com.vincent.rsf.server.manager.schedules;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.SnowflakeIdWorker;
import com.vincent.rsf.server.manager.entity.Loc;
import com.vincent.rsf.server.manager.entity.Task;
import com.vincent.rsf.server.manager.enums.TaskStsType;
import com.vincent.rsf.server.manager.enums.TaskType;
import com.vincent.rsf.server.manager.service.LocService;
import com.vincent.rsf.server.manager.service.TaskService;
import com.vincent.rsf.server.system.constant.GlobalConfigCode;
import com.vincent.rsf.server.system.entity.*;
import com.vincent.rsf.server.system.service.ConfigService;
import com.vincent.rsf.server.system.service.impl.*;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import routeR.calculationR.RouteWmsStepFlow;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * @author Munch D. Luffy
 * @date 2026/01/29
 * 缓存区域任务自动触发
 */
@Slf4j
@Component
public class TaskMissionSchedules {

    public static Logger logger = LoggerFactory.getLogger(TaskMissionSchedules.class);

    @Autowired
    private TaskService taskService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private LocService locService;
    @Autowired
    private TaskPathTemplateMergeServiceImpl taskPathTemplateMergeService;
    @Autowired
    private TaskInstanceServiceImpl taskInstanceService;
    @Autowired
    private TaskPathTemplateServiceImpl taskPathTemplateService;
    @Autowired
    private TaskPathTemplateNodeServiceImpl taskPathTemplateNodeService;
    @Autowired
    private SubsystemFlowTemplateServiceImpl subsystemFlowTemplateService;
    @Autowired
    private FlowStepTemplateServiceImpl flowStepTemplateService;
    @Autowired
    private TaskInstanceNodeServiceImpl taskInstanceNodeService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private FlowInstanceServiceImpl flowInstanceService;
    @Autowired
    private FlowStepInstanceServiceImpl flowStepInstanceService;

    /**
     * @author Munch D. Luffy
     * @date 2026/01/15
     * @description: 初始任务规划路径
     * @version 1.0
     */
    @Scheduled(cron = "0/2 * * * * ?")
    @Transactional(rollbackFor = Exception.class)
    public void missionTemplate() throws Exception {
        Config config = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.AUTO_TEMPLATE_PLANNING_STEP_FLOW));
        if (!Boolean.parseBoolean(config.getVal())) {
            return;
        }
        List<Task> taskList = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskStatus, TaskStsType.MISSION_INITIAL.id));
        if (Objects.isNull(taskList)) {
            return;
        }
        taskList.forEach(task -> {
            String sou = null;
            String end = null;
            if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_EMPTY_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_IN.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
                sou = task.getOrgSite();
                Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getTargLoc()));
                end = loc.getAreaId().toString();
                task.setTaskStatus(TaskStsType.GENERATE_IN.id);
            } else if (task.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_EMPTY_OUT.type)) {
                Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getOrgLoc()));
                sou = loc.getAreaId().toString();
                end = task.getTargSite();
                task.setTaskStatus(TaskStsType.GENERATE_OUT.id);
            }
            List<TaskPathTemplateMerge> taskPathTemplateMergeList = taskPathTemplateMergeService.list(new LambdaQueryWrapper<TaskPathTemplateMerge>().eq(TaskPathTemplateMerge::getSourceType, sou).eq(TaskPathTemplateMerge::getTargetType, end));
            if (Objects.isNull(taskPathTemplateMergeList) || taskPathTemplateMergeList.isEmpty()) {
                List<TaskPathTemplateMerge> list = taskPathTemplateMergeService.list(new LambdaQueryWrapper<TaskPathTemplateMerge>().eq(TaskPathTemplateMerge::getStepSize,1));
                if (!Cools.isEmpty(list)) {
                    List<String[]> stationList = new ArrayList<>();
                    list.forEach(taskPathTemplate -> {
                        stationList.add(taskPathTemplate.route());
                    });
                    List<Long> longs = RouteWmsStepFlow.routeGet(stationList, sou, end);
                    if (longs != null && !longs.isEmpty()) {
                        TaskPathTemplateMerge taskPathTemplateMerge = new TaskPathTemplateMerge();
                        taskPathTemplateMerge.setTemplateCode(sou+"===>"+end);
                        taskPathTemplateMerge.setTemplateName(sou+"===>"+end);
                        taskPathTemplateMerge.setSourceType(sou);
                        taskPathTemplateMerge.setTargetType(end);
                        List<Integer> longList = new ArrayList<>();
                        for (Long id : longs) {
                            TaskPathTemplateMerge one = taskPathTemplateMergeService.getOne(new LambdaQueryWrapper<TaskPathTemplateMerge>().eq(TaskPathTemplateMerge::getId, id));
                            longList.addAll(one.getConditionExpression());
                        }
                        taskPathTemplateMerge.setConditionExpression(longList);
                        taskPathTemplateMerge.setStepSize(longList.size());
                        taskPathTemplateMergeService.save(taskPathTemplateMerge);
                    }
                    System.out.println("任务："+task.getTaskCode()+"查询步序为："+longs);
                }
            } else {
                //生成实际路径
                boolean actualPath = generateActualPath(task, taskPathTemplateMergeList.get(0));
                if (!actualPath) {
                    log.error("生成实际路径失败");
                }
            }
        });
    }


    public boolean generateActualPath(Task task,TaskPathTemplateMerge taskPathTemplateMerge) {
        boolean actualPath = false;
        List<Integer> conditionExpression = taskPathTemplateMerge.getConditionExpression();
        Integer i = 0;//it顺序
        Integer j = 0;//suT顺序

        TaskInstance taskInstance = new TaskInstance(taskPathTemplateMerge,task);
        boolean save = taskInstanceService.save(taskInstance);
        if (!save) {
            return false;
        }
        for (Integer id : conditionExpression) {
            TaskPathTemplate taskPathTemplate = taskPathTemplateService.getById(id);
            if (taskPathTemplate == null) {
                return false;
            }
            List<TaskPathTemplateNode> taskPathTemplateNodeList = taskPathTemplateNodeService.list(new LambdaQueryWrapper<TaskPathTemplateNode>().eq(TaskPathTemplateNode::getTemplateId, taskPathTemplate.getId()));
            for (TaskPathTemplateNode taskPathTemplateNode : taskPathTemplateNodeList) {
                TaskInstanceNode taskInstanceNode = new TaskInstanceNode(taskPathTemplateNode);
                taskInstanceNode.setTaskId(taskInstance.getId());
                taskInstanceNode.setTaskNo(taskInstance.getTaskNo());
                i++;
                taskInstanceNode.setNodeOrder(i);
                taskInstanceNode.setNodeCode(String.valueOf(snowflakeIdWorker.nextId()));
                taskInstanceNodeService.save(taskInstanceNode);
                List<SubsystemFlowTemplate> subsystemFlowTemplateList = subsystemFlowTemplateService.list(new LambdaQueryWrapper<SubsystemFlowTemplate>().eq(SubsystemFlowTemplate::getFlowCode, taskPathTemplateNode.getNodeCode())
                        .eq(SubsystemFlowTemplate::getSystemCode, taskPathTemplateNode.getSystemCode()));
                for (SubsystemFlowTemplate subsystemFlowTemplate : subsystemFlowTemplateList) {
                    FlowInstance flowInstance = new FlowInstance(subsystemFlowTemplate);
                    flowInstance.setFlowInstanceNo(String.valueOf(snowflakeIdWorker.nextId()));
                    flowInstance.setTaskId(taskInstance.getId());
                    flowInstance.setTaskNo(taskInstance.getTaskNo());
                    flowInstance.setNodeInstanceId(taskInstanceNode.getId());
                    flowInstance.setNodeCode(String.valueOf(snowflakeIdWorker.nextId()));
                    flowInstanceService.save(flowInstance);
                    List<FlowStepTemplate> flowStepTemplateList = flowStepTemplateService.list(new LambdaQueryWrapper<FlowStepTemplate>().eq(FlowStepTemplate::getFlowId, subsystemFlowTemplate.getId()));
                    for (FlowStepTemplate flowStepTemplate : flowStepTemplateList) {
                        j++;
                        FlowStepInstance flowStepInstance = new FlowStepInstance(flowStepTemplate);
                        flowStepInstance.setFlowInstanceId(flowInstance.getId());
                        flowStepInstance.setFlowInstanceNo(flowInstance.getFlowInstanceNo());
                        flowStepInstance.setStepOrder(j);
                        flowStepInstance.setStepCode(String.valueOf(snowflakeIdWorker.nextId()));
                        flowStepInstanceService.save(flowStepInstance);
                    }
                }
            }
        }
        task.setDeviceSiteId(taskInstance.getId());
        taskService.updateById(task);
        return actualPath;
    }


}