using HslCommunication;
using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core.EFDbContext;
using WIDESEA_Core.Utilities;
using WIDESEA_Entity.CustomModels.RGVModel;
using WIDESEA_Entity.DomainModels;
using WIDESEA_Services;
using WIDESEA_Services.IRepositories;
using WIDESEA_Services.Repositories;
using WIDESEA_Services.Services;
using WIDESEA_Services.Services.APIInvoke.RGV;
using WIDESEA_WCS.Jobs;
using WIDESEA_Common.Tools;
using WIDESEA_WCS.WCSClient;
using static WIDESEA_Entity.CustomModels.RGVModel.RgvSendTaskModel;
using static WIDESEA_Entity.CustomModels.RGVModel.RgvDeviceStatusModel;
using WIDESEA_Core.Services;
using WIDESEA_Core.Enums;

namespace WIDESEA_WCS
{

    [DisallowConcurrentExecution]
    public partial class RgvDispatchJob : JobBase, IJob
    {

        /// <summary>
        /// RGV(有轨小车)调度
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>

        public Task Execute(IJobExecutionContext context)
        {
            return Task.Run(() =>
            {
                var executeLog = ExecuteJob(context, () => Run(context));
            });
        }
        public string Run(IJobExecutionContext context)
        {
            using (VOLContext dbCcontext = new VOLContext())
            {

                WebResponseContent content = new WebResponseContent();
                IDt_TaskRGVinfoRepository taskRGVinfoRepository = new Dt_TaskRGVinfoRepository(dbCcontext);
                IDt_TaskWCSinfoRepository taskWCSinfoRepository = new Dt_TaskWCSinfoRepository(dbCcontext);
                //查看PLC连接的情况
                PLCClient client = WCSService.Clients.Find(r => r.PLCName == "LineDevice");
                if (!client.IsConnected)
                {
                    // Console.WriteLine("RGV无法调度，线体PLC与WCS系统断开了连接");
                    return "RGV无法调度，线体PLC与WCS系统断开了连接";
                }

                //发送任务之前，看是否有小车可用
                content = RGVAPIInvokeGetRgvInfo.GetRgvInfo();
                if (!content.Status)
                    return $"获取小车状态出错，原因：{content.Message}";

                RgvDeviceStatusModel rgvData = (RgvDeviceStatusModel)content.Data;
                int carCount = 0;
                List<int> currentLayer = new List<int>();
                foreach (var item in rgvData.data)
                {
                    //0离线 1正常 2故障
                    if (item.status != 1)
                        carCount++;
                    else
                        currentLayer.Add(item.layer);
                }
                if (carCount == 3)
                {
                    Console.WriteLine($"当前无小车可用，无法下发任务");
                    return $"当前无小车可用，无法下发任务";
                }

                //找等待下发的任务
                List<Dt_TaskRGVinfo> rgvTaskList = taskRGVinfoRepository.Find(x => x.rgvtask_taskStatus == RGVTaskState.RgvTaskState_Wait_Send.ToString()).OrderBy(r => r.rgvtask_msgTime).ToList();
                if (null != rgvTaskList && rgvTaskList.Count > 0)
                {

                    //暂时注释
                    int modelValue = int.Parse(client.ReadValue(CLineInfoDBName.R_System_Inline_Run_Model.ToString(), "System").ToString());
                    //1=手动  2=单机 3=联机
                    if (modelValue != 3)
                        rgvTaskList = rgvTaskList.Where(r => r.rgvtask_areaCode != "InboundArea").ToList();

                    modelValue = int.Parse(client.ReadValue(CLineInfoDBName.R_System_Inline_Run_Model.ToString(), "OutSystem").ToString());
                    if (modelValue != 3)
                        rgvTaskList = rgvTaskList.Where(r => r.rgvtask_areaCode != "OutboundArea").ToList();



                    if (null != rgvTaskList)
                    {
                        List<Dt_TaskRGVinfo> listTask = new List<Dt_TaskRGVinfo>();
                        //优先出库区
                        List<Dt_TaskRGVinfo> outboundArea = rgvTaskList.FindAll(r => r.rgvtask_areaCode != "InboundArea");
                        if (outboundArea.Count > 0)
                            listTask.AddRange(outboundArea);


                        List<Dt_TaskRGVinfo> inboundArea = rgvTaskList.FindAll(r => r.rgvtask_areaCode != "OutboundArea");
                        if (inboundArea.Count > 0)
                        {
                            int layer = 0;
                            List<Dt_TaskRGVinfo> layerTask = new List<Dt_TaskRGVinfo>();
                            List<Dt_TaskRGVinfo> ortherTask = new List<Dt_TaskRGVinfo>();
                            foreach (var item in inboundArea)
                            {
                                if (item.rgvtask_taskType.Equals(RGVTaskType.RgvTaskType_Inbound.ToString()))
                                    layer = int.Parse(item.rgvtask_startNode.Split('-')[0]);
                                else if (item.rgvtask_taskType.Equals(RGVTaskType.RgvTaskType_Outbound.ToString()))
                                    layer = int.Parse(item.rgvtask_endNode.Split('-')[0]);

                                if (currentLayer.Contains(layer))
                                    layerTask.Add(item);
                                else
                                    ortherTask.Add(item);
                            }

                            if (layerTask.Count > 0)
                                listTask.AddRange(layerTask);

                            if (ortherTask.Count > 0)
                                listTask.AddRange(ortherTask);
                        }
                        rgvTaskList = listTask;
                    }
                    foreach (var rgvTask in rgvTaskList)
                    {
                        //找到RGV任务对应的WCS任务，看是否有会冲突的任务发生，如果有？先不下发：下发
                        //比如有一个入库任务正在执行，目的站台为：050301，那么走050301的出库测量任务RGV段的则不能下发，避免冲突
                        Dt_TaskWCSinfo wcsInfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_taskNumber == rgvTask.rgvtask_wcsTaskNumber);
                        if (null == wcsInfo)
                        {
                            //手动任务
                            if (rgvTask.rgvtask_wcsTaskNumber == 0 && rgvTask.rgvtask_taskId == "0")
                                SendRGVTaskAction(rgvTask, wcsInfo, taskRGVinfoRepository, taskWCSinfoRepository);
                            else
                                continue;
                        }

                        //再做一个保护，查看对应的放货站台上是有有货，即读取站台是否处于负载待机的状态，如果是，说明有东西
                        if (wcsInfo.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString() ||
                            wcsInfo.wcstask_type == TaskType.TaskType_Empty_Pallet_Outbound.ToString() ||
                            wcsInfo.wcstask_type == TaskType.TaskType_Box_Pallet_Outbound.ToString() ||

                             wcsInfo.wcstask_type == TaskType.TaskType_CheckOutbound.ToString() ||
                            //移库需要跨层
                            (wcsInfo.wcstask_type == TaskType.TaskType_MoveOutbound.ToString() && wcsInfo.wcstask_startPoint != wcsInfo.wcstask_endPoint)
                            )
                        {
                            //穿梭车放货站台
                            string targetStation = wcsInfo.wcstask_endLocation;
                            //判断有到当前放货位置的就不执行
                            Dt_TaskWCSinfo executingTask = taskWCSinfoRepository.FindFirst(r => r.wcstask_endPoint == targetStation && r.wcstask_id != wcsInfo.wcstask_id);
                            if (null != executingTask)
                                continue;

                            //if (rgvTask.rgvtask_areaCode.Equals("OutboundArea"))
                            //{
                            //    //当前层有任务就不执行
                            //    Dt_TaskRGVinfo rgvcurrentTask = taskRGVinfoRepository.FindFirst(r => (r.rgvtask_startNode == rgvTask.rgvtask_startNode ||
                            //    rgvTask.rgvtask_endNode == r.rgvtask_endNode || rgvTask.rgvtask_startNode == r.rgvtask_endNode ||
                            //    rgvTask.rgvtask_endNode == r.rgvtask_startNode) && r.rgvtask_taskStatus != RGVTaskState.RgvTaskState_Wait_Send.ToString());
                            //    if (null != rgvcurrentTask)
                            //        continue;
                            //}

                            if (rgvTask.rgvtask_areaCode.Equals("InboundArea") && !rgvTask.rgvtask_taskType.Equals(RGVTaskType.RgvTaskType_Inbound.ToString()))
                            {
                                //读取负载待机,有货
                                bool flag = bool.Parse(client.ReadValue(CLineInfoDBName.R_Line_LoadSleep.ToString(), rgvTask.rgvtask_endNode).ToString());
                                bool noflag = bool.Parse(client.ReadValue(CLineInfoDBName.R_Line_NoLoadSleep.ToString(), rgvTask.rgvtask_endNode).ToString());
                                if (flag || !noflag)
                                    continue;
                                else
                                {
                                    Dt_TaskRGVinfo currentTask = taskRGVinfoRepository.FindFirst(r => r.rgvtask_endNode == rgvTask.rgvtask_endNode && r.rgvtask_taskStatus != RGVTaskState.RgvTaskState_Wait_Send.ToString());
                                    if (null != currentTask)
                                        continue;
                                }
                            }





                            //此处查看当前正在进行的测量任务条数，需要控制数量，线体缓存数量有限，测量需要时间，暂定3个
                            if (wcsInfo.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString())
                            {
                                List<Dt_TaskWCSinfo> measureList = taskWCSinfoRepository.Find(x =>
                                x.wcstask_state != TaskState.TaskState_Assigned.ToString() && (x.wcstask_endPoint == "10301" || x.wcstask_startPoint == "10301"));
                                if (measureList.Count > 1)//tx 0921   2->1
                                {
                                    //说明测量任务达到上限值，需要等待
                                    Console.WriteLine("当前执行的测量任务已达到上限，其它测量任务需等待");
                                    continue;
                                }
                            }
                        }
                        SendRGVTaskAction(rgvTask, wcsInfo, taskRGVinfoRepository, taskWCSinfoRepository);
                    }
                }
            }
            return "";
        }

    }
}