RCS / RCS_Differential_Slam_Changsha · Files

using RCS.Dal;
using RCS.Model.Comm;
using RCS.Model.Entity;
using RCS.Model.PLC;
using RCS.WinClient.Common;
using RCS.WinClient.WebApi.Client;
using SqlSugar;
using System.Collections.ObjectModel;
using System.Data;
using System.Threading.Tasks;
using System.Windows.Interop;
using System.Windows.Media;
using static RCS.Model.Comm.EnumMsg;




namespace RCS.WinClient.Service
{
    public class TaskManage
    {
        private static object taskBuildLock = new object();

        /// <summary>
        /// 任务创建
        /// </summary>
        /// <param name="strTaskId">任务ID</param>
        /// <param name="strTaskGroup">任务群组</param>
        /// <param name="strTaskPallet">任务条码</param>
        /// <param name="intTaskLevel">任务等级</param>
        /// <param name="strAgvNo">执行AGV</param>
        /// <param name="startBarcode">起点</param>
        /// <param name="endBarcode">终点</param>
        /// <param name="strTaskNo">任务号</param>
        /// <returns></returns>
        public static BllResult<Base_Task> TaskBuild(string strTaskId, string? strTaskGroup, string? strTaskPallet, int intTaskLevel, string? strAgvNo, string startBarcode, string? endBarcode, string? strTaskNo, string? startStationName, string? endStationName, short heightOrAngle = 0)
        {
            lock (taskBuildLock)
            {
                try
                {
                    #region 校验数据、获取任务号
                    Base_Agv? agv = null;
                    //Base_Station startStation = null;
                    Base_Station? endStation = null;
                    if (!string.IsNullOrEmpty(strTaskNo) && App.TaskList.Any(t => t.TaskNo == strTaskNo))
                    {
                        return BllResult<Base_Task>.Success($"已经存在任务");
                    }
                    if (!string.IsNullOrEmpty(strAgvNo))
                    {
                        agv = App.AgvList.FirstOrDefault(x => x.AgvNo == strAgvNo);
                        if (agv != null && agv.AgvTask != null)
                        {
                            var msg = $"AGV【{agv.AgvNo}】已有【{agv.AgvTask.TaskType}】的任务【{agv.AgvTask.TaskNo}】，不能下发【{strTaskId}】任务！";
                            return BllResult<Base_Task>.Error(msg);
                        }
                        var tempTask = App.TaskList.FirstOrDefault(x => x.TaskAgvNo == strAgvNo);
                        if (tempTask != null)
                        {
                            var msg = $"AGV【{strAgvNo}】已有【{tempTask.TaskType}】的任务【{tempTask.TaskNo}】，不能下发【{strTaskId}】任务";
                            return BllResult<Base_Task>.Error(msg);
                        }
                    }
                    if (!string.IsNullOrEmpty(startStationName) && !string.IsNullOrEmpty(endStationName))
                    {
                        if (App.TaskList.Any(t => t.Initial == startStationName && t.Target == endStationName))
                        {
                            var msg = $"存在从工位【{startStationName}】到工位【{endStationName}】的任务，请稍后下发";
                            return BllResult<Base_Task>.Error(msg);
                        }
                    }
                    if (strTaskId == EnumMsg.TaskType.取消充电.ToString())
                    {
                        if (string.IsNullOrEmpty(startBarcode) || string.IsNullOrEmpty(endBarcode))
                        {
                            if (agv != null && !string.IsNullOrEmpty(agv.Barcode))
                            {
                                startBarcode = agv.Barcode;
                                endBarcode = agv.Barcode;
                            }
                            else
                            {
                                var msg = $"【取消充电】任务没有起点和终点，AGV也不在点位上，无法下发【取消充电】任务";
                                return BllResult<Base_Task>.Error(msg);
                            }
                        }
                    }

                    var startPoint = App.PointList.FirstOrDefault(t => t.Barcode == startBarcode);
                    var endPoint = App.PointList.FirstOrDefault(t => t.Barcode == endBarcode);
                    if (startPoint == null)
                    {
                        var msg = "任务起点未找到!";
                        return BllResult<Base_Task>.Error(msg);
                    }
                    if (!startPoint.IsEnable)
                    {
                        var msg = "任务起点被禁用!";
                        return BllResult<Base_Task>.Error(msg);
                    }

                    if (endPoint == null)
                    {
                        var msg = "任务终点未找到!";
                        return BllResult<Base_Task>.Error(msg);
                    }
                    if (!endPoint.IsEnable)
                    {
                        var msg = "任务终点被禁用!";
                        return BllResult<Base_Task>.Error(msg);
                    }
                    //if (strTaskId != EnumMsg.TaskType.出库区任务.ToString() && !string.IsNullOrEmpty(endBarcode))
                    //{
                    //    if (endPoint == null)
                    //    {
                    //        var msg = "任务终点未找到!";
                    //        return BllResult<Base_Task>.Error(msg);
                    //    }
                    //    if (!endPoint.IsEnable)
                    //    {
                    //        var msg = "任务起点被禁用!";
                    //        return BllResult<Base_Task>.Error(msg);
                    //    }
                    //}
                    if (string.IsNullOrEmpty(strTaskNo))
                    {
                        var result = ComnMethod.GetTaskNo();
                        if (!result.IsSuccess)
                        {
                            return BllResult<Base_Task>.Error($"当前任务号获取失败");
                        }
                        strTaskNo = result.Data;
                    }

                    if (strTaskId == EnumMsg.TaskType.充电.ToString() || strTaskId == EnumMsg.TaskType.取消充电.ToString())
                    {
                        if (string.IsNullOrWhiteSpace(endStationName))
                        {
                            endStation = App.StationList.FirstOrDefault(t => t.StationType == EnumMsg.StationType.充电桩 &&
                                                                            (t.Barcode == endBarcode || t.Barcode == endBarcode.Point().Data.PreBarcode));
                        }
                        else
                        {
                            endStation = App.StationList.FirstOrDefault(t => t.Name == endStationName && t.StationType == EnumMsg.StationType.充电桩);
                        }
                        if (endStation == null)
                        {
                            var msg = $"创建【{strTaskId}】任务失败，因为充电桩【{endStationName}】不存在！";
                            App.ExFile.MessageError("TaskBuild", msg);
                            return BllResult<Base_Task>.Error(msg);
                        }
                        if (agv == null)
                        {
                            var msg = $"没有指定AGV，不能生成充电任务！";
                            App.ExFile.MessageError("TaskBuild", msg);
                            return BllResult<Base_Task>.Error(msg);
                        }
                        endStationName = endStation.Name;
                        if (strTaskId == EnumMsg.TaskType.充电.ToString())
                        {
                            agv.LockStation = endStation;
                            endStation.IsLocked = true;
                            var updateAgvResult = UpdateManage.UpdateAgv(agv);
                            var updateAtationResult = UpdateManage.UpdateStation(endStation);
                        }
                    }

                    #endregion

                    #region 给Base_Task赋值
                    var task = new Base_Task();
                    task.HeightOrAngle = heightOrAngle;
                    task.TaskNo = strTaskNo;
                    task.TaskType = strTaskId;
                    task.TaskGroup = strTaskGroup;
                    task.TaskLevel = intTaskLevel;
                    task.TaskSplitStep = 1;
                    task.TaskAgvNo = strAgvNo;
                    task.IsSubmit = false;
                    task.TaskPallet = string.IsNullOrEmpty(strTaskPallet) ? "" : strTaskPallet;

                    //获取任务起点终点站台
                    task.Initial = startStationName;
                    task.Target = endStationName;

                    task.StartPoint = startPoint;
                    task.EndPoint = endPoint;
                    task.StartBarcode = startBarcode;
                    task.EndBarcode = endBarcode;

                    task.AcceptTime = DateTime.Now;
                    task.SubTaskList = new ObservableCollection<Base_SubTask>();
                    task.BeginTime = null;
                    task.EndTime = null;
                    task.TaskErrMsg = "";
                    task.Direction = 0;
                    #endregion

                    //更新数据库
                    var _taskDb = new BaseDal<Base_Task>();
                    var insertresult = _taskDb.Insert(task);
                    if (!insertresult.IsSuccess)
                    {
                        var msg = $"创建任务【{task.TaskNo}】时插入数据库失败，原因：{insertresult.Message}";
                        App.ExFile.MessageError("TaskBuild", msg);
                        return BllResult<Base_Task>.Error(msg);
                    }
                    else
                    {
                        App.AppDispatcher.Invoke(new Action(() =>
                        {
                            App.TaskList.Add(task);
                        }));
                        return BllResult<Base_Task>.Success(task, $"创建任务【{task.TaskNo}】成功！");
                    }
                }
                catch (Exception ex)
                {
                    var msg = $"建立任务【{strTaskId}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                    App.ExFile.MessageError("TaskBuild", msg);
                    return BllResult<Base_Task>.Error(msg);
                }
            }
        }




