using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.LocationEnum;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_DTO;
using WIDESEAWCS_DTO.RGV.FOURBOT;
using WIDESEAWCS_DTO.WMS;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_Tasks
{
    public partial class TaskJob
    {
        /// <summary>
        /// 下发四向车新建入库任务
        /// </summary>
        /// <param name="tasks"></param>
        public void SendRGVNewInTask(List<Dt_Task> tasks)
        {
            FOURBOTnewMovePodTask fOURBOTnewMovePodTask = new();
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo? apiInfo = _apiInfoService.Repository.QueryFirst(x => x.ApiCode == nameof(FOURBOTnewMovePodTask)) ?? throw new Exception("未找到四向车任务下发接口配置信息！请检查接口配置");
                foreach (var task in tasks)
                {
                    fOURBOTnewMovePodTask = new()
                    {
                        priority = task.Grade,
                        podID = task.PalletCode,
                        desExt = new
                        {
                            unload = 0//是否放下容器,0否1是
                        },
                        desStationCodes = task.SourceAddress,
                        desType = 5
                    };
                    fOURBOTnewMovePodTask.requestID += task.TaskId;
                    try
                    {
                        string response = HttpHelper.Post(apiInfo.ApiAddress, fOURBOTnewMovePodTask.Serialize());
                        FOURBOTReturn fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                        content.OK(data: fOURBOTReturn);
                        if (fOURBOTReturn.returnCode != 0) throw new Exception(fOURBOTReturn.returnUserMsg);

                        string dataJson = fOURBOTReturn.data.ToString();
                        FOURBOTnewMovePodTaskResponseData? fOURBO = JsonConvert.DeserializeObject<FOURBOTnewMovePodTaskResponseData>(dataJson);
                        if (fOURBO == null || fOURBO.taskID == 0)
                        {
                            throw new Exception($"未获取到四向车返回的任务ID，返回数据：{response}");
                        }
                        //FOURBOTnewMovePodTaskResponseData fOURBO = fOURBOTReturn.data as FOURBOTnewMovePodTaskResponseData ?? throw new Exception("未获取到四向车返回的任务ID");
                        task.RGVTaskId = fOURBO.taskID;
                        task.ExceptionMessage = "";
                        task.TaskState = (int)TaskStatusEnum.Execut;
                        task.Dispatchertime = DateTime.Now;
                    }
                    catch (Exception ex)
                    {
                        task.ExceptionMessage = ex.Message;
                        content.Error(ex.Message);
                    }
                    finally
                    {
                        _trackloginfoService.AddTrackLog(fOURBOTnewMovePodTask, content, "下发四向车新建入库任务", "", "");
                    }
                }
                var uptasks = tasks.Where(task => string.IsNullOrEmpty(task.ExceptionMessage)).ToList();
                if (uptasks.Count() > 0) _taskService.UpdateData(uptasks);
                var errortasks = tasks.Where(task => !string.IsNullOrEmpty(task.ExceptionMessage)).ToList();
                if (errortasks.Count() > 0)
                {
                    foreach (var item in errortasks)
                    {
                        Thread.Sleep(500);
                        _taskService.ErrorTaskFeedback(item, true);
                    }
                }
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
        }

        #region 
        /// <summary>
        /// 下发四向车外形检测任务
        /// </summary>
        /// <param name="tasks"></param>
        public void SendRGVCheckShapeTask(List<Dt_Task> tasks)
        {
            FOURBOTnewMovePodTask fOURBOTnewMovePodTask = new();
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo? apiInfo = _apiInfoService.Repository.QueryFirst(x => x.ApiCode == nameof(FOURBOTnewMovePodTask)) ?? throw new Exception("未找到四向车任务下发接口配置信息！请检查接口配置");
                foreach (var item in tasks)
                {
                    fOURBOTnewMovePodTask.priority = item.Grade;
                    fOURBOTnewMovePodTask.podID = item.PalletCode;
                    //fOURBOTnewMovePodTask.destination = item.NextAddress;
                    fOURBOTnewMovePodTask.desExt = new
                    {
                        unload = 0//是否放下容器,0否1是
                    };
                    fOURBOTnewMovePodTask.taskExt = new
                    {
                        keepRobot = 1,
                        keepRobotTimeout = 1
                    };
                    fOURBOTnewMovePodTask.requestID += item.TaskId;
                    fOURBOTnewMovePodTask.desType = 1;
                    fOURBOTnewMovePodTask.desNodeID = item.NextAddress;
                    string response = HttpHelper.Post(apiInfo.ApiAddress, fOURBOTnewMovePodTask.Serialize());
                    FOURBOTReturn fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                    content.OK(data: fOURBOTReturn);
                    if (fOURBOTReturn.returnCode == 0)
                    {
                        string dataJson = fOURBOTReturn.data.ToString();
                        FOURBOTnewMovePodTaskResponseData? fOURBO = JsonConvert.DeserializeObject<FOURBOTnewMovePodTaskResponseData>(dataJson);
                        if (fOURBO == null || fOURBO.taskID == 0)
                        {
                            throw new Exception($"未获取到四向车返回的任务ID，返回数据：{response}");
                        }
                        //FOURBOTnewMovePodTaskResponseData fOURBO = fOURBOTReturn.data as FOURBOTnewMovePodTaskResponseData ?? throw new Exception("未获取到四向车返回的任务ID");
                        item.RGVTaskId = fOURBO.taskID;
                        item.Dispatchertime = DateTime.Now;
                        item.TaskState = (int)TaskStatusEnum.TakeFinish;
                    }
                }
                _taskService.UpdateData(tasks);
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            finally
            {
                _trackloginfoService.AddTrackLog(fOURBOTnewMovePodTask, content, "下发四向车外形检测任务", "", "");
            }
        }
        #endregion

        #region 处理出库任务是否需要移库
        /// <summary>
        /// 处理出库任务是否需要移库
        /// </summary>
        /// <param name="tasks"></param>
        public void IsMoveTask(List<Dt_Task> tasks)
        {

            object requestData = null;  // 添加变量记录请求数据
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo? apiInfo = _apiInfoService.Repository.QueryFirst(x => x.ApiCode == nameof(GetBlockPodContentDto)) ?? throw new Exception("未找到批量获取阻碍托盘关系接口配置信息！请检查接口配置");
                List<Dt_Task> dt_Tasks = new List<Dt_Task>();
                var PalletCodes = tasks.Select(x => x.PalletCode).ToList();
                //GetBlockPodContentDto content = new GetBlockPodContentDto();
                var request = new GetBlockPodContentListDto
                {
                    content = new List<GetBlockPodContentDto>
                    {
                        new GetBlockPodContentDto
                        {
                            candidatePodIDs = PalletCodes,
                            num = 0 // 0表示全部出，如果需要限制数量可以调整
                        }
                    }
                };
                requestData = request;  // 保存请求数据用于日志
                //content.candidatePodIDs = tasks.Select(x => x.PalletCode).ToList();
                //string response = HttpHelper.Post("http://127.0.0.1:4523/m2/6165241-5857331-default/440906899?apifoxApiId=440906899", request.Serialize());

                string response = HttpHelper.Post(apiInfo.ApiAddress, request.Serialize());
                FOURBOTReturn fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                content.OK(data: fOURBOTReturn);
                if (fOURBOTReturn.returnCode == 0)
                {
                    //ReturnBlockPodResultDto getBlockPod = fOURBOTReturn.data as ReturnBlockPodResultDto ?? throw new Exception("未获取到阻碍托盘关系数据");
                    var dataJson = fOURBOTReturn.data.ToString();
                    ReturnBlockPodResultDto? getBlockPod = JsonConvert.DeserializeObject<ReturnBlockPodResultDto>(dataJson);
                    if (getBlockPod.Result.Count == 0)
                    {
                        throw new Exception("未获取到阻碍托盘关系数据");
                    }
                    foreach (var Result in getBlockPod.Result)
                    {
                        foreach (var item in Result.outPods)
                        {
                            var task = tasks.First(x => x.PalletCode == item.outPod);
                            if (item.blockPods != null && item.blockPods.Count > 0)
                                item.blockPods = item.blockPods.Except(PalletCodes).ToList();
                            if (item.blockPods != null && item.blockPods.Count > 0)
                            {
                                #region 判断阻碍托是否为出库任务
                                //var except = item.blockPods.Except(PalletCodes).ToList();
                                #endregion
                                var responseContent = AddMoveTask(item.blockPods, task);//添加移库任务
                                if (!responseContent.Status) task.ExceptionMessage = responseContent.Message;
                                else
                                {
                                    task.TaskState = (int)TaskStatusEnum.RGV_WaitMoveToExecute;
                                }
                                dt_Tasks.Add(task);
                            }
                            else
                            {
                                task.TaskState = (int)TaskStatusEnum.RGV_WaitSend;
                                dt_Tasks.Add(task);
                            }
                        }
                    }
                    _taskService.UpdateData(dt_Tasks);
                    content.OK();
                }
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            finally
            {
                _trackloginfoService.AddTrackLog(requestData, content, "处理出库任务是否需要移库", "", "");
            }
        }
        #endregion

        #region 下发外形检测成功任务
        /// <summary>
        /// 下发外形检测成功任务
        /// </summary>
        /// <param name="tasks"></param>
        public void SendCheckShapeingOkTask(List<Dt_Task> tasks)
        {
            FOURBOTnewMovePodTask fOURBOTnewMovePodTask = new();
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo? apiInfo = _apiInfoService.Repository.QueryFirst(x => x.ApiCode == nameof(FOURBOTnewMovePodTask)) ?? throw new Exception("未找到四向车任务下发接口配置信息！请检查接口配置");
                var tasksToUpdate = new List<Dt_Task>();
                var locationsToUpdate = new List<Dt_RGVLocationInfo>();
                var stationsToUpdate = new List<Dt_StationManger>();
                #region 任务下发
                var item = tasks.FirstOrDefault();
                if (item != null)
                {
                    try
                    {
                        #region 获取货位
                        var rGVLocationInfo = _rGVLocationInfoService.GetInFreeLocationInfo(item.Roadway.ObjToInt());
                        if (rGVLocationInfo == null)
                        {
                            item.ExceptionMessage = $"未找到终点库区【{item.Roadway}】可用空货位！";
                        }
                        #endregion
                        else
                        {
                            fOURBOTnewMovePodTask = new FOURBOTnewMovePodTask
                            {
                                priority = item.Grade,
                                podID = item.PalletCode,
                                desStorageID = rGVLocationInfo.LocationCode,
                                //destination = rGVLocationInfo.LocationCode,
                                desExt = new { unload = 1 }, // 是否放下容器,0否1是
                                desType = 2
                            };
                            fOURBOTnewMovePodTask.taskExt = new
                            {
                                autoToRest = 1
                            };
                            fOURBOTnewMovePodTask.requestID = DateTime.Now.ToString("yyyyMMddHHmmssfff") + item.TaskId;
                            item.CurrentAddress = item.NextAddress;
                            item.NextAddress = rGVLocationInfo.LocationCode;
                            item.TargetAddress = rGVLocationInfo.LocationCode;
                            item.Roadway = rGVLocationInfo.RoadwayNo;

                            string response = HttpHelper.Post(apiInfo.ApiAddress, fOURBOTnewMovePodTask.Serialize());
                            var fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                            content.OK(data: fOURBOTReturn);
                            if (fOURBOTReturn.returnCode == 0)
                            {
                                var data = fOURBOTReturn.data.ToString();
                                var fOURBO = data.DeserializeObject<FOURBOTnewMovePodTaskResponseData>();
                                item.RGVTaskId = fOURBO.taskID;
                                item.TaskState = (int)TaskStatusEnum.Puting;
                                rGVLocationInfo.LocationStatus = LocationStatusEnum.InLock.ObjToInt();
                                item.Dispatchertime = DateTime.Now;
                                locationsToUpdate.Add(rGVLocationInfo);

                                #region 释放入库站台
                                var stationManger = _stationMangerService.GetInStationInfo(item.SourceAddress);
                                if (stationManger != null)
                                {
                                    stationManger.IsOccupied = LocationStatusEnum.Free.ObjToInt();
                                    stationsToUpdate.Add(stationManger);
                                }
                                content.OK();
                                #endregion
                            }
                            else
                            {
                                item.ExceptionMessage = $"四向车接口返回错误：{fOURBOTReturn.returnMsg}";
                                // 记录失败的任务
                                content.Error($"四向车接口返回错误：{fOURBOTReturn.returnMsg}");
                            }
                            tasksToUpdate.Add(item);
                        }
                    }
                    catch (Exception ex)
                    {
                        item.ExceptionMessage = $"处理任务异常：{ex.Message}";
                        //WriteError($"{nameof(TaskJob)}-{item.TaskId}", ex.Message, ex);
                        content.Error($"四向车接口返回错误：{ex.Message}");
                    }
                    finally
                    {

                    }
                }
                #region MyRegion
                //foreach (var item in tasks)
                //{
                //    try
                //    {
                //        #region 获取货位
                //        var rGVLocationInfo = _rGVLocationInfoService.GetFreeLocationInfo(item.Roadway);
                //        if (rGVLocationInfo == null)
                //        {
                //            item.ExceptionMessage = $"未找到终点库区【{item.Roadway}】可用空货位！";
                //            continue;
                //        }
                //        #endregion
                //        fOURBOTnewMovePodTask = new FOURBOTnewMovePodTask
                //        {
                //            priority = item.Grade,
                //            podID = item.PalletCode,
                //            desStorageID = rGVLocationInfo.LocationCode,
                //            //destination = rGVLocationInfo.LocationCode,
                //            desExt = new { unload = 1 }, // 是否放下容器,0否1是
                //            desType = 2
                //        };
                //        fOURBOTnewMovePodTask.taskExt = new
                //        {
                //            autoToRest = 1
                //        };
                //        item.CurrentAddress = item.NextAddress;
                //        item.NextAddress = rGVLocationInfo.LocationCode;
                //        item.TargetAddress = rGVLocationInfo.LocationCode;
                //        item.Roadway = rGVLocationInfo.RoadwayNo;

                //        string response = HttpHelper.Post(apiInfo.ApiAddress, fOURBOTnewMovePodTask.Serialize());
                //        var fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                //        content.Data = fOURBOTReturn;
                //        if (fOURBOTReturn.returnCode == 0)
                //        {
                //            var data = fOURBOTReturn.data.ToString();
                //            var fOURBO = data.DeserializeObject<FOURBOTnewMovePodTaskResponseData>();
                //            item.RGVTaskId = fOURBO.taskID;
                //            item.TaskState = (int)TaskStatusEnum.Puting;

                //            rGVLocationInfo.LocationStatus = LocationStatusEnum.InLock.ObjToInt();
                //            locationsToUpdate.Add(rGVLocationInfo);

                //            #region 释放入库站台
                //            var stationManger = _stationMangerService.GetInStationInfo(item.SourceAddress);
                //            if (stationManger != null)
                //            {
                //                stationManger.IsOccupied = LocationStatusEnum.Free.ObjToInt();
                //                stationsToUpdate.Add(stationManger);
                //            }
                //            content.OK();
                //            #endregion
                //        }
                //        else
                //        {
                //            item.ExceptionMessage = $"四向车接口返回错误：{fOURBOTReturn.returnMsg}";
                //            // 记录失败的任务
                //            content.Error($"四向车接口返回错误：{fOURBOTReturn.returnMsg}");
                //        }
                //    }
                //    catch (Exception ex)
                //    {
                //        item.ExceptionMessage = $"处理任务异常：{ex.Message}";
                //        //WriteError($"{nameof(TaskJob)}-{item.TaskId}", ex.Message, ex);
                //        content.Error($"四向车接口返回错误：{ex.Message}");
                //    }
                //    tasksToUpdate.Add(item);
                //} 
                #endregion
                #endregion
                #region 更新数据
                // 如果有需要更新的数据，才执行事务
                if (tasksToUpdate.Any() || locationsToUpdate.Any() || stationsToUpdate.Any())
                {
                    try
                    {
                        _unitOfWorkManage.BeginTran();

                        if (tasksToUpdate.Any())
                            _taskService.UpdateData(tasksToUpdate);
                        if (locationsToUpdate.Any())
                            _rGVLocationInfoService.UpdateData(locationsToUpdate);
                        if (stationsToUpdate.Any())
                            _stationMangerService.UpdateData(stationsToUpdate);

                        _unitOfWorkManage.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _unitOfWorkManage.RollbackTran();
                        WriteError(nameof(TaskJob), ex.Message, ex);
                    }
                }
                #endregion
            }
            catch (Exception ex)
            {
                WriteError(nameof(TaskJob), ex.Message, ex);
                content.Error($"下发外形检测任务失败{ex.Message}");
            }
            finally
            {
                _trackloginfoService.AddTrackLog(fOURBOTnewMovePodTask, content, "下发外形检测成功任务", "", "");
            }
        }
        #endregion

        #region 下发外形检测失败任务
        public void SendCheckShapeingNGTask(List<Dt_Task> tasks)
        {
            FOURBOTnewMovePodTask fOURBOTnewMovePodTask = new();
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo? apiInfo = _apiInfoService.Repository.QueryFirst(x => x.ApiCode == nameof(FOURBOTnewMovePodTask)) ?? throw new Exception("未找到四向车任务下发接口配置信息！请检查接口配置");
                foreach (var item in tasks)
                {
                    Dt_StationManger stationManger = _stationMangerService.GetInStationInfo(item.SourceAddress);
                    item.CurrentAddress = item.NextAddress;
                    item.NextAddress = stationManger.StationCode;
                    fOURBOTnewMovePodTask.priority = item.Grade;
                    fOURBOTnewMovePodTask.podID = item.PalletCode;
                    //fOURBOTnewMovePodTask.desNodeID = item.NextAddress;
                    fOURBOTnewMovePodTask.desStationCodes = item.NextAddress;
                    fOURBOTnewMovePodTask.desExt = new
                    {
                        unload = 1//是否放下容器,0否1是
                    };
                    fOURBOTnewMovePodTask.taskExt = new
                    {
                        autoToRest = 1
                    };
                    fOURBOTnewMovePodTask.desType = 5;
                    string response = HttpHelper.Post(apiInfo.ApiAddress, fOURBOTnewMovePodTask.Serialize());
                    FOURBOTReturn fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                    content.Data = fOURBOTReturn;
                    if (fOURBOTReturn.returnCode == 0)
                    {
                        //FOURBOTnewMovePodTaskResponseData fOURBO = fOURBOTReturn.data as FOURBOTnewMovePodTaskResponseData ?? throw new Exception("未获取到四向车返回的任务ID");
                        string dataJson = fOURBOTReturn.data.ToString();
                        FOURBOTnewMovePodTaskResponseData? fOURBO = JsonConvert.DeserializeObject<FOURBOTnewMovePodTaskResponseData>(dataJson);
                        content.OK(data: fOURBO);
                        if (fOURBO == null || fOURBO.taskID == 0)
                        {
                            throw new Exception($"未获取到四向车返回的任务ID，返回数据：{response}");
                        }
                        item.RGVTaskId = fOURBO.taskID;
                        item.TaskState = (int)TaskStatusEnum.Puting;
                        item.Dispatchertime = DateTime.Now;
                    }
                }
                _taskService.UpdateData(tasks);
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            finally
            {
                _trackloginfoService.AddTrackLog(fOURBOTnewMovePodTask, content, "下发外形检测失败任务", "", "");
            }
        }
        #endregion

        #region 添加移库任务
        public WebResponseContent AddMoveTask(List<string> blockPods, Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                List<Dt_RGVLocationInfo> rGVLocationInfos = _rGVLocationInfoService.Repository.QueryData(x => blockPods.Contains(x.PalletCode));
                var Items = _rGVLocationInfoService.GetMoveFreeLocationInfo(rGVLocationInfos);

                List<Dt_Task> tasks = Items.Item1;
                List<Dt_RGVLocationInfo> _UpRGVLocationInfos = Items.Item2;
                if (tasks.Count < blockPods.Count) throw new Exception("可移库空货位少于需移库托盘数量");

                tasks.ForEach(x =>
                {
                    x.TaskNum = _taskService.GetTaskNum(nameof(SequenceEnum.SeqTaskNum));
                    //x.WMSTaskNum = task.WMSTaskNum;
                });
                rGVLocationInfos.ForEach(x =>
                {
                    x.LocationStatus = LocationStatusEnum.MoveLock.ObjToInt();
                });
                _UpRGVLocationInfos.ForEach(x =>
                {
                    x.LocationStatus = LocationStatusEnum.MoveLock.ObjToInt();
                });
                try
                {
                    _unitOfWorkManage.BeginTran();
                    _rGVLocationInfoService.UpdateData(rGVLocationInfos);
                    _rGVLocationInfoService.UpdateData(_UpRGVLocationInfos);
                    _taskService.AddData(tasks);
                    _unitOfWorkManage.CommitTran();
                    content.OK();
                }
                catch (Exception ex)
                {
                    _unitOfWorkManage.RollbackTran();
                    throw new Exception(ex.Message);
                }
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        #endregion

        #region 下发四向车批量移库任务
        public void SendMoveTasks(List<Dt_Task> tasks)
        {
            WebResponseContent content = new WebResponseContent();
            List<Dt_Task> dt_Tasks = new List<Dt_Task>();
            MoveBlockPodContentDto moveBlock = new MoveBlockPodContentDto();
            try
            {

                Dt_ApiInfo? apiInfo = _apiInfoService.Repository.QueryFirst(x => x.ApiCode == nameof(MoveBlockPodContentDto)) ?? throw new Exception("未找到四向车批量搬运阻碍托任务接口配置信息！请检查接口配置");
                foreach (var item in tasks)
                {
                    MoveBlockPodContentDtoInfo moveBlockInfo = new MoveBlockPodContentDtoInfo()
                    {
                        podID = item.PalletCode,
                        des = item.TargetAddress
                    };
                    moveBlock.content.Add(moveBlockInfo);
                }
                string response = HttpHelper.Post(apiInfo.ApiAddress, moveBlock.Serialize());
                FOURBOTReturn fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                content.OK(data: fOURBOTReturn);
                if (fOURBOTReturn.returnCode == 0)
                {
                    string dataJson = fOURBOTReturn.data.ToString();
                    //MoveBlockPodsDataDto moveBlockPodsData = fOURBOTReturn.data as MoveBlockPodsDataDto ?? throw new Exception("未获取到四向车批量搬运阻碍托返回的任务ID");
                    MoveBlockPodsDataDto? moveBlockPodsData = JsonConvert.DeserializeObject<MoveBlockPodsDataDto>(dataJson);
                    if (moveBlockPodsData == null || moveBlockPodsData.succList.Count == 0)
                    {
                        throw new Exception($"未获取到四向车返回的任务ID，返回数据：{response}");
                    }

                    foreach (var item in moveBlockPodsData.succList)
                    {
                        if (item.taskID == 0)
                            continue;  // 跳过无效的任务ID
                        var task = tasks.First(x => x.PalletCode == item.podID);
                        task.RGVTaskId = item.taskID;
                        task.TaskState = TaskStatusEnum.RGV_MoveTaskSend.ObjToInt();
                        task.Dispatchertime = DateTime.Now;
                        dt_Tasks.Add(task);
                    }
                    _taskService.UpdateData(dt_Tasks);
                    content.OK();
                }
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            finally
            {
                _trackloginfoService.AddTrackLog(moveBlock, content, "下发四向车批量移库任务", "", "");
            }
        }
        #endregion

        #region 处理待移库后出库任务
        public void MoveToExecuteTask(List<Dt_Task> tasks)
        {
            try
            {
                foreach (var item in tasks)
                {
                    var takes = _taskService.Repository.QueryFirst(x => x.Roadway == item.Roadway && x.TaskType == (int)TaskTypeEnum.CPMoveInventory && (x.TaskState == (int)TaskStatusEnum.RGV_NewMoveTask || x.TaskState == (int)TaskStatusEnum.RGV_MoveTaskSend));
                    if (takes == null)
                    {
                        item.TaskState = (int)TaskStatusEnum.RGV_WaitSend;
                        item.Dispatchertime = DateTime.Now;
                    }
                }
                _taskService.UpdateData(tasks);
            }
            catch (Exception ex)
            {
                WriteError(nameof(TaskJob), ex.Message, ex);
            }
        }
        #endregion

        #region 下发出库任务
        public void SendOutTask(List<Dt_Task> tasks)
        {
            FOURBOTnewMovePodTask fOURBOTnewMovePodTask = new();
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo? apiInfo = _apiInfoService.Repository.QueryFirst(x => x.ApiCode == nameof(FOURBOTnewMovePodTask)) ?? throw new Exception("未找到四向车任务下发接口配置信息！请检查接口配置");
                var i = 0;
                foreach (var item in tasks)
                {
                    i++;
                    var stationManger = _stationMangerService.GetOutStationInfo(item.TargetAddress);
                    //if (stationManger.IsOccupied != LocationStatusEnum.Free.ObjToInt())
                    //{
                    //    item.ExceptionMessage = $"出库站台【{stationManger.StationCode}】被占用";
                    //    continue;
                    //}
                    item.NextAddress = stationManger.StationCode;
                    #region 下发出库任务
                    fOURBOTnewMovePodTask.priority = item.Grade;
                    fOURBOTnewMovePodTask.podID = item.PalletCode;
                    //fOURBOTnewMovePodTask.desNodeID = item.NextAddress;
                    fOURBOTnewMovePodTask.desStationCodes = item.NextAddress;
                    fOURBOTnewMovePodTask.desExt = new
                    {
                        unload = 1//是否放下容器,0否1是
                    };
                    fOURBOTnewMovePodTask.taskExt = new
                    {
                        autoToRest = 1
                    };
                    fOURBOTnewMovePodTask.desType = 5;
                    fOURBOTnewMovePodTask.requestID = DateTime.Now.ToString("yyyyMMddHHmmssfff") + item.TaskId;
                    string response = HttpHelper.Post(apiInfo.ApiAddress, fOURBOTnewMovePodTask.Serialize());
                    FOURBOTReturn fOURBOTReturn = response.DeserializeObject<FOURBOTReturn>();
                    content.OK(data: fOURBOTReturn);
                    if (fOURBOTReturn.returnCode == 0)
                    {
                        string dataJson = fOURBOTReturn.data.ToString();
                        FOURBOTnewMovePodTaskResponseData? fOURBO = JsonConvert.DeserializeObject<FOURBOTnewMovePodTaskResponseData>(dataJson);
                        if (fOURBO == null || fOURBO.taskID == 0)
                        {
                            throw new Exception($"未获取到四向车返回的任务ID，返回数据：{response}");
                        }
                        item.RGVTaskId = fOURBO.taskID;
                        item.TaskState = (int)TaskStatusEnum.Execut;
                        item.Dispatchertime = DateTime.Now;
                        //stationManger.IsOccupied = LocationStatusEnum.Lock.ObjToInt();
                        //_stationMangerService.UpdateData(stationManger);
                    }
                    #endregion
                }
                _taskService.UpdateData(tasks);
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            finally
            {
                _trackloginfoService.AddTrackLog(fOURBOTnewMovePodTask, content, "下发四向车出库任务", "", "");
            }
        }
        #endregion
    }
}