        /// <summary>
        /// 任务创建
        /// </summary>
        /// <param name="strTaskId">任务ID</param>
        /// <param name="strTaskGroup">任务群组</param>
        /// <param name="strTaskPallet">任务条码</param>
        /// <param name="intTaskLevel">任务等级</param>
        /// <param name="strAgvNo">执行AGV</param>
        /// <param name="startBarcode">起点</param>
        /// <param name="endBarcode">终点</param>
        /// <param name="strTaskNo">任务号</param>
        /// <returns></returns>
        public static BllResult<Base_Task> TaskBuild(TaskBuildDto taskBuild)
        {

            lock (taskBuildLock)
            {
                try
                {
                    #region 校验数据、获取任务号
                    Base_Agv? agv = null;
                    //Base_Station startStation = null;
                    Base_Station? endStation = null;
                    if (!string.IsNullOrEmpty(taskBuild.TaskNo) && App.TaskList.Any(t => t.TaskNo == taskBuild.TaskNo))
                    {
                        return BllResult<Base_Task>.Success($"已经存在任务");
                    }
                    if (!string.IsNullOrEmpty(taskBuild.AgvNo))
                    {
                        agv = App.AgvList.FirstOrDefault(x => x.AgvNo == taskBuild.AgvNo);
                        if (agv != null && agv.AgvTask != null)
                        {
                            var msg = $"AGV【{agv.AgvNo}】已有【{agv.AgvTask.TaskType}】的任务【{agv.AgvTask.TaskNo}】，不能下发【{taskBuild.TaskType}】任务！";
                            return BllResult<Base_Task>.Error(msg);
                        }
                        var tempTask = App.TaskList.FirstOrDefault(x => x.TaskAgvNo == taskBuild.AgvNo);
                        if (tempTask != null)
                        {
                            var msg = $"AGV【{taskBuild.AgvNo}】已有【{tempTask.TaskType}】的任务【{tempTask.TaskNo}】，不能下发【{taskBuild.TaskType}】任务";
                            return BllResult<Base_Task>.Error(msg);
                        }
                    }
                    if (!string.IsNullOrEmpty(taskBuild.StartStationName) && !string.IsNullOrEmpty(taskBuild.EndStationName))
                    {
                        if (App.TaskList.Any(t => t.Initial == taskBuild.StartStationName && t.Target == taskBuild.EndStationName))
                        {
                            var msg = $"存在从工位【{taskBuild.StartStationName}】到工位【{taskBuild.EndStationName}】的任务，请稍后下发";
                            return BllResult<Base_Task>.Error(msg);
                        }
                    }
                    //除输送线外，不能下发同站台的任务
                    var flag = App.TaskList.Any(_task =>
                         !taskBuild.StartStationName.IsNullOrEmpty() && _task.Initial == taskBuild.StartStationName && !_task.Initial.In("P1001", "P1002")
                      || !taskBuild.EndStationName.IsNullOrEmpty() && _task.EndBarcode == taskBuild.EndStationName && !_task.Target.In("P1001", "P1002"));
                    if (flag)
                    {
                        var msg = $"存在同起点或终点的的任务，请稍后下发";
                        return BllResult<Base_Task>.Error(msg);
                    }

                    if (taskBuild.TaskType == EnumMsg.TaskType.取消充电.ToString())
                    {
                        if (string.IsNullOrEmpty(taskBuild.StartBarcode) || string.IsNullOrEmpty(taskBuild.EndBarcode))
                        {
                            if (agv != null && !string.IsNullOrEmpty(agv.Barcode))
                            {
                                taskBuild.EndBarcode = agv.Barcode;
                                taskBuild.StartBarcode = agv.Barcode;
                            }
                            else
                            {
                                var msg = $"【取消充电】任务没有起点和终点，AGV也不在点位上，无法下发【取消充电】任务";
                                return BllResult<Base_Task>.Error(msg);
                            }
                        }
                    }

                    var startPoint = App.PointList.FirstOrDefault(t => t.Barcode == taskBuild.StartBarcode);
                    var endPoint = App.PointList.FirstOrDefault(t => t.Barcode == taskBuild.EndBarcode);
                    if (startPoint == null)
                    {
                        var msg = "任务起点未找到!";
                        return BllResult<Base_Task>.Error(msg);
                    }
                    if (!startPoint.IsEnable)
                    {
                        var msg = "任务起点被禁用!";
                        return BllResult<Base_Task>.Error(msg);
                    }

                    if (endPoint == null)
                    {
                        var msg = "任务终点未找到!";
                        return BllResult<Base_Task>.Error(msg);
                    }
                    if (!endPoint.IsEnable)
                    {
                        var msg = "任务终点被禁用!";
                        return BllResult<Base_Task>.Error(msg);
                    }

                    if (string.IsNullOrEmpty(taskBuild.TaskNo))
                    {
                        var result = ComnMethod.GetTaskNo();
                        if (!result.IsSuccess)
                        {
                            return BllResult<Base_Task>.Error($"当前任务号获取失败");
                        }
                        taskBuild.TaskNo = result.Data;
                    }

                    if (taskBuild.TaskType == EnumMsg.TaskType.充电.ToString() || taskBuild.TaskType == EnumMsg.TaskType.取消充电.ToString())
                    {
                        if (string.IsNullOrWhiteSpace(taskBuild.EndStationName))
                        {
                            endStation = App.StationList
                                .FirstOrDefault(t => t.StationType == EnumMsg.StationType.充电桩
                                && (t.Barcode == taskBuild.EndBarcode || t.Barcode == taskBuild.EndBarcode?.Point().Data.PreBarcode));
                        }
                        else
                        {
                            endStation = App.StationList.FirstOrDefault(t => t.Name == taskBuild.EndStationName
                            && t.StationType == EnumMsg.StationType.充电桩);
                        }
                        if (endStation == null)
                        {
                            var msg = $"创建【{taskBuild.TaskType}】任务失败，因为充电桩【{taskBuild.EndStationName}】不存在！";
                            App.ExFile.MessageError("TaskBuild", msg);
                            return BllResult<Base_Task>.Error(msg);
                        }
                        if (agv == null)
                        {
                            var msg = $"没有指定AGV，不能生成充电任务！";
                            App.ExFile.MessageError("TaskBuild", msg);
                            return BllResult<Base_Task>.Error(msg);
                        }
                        taskBuild.EndStationName = endStation.Name;
                        if (taskBuild.TaskType == EnumMsg.TaskType.充电.ToString())
                        {
                            agv.LockStation = endStation;
                            endStation.IsLocked = true;
                            var updateAgvResult = UpdateManage.UpdateAgv(agv);
                            var updateAtationResult = UpdateManage.UpdateStation(endStation);
                        }
                    }

                    #endregion

                    #region 给Base_Task赋值
                    var task = new Base_Task
                    {
                        HeightOrAngle = taskBuild.HeightOrAngle,
                        TaskNo = taskBuild.TaskNo,
                        TaskType = taskBuild.TaskType,
                        TaskGroup = taskBuild.TaskGroup,
                        TaskLevel = taskBuild.TaskLevel,
                        TaskAgvNo = taskBuild.AgvNo,
                        TaskPallet = taskBuild.TaskPalletNo,

                        //获取任务起点终点站台
                        Initial = taskBuild.StartStationName,
                        Target = taskBuild.EndStationName,

                        StartPoint = startPoint,
                        EndPoint = endPoint,


                        AcceptTime = DateTime.Now,
                    };

                    #endregion

                    //更新数据库
                    var _taskDb = new BaseDal<Base_Task>();
                    var insertresult = _taskDb.Insert(task);
                    if (!insertresult.IsSuccess)
                    {
                        var msg = $"创建任务【{task.TaskNo}】时插入数据库失败，原因：{insertresult.Message}";
                        App.ExFile.MessageError("TaskBuild", msg);
                        return BllResult<Base_Task>.Error(msg);
                    }
                    else
                    {
                        App.AppDispatcher.Invoke(new Action(() =>
                        {
                            App.TaskList.Add(task);
                        }));
                        return BllResult<Base_Task>.Success(task, $"创建任务【{task.TaskNo}】成功！");
                    }
                }
                catch (Exception ex)
                {
                    var msg = $"建立任务【{taskBuild.TaskType}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                    App.ExFile.MessageError("TaskBuild", msg);
                    return BllResult<Base_Task>.Error(msg);
                }
            }
        }



        /// <summary>
        /// 任务删除
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public static BllResult TaskDelete(string taskNo, int state = 140, string remark = "")
        {
            try
            {
                var task = App.TaskList.FirstOrDefault(a => a.TaskNo == taskNo);
                if (task == null)
                {
                    return BllResult.Error($"删除任务【{taskNo}】失败，未查询到对应的任务！");
                }
                if (task.TaskState < EnumMsg.TaskState.自动完成) task.TaskState = EnumMsg.TaskState.手动删除;
                return TaskDelete(task, state, remark);
            }
            catch (Exception ex)
            {
                var msg = $"删除任务【{taskNo}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageError("TaskDelete", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 任务删除
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public static BllResult TaskDelete(Base_Task task, int state = 140, string remark = "")
        {
            try
            {
                if (task == null)
                {
                    return BllResult.Error($"删除任务失败，任务不能为空！");
                }
                var agv = App.AgvList.FirstOrDefault(x => x.AgvNo == task.TaskAgvNo);
                var subTask = task.SubTaskList.FirstOrDefault();
                if (subTask != null && subTask.SubTaskState < EnumMsg.SubTaskState.自动完成)
                {
                    switch (task.TaskState)
                    {
                        case EnumMsg.TaskState.自动删除:
                            subTask.SubTaskState = EnumMsg.SubTaskState.自动删除;
                            break;
                        case EnumMsg.TaskState.手动完成:
                            subTask.SubTaskState = EnumMsg.SubTaskState.手动完成;
                            break;
                        case EnumMsg.TaskState.手动删除:
                            subTask.SubTaskState = EnumMsg.SubTaskState.手动删除;
                            break;
                    }
                }
                //如果子任务是行走，并且已经执行，且车正在忙碌中，就不能删除，会让不在点位上停，导致丢位置。为了保护充电桩，也不能直接删除充电任务。
                //要标记为已删除，然后等车不忙碌的时候，再删除。
                if (agv != null && subTask != null && agv.AgvState == EnumMsg.AGVState.自动忙碌 && agv.Error.IsNullOrEmpty() && subTask.SubTaskState >= EnumMsg.SubTaskState.已执行)
                {
                    if (subTask.ActionType == EnumMsg.ActionType.普通行走 || subTask.ActionType == EnumMsg.ActionType.倒车行走
                        || subTask.ActionType == EnumMsg.ActionType.充电 || subTask.ActionType == EnumMsg.ActionType.取消充电)
                    {
                        return BllResult.Success($"任务【{task.TaskNo}】标记为【{task.TaskState}】，等待AGV不忙碌后执行！");
                    }
                }

                #region 清除数据库数据
                BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                BaseDal<Base_SubTask> _sonTaskDb = new BaseDal<Base_SubTask>();
                BaseDal<Base_PathPoint> _pathPointDb = new BaseDal<Base_PathPoint>();

                _taskDb.BeginTran();
                BllResult deleteresult1 = BllResult.Success();
                BllResult deleteresult2 = BllResult.Success();
                if (task.SubTaskList.Count > 0)
                {
                    if (task.SubTaskList[0].PathPointList.Count > 0)
                    {
                        deleteresult1 = _pathPointDb.Delete(it => it.SubTaskNo == task.SubTaskList[0].SubTaskNo);
                    }
                    deleteresult2 = _sonTaskDb.Delete(it => it.TaskNo == task.TaskNo);
                }
                var deleteresult3 = _taskDb.Delete(it => it.TaskNo == task.TaskNo);
                if (deleteresult1.IsSuccess && deleteresult2.IsSuccess && deleteresult3.IsSuccess)
                {

                    task.EndTime = DateTime.Now;
                    //task.TaskState = EnumMsg.ErrMsg.手动删除任务.ToString();

                    #region 插入主任务历史记录表
                    try
                    {
                        Log_Task Logtask = new Log_Task();
                        Logtask.ID = task.ID;
                        Logtask.TaskNo = task.TaskNo;
                        Logtask.TaskType = task.TaskType;
                        Logtask.TaskGroup = task.TaskGroup;
                        Logtask.TaskLevel = task.TaskLevel;
                        Logtask.TaskSplitStep = task.TaskSplitStep;
                        Logtask.TaskAgvNo = task.TaskAgvNo;
                        Logtask.IsSubmit = task.IsSubmit;
                        Logtask.TaskPallet = task.TaskPallet;
                        Logtask.Initial = task.Initial;
                        Logtask.Target = task.Target;
                        Logtask.StartPoint = task.StartPoint;
                        Logtask.EndPoint = task.EndPoint;
                        Logtask.StartBarcode = task.StartBarcode;
                        Logtask.EndBarcode = task.EndBarcode;
                        Logtask.AcceptTime = task.AcceptTime;
                        Logtask.BeginTime = task.BeginTime;
                        Logtask.EndTime = DateTime.Now;
                        Logtask.TaskErrMsg = task.TaskErrMsg;
                        Logtask.Direction = task.Direction;
                        Logtask.TaskState = task.TaskState;
                        //更新数据库
                        BaseDal<Log_Task> _logtaskDb = new BaseDal<Log_Task>();
                        var insertresultTask = _logtaskDb.Insert(Logtask);
                        if (!insertresultTask.IsSuccess)
                            throw new Exception(insertresultTask.Message);
                        if (task.TaskGroup == EnumMsg.TaskGroup.WMS任务.ToString()
                            && state != -1
                            && WebApiClient.ToAcsWebApiTaskState(task, state) is BllResult res && !res.IsSuccess)
                        {
                            throw new Exception($"任务状态上报上游系统失败{res.Message}");
                        }
                        _taskDb.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _taskDb.RollbackTran();
                        var msg = $"插入主任务历史记录表任务完成发生异常，{ex}";
                        App.ExFile.MessageError("subTaskManage", msg);
                        return BllResult.Error(msg);
                    }
                    #endregion
                }
                else
                {
                    _taskDb.RollbackTran();
                    var msg = $"删除任务【{task.TaskNo}】失败，主任务数据库删除失败！删除路径：{deleteresult1.Message}，删除子任务：{deleteresult2.Message}，删除主任务：{deleteresult3.Message}";
                    App.ExFile.MessageError("TaskDelete", msg);
                    return BllResult.Error(msg);
                }

                #endregion

                // 删除任务的时候，如果AGV匹配了站台，要修改站台信息
                if (agv != null && agv.LockStation != null)
                {
                    Base_Station station = App.StationList.Find(a => a.Name == agv.LockStation?.Name) ?? throw new Exception($"agv{agv.AgvNo}锁定的站台{agv.LockStation}不存在");
                    if (station != null)
                    {
                        station.IsLocked = false;
                        UpdateManage.UpdateStation(station);
                    }
                    //取消任务的时候，如果AGV有执行
                    agv!.LockStation = null;
                    agv.ChooseStation = "";
                    UpdateManage.UpdateAgv(agv);
                }

                App.AppDispatcher.Invoke(new Action(() =>
                {
                    if (agv != null)
                    {
                        if (agv.AgvTask == task)
                        {
                            agv.PathPointList.Clear();
                            agv.AgvTask.SubTaskList.Clear();
                            agv.AgvTask = null;
                        }
                        agv.FreeTime = DateTime.Now;
                    }
                    App.TaskList.Remove(task);
                }));


                return BllResult.Success($"成功删除任务【{task.TaskNo}】！");
            }
            catch (Exception ex)
            {
                var msg = $"删除任务【{task.TaskNo}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageError("TaskDelete", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 重置任务状态
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public static BllResult TaskReset(Base_Task task)
        {

            try
            {
                BaseDal<Base_SubTask> _sonTaskDb = new BaseDal<Base_SubTask>();
                BaseDal<Base_PathPoint> _pathPointDb = new BaseDal<Base_PathPoint>();
                BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();

                Base_Agv? agv = App.AgvList.FirstOrDefault(a => a.AgvNo == task.TaskAgvNo);

                _taskDb.BeginTran();
                BllResult _sonTaskResult = BllResult.Success();
                BllResult _pathPointResult = BllResult.Success();
                //清除所有子任务及其路径
                if (task.SubTaskList.Count > 0)
                {
                    _sonTaskResult = _sonTaskDb.Delete(it => it.TaskNo == task.TaskNo);
                    if (task.SubTaskList[0].PathPointList.Count > 0)
                    {
                        _pathPointResult = _pathPointDb.Delete(it => it.SubTaskNo == task.SubTaskList[0].SubTaskNo);
                    }
                }
                //更新主任务
                var updateresult = _taskDb.Update(it => it.TaskNo == task.TaskNo, it => new Base_Task()
                {
                    EndTime = null,
                    IsSubmit = false,
                    TaskAgvNo = "",
                    TaskState = EnumMsg.TaskState.手动重置,
                    BeginTime = null

                });
                if (updateresult.IsSuccess && _sonTaskResult.IsSuccess && _pathPointResult.IsSuccess)
                {
                    _taskDb.CommitTran();
                    if (task.SubTaskList.Count > 0)
                    {
                        App.AppDispatcher.Invoke(() =>
                        {
                            task.SubTaskList[0].PathPointList.Clear();
                            task.SubTaskList.Clear();
                        });
                    }

                    task.IsSubmit = false;
                    task.TaskAgvNo = "";
                    task.EndTime = null;
                    task.TaskState = EnumMsg.TaskState.手动重置;
                    task.BeginTime = null;
                }
                else
                {
                    _taskDb.RollbackTran();
                    var msg = $"主任务数据库重置失败【{task.TaskNo}】失败，主任务数据库删除失败！删除路径：{_pathPointResult.Message}，删除子任务：{_sonTaskResult.Message}，更新主任务：{updateresult.Message}";

                    App.ExFile.MessageBusinessErr("TaskReset", msg);
                    return BllResult.Error("主任务数据库重置失败");
                }
                if (task.TaskAgvNo != "")
                {
                    UpdateManage.InsertAgvMilage(task);
                }
                //清除agv任务，重置空闲时间
                if (agv != null && agv.AgvTask == task)
                {
                    agv.AgvTask = null;
                    agv.FreeTime = DateTime.Now;
                }
                //解锁站台
                if (agv != null && agv.LockStation != null)
                {
                    UpdateManage.UpdateAgvMsg(agv);
                    agv.LockStation = null;
                }
            }
            catch (Exception Ex)
            {
                App.ExFile.MessageError("TaskReset", Ex.ToString());
                return BllResult.Error(Ex.Message);
            }
            return BllResult.Success();
        }

        /// <summary>
        /// 把任务下发给AGV
        /// </summary>
        /// <returns></returns>
        public static void AgvGetTask()
        {
            try
            {
                foreach (var task in App.TaskList)
                {
                    CheckTask(task, out _);
                }
                //如果没有可用的小车，就不分解任务
                var existFreeAgv = App.AgvList.Any(t => t.IsEnable && t.IsOnline && t.AgvTask == null &&
                                                       (t.AgvState == EnumMsg.AGVState.自动空闲 || t.AgvState == EnumMsg.AGVState.充电中));
                if (!existFreeAgv)
                {
                    return;
                }

                #region 筛选可以执行的任务
                var excuteTaskList = App.TaskList.OrderByDescending(t => t.TaskLevel).ToList();
                //excuteTaskList = excuteTaskList.Where(task =>
                //{
                //    var flag = App.TaskList.Any(x => x.StartBarcode == task.EndBarcode && task.Target.In("P1001", "P1002"));
                //    if (flag)
                //    {
                //        task.TaskErrMsg = $"同输送线【{task.Target}】有出库任务，出库任务优先执行";
                //        return false;
                //    }
                //    return true;
                //}
                // ).ToList();
                #endregion

                #region 检查已经分配AGV的任务，如果小车不能用，不在线，就把分配的AGV编码改为空
                for (int index = 0; index < excuteTaskList.Count; index++)
                {
                    Base_Task task = excuteTaskList[index];
                    if (task.IsSubmit) continue;
                    if (task.TaskAgvNo == "") continue;
                    // 检查任务是否可以执行，是否无错误提示
                    if (!string.IsNullOrEmpty(task.TaskErrMsg)) continue;
                    //如果任务未提交，且已经分配AGV，但是AGV不能使用就删除任务分配的小车
                    Base_Agv? agv = App.AgvList.FirstOrDefault(a => a.AgvNo == task.TaskAgvNo);
                    if (agv == null)
                    {
                        task.TaskErrMsg = "指定的AGV【】不存在！任务无法执行！";
                        continue;
                    }
                    //如果是配送任务未下发，且分配的车不可用，就换车来执行
                    if (!agv.IsEnable || !agv.IsOnline)
                    {
                        continue;
                    }
                    //检查AGV是否有任务列表中不存在的任务，导致无法执行其他任务的情况
                    if (agv.AgvTask != null && !App.TaskList.Any(t => t.TaskNo == agv.AgvTask.TaskNo))
                    {
                        var msg = $"AGV存在任务【{agv.AgvTask.TaskNo}】，但是任务列表中不存在，任务无法拆解，AGV也无法执行其他任务！";
                        agv.StopReason = ComnMethod.GetStopReason(agv.StopReason, msg);
                        App.ExFile.MessageBusinessErr("AgvGetTask", msg);
                        agv.AgvTask = null;
                        continue;
                    }
                    //无任务、自动空闲时候才能处理任务
                    if (agv.AgvTask == null && agv.AgvState == EnumMsg.AGVState.自动空闲)
                    {
                        //// 当电量过低，就只能执行 行走避让 和 充电 任务
                        //if (task.TaskID != EnumMsg.TaskType.回家.ToString() && task.TaskID != EnumMsg.TaskType.充电.ToString() && agv.Voltage <= App.GetKeyValue("DangerCharge"))
                        //{
                        //    var msg = $"AGV【{agv.AgvNo}】的电量过低，只能执行【充电】和【行走】，无法执行【{task.TaskID}】任务【{task.TaskNo}】！";
                        //    task.TaskErrMsg = msg;
                        //    agv.StopReason = ComnMethod.GetStopReason(agv.StopReason, msg);
                        //    continue;
                        //}


                        // 当电量过低，就只能执行 行走避让 和 充电 任务
                        if (agv.Voltage <= App.GetKeyValue("DangerCharge") && task.TaskGroup != EnumMsg.TaskGroup.RCS单步任务.ToString())
                        {
                            var msg = $"AGV【{agv.AgvNo}】的电量过低，只能执行【充电】和【行走】，无法执行【{task.TaskType}】任务【{task.TaskNo}】！";
                            task.TaskErrMsg = msg;
                            agv.StopReason = ComnMethod.GetStopReason(agv.StopReason, msg);
                            continue;
                        }
                        //// 放货必须有货才行
                        //if (task.TaskID == EnumMsg.TaskType.放货.ToString() && agv.InStock == EnumMsg.InStock.全部无货)
                        //{
                        //    var msg = $"任务【{task.TaskNo}】不能下发，执行放货任务必须要有货，而是小车无货！";
                        //    task.TaskErrMsg = msg;
                        //    continue;
                        //}
                        //// 取货必须无货才行
                        //if (task.TaskID == EnumMsg.TaskType.取货.ToString() && agv.InStock != EnumMsg.InStock.全部无货)
                        //{
                        //    var msg = $"任务【{task.TaskNo}】不能下发，执行取货任务必须要无货，可是小车有货！";
                        //    task.TaskErrMsg = msg;
                        //    continue;
                        //}
                        TaskSubmit(task, agv);
                        return;
                    }
                    // 无任务、充电时候只能下发取消充电任务
                    if (agv.AgvTask == null && agv.AgvState == EnumMsg.AGVState.充电中)
                    {
                        if (task.TaskType != EnumMsg.TaskType.取消充电.ToString())
                        {
                            var msg = $"任务【{task.TaskNo}】不能下发，充电时候只能执行取消充电任务！";
                            task.TaskErrMsg = msg;
                            continue;
                        }
                        TaskSubmit(task, agv);
                        return;
                    }
                }
                #endregion

                #region 把【未分配AGV、未下发】的任务，分配执行的AGV，修改任务的下发状态改为ture，同时回传状态给上游系统，
                //找出【未停止、未提交给AGV、未分配AGV】的主任务，按照优先级排序
                List<Base_Task> tasks = excuteTaskList.Where(b => !b.IsSubmit && string.IsNullOrEmpty(b.TaskAgvNo))
                                                      .OrderByDescending(a => a.TaskLevel)
                                                      .ThenBy(x => x.AcceptTime)
                                                      .ToList();

                for (int index = 0; index < tasks.Count; index++)
                {
                    Base_Task task = tasks[index];
                    //未提交任务中是否有任务等级超过当前任务的
                    if (tasks.Find(a => a.TaskLevel > task.TaskLevel && task.TaskType == a.TaskType) is Base_Task _task)
                    {
                        task.TaskErrMsg = $"存在优先级更高的任务{_task.TaskNo}";
                        continue;
                    }
                    // 检查任务是否可以执行，不可以就写入错误提示
                    if (!CheckTask(task, out var agv)) continue;
                    if (agv != null)
                    {
                        TaskSubmit(task, agv);
                        return;
                    }
                    // 检查任务是否可以执行，是否无错误提示
                    if (!string.IsNullOrEmpty(task.TaskErrMsg)) continue;

                    //获取当前任务群组的所能派遣的小车任务群组
                    var agvGroups = App.TaskAgvGroupList.Where(t => t.TaskType == task.TaskGroup).Select(t => t.AgvGroup).ToList();
                    //根据任务起点或者终点来找AGV
                    agv = App.AgvList.FirstOrDefault(_agv =>
                       _agv.IsCanExecTask()
                       && (_agv.Barcode == task.StartPoint.Barcode || _agv.Barcode == task.StartPoint.PreBarcode)
                       && agvGroups.Contains(_agv.Group));
                    if (agv != null)
                    {
                        TaskSubmit(task, agv);
                        return;
                    }


                    // 根据起点查找最近的AGV
                    agv = ComnMethod.GetNearAgv(task.StartPoint, task);
                    if (agv != null)
                    {
                        TaskSubmit(task, agv);
                        return;
                    }
                }
                #endregion
            }
            catch (Exception ex)
            {
                App.ExFile.MessageError("TaskManage", $"任务获取小车发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}");
            }
        }

        /// <summary>
        /// 检查任务是否可以执行，不可以就写入错误提示
        /// </summary>
        /// <param name="task">主任务</param>
        /// <param name="agv">分配的AGV</param>
        /// <returns></returns>
        private static bool CheckTask(Base_Task task, out Base_Agv? agv)
        {
            agv = null;
            if (task.IsSubmit) return true;
            var isShield = App.GetKeyValue("IsShieldStationSignal");
            // 判断配送任务能否执行
            if (task.TaskType == EnumMsg.TaskType.输送线任务.ToString())
            {
                var initial = App.EquipmentList.FirstOrDefault(t => t.Name == task.Initial);
                if (initial != null)
                {
                    if (initial.Type == EnumPLC.EquipmentType.HuaHengStation.ToString())
                    {
                        var placeholder = initial[EnumPLC.PLCHuaHengProps.PickReady.ToString()];
                        if (isShield == 0 && placeholder != null && placeholder.Value == EnumPLC.PLCBool.False.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Initial}】无货，不能取货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】无货，不能取货！");
                            return false;
                        }
                    }
                }

                var target = App.EquipmentList.FirstOrDefault(t => t.Name == task.Target);
                if (target != null)
                {
                    if (target.Type == EnumPLC.EquipmentType.HuaHengStation.ToString())
                    {
                        var placeholder = target[EnumPLC.PLCHuaHengProps.PickReady.ToString()];
                        if (isShield == 0 && placeholder != null && placeholder.Value == EnumPLC.PLCBool.True.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Target}】有货，不能放货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Target}】有货，不能放货！");
                            return false;
                        }
                        //var acsPlaceholder = target[EnumPLC.ACSHuaHengProps.ACSPlaceholder.ToString()];
                        //if (acsPlaceholder != null && acsPlaceholder.Value != EnumPLC.ACSPlaceholder.无预占.GetIndexString())
                        //{
                        //    task.TaskErrMsg = $"站台【{task.Initial}】被预占，不能放货！";
                        //    //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】被预占，不能放货！");
                        //    return false;
                        //}
                    }
                }

                //同一个站台，如果有多个取货任务，那么需要等前面的取货完成，才能下发后面的。还有超过3个倒车行走，说明还没到取货站台附属点。         
                var pickTask = App.TaskList.FirstOrDefault(x => x.TaskNo != task.TaskNo && x.Initial == task.Initial &&
                                                                x.SubTaskList.Count(y => y.ActionType == EnumMsg.ActionType.倒车行走) > 3 &&
                                                               (x.TaskLevel > task.TaskLevel || (x.TaskLevel == task.TaskLevel && x.AcceptTime < task.AcceptTime)));
                if (pickTask != null)
                {
                    task.TaskErrMsg = $"要等前面任务【{pickTask.TaskNo}】先取站台【{task.Initial}】的货！";
                    return false;
                }
                #region 暂时注释，因为输送线可以扫码，放货顺序错误没关系，目前不会库位往库位放货
                ////同一个站台，如果有多个放货任务，那么需要等前面的放货完成，才能下发后面的。还有超过2个倒车行走，说明还没到放货站台附属点。
                //var putTask = App.TaskList.FirstOrDefault(x => x.TaskNo != task.TaskNo && x.Target == task.Target && 
                //                                               x.SubTaskList.Count(y => y.ActionType == EnumMsg.ActionType.倒车行走) > 1 &&
                //                                              (x.TaskLevel > task.TaskLevel || (x.TaskLevel == task.TaskLevel && x.AcceptTime < task.AcceptTime)));
                //if (putTask != null)
                //{
                //    task.TaskErrMsg = $"需要等待前面的任务【{putTask.TaskNo}】先放货！";
                //    return false;
                //}
                #endregion
            }

            else if (task.TaskType == EnumMsg.TaskType.出库区任务.ToString())
            {
                var endPoint = task.EndPoint!;
                var areaPoints = App.PointList.FindAll(x => x.RegionName == endPoint.RegionName && !string.IsNullOrEmpty(endPoint.RegionName));
                //校验任务的出库区域，防止多辆车跑去同一个管制区，导致卡死。
                var otherTasks = App.TaskList.Where(_task => areaPoints.Any(_point => _point.Barcode == _task.EndBarcode && _task.TaskNo != task.TaskNo));
                if (otherTasks.Any())
                {
                    var otherTask = otherTasks.FirstOrDefault(_task => _task.IsSubmit);

                    if (otherTask != null)
                    {
                        task.TaskErrMsg = $"要等前面任务【{otherTask.TaskNo}】在管制区【{endPoint.RegionName}】执行完毕";
                        return false;
                    }
                    //校验库位优先级
                    //巷道点，根据x值与巷道点的差值进行优先级判断
                    var judePoint = App.PointList.Find(x => x.Barcode == "720") ?? throw new Exception("巷道点查找失败");//先根据点位进行判断，后续可以按照点类型

                    //var flag = endPoint.IntY > judePoint.IntY && otherTasks.FirstOrDefault(_task => _task.EndPoint!.IntY > endPoint.IntY) is Base_Task otherTask1
                    //    || endPoint.IntY < judePoint.IntY && otherTasks.FirstOrDefault(_task => _task.EndPoint!.IntY < endPoint.IntY) is Base_Task otherTask2;

                    if (endPoint.IntX > judePoint.IntX && otherTasks.FirstOrDefault(_task => _task.EndPoint!.IntX > endPoint.IntX && _task.TaskNo != task.TaskNo) is Base_Task otherTask1)
                    {
                        task.TaskErrMsg = $"存在库位优先级别更高的任务，需要等待前面的任务【{otherTask1.TaskNo}】执行完毕";
                        return false;
                    }
                    else if (endPoint.IntX < judePoint.IntX && otherTasks.FirstOrDefault(_task => _task.EndPoint!.IntX < endPoint.IntX && _task.TaskNo != task.TaskNo) is Base_Task otherTask2)
                    {
                        task.TaskErrMsg = $"存在库位优先级别更高的任务，需要等待前面的任务【{otherTask2.TaskNo}】执行完毕";
                        return false;
                    }
                }
                //同一个站台，如果有多个取货任务，那么需要等前面的取货完成，才能下发后面的。还有超过2个倒车行走，说明还没到取货站台附属点。           
                var pickTask = App.TaskList.FirstOrDefault(x => x.TaskNo != task.TaskNo && x.Initial == task.Initial &&
                                                                x.SubTaskList.Count(y => y.ActionType == EnumMsg.ActionType.倒车行走) > 2 &&
                                                               (x.TaskLevel > task.TaskLevel || (x.TaskLevel == task.TaskLevel && x.AcceptTime < task.AcceptTime)));
                if (pickTask != null)
                {
                    task.TaskErrMsg = $"要等前面任务【{pickTask.TaskNo}】先取站台【{task.Initial}】的货！";
                    return false;
                }
                //校验agv
                var otherAgv = App.AgvList.Find(_agv => areaPoints.Any(_point => _point.Barcode == _agv.Barcode));
                if (otherAgv != null)
                {
                    if (otherAgv.AgvTask != null)
                    {
                        //task.TaskErrMsg = $"需要等待区域中agv【{otherAgv.AgvNo}】回家";
                        task.TaskErrMsg = $"需要等待区域中agv【{otherAgv.AgvNo}】任务执行完毕";
                        return false;
                    }
                    else if (!otherAgv.IsCanExecTask())
                    {
                        task.TaskErrMsg = $"区域中agv【{otherAgv.AgvNo}】状态不能执行任务，请检查agv是否异常";
                        return false;
                    }
                    else
                    {
                        agv = otherAgv;
                        return true;

                    }
                }

            }
            task.TaskErrMsg = string.Empty;
            return true;
        }

        /// <summary>
        /// 检查AGV是否可以执行任务，不可以就写入错误提示
        /// </summary>
        /// <param name="task">新任务</param>
        /// <param name="excutingTask">执行中主任务</param>
        /// <param name="agv">用来执行新任务的AGV</param>
        /// <returns></returns>
        private static bool CheckAgv(Base_Task task, Base_Agv agv)
        {
            //还有任务未执行完就不能执行任务
            if (agv.AgvTask != null)
            {
                return false;
            }
            //货叉必须在低位才能执行任务
            if (task.TaskType != EnumMsg.TaskType.上升到顶.ToString() && task.TaskType != EnumMsg.TaskType.下降到底.ToString() && agv.HeightState != EnumMsg.HeightState.低位)
            {
                task.TaskErrMsg = $"AGV顶升不在低位，不能执行任务！";
                return false;
            }
            if (!agv.IsNotHaveGoods())
            {
                if (task.EndPoint.PointType == EnumMsg.PointType.充电点 || task.EndPoint.PointType == EnumMsg.PointType.整体旋转点)
                {
                    task.TaskErrMsg = $"AGV有货的时候，不能去充电点、旋转点！";
                    return false;
                }
            }

            // 当电量过低，就只能执行 行走避让 和 充电 任务
            if (task.TaskGroup == EnumMsg.TaskGroup.RCS单步任务.ToString() && agv.Voltage <= App.GetKeyValue("DangerCharge"))
            {
                task.TaskErrMsg = $"AGV【{agv.AgvNo}】的电量过低，只能执行【充电】和【行走】等单步任务！";
                return false;
            }
            //有时候会出现并发问题，导致有任务还生成了行走避让，所以AGV不在行走任务的起点，就直接删除行走任务
            if (task.TaskType == EnumMsg.TaskType.普通行走.ToString())
            {
                if (task.StartBarcode != agv.Barcode)
                {
                    task.TaskState = EnumMsg.TaskState.自动删除;
                    TaskDelete(task);
                    return false;
                }
            }
            // 判断取货任务能否执行
            if (task.TaskType == EnumMsg.TaskType.输送线任务.ToString())
            {
                if (!agv.IsNotHaveGoods())
                {
                    task.TaskErrMsg = "执行任务必须要AGV无货！";
                    //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，执行取货任务必须要AGV无货！");
                    return false;
                }
            }
            // 充电时候只能下发取消充电任务
            if (agv.AgvState == EnumMsg.AGVState.充电中)
            {
                if (task.TaskType == EnumMsg.TaskType.取消充电.ToString())
                {
                    return true;
                }
                task.TaskErrMsg = "任务不能下发，充电时候只能执行取消充电任务！";
                return false;
            }

            return agv.AgvState == EnumMsg.AGVState.自动空闲;
        }

        /// <summary>
        /// 提交任务给AGV，并调用【任务回传】接口向上游系统回传状态
        /// </summary>
        /// <param name="task"></param>
        /// <param name="agv"></param>
        public static void TaskSubmit(Base_Task task, Base_Agv agv)
        {
            try
            {
                //BllResult result = BllResult.Sucess();
                ////维修房站台
                //var repairStation = App.StationList.FirstOrDefault(t => t.Name == "维修房");
                ////如果是要往维修房站台放货，就先写入【请求站台预占】信号
                //if (repairStation != null && task.Target == repairStation.Name)
                //{
                //    task.CommandSending = true;
                //    EquipmentExecutor.Instance.RequestOperator(repairStation.Name, EnumMsg.TaskRequestType.请求站台预占, true);
                //    Thread.Sleep(EquipmentExecutor.Instance.Delay);
                //    result = EquipmentExecutor.Instance.RequestOperator(repairStation.Name, EnumMsg.TaskRequestType.请求站台预占, true);
                //}
                //if (!result.Success)
                //{
                //    task.CommandSending = false;
                //    App.ExFile.MessageBusinessErr($"TaskSubmit", $"任务提交的时候，站台预先占位失败，{result.Msg}");
                //    return;
                //}

                BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                var updateresult = _taskDb.Update(it => it.TaskNo == task.TaskNo, it => new Base_Task()
                {
                    TaskErrMsg = "",
                    IsSubmit = true,
                    TaskAgvNo = agv.AgvNo,
                });
                if (updateresult.IsSuccess)
                {
                    //路径创建完成，返回任务执行中
                    task.TaskErrMsg = "";
                    task.IsSubmit = true;
                    task.TaskAgvNo = agv.AgvNo;
                    agv.AgvTask = task;
                }
                //task.CommandSending = false;
            }
            catch (Exception ex)
            {
                //if (task != null) task.CommandSending = false;
                App.ExFile.MessageError($"TaskManage", $"下发任务【{task.TaskNo}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}");
            }
        }

        /// <summary>
        /// 任务的分解
        /// </summary>
        public static void TaskSplit()
        {
            var taskList = App.TaskList.Where(a => a.IsSubmit && a.BeginTime == null && a.SubTaskList.Count == 0).ToList();
            var random = new Random();
            var _taskDb = new BaseDal<Base_Task>();
            var _sonTaskDb = new BaseDal<Base_SubTask>();

            for (var i = 0; i < taskList.Count; i++)
            {
                var task = taskList[i];
                try
                {
                    task.TaskErrMsg = string.Empty;
                    #region agv状态校验
                    var agv = App.AgvList.FirstOrDefault(x => x.AgvNo == task.TaskAgvNo);
                    if (agv == null)
                    {
                        task.TaskErrMsg = EnumMsg.ErrMsg.小车号不存在.ToString();
                        continue;
                    }
                    if (!agv.IsEnable || !agv.IsOnline)
                    {
                        task.TaskErrMsg = EnumMsg.ErrMsg.小车状态不合理.ToString();
                        continue;
                    }
                    var agvPoint = App.PointList.FirstOrDefault(x => x.Barcode == agv.Barcode);
                    if (agvPoint == null && App.GetKeyValue("IsTestMode") < 1)
                    {
                        task.TaskErrMsg = $"AGV点位【{agv.Barcode}】在地图中不存在！";
                        continue;
                    }
                    if (task.TaskType != EnumMsg.TaskType.取消充电.ToString() && agv.AgvState != EnumMsg.AGVState.自动空闲)
                    {
                        task.TaskErrMsg = EnumMsg.ErrMsg.小车状态不合理.ToString();
                        continue;
                    }
                    if (task.TaskType == EnumMsg.TaskType.取消充电.ToString() && agv.AgvState != EnumMsg.AGVState.充电中)
                    {
                        task.TaskErrMsg = EnumMsg.ErrMsg.小车状态不合理.ToString();
                        continue;
                    }
                    #endregion
                    var splitList = App.Config_TaskSplitList.Where(a => a.TaskType == task.TaskType).OrderBy(x => x.SerialNo).ToList();
                    if (splitList.Count == 0)
                    {
                        task.TaskErrMsg = EnumMsg.ErrMsg.分解任务未找到任务ID.ToString();
                        continue;
                    }

                    #region 站台方向校验,如果校验未通过，修改行走任务的方向
                    if (agv.AgvType != EnumMsg.AgvType.叉车)
                    {
                        if (App.GetKeyValue("IsAllowStationRotate") < 1
                            && App.StationList.Find(x => x.Barcode == agv.Barcode) is Base_Station station
                            //&& App.PointList.Find(x => x.Barcode == station.PreBarcode) is Base_Point prePoint
                            )
                        {

                            List<Config_TaskSplit> splitListTemp = [];
                            foreach (var item in splitList)
                            {
                                if (item.Clone() is Config_TaskSplit temp)
                                {
                                    splitListTemp.Add(temp);
                                }
                            }
                            splitList = splitListTemp;

                            var first = ComnMethod.GetFirstMoveSubTaskConfig(splitList);
                            if (first != null)
                            {
                                Direction preDirection = ComnMethod.GetPrePointDirection(station.Point) ?? 0;
                                var flag = agv.AgvDirection.ToString() != Direction.无方向.ToString()
                                   && agv.AgvDirection.ToString()[0] == preDirection.ToString()[0];
                                if (flag &&
                                    (agv.AgvDirection != preDirection && first.AgvTaskType == EnumMsg.ActionType.普通行走)
                                    || (agv.AgvDirection == preDirection && first.AgvTaskType == EnumMsg.ActionType.倒车行走))
                                {

                                    if (first.AgvTaskType == EnumMsg.ActionType.普通行走)
                                    {
                                        first.AgvTaskType = EnumMsg.ActionType.倒车行走;
                                        App.ExFile.MessageBusinessErr("TaskSplit", $"分解任务{task.TaskNo}时由于agv{agv.AgvNo}在站台，并且方向与站台方向不匹配修改任务类型为{first.AgvTaskType}");

                                    }
                                    else if (first.AgvTaskType == EnumMsg.ActionType.倒车行走)
                                    {
                                        first.AgvTaskType = EnumMsg.ActionType.普通行走;
                                        App.ExFile.MessageBusinessErr("TaskSplit", $"分解任务{task.TaskNo}时由于agv{agv.AgvNo}在站台，并且方向与站台方向不匹配修改任务类型为{first.AgvTaskType}");
                                    }
                                    else
                                    {
                                        App.ExFile.MessageBusinessErr("TaskSplit", $"分解任务{task.TaskNo}时由于agv{agv.AgvNo}在站台，并且方向与站台方向不匹配,并且无法修站台");
                                        //continue;
                                    }


                                    var second = new Config_TaskSplit()
                                    {
                                        SerialNo = first.SerialNo + 1,
                                        FromPoint = ConfigToFromPoint.当前点附属点,
                                        ToPoint = first.ToPoint,
                                        TaskType = first.TaskType,
                                        //ID = first.ID,
                                        IsCarry = first.IsCarry,
                                        TaskRequestType = RequestType.信号发送完成,
                                        AgvTaskType = ActionType.普通行走,
                                    };
                                    first.ToPoint = ConfigToFromPoint.当前点附属点;
                                    //后续任务序号加大
                                    splitList.FindAll(x => x.SerialNo > first.SerialNo).ForEach(x => x.SerialNo += 10);
                                    splitList.Add(second);
                                    splitList = splitList.OrderBy(x => x.SerialNo).ToList();
                                }

                            }
                        }
                    }


                    #endregion


                    //因为展厅激光配送第二条任务是倒退行走；新增判断小车当前点是否是站台,如果不是的话就不用执行倒退行走，分解任务时直接从第3步开始
                    if(task.TaskType == EnumMsg.TaskType.展厅激光配送.ToString() && agvPoint.PointType != PointType.站台点)
                    {
                        task.TaskSplitStep = 3;
                    }

                    //add by liaoyu on 20240805
                    if (task.TaskType == EnumMsg.TaskType.充电.ToString())
                    {
                        //如果车在充电点，就从第4步开始
                        if (task.EndBarcode == agv.Barcode)
                        {
                            var first = splitList
                                .FirstOrDefault(x => x.FromPoint == EnumMsg.ConfigToFromPoint.任务终点)
                                ?? throw new Exception($"充电任务{task.TaskNo}分解失败，任务终点不存在");
                            task.TaskSplitStep = first.SerialNo;
                        }

                    }

                    if (task.TaskType.Contains(EnumMsg.TaskType.物料入库.ToString())
                        || task.TaskType == EnumMsg.TaskType.物料出库.ToString())
                    {
                        //如果车在库位前置点，就从第4步开始
                        var endStation = App.StationList.Find(x => x.Barcode == agv.Barcode);
                        if (task.StartPoint.Barcode == agv.Barcode && endStation != null && !endStation.Name.StartsWith('P'))
                        {
                            var first = splitList
                               .FirstOrDefault(x => x.FromPoint == EnumMsg.ConfigToFromPoint.任务起点)
                               ?? throw new Exception($"充电任务{task.TaskNo}分解失败，任务起点不存在");
                            //可以更改为描述不写死：如取货后退行走
                            task.TaskSplitStep = first.SerialNo;
                        }
                    }

                    if (task.TaskType.Contains(EnumMsg.TaskType.回家.ToString()))
                    {
                        //如果车已经在终点，直接完成
                        if (task.EndBarcode == agv.Barcode)
                        {
                            taskList.RemoveAt(i);
                            i--;
                            continue;
                        }
                    }
                    int intNum = random.Next(99999) * 100;
                    var sonTaskList = new List<Base_SubTask>();
                    for (var j = 0; j < splitList.Count; j++)
                    {
                        var config = splitList[j];

                        if (config.SerialNo < task.TaskSplitStep)
                        {
                            continue;
                        }

                        //if(task.Initial == "P106" && agv.Barcode == "106")
                        //{
                        //    if (config.SerialNo == 4) continue;
                        //}

                        //if (agv.Barcode == "105" && task.Initial == "P105")
                        //{
                        //    if (config.SerialNo < 3) continue;
                        //}
                        //if (agv.Barcode == "108" && task.Initial == "P108")
                        //{
                        //    if (config.SerialNo < 3) continue;
                        //}

                        //if ((agv.Barcode != "105" || agv.Barcode != "108") && config.SerialNo == 1 && task.TaskType == EnumMsg.TaskType.展厅配送测试.ToString())
                        //{
                        //    continue;
                        //}

                        //if ((task.Initial == "P105" || task.Initial == "P108") && config.SerialNo == 4)
                        //{
                        //    continue;
                        //}
                        //if ((task.Target == "P105" || task.Target == "P108") && config.SerialNo == 11)
                        //{
                        //    continue;
                        //}


                        #region 配置的如果是起点、终点类型，那就根据任务计算出点位

                        Base_Point? startPoint = null;
                        Base_Point? endPoint = null;

                        if (Enum.IsDefined(typeof(EnumMsg.ConfigToFromPoint), config.FromPoint))
                        {
                            if (config.AgvTaskType == EnumMsg.ActionType.充电)
                            {
                                startPoint = task.EndPoint;
                            }
                            else
                            {
                                startPoint = ComnMethod.GetTaskPoint(task, config.FromPoint);
                            }
                        }
                        else
                        {
                            startPoint = App.PointList.FirstOrDefault(a => a.Barcode == config.FromPoint.GetIndexString());
                        }

                        if (Enum.IsDefined(typeof(EnumMsg.ConfigToFromPoint), config.ToPoint))
                        {
                            endPoint = ComnMethod.GetTaskPoint(task, config.ToPoint);
                        }
                        else
                        {
                            endPoint = App.PointList.FirstOrDefault(a => a.Barcode == config.ToPoint.GetIndexString());
                        }

                        if (startPoint == null || endPoint == null)
                        {
                            task.TaskErrMsg = EnumMsg.ErrMsg.分解任务未找到起点或终点.ToString();
                            break;
                        }

                        #endregion

                        #region 跨区域重新分配起点终点属性

                        var listPoints = new List<Base_Point>();
                        var subTaskState = EnumMsg.SubTaskState.等待建立路径;
                        if (config.FromPoint == EnumMsg.ConfigToFromPoint.等待分配 || config.ToPoint == EnumMsg.ConfigToFromPoint.等待分配)
                        {
                            subTaskState = EnumMsg.SubTaskState.等待分配终点;
                            listPoints.Add(startPoint);
                            listPoints.Add(endPoint);
                        }
                        else
                        {
                            listPoints = ComnMethod.GetAreaPoint(startPoint, endPoint);
                            if (listPoints == null)
                            {
                                task.TaskErrMsg = EnumMsg.ErrMsg.分解任务未找到起点或终点.ToString();
                                break;
                            }
                            //如果起点等于终点的行走任务，且询问状态大于任务完成，那就不生成这条子任务。
                            if (startPoint.Barcode == endPoint.Barcode && config.AgvTaskType == EnumMsg.ActionType.普通行走 && config.TaskRequestType > EnumMsg.RequestType.任务完成信号)
                            {
                                continue;
                            }
                        }
                        #endregion

                        #region 根据不同的情况取起升高度、充电距离
                        ushort height = 0;
                        // 如果子任务是充电、取消充电，那就找到站台，然后任务根据站台的方向、长度来设置子任务的车头方向和充电距离
                        if (config.AgvTaskType == EnumMsg.ActionType.充电 || config.AgvTaskType == EnumMsg.ActionType.取消充电)
                        {
                            var endStation = App.StationList.FirstOrDefault(a => a.Barcode == endPoint.Barcode && a.StationType == EnumMsg.StationType.充电桩);
                            if (endStation != null)
                            {
                                height = endStation.LowHeight;
                            }
                        }
                        //如果配送任务，并且是【升降到指定高度】动作，就要找出主任务的站台，然后去找到站台高度，记录到子任务的高度中 
                        if (config.AgvTaskType == EnumMsg.ActionType.升降到指定高度)
                        {
                            var stationName = string.Empty;
                            if (config.FromPoint == EnumMsg.ConfigToFromPoint.任务起点 || config.FromPoint == EnumMsg.ConfigToFromPoint.起点站台附属点)
                            {
                                stationName = task.Initial;
                            }
                            if (config.FromPoint == EnumMsg.ConfigToFromPoint.任务终点 || config.FromPoint == EnumMsg.ConfigToFromPoint.终点站台附属点)
                            {
                                stationName = task.Target;
                            }
                            var startStation = App.StationList.Find(x => x.Name == stationName && x.StationType != EnumMsg.StationType.充电桩);
                            if (startStation != null)
                            {
                                //取货完成要高位高度出来
                                if (config.FromPoint == EnumMsg.ConfigToFromPoint.任务起点)
                                {
                                    height = startStation.HighHeight;
                                }
                                //取货进去要低位高度进去
                                if (config.FromPoint == EnumMsg.ConfigToFromPoint.起点站台附属点)
                                {
                                    if (j < splitList.Count - 1 && splitList[j + 1].ToPoint == EnumMsg.ConfigToFromPoint.任务起点)
                                    {
                                        height = startStation.LowHeight;
                                    }
                                }
                                //放货结束要低位高度出来
                                if (config.FromPoint == EnumMsg.ConfigToFromPoint.任务终点)
                                {
                                    height = startStation.LowHeight;
                                }
                                //取货完成要高位高度出来
                                if (config.FromPoint == EnumMsg.ConfigToFromPoint.终点站台附属点)
                                {
                                    if (j < splitList.Count - 1 && splitList[j + 1].ToPoint == EnumMsg.ConfigToFromPoint.任务终点)
                                    {
                                        height = startStation.HighHeight;
                                    }
                                }
                            }
                            //如果没有计算出高度，就获取配置的高度
                            if (height == 0 && config.Height > 0)
                            {
                                height = (ushort)config.Height;
                            }
                            if (height == 0 && App.GetKeyValue("IsShieldStationHeight") == 0)
                            {
                                task.TaskErrMsg = EnumMsg.ErrMsg.获取货架高度失败.ToString();
                                break;
                            }
                        }

                        #endregion


                        #region 实例化子任务，并且添加到数据库
                        var sonTask = new Base_SubTask();
                        if (task.TaskType.In(EnumMsg.ActionType.升降到指定高度.ToString(), EnumMsg.ActionType.旋转.ToString(), EnumMsg.ActionType.转盘旋转.ToString()))
                        {
                            height = (ushort)task.HeightOrAngle;
                            sonTask.Angle = (short)task.HeightOrAngle;
                        }
                        sonTask.ActionType = config.AgvTaskType;
                        sonTask.StartPoint = listPoints.First();
                        sonTask.EndPoint = listPoints.Last();
                        sonTask.StartBarcode = sonTask.StartPoint.Barcode;
                        sonTask.EndBarcode = sonTask.EndPoint.Barcode;
                        sonTask.SerialNo = config.SerialNo;
                        sonTask.SubTaskNo = (uint)(intNum + config.SerialNo);
                        sonTask.TaskNo = task.TaskNo;
                        sonTask.TaskId = task.ID;
                        sonTask.Height = height;
                        sonTask.WaitTime = config.WaitTime;
                        sonTask.IsCarry = config.IsCarry;
                        sonTask.RequestType = config.TaskRequestType;
                        sonTask.PathPointList = new List<Base_PathPoint>();
                        sonTask.SubTaskState = subTaskState;
                        sonTask.TaskStage = config.TaskStage;
                        sonTask.ConfigTaskSplit = config;
                        sonTask.BeginTime = null;
                        sonTask.EndTime = null;
                        sonTaskList.Add(sonTask);
                        #endregion
                    }

                    if (!string.IsNullOrEmpty(task.TaskErrMsg))
                    {
                        continue;
                    }

                    #region 添加子任务到任务中，更新任务开始时间，并且更新任务和子任务到数据库

                    //将拆解的任务插入到子任务表中，并且更新主任务表的开始时间
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        foreach (Base_SubTask getSonTask in sonTaskList)
                        {
                            task.SubTaskList.Add(getSonTask);
                        }
                        task.BeginTime = DateTime.Now;
                    }));

                    //更新数据库
                    _taskDb.BeginTran();
                    //var insertResult = _sonTaskDb.Insert(sonTaskList);
                    for (int z = 0; z < sonTaskList.Count; z++)
                    {

                        var insertResult = _sonTaskDb.Insert(sonTaskList[z]);
                        if (!insertResult.IsSuccess)
                        {
                            var msg = $"拆解任务【{task}】生成子任务的时候，插入数据库失败，插入子任务：{insertResult.Message}";

                            throw new Exception(msg);
                        }
                    }
                    var updateResult = _taskDb.Update(it => it.TaskNo == task.TaskNo,
                                                      it => new Base_Task()
                                                      {
                                                          BeginTime = task.BeginTime
                                                      });
                    if (!updateResult.IsSuccess)
                    {
                        var msg = $"拆解任务【{task}】生成子任务的时候，插入数据库失败，修改主任务状态： {updateResult.Message}";
                        throw new Exception(msg);
                    }
                    _taskDb.CommitTran();
                    //else
                    //{
                    //    _taskDb.RollbackTran();
                    //    App.AppDispatcher.Invoke(new Action(() =>
                    //    {
                    //        task.BeginTime = null;
                    //        task.SubTaskList.Clear();
                    //    }));
                    //    var msg = $"拆解任务【{task}】生成子任务的时候，插入数据库失败，插入子任务：{insertResult.Message}，修改主任务状态： {updateResult.Message}";
                    //    App.ExFile.MessageError("TaskSplit", msg);
                    //}
                    #endregion
                }
                catch (Exception ex)
                {
                    var msg = $"拆解任务【{task}】生成子任务的时候，发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                    _taskDb.RollbackTran();
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        task.BeginTime = null;
                        task.SubTaskList.Clear();
                    }));
                    App.ExFile.MessageError("TaskSplit", msg);
                }
            }
        }

        /// <summary>
        /// 为路径被卡住，建立路径失败的子任务，增加一条行走子任务，来避让其他任务。
        /// </summary>
        public static void AvoidSubTask()
        {
            // 建立路径失败的子任务
            var task = App.TaskList.FirstOrDefault(x => x.BeginTime != null && x.SubTaskList.Count > 0 &&
                                                        x.SubTaskList[0].SubTaskState == EnumMsg.SubTaskState.建立路径失败 &&
                                                        x.SubTaskList[0].ActionType == EnumMsg.ActionType.普通行走);
            if (task == null) return;
            var agv = App.AgvList.FirstOrDefault(x => x.AgvNo == task.TaskAgvNo);
            if (agv == null || string.IsNullOrEmpty(agv.Barcode))
            {
                return;
            }
            //如果是一个手动行走或是充电任务被阻挡，导致任务建立路径失败，就删除充电任务
            if (task.TaskType == EnumMsg.TaskType.普通行走.ToString() || task.TaskType == EnumMsg.TaskType.充电.ToString())
            {
                task.TaskState = EnumMsg.TaskState.自动删除;
                TaskDelete(task);
                return;
            }

            // 已经建立路径的子任务
            var taskExecuting = App.TaskList.FirstOrDefault(x => x.BeginTime != null && x.SubTaskList.Count > 0 &&
                                                                 x.SubTaskList[0].SubTaskState >= EnumMsg.SubTaskState.已建立路径 &&
                                                                 x.SubTaskList[0].ActionType == EnumMsg.ActionType.普通行走);
            if (taskExecuting == null) return;
            //如果是一个手动行走或是充电任务阻挡了路径生成，就删除充电任务
            if (taskExecuting.TaskType == EnumMsg.TaskType.普通行走.ToString() || taskExecuting.TaskType == EnumMsg.TaskType.充电.ToString())
            {
                task.TaskState = EnumMsg.TaskState.自动删除;
                TaskDelete(taskExecuting);
                return;
            }

            var homeBarcode = ComnMethod.GetHomeBarcode(taskExecuting, agv);
            if (string.IsNullOrEmpty(homeBarcode) || homeBarcode == agv.Barcode)
            {
                return;
            }

            //新建一条避让的子任务
            Base_SubTask newSubTask = new Base_SubTask();
            newSubTask.ActionType = EnumMsg.ActionType.普通行走;
            newSubTask.StartPoint = App.PointList.First(x => x.Barcode == agv.Barcode);
            newSubTask.EndPoint = App.PointList.First(x => x.Barcode == homeBarcode);
            newSubTask.StartBarcode = newSubTask.StartPoint.Barcode;
            newSubTask.EndBarcode = newSubTask.EndPoint.Barcode;
            newSubTask.SerialNo = 99;
            newSubTask.SubTaskNo = App.AvoidSubTaskNo;
            newSubTask.TaskNo = task.TaskNo;
            newSubTask.WaitTime = 0;
            newSubTask.IsCarry = false;
            newSubTask.RequestType = EnumMsg.RequestType.信号发送完成;
            newSubTask.Height = 0;
            newSubTask.PathPointList = new List<Base_PathPoint>();
            newSubTask.SubTaskState = EnumMsg.SubTaskState.等待建立路径;
            newSubTask.BeginTime = null;
            newSubTask.EndTime = null;

            App.AppDispatcher.Invoke(new Action(() =>
            {
                //将建立路径失败的子任务，修改为初始化
                var subTask = task.SubTaskList[0];
                subTask.SubTaskState = EnumMsg.SubTaskState.等待建立路径;
                subTask.StartPoint = newSubTask.EndPoint;
                subTask.StartBarcode = subTask.StartPoint.Barcode;

                //插入到第一条，用来执行避让，先让开路径，让另外的任务可以继续执行。
                task.SubTaskList.Insert(0, newSubTask);
            }));
        }

        /// <summary>
        /// 重新分配子任务的终点信息
        /// </summary>
        public static BllResult RedistributionSubTaskEndStation(Base_Task task, string stationName)
        {
            var station = App.StationList.Find(x => x.Barcode == stationName);
            if (station == null) return BllResult.Error($"站台{stationName}不存在");
            Base_Point point = App.PointList.Find(x => x.Barcode == station.Barcode) ?? throw new Exception($"点{station.Barcode}不存在");
            var subTasks = task.SubTaskList.Where(x => x.ConfigTaskSplit?.ToPoint == ConfigToFromPoint.等待分配 || x.ConfigTaskSplit?.FromPoint == ConfigToFromPoint.等待分配);
            foreach (var subTask in subTasks)
            {
                if (subTask.EndBarcode.IsNullOrEmpty())
                {
                    subTask.EndPoint = point;
                }
                if (subTask.StartBarcode.IsNullOrEmpty())
                {
                    subTask.StartPoint = point;
                }
            }
            task.EndPoint = point;
            return BllResult.Success();

        }
        /// <summary>
        /// 子任务任务完成
        /// </summary>
        /// <param name="clientMsg"></param>
        /// <returns></returns>
        public static BllResult SonTaskFinish(Base_Agv agv)
        {
            try
            {
                if (agv.AgvTask == null || agv.AgvTask.SubTaskList.Count == 0)
                {
                    var msg = $"完成第一条子任务失败，子任务为空，不能完成！";
                    App.ExFile.MessageError("SonTaskFinish", msg);
                    return BllResult.Error(msg);
                }
                Base_SubTask sonTask = agv.AgvTask.SubTaskList.First();
                BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                BaseDal<Base_SubTask> _sonTaskDb = new BaseDal<Base_SubTask>();
                BaseDal<Base_PathPoint> _pathPointDb = new BaseDal<Base_PathPoint>();

                //更新子任务,删除路径
                BllResult deleteresult1 = BllResult.Success();
                _sonTaskDb.BeginTran();
                BllResult deleteresult2 = _pathPointDb.Delete(it => it.SubTaskNo == sonTask.SubTaskNo);
                BllResult deleteresult3 = _sonTaskDb.Delete(it => it.SubTaskNo == sonTask.SubTaskNo);
                //如果是最后一条子任务，就把主任务也删除
                if (agv.AgvTask.SubTaskList.Count == 1)
                {
                    deleteresult1 = _taskDb.Delete(it => it.TaskNo == agv.AgvTask.TaskNo);
                }
                if (deleteresult1.IsSuccess && deleteresult2.IsSuccess && deleteresult3.IsSuccess)
                {
                    _sonTaskDb.CommitTran();
                    sonTask.EndTime = DateTime.Now;
                    //sonTask.SubTaskState = EnumMsg.SubTaskState.自动完成;

                    #region 插入子任务历史记录表
                    try
                    {
                        //新增任务历史表数据的插入
                        BaseDal<Log_SubTask> _logSubTaskDb = new BaseDal<Log_SubTask>();
                        Log_SubTask logSubTask = new Log_SubTask();

                        //logSubTask.ID = sonTask.ID;
                        logSubTask.TaskNo = sonTask.TaskNo;
                        logSubTask.SerialNo = sonTask.SerialNo;
                        logSubTask.SubTaskNo = sonTask.SubTaskNo;
                        logSubTask.ActionType = sonTask.ActionType;
                        logSubTask.Height = sonTask.Height;
                        logSubTask.WaitTime = sonTask.WaitTime;
                        logSubTask.IsCarry = sonTask.IsCarry;
                        logSubTask.RequestType = sonTask.RequestType;
                        logSubTask.StartPoint = sonTask.StartPoint;
                        logSubTask.EndPoint = sonTask.EndPoint;
                        logSubTask.StartBarcode = sonTask.StartBarcode;
                        logSubTask.EndBarcode = sonTask.EndBarcode;
                        logSubTask.BeginTime = sonTask.BeginTime;
                        logSubTask.EndTime = sonTask.EndTime;
                        logSubTask.SubTaskState = sonTask.SubTaskState;
                        //更新数据库
                        var insertresultSubTask = _logSubTaskDb.Insert(logSubTask);
                        if (!insertresultSubTask.IsSuccess)
                            throw new Exception(insertresultSubTask.Message);
                    }
                    catch (Exception ex)
                    {
                        var msg = $"完成第一条子任务失败，插入子任务历史记录表任务完成发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                        App.ExFile.MessageError("subTaskManage", msg);
                    }
                    #endregion

                    #region 插入主任务历史记录表
                    if (agv.AgvTask.SubTaskList.Count == 1)
                    {
                        try
                        {
                            Log_Task Logtask = new Log_Task();
                            //Logtask.ID = agv.AgvTask.ID;
                            Logtask.TaskNo = agv.AgvTask.TaskNo;
                            Logtask.TaskType = agv.AgvTask.TaskType;
                            Logtask.TaskGroup = agv.AgvTask.TaskGroup;
                            Logtask.TaskLevel = agv.AgvTask.TaskLevel;
                            Logtask.TaskSplitStep = agv.AgvTask.TaskSplitStep;
                            Logtask.TaskAgvNo = agv.AgvTask.TaskAgvNo;
                            Logtask.IsSubmit = agv.AgvTask.IsSubmit;
                            Logtask.TaskPallet = agv.AgvTask.TaskPallet;
                            Logtask.Initial = agv.AgvTask.Initial;
                            Logtask.Target = agv.AgvTask.Target;
                            Logtask.StartPoint = agv.AgvTask.StartPoint;
                            Logtask.EndPoint = agv.AgvTask.EndPoint;
                            Logtask.StartBarcode = agv.AgvTask.StartBarcode;
                            Logtask.EndBarcode = agv.AgvTask.EndBarcode;
                            Logtask.AcceptTime = agv.AgvTask.AcceptTime;
                            Logtask.BeginTime = agv.AgvTask.BeginTime;
                            Logtask.EndTime = DateTime.Now;
                            Logtask.TaskErrMsg = agv.AgvTask.TaskErrMsg;
                            Logtask.Direction = agv.AgvTask.Direction;
                            Logtask.TaskState = EnumMsg.TaskState.自动完成;
                            //更新数据库
                            BaseDal<Log_Task> _logtaskDb = new BaseDal<Log_Task>();
                            var insertresultTask = _logtaskDb.Insert(Logtask);
                        }
                        catch (Exception ex)
                        {
                            var msg = $"完成第一条子任务失败，插入主任务历史记录表任务完成发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                            App.ExFile.MessageError("subTaskManage", msg);
                        }
                    }

                    #endregion
                }
                else
                {
                    _sonTaskDb.RollbackTran();
                    var msg = $"完成第一条子任务失败，删除任务和路径失败，原因：{deleteresult1.Message}  {deleteresult2.Message}  {deleteresult3.Message}";
                    App.ExFile.MessageError("SonTaskFinish", msg);
                    return BllResult.Error(msg);
                }
                //取消充电后，要解锁充电桩
                if (sonTask.ActionType == EnumMsg.ActionType.取消充电 && agv.LockStation != null)
                {
                    var station = App.StationList.FirstOrDefault(a => a.Name == agv.LockStation?.Name);
                    if (station != null)
                    {
                        station.IsLocked = false;
                        UpdateManage.UpdateStation(station);
                    }
                    agv.LockStation = null;
                }

                //取消充电后，要解锁充电桩
                if (sonTask.ActionType == EnumMsg.ActionType.取消充电 && agv.LockStation != null)
                {
                    var station = App.StationList.FirstOrDefault(a => a.Name == agv.LockStation?.Name);
                    if (station != null)
                    {
                        station.IsLocked = false;
                        UpdateManage.UpdateStation(station);
                    }
                    agv.LockStation = null;
                }

                if (agv.AgvTask.SubTaskList.Count == 1)
                {
                    #region 告知WEB界面任务完成

                    //var ToWeb = WebApiClient.ToWebTaskRefresh(task, 99);

                    #endregion 告知WEB界面任务完成

                    //更新任务里程
                    UpdateManage.InsertAgvMilage(agv.AgvTask);
                    //20180925
                    //更新充电记录
                    if (sonTask.ActionType == EnumMsg.ActionType.充电 || sonTask.ActionType == EnumMsg.ActionType.取消充电)
                    {
                        if (agv.AgvTask.TaskType == "充电")
                        {
                            agv.ChargeTime = DateTime.Now;
                        }
                        agv.StartVoltage = agv.Voltage;
                        //充电任务结束,记录开始充电电量
                        UpdateManage.InsertAgvCharge(agv.AgvTask);
                    }
                    //更新界面
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        App.TaskList.Remove(agv.AgvTask);
                        agv.PathPointList.Clear();
                        agv.AgvTask.SubTaskList.RemoveAt(0);
                        agv.AgvTask = null;
                        agv.FreeTime = DateTime.Now;
                        //agv.ChooseStation = "";
                        agv.Milage = 0;
                    }));
                    UpdateManage.UpdateAgv(agv);
                }
                else
                {
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        agv.PathPointList.Clear();
                        agv.AgvTask.SubTaskList.RemoveAt(0);
                    }));
                }
                return BllResult.Success("完成第一条子任务成功！");
            }
            catch (Exception ex)
            {
                var msg = $"完成第一条子任务发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageError("TaskManage", msg);
                return BllResult.Error(msg);
            }
        }

        public static string GetTaskType(Base_Point fromPoint, Base_Point toPoint)
        {
            if (fromPoint.GetArea() != toPoint.GetArea())
                throw new Exception("任务不能跨区");
            var endStation = App.StationList.FirstOrDefault(x => x.Barcode == toPoint.Barcode);

            if (endStation != null && endStation.Name.In("P1001", "P1002"))
            {
                return EnumMsg.TaskType.物料入库.ToString();
            }
            return EnumMsg.TaskType.物料出库.ToString();
        }
        #region 测试任务

        /// <summary>
        /// 循环行走任务
        /// </summary>
        public static void WalkTask()
        {
            try
            {
                foreach (var crcleTask in App.ManualCycleList)
                {
                    string fromBarcode = crcleTask.FromBarcode;
                    string toBarcode = crcleTask.ToBarcode;
                    string strTaskID = crcleTask.TaskType;
                    string agvNo = crcleTask.AgvNo;
                    if (agvNo != string.Empty)
                    {
                        Base_Agv agv = App.AgvList.FirstOrDefault(b => b.AgvNo == agvNo);
                        //if (agv.AgvState != EnumMsg.State.自动空闲) continue;
                        Base_Task fTask = App.TaskList.FirstOrDefault(a => a.IsSubmit && a.TaskAgvNo == agv.AgvNo);
                        #region 注释间隔时间
                        //int intTaskTime = 0;
                        //if (agv.taskTime != DateTime.MinValue)
                        //{
                        //    TimeSpan ts1 = new TimeSpan(agv.taskTime.Ticks);
                        //    TimeSpan ts2 = new TimeSpan(DateTime.Now.Ticks);
                        //    TimeSpan ts3 = ts2.Subtract(ts1).Duration();
                        //    intTaskTime = ts3.Minutes * 60 + ts3.Seconds;
                        //}
                        //if (intTaskTime < App.TaskTime) continue;
                        #endregion

                        if (fTask == null)
                        {
                            if (agv.Barcode == toBarcode)
                            {
                                fromBarcode = toBarcode;
                                toBarcode = fromBarcode;
                            }
                            TaskBuild(strTaskID, "", "", 1, agv.AgvNo, agv.Barcode, toBarcode, "", "", "");
                        }
                    }
                    else
                    {
                        var fTask = App.TaskList.Where(a => a.TaskType == strTaskID).ToList();
                        if (fTask.Count != 0)
                        {
                            if (fTask.Count == 1 && fTask[0].IsSubmit)
                            {
                                //判断当前任务起点和终点
                                fromBarcode = fTask[0].EndBarcode;
                                toBarcode = fTask[0].StartBarcode;
                            }
                            else
                            {
                                continue;
                            }
                        }
                        TaskBuild(strTaskID, "", "", 1, "", fromBarcode, toBarcode, "", "", "");
                    }
                }
            }
            catch (Exception ex)
            {
                ComnMethod.Message(ex.ToString());
            }
        }



        public static void AddRadomTasks(Base_Agv? agv, List<string>? taskTypes)
        {
            string? taskType = null;
            if (taskTypes != null)
            {
                taskType = taskTypes.Get(new Random().Next(taskTypes.Count));
            }

            if (string.IsNullOrEmpty(taskType))
            {
                if (new Random().Next(2) == 1)
                {
                    taskType = EnumMsg.TaskType.输送线任务.ToString();
                }
                else
                {
                    taskType = EnumMsg.TaskType.出库区任务.ToString();
                }
            }
            for (int i = 0; i < 3; i++)
            {
                List<string> startPoints;
                List<string> endPoints;
                var cc = App.StationList.FindAll(x => x.StationType == EnumMsg.StationType.工位 && x.Name.StartsWith("D"));
                var localtion = App.StationList.FindAll(x => x.StationType == EnumMsg.StationType.工位 && !x.Name.StartsWith("D"));

                if (taskType == EnumMsg.TaskType.输送线任务.ToString())
                {
                    if (new Random().Next(2) == 1)
                    {
                        startPoints = cc.Select(x => x.Code).ToList();
                        endPoints = localtion.Select(x => x.Code).ToList();
                    }
                    else
                    {
                        startPoints = localtion.Select(x => x.Code).ToList();
                        endPoints = cc.Select(x => x.Code).ToList();
                    }
                }
                //地面库任务
                else
                {
                    startPoints = localtion.Select(x => x.Code).ToList();
                    endPoints = App.PointList.FindAll(x => (x.IntX >= 3 && x.IntX < 17 || x.IntX > 23 && x.IntX <= 18)
                                && x.IntY >= 995 && x.IntY <= 997).Select(x => x.Barcode).ToList();
                }

                if (startPoints.Count == 0 || endPoints.Count == 0) return;

                var index = new Random().Next(startPoints.Count);
                var startPoint = startPoints[index];
                index = new Random().Next(endPoints.Count);
                var endPoint = endPoints[index];

                var startStation = App.StationList.Find(x => x.Barcode == startPoint);
                var endStation = App.StationList.Find(x => x.Barcode == endPoint);
                //是否屏蔽交互信号
                var isShield = App.GetKeyValue("IsShieldStationSignal");
                if (isShield == 0)
                {
                    if (startStation != null && endStation != null)
                    {
                        var startEquipment = App.EquipmentList.Find(x => x.Code == startPoint);
                        var endEquipment = App.EquipmentList.Find(x => x.Code == endPoint);

                        if (startEquipment != null && startEquipment![EnumPLC.PLCHuaHengProps.PickReady.ToString()].Value != EnumPLC.PLCBool.True.ToString()
                            || endEquipment != null && endEquipment![EnumPLC.PLCHuaHengProps.PickReady.ToString()].Value == EnumPLC.PLCBool.True.ToString())
                        {
                            continue;
                        }
                    }
                }



                TaskBuild(taskType, EnumMsg.TaskGroup.RCS复合任务.ToString(), "1", 1, agv?.AgvNo, startPoint, endPoint, "", startStation!.Name, endStation?.Name ?? endPoint);
                break;
            }

        }


        public static void AddRadomTasks(Base_Agv? agv, List<string>? taskTypes, bool flag)
        {


            var getTaskInitAndTarget = (string taskType) =>
            {
                List<string> startPoints;
                List<string> endPoints;
                var res = ComnMethod.ByTaskTypeGetStation(taskType);
                if (taskType == TaskType.物料入库.ToString())
                {
                    startPoints = res.Select(x => x.Barcode).ToList();
                    endPoints = res.Where(x => x.Name.In("P1001", "P1002")).Select(x => x.Barcode).ToList();
                }
                else
                {
                    startPoints = res.Select(x => x.Barcode).ToList();
                    endPoints = res.Where(x => !x.Name.In("P1001", "P1002")).Select(x => x.Barcode).ToList();
                }

                return (startPoints, endPoints);
            };

            var isTaskCanExec = (string startStation, string endStation) =>
            {

                //是否屏蔽交互信号
                var isShield = App.GetKeyValue("IsShieldStationSignal");
                if (isShield == 0)
                {
                    if (startStation != null && endStation != null)
                    {
                        var startEquipment = App.EquipmentList.Find(x => x.Name == startStation);
                        var endEquipment = App.EquipmentList.Find(x => x.Name == endStation);

                        if (startEquipment != null && startEquipment![EnumPLC.PLCHuaHengProps.PickReady]?.Value != EnumPLC.PLCBool.True.ToString())
                        {
                            return false;
                        }
                        else if (endEquipment != null && endEquipment![EnumPLC.PLCHuaHengProps.PickReady]?.Value == EnumPLC.PLCBool.True.ToString())
                        {
                            return false;
                        }
                        //if (startEquipment == null || endEquipment == null) throw new Exception("添加随机任务时起点或者终点的设备不存在");
                        //if ( startEquipment![EnumPLC.PLCHuaHengProps.PickReady]?.Value != EnumPLC.PLCBool.True.ToString()
                        //    || endEquipment![EnumPLC.PLCHuaHengProps.PickReady]?.Value == EnumPLC.PLCBool.True.ToString())
                        //{
                        //    return false;
                        //}
                    }
                }

                return true;
            };
            AddRadomTasks(agv, taskTypes, getTaskInitAndTarget, isTaskCanExec);


        }



        /// <summary>
        /// 
        /// </summary>
        /// <param name="agv"></param>
        /// <param name="taskTypes"></param>
        /// <param name="GetTaskInitAndTarget">根据任务类型获取终点</param>
        /// <param name="IsTaskCanExec">根据起点与终点判断任务是否能执行</param>
        public static void AddRadomTasks(Base_Agv? agv, List<string>? taskTypes, Func<string, (List<string>, List<string>)> GetTaskInitAndTarget, Func<string, string, bool> IsTaskCanExec)
        {
            string? taskType = null;
            if (taskTypes != null)
            {
                taskType = taskTypes.Get(new Random().Next(taskTypes.Count));
            }

            if (taskType == null)
                return;

            for (int i = 0; i < 3; i++)
            {
                (var startPoints, var endPoints) = GetTaskInitAndTarget(taskType);

                if (startPoints.Count == 0 || endPoints.Count == 0) return;

                var radom = new Random();
                var startPointBarcode = startPoints[radom.Next(startPoints.Count)];
                endPoints = endPoints.FindAll(x => x != startPointBarcode);
                var endPointBarcode = endPoints[radom.Next(endPoints.Count)];

                var startStation = App.StationList.Find(x => x.Barcode == startPointBarcode) ?? throw new Exception($"随机任务生成，点位{startPointBarcode}对应站台不存在");
                var endStation = App.StationList.Find(x => x.Barcode == endPointBarcode) ?? throw new Exception($"随机任务生成，点位{endPointBarcode}对应站台不存在"); ;

                if (!IsTaskCanExec(startStation.Name, endStation.Name))
                    continue;

                TaskBuild(taskType, EnumMsg.TaskGroup.RCS复合任务.ToString(), "1", 1, agv?.AgvNo, startPointBarcode, endPointBarcode, "", startStation!.Name, endStation?.Name ?? endPointBarcode);
                break;
            }

        }



        #endregion 测试任务
    }

    public class TaskBuildDto
    {
        public TaskBuildDto()
        {
        }
        public TaskBuildDto(string taskType)
        {
            TaskType = taskType;
        }
        public TaskBuildDto(string taskType, int taskLevel, string? startBarcode, string endBarcode, string? startStationName, string? endStationName, short heightOrAngle)
        {
            TaskType = taskType;
            TaskLevel = taskLevel;
            StartBarcode = startBarcode;
            EndBarcode = endBarcode;
            StartStationName = startStationName;
            EndStationName = endStationName;
            HeightOrAngle = heightOrAngle;
        }

        public string TaskType { get; set; }
        public string? TaskGroup { get; set; }
        public string TaskPalletNo { get; set; } = string.Empty;
        public int TaskLevel { get; set; }
        public string? AgvNo { get; set; }
        public string? StartBarcode { get; set; }
        public string? EndBarcode { get; set; }
        public string? TaskNo { get; set; }
        public string? StartStationName { get; set; }
        public string? EndStationName { get; set; }
        public short HeightOrAngle { get; set; } = 0;
    }
}