#region << 版 本 注 释 >>
/*----------------------------------------------------------------
 * 命名空间：WIDESEA_TaskInfoService
 * 创建者：胡童庆
 * 创建时间：2024/8/2 16:13:36
 * 版本：V1.0.0
 * 描述：
 *
 * ----------------------------------------------------------------
 * 修改人：
 * 修改时间：
 * 版本：V1.0.1
 * 修改说明：
 * 
 *----------------------------------------------------------------*/
#endregion << 版 本 注 释 >>

using Autofac.Core;
using AutoMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Org.BouncyCastle.Math.EC;
using SixLabors.ImageSharp;
using SqlSugar;
using System.ComponentModel;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.Log;
using WIDESEA_Common.OtherEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Utilities;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.Task;
using WIDESEA_IBasicService;
using WIDESEA_IInboundService;
using WIDESEA_IOutboundService;
using WIDESEA_IRecordService;
using WIDESEA_IStockService;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService : ServiceBase<Dt_Task, IRepository<Dt_Task>>, ITaskService
    {
        private readonly ILogger<TaskService> _logger;
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IStockInfoService _stockInfoService;
        private readonly ILocationInfoService _locationInfoService;
        private readonly IWarehouseService _warehouseService;
        private readonly IRoadWayinfoService _roadWayinfoService;
        private readonly ITask_HtyService _task_HtyService;
        private Timer _timer;
        public IRepository<Dt_Task> Repository => BaseDal;

        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
                {nameof(Dt_Task.Grade),OrderByType.Desc },
                {nameof(Dt_Task.CreateDate),OrderByType.Asc},
            };

        public List<int> TaskTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public TaskService(ILogger<TaskService> logger, IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, ILocationInfoService locationInfoService,
            IWarehouseService warehouseService, IRoadWayinfoService roadWayinfoService, ITask_HtyService task_HtyService) : base(BaseDal)
        {
            _logger = logger;
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
            _locationInfoService = locationInfoService;
            _warehouseService = warehouseService;
            _roadWayinfoService = roadWayinfoService;
            _task_HtyService = task_HtyService;
        }
        public string MES_InReporttask = WIDESEA_Core.Helper.AppSettings.Configuration["MES_InReporttask"]; //入库反馈信息
        public string MES_OutReporttask = WIDESEA_Core.Helper.AppSettings.Configuration["MES_OutReporttask"];   //出库反馈信息
        public string MES_InventoryUpdateApply = WIDESEA_Core.Helper.AppSettings.Configuration["MES_InventoryUpdateApply"];   //储位异动申请
        public string MES_InventoryUpdateCallback = WIDESEA_Core.Helper.AppSettings.Configuration["MES_InventoryUpdateCallback"];   //储位异动申请
        public string MES_TaskErrorInfoCallback = WIDESEA_Core.Helper.AppSettings.Configuration["MES_TaskErrorInfoCallback"];   //任务异常上报
        public string WCS_SendConveyorTask = WIDESEA_Core.Helper.AppSettings.Configuration["WCS_SendConveyorTask"];   //输送线任务下发
        public string WCS_SendStackerTask = WIDESEA_Core.Helper.AppSettings.Configuration["WCS_SendStackerTask"];   //堆垛机任务下发


        public WebResponseContent CESTEXT()
        {

            return WebResponseContent.Instance.OK();
        }


        //手动，任务上报
        #region
        public WebResponseContent MESManualUpload(SaveModel saveModel)
        {
            WebResponseContent response = new WebResponseContent();

            List<Dt_Task> stdata=new List<Dt_Task>();
            try
            {
                foreach (var key in saveModel.DelKeys)
                {
                    int taskId = int.Parse(key.ToString());
                    Dt_Task task = BaseDal.QueryFirst(x => x.TaskId == taskId);
                    
                    WebResponseContent taskResult = ProcessTask(task);
                    if (!taskResult.Status)
                    {
                        WriteLog.Write_Log("WMS_手动上报任务", $"任务上报", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode},", $"原因：{taskResult.Message}");
                        return taskResult;
                    }
                    stdata.Add(task);
                }
                WriteLog.Write_Log("WMS_手动上报任务", $"任务上报", $"成功", $"上报的数据：{stdata.ToJson()}");
                return response.OK("所有任务处理成功");
            }
            catch (Exception ex)
            {
                WriteLog.Write_Log("WMS_手动上报任务", $"任务上报", $"失败", $"WMS任务完成错误：{ex.Message}");
                return response.Error($"WMS任务完成错误：{ex.Message}");
            }
        }

        private WebResponseContent ProcessTask(Dt_Task task)
        {
            WebResponseContent response = new WebResponseContent();

            switch ((TaskTypeEnum)task.TaskType)
            {
                case TaskTypeEnum.Inbound:
                    if (task.TaskStatus != (int)InTaskStatusEnum.InPLCException &&
                        task.TaskStatus != (int)InTaskStatusEnum.InSCException)
                    {
                        return response.Error($"任务类型错误，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                    }
                    return HandleInboundTask(task,
                        GetWcsType(task.TaskStatus,
                        (int)InTaskStatusEnum.InPLCException,
                        (int)InTaskStatusEnum.InSCException)
                        );

                case TaskTypeEnum.Outbound:
                    if (task.TaskStatus != (int)OutTaskStatusEnum.OutPLCException &&
                        task.TaskStatus != (int)OutTaskStatusEnum.OutSCException)
                    {
                        return response.Error($"任务类型错误，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                    }
                    return HandleOutboundTask(task, GetWcsType(task.TaskStatus,
                        (int)OutTaskStatusEnum.OutPLCException,
                        (int)OutTaskStatusEnum.OutSCException));

                case TaskTypeEnum.Relocation:
                    return HandleRelocationTask(task, 2);

                default:
                    return response.Error($"任务类型错误，任务号：{task.TaskId},托盘编号：{task.PalletCode},类型：{task.TaskType}");
            }
        }

        private int GetWcsType(int taskStatus, int plcStatus, int scStatus)
        {
            if (taskStatus == plcStatus) return 1;
            if (taskStatus == scStatus) return 2;
            return 0;
        }

        #endregion

        /// <summary>
        /// 任务完成接口
        /// </summary>
        /// <param name="wCSTask"></param>
        /// <returns></returns>

        #region 任务完成
        public WebResponseContent TaskCompleted(WCSTaskDTO wCSTask)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskId == wCSTask.TaskNum && x.PalletCode == wCSTask.PalletCode);
                if (task == null)
                    return webResponse.Error("未找到任务信息", 404);
                return TaskCompletedtask(task, wCSTask.TaskType);
            }
            catch (Exception ex)
            {
                return webResponse.Error($"WMS任务完成错误：{ex.Message}");
            }
        }

        public WebResponseContent TaskCompletedtask(Dt_Task task, int wcstype)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                switch ((TaskTypeEnum)task.TaskType)
                {
                    case TaskTypeEnum.Inbound:
                        return HandleInboundTask(task, wcstype);
                    case TaskTypeEnum.Outbound:
                        return HandleOutboundTask(task, wcstype);
                    case TaskTypeEnum.Relocation:
                        return HandleRelocationTask(task, wcstype);
                    default:
                        return webResponse.Error($"任务类型错误，任务号：{task.TaskId},托盘编号：{task.PalletCode},类型：{task.TaskType}");
                }
            }
            catch (Exception ex)
            {
                return webResponse.Error($"WMS任务完成错误：{ex.Message}");
            }
        }



        private WebResponseContent HandleInboundTask(Dt_Task task, int wcsTaskType)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                switch (wcsTaskType)
                {
                    case 1:

                        if (string.IsNullOrEmpty(task.TargetAddress))
                        {
                            if (task.TaskStatus == (int)InTaskStatusEnum.PLC_InExecuting || task.TaskStatus == (int)InTaskStatusEnum.InPLCException)
                            {
                                int loctype = 0;
                                if (task.Roadway == "1" || task.Roadway == "2")
                                {
                                    if (task.PalletType == "1") loctype = (int)LocationTypeEnum.SmallPallet;
                                    else if (task.PalletType == "2") loctype = (int)LocationTypeEnum.MediumPallet;
                                }
                                else
                                {
                                    loctype = (int)LocationTypeEnum.LargePallet;
                                }

                                //查找货位，更新任务
                                Dt_LocationInfo dt_Location = _locationInfoService.GetLocation(task.Roadway, loctype);
                                if (dt_Location == null)
                                {
                                    WriteLog.Write_Log("WCS_入库_上报完成", $"输送线完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"未找到该货位信息,托盘编号：{task.PalletCode}");
                                    return content.Error($"未找到该货位信息,托盘编号：{task.PalletCode}");
                                }
                                Dt_LocationInfo ShallowCargoHold = _locationInfoService.ShallowGetLocation(dt_Location.RoadwayNo, dt_Location.LocationType, dt_Location.Row, dt_Location.Layer, dt_Location.Column);
                                if (ShallowCargoHold == null)
                                {
                                    WriteLog.Write_Log("WCS_入库_上报完成", $"输送线完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"未找到该货位信息,货位编号:{dt_Location.LocationCode}的浅货位");
                                    return content.Error($"未找到该货位信息,货位编号:{dt_Location.LocationCode}的浅货位");
                                }
                                if (ShallowCargoHold.LocationStatus != (int)LocationStatusEnum.Free) return content.Error($"任务号：{task.TaskId},托盘编号：{task.PalletCode},查找的货位浅货位有货，货位编号：{ShallowCargoHold.LocationCode}");

                                if (task.PalletCode[0] == 1 && (dt_Location.RoadwayNo == "1" || dt_Location.RoadwayNo == "2") && dt_Location.Column < 4)
                                {
                                    WriteLog.Write_Log("WCS_入库_上报完成", $"输送线完成", $"失败,托盘条码：{task.PalletCode},货位编号:{dt_Location.LocationCode}", $"条码为高托盘，但是查找的货位要入在低托盘下");
                                    return content.Error($"条码为高托盘，但是查找的货位要入在低托盘下，故障,托盘条码：{task.PalletCode},货位编号:{dt_Location.LocationCode}");
                                }


                                Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(task.Roadway);

                                task.TargetAddress = dt_Location.LocationCode;
                                task.CurrentAddress = _Roadwayinfo.InSCStationCode;
                                task.NextAddress = dt_Location.LocationCode;
                                task.TaskStatus = (int)InTaskStatusEnum.PLC_InFinish;

                                dt_Location.LocationStatus = (int)LocationStatusEnum.Lock;

                                Dt_StockInfo dt_StockInfo = new Dt_StockInfo();
                                dt_StockInfo.PalletCode = task.PalletCode;
                                dt_StockInfo.PalletType = task.PalletType;
                                dt_StockInfo.WarehouseId = task.WarehouseId;
                                dt_StockInfo.LocationCode = dt_Location.LocationCode;
                                dt_StockInfo.StockStatus = (int)StockStatusEmun.入库中;
                                dt_StockInfo.Creater = "MWS";
                                dt_StockInfo.CreateDate = DateTime.Now;
                                dt_StockInfo.Roadway = task.Roadway;


                                _unitOfWorkManage.BeginTran();
                                _stockInfoService.AddData(dt_StockInfo);
                                _locationInfoService.UpdateData(dt_Location);
                                BaseDal.UpdateData(task);
                                _unitOfWorkManage.CommitTran();
                                WriteLog.Write_Log("WCS_入库_上报完成", $"输送线完成", $"成功，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"已接收入库输送线完成信息,添加库存信息：{dt_StockInfo.ToJson()}，修改货位：{dt_Location.ToJson()}");

                                return content.OK($"已接收入库输送线完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                WriteLog.Write_Log("WCS_入库_上报完成", $"输送线完成", $"成功，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上报失败，当前任务不是输送线执行中，WCS上报完成失败");
                                return content.Error("上报失败，当前任务不是输送线执行中，WCS上报完成失败");
                            }


                        }
                        else
                        {
                            //判断是否有该站台
                            if (task.TaskStatus == (int)InTaskStatusEnum.PLC_InExecuting || task.TaskStatus == (int)InTaskStatusEnum.InPLCException)
                            {
                                string Resultplc = MesInTaskStatusEnum.Finish.GetDescription();
                                MES_parameter mES_PCLParameter = InStoreDocCallback(task.TaskNum, Resultplc, "操作成功", task.PalletCode, task.TargetAddress);
                                if (mES_PCLParameter.Result == "Y")
                                {
                                    task.TaskStatus = (int)InTaskStatusEnum.PLC_InFinish;
                                    _unitOfWorkManage.BeginTran();
                                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                                    _unitOfWorkManage.CommitTran();
                                    WriteLog.Write_Log("WCS_入库_上报完成", $"输送线点到点完成", $"成功，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"输送线任务已反馈至上游");
                                    return content.OK($"输送线任务已反馈至上游，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                                }
                                else
                                {
                                    task.NumberSsuances = 3;
                                    task.TaskStatus = (int)InTaskStatusEnum.InPLCException;
                                    task.Remark = "输送线入库：上传MES失败，原因：" + mES_PCLParameter.ResultMsg;
                                    BaseDal.UpdateData(task);
                                    WriteLog.Write_Log("WCS_入库_上报完成", $"输送线点到点完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"输送线任务已反馈至上游");
                                    return content.Error("上传MES失败，原因：" + mES_PCLParameter.ResultMsg);
                                }
                            }
                            else
                            {
                                WriteLog.Write_Log("WCS_入库_上报完成", $"输送线点到点完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上报失败，当前任务不是输送线执行中，WCS上报完成失败");
                                return content.Error($"上报失败，当前任务不是输送线执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }

                        }
                    case 2:
                        if (task.TaskStatus == (int)InTaskStatusEnum.SC_IntExecuting || task.TaskStatus == (int)InTaskStatusEnum.InSCException)
                        {
                            string Resultsc = MesInTaskStatusEnum.Finish.GetDescription();
                            //上报MES任务完成
                            MES_parameter mES_Parameter = InStoreDocCallback(task.TaskNum, Resultsc, "操作成功", task.PalletCode, task.TargetAddress);
                            if (mES_Parameter.Result == "Y")
                            {
                                Dt_StockInfo dt_Stockowc = _stockInfoService.Repository.QueryData(x => x.PalletCode == task.PalletCode).FirstOrDefault();
                                Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stockowc.LocationCode).FirstOrDefault();

                                dt_Stockowc.StockStatus = (int)StockStatusEmun.已入库;
                                dt_LocationInfo.LocationStatus = (int)LocationStatusEnum.InStock;
                                task.TaskStatus = (int)InTaskStatusEnum.InFinish;

                                _unitOfWorkManage.BeginTran();
                                _stockInfoService.UpdateData(dt_Stockowc);
                                _locationInfoService.UpdateData(dt_LocationInfo);
                                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                                _unitOfWorkManage.CommitTran();

                                WriteLog.Write_Log("WCS_入库_上报完成", $"堆垛机完成", $"成功，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"修改后的库存：{dt_Stockowc.ToJson()},修改后的库位信息：{dt_LocationInfo.ToJson()}");
                                return content.OK($"已接收入库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                task.NumberSsuances = 3;
                                task.TaskStatus = (int)InTaskStatusEnum.InSCException;
                                task.Remark = "堆垛机入库，上传MES失败，原因：" + mES_Parameter.ResultMsg;
                                BaseDal.UpdateData(task);
                                WriteLog.Write_Log("WCS_入库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上传MES失败，原因：{mES_Parameter.ResultMsg}");
                                return content.Error("上传MES失败，原因：" + mES_Parameter.ResultMsg);
                            }
                        }
                        else
                        {
                            WriteLog.Write_Log("WCS_入库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上报失败，当前任务不是堆垛机执行中，WCS上报完成失败");
                            return content.Error($"上报失败，当前任务不是堆垛机执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }

                    default:
                        WriteLog.Write_Log("WCS_入库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"WCS上报类型错误：{wcsTaskType}");
                        return content.Error($"WCS上报类型错误：{wcsTaskType}");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                WriteLog.Write_Log("WCS_入库_上报完成", $"堆垛机完成", $"失败,任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"WCS任务完成接口故障，原因：{ex.Message}");
                return content.Error($"WCS任务完成接口故障，原因：{ex.Message}");
            }
        }

        private WebResponseContent HandleOutboundTask(Dt_Task task, int wcsTaskType)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                switch (wcsTaskType)
                {
                    case 1:
                        if (task.TaskStatus == (int)OutTaskStatusEnum.PLC_OutExecuting || task.TaskStatus == (int)OutTaskStatusEnum.OutPLCException)
                        {
                            string Resultplc = MesOutTaskStatusEnum.Finish.GetDescription();
                            //上报MES任务完成
                            MES_parameter mES_Parameter = OutStoreDocCallback(task.TaskNum, Resultplc, "操作成功");
                            if (mES_Parameter.Result == "Y")
                            {
                                task.TaskStatus = (int)OutTaskStatusEnum.PLC_OutFinish;
                                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);

                                WriteLog.Write_Log("WCS_出库_上报完成", $"输送线完成",$"成功,任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"已接收出库输送线完成信息");
                                return content.OK($"已接收出库输送线完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                task.NumberSsuances =3;
                                task.TaskStatus = (int)OutTaskStatusEnum.OutPLCException;
                                task.Remark = "出库，输送线上传MES失败，原因：" + mES_Parameter.ResultMsg;
                                BaseDal.UpdateData(task);
                                WriteLog.Write_Log("WCS_出库_上报完成", $"输送线完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上传MES失败，原因：{mES_Parameter.ResultMsg}");
                                return content.Error("上传MES失败，原因：" + mES_Parameter.ResultMsg);
                            }

                        }
                        else
                        {
                            WriteLog.Write_Log("WCS_出库_上报完成", $"输送线完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上报失败，WMS当前任务不是输送线执行中，WCS上报完成失败");
                            return content.Error($"上报失败，WMS当前任务不是输送线执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }

                    case 2:

                        if (task.TaskStatus == (int)OutTaskStatusEnum.SC_OutExecuting || task.TaskStatus == (int)OutTaskStatusEnum.OutSCException)
                        {
                            //获取对应PLC站台信息
                            Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(task.Roadway);
                            task.CurrentAddress = _Roadwayinfo.OutStationCode;
                            task.NextAddress = task.TargetAddress;
                            task.TaskStatus = (int)OutTaskStatusEnum.SC_OutFinish;

                            Dt_StockInfo dt_Stockowc = _stockInfoService.Repository.QueryData(x => x.PalletCode == task.PalletCode).FirstOrDefault();
                            Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stockowc.LocationCode).FirstOrDefault();
                            dt_LocationInfo.LocationStatus = (int)LocationStatusEnum.Free;

                            string Result = MesOutTaskStatusEnum.Outstore.GetDescription();
                            //调取上游系统反馈开始任务
                            MES_parameter mES_SCParameter = OutStoreDocCallback(task.TaskNum, Result, "操作成功");
                            if (mES_SCParameter.Result == "Y")
                            {
                                _unitOfWorkManage.BeginTran();
                                _stockInfoService.DeleteData(dt_Stockowc);
                                _locationInfoService.UpdateData(dt_LocationInfo);
                                BaseDal.UpdateData(task);
                                _unitOfWorkManage.CommitTran();
                                WriteLog.Write_Log("WCS_出库_上报完成", $"堆垛机完成",$"成功，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"删除的库存：{dt_Stockowc.ToJson()},修改的货位：{dt_LocationInfo.ToJson()}");

                                return content.OK($"已接收出库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                task.NumberSsuances = 3;
                                task.TaskStatus = (int)OutTaskStatusEnum.OutSCException;
                                task.Remark = "堆垛机出库：上传MES失败，原因：" + mES_SCParameter.ResultMsg;
                                BaseDal.UpdateData(task);
                                WriteLog.Write_Log("WCS_出库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上传MES失败，原因：{mES_SCParameter.ResultMsg}");
                                return content.Error("上传MES失败，原因：" + mES_SCParameter.ResultMsg);
                            }
                        }
                        else
                        {
                            WriteLog.Write_Log("WCS_出库_上报完成", $"堆垛机完成", $"失败,任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上报失败，WMS当前任务不是堆垛机执行中，WCS上报完成失败");
                            return content.Error($"上报失败，WMS当前任务不是堆垛机执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }

                    default:
                        WriteLog.Write_Log("WCS_出库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"WCS上报类型错误：{wcsTaskType}");
                        return content.Error($"WCS上报类型错误：{wcsTaskType}");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                WriteLog.Write_Log("WCS_出库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"WCS任务完成接口故障，原因：{ex.Message}");
                return content.Error($"WCS任务完成接口故障，原因：{ex.Message}");
            }
        }

        private WebResponseContent HandleRelocationTask(Dt_Task task, int wcsTaskType)
        {
            WebResponseContent responseContent = new WebResponseContent();
            try
            {
                if (wcsTaskType == 2)
                {
                    if (task.TaskStatus == (int)RelocationTaskStatusEnum.RelocationExecuting)
                    {
                        //上报MES任务完成
                        MES_parameter mES_Parameter = AbnormalStorageLocation(task.PalletCode, task.SourceAddress, task.TargetAddress);
                        if (mES_Parameter.Result == "Y")
                        {
                            Dt_Task dtOutWit=BaseDal.QueryData(x=>x.PalletCode==task.PalletCode && x.TaskStatus== (int)OutTaskStatusEnum.OutWait).FirstOrDefault();

                            Dt_LocationInfo OriginalLocation = _locationInfoService.Repository.QueryData(x => x.LocationCode == task.SourceAddress).FirstOrDefault();
                            Dt_LocationInfo NewLocation = _locationInfoService.Repository.QueryData(x => x.LocationCode == task.TargetAddress).FirstOrDefault();
                            Dt_StockInfo dt_StockInfo = _stockInfoService.Repository.QueryData(x => x.LocationCode == task.SourceAddress).FirstOrDefault();

                            List<Dt_LocationInfo> dt_Locations = new List<Dt_LocationInfo>();

                            OriginalLocation.LocationStatus = (int)LocationStatusEnum.Free;
                            NewLocation.LocationStatus = dtOutWit != null? (int)LocationStatusEnum.Lock:(int)LocationStatusEnum.InStock;
                            dt_StockInfo.LocationCode = NewLocation.LocationCode;
                            dt_StockInfo.StockStatus = dtOutWit != null? (int)StockStatusEmun.出库中:(int)StockStatusEmun.已入库;
                            task.TaskStatus = (int)RelocationTaskStatusEnum.RelocationFinish;

                            if(dtOutWit != null)
                            {
                                dtOutWit.TaskStatus = (int)OutTaskStatusEnum.OutNew;
                                dtOutWit.SourceAddress = NewLocation.LocationCode;
                                dtOutWit.CurrentAddress = NewLocation.LocationCode;
                            }
                            



                            dt_Locations.Add(OriginalLocation);
                            dt_Locations.Add(NewLocation);

                            _unitOfWorkManage.BeginTran();
                            if(dtOutWit!=null) BaseDal.UpdateData(dtOutWit);

                            _locationInfoService.UpdateData(dt_Locations);
                            _stockInfoService.UpdateData(dt_StockInfo);
                            BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                            _unitOfWorkManage.CommitTran();

                            WriteLog.Write_Log("WCS_移库_上报完成", $"堆垛机完成", $"成功,任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"修改的货位：{dt_Locations.ToJson()},修改的库存：{dt_StockInfo.ToJson()}");
                            return responseContent.OK($"已接收移库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }
                        else
                        {
                            task.NumberSsuances = 3;
                            task.TaskStatus = (int)RelocationTaskStatusEnum.RelocationException;
                            task.Remark = "移库，上传MES失败，原因：" + mES_Parameter.ResultMsg;
                            BaseDal.UpdateData(task);
                            WriteLog.Write_Log("WCS_移库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上传MES失败，原因：{mES_Parameter.ResultMsg}");
                            return responseContent.Error("上传MES失败，原因：" + mES_Parameter.ResultMsg);
                        }
                    }
                    else
                    {
                        WriteLog.Write_Log("WCS_移库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"上报失败，WMS当前任务不是堆垛机执行中，WCS上报完成失败");
                        return responseContent.Error($"上报失败，WMS当前任务不是堆垛机执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                    }

                }
                else
                {
                    WriteLog.Write_Log("WCS_移库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"WCS上报类型错误：{wcsTaskType}");
                    return responseContent.Error($"WCS上报类型错误：{wcsTaskType}");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                WriteLog.Write_Log("WCS_移库_上报完成", $"堆垛机完成", $"失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}", $"WCS任务完成接口故障，原因：{ex.Message}");
                return responseContent.Error($"WMS系统错误，原因：{ex.Message}");
            }

        }

        #endregion



        //任务任务恢复
        public WebResponseContent WMSTaskRecovery(SaveModel saveModel)
        {
            WebResponseContent response = new WebResponseContent();
            List<Dt_Task> dt_Task = new List<Dt_Task>();
            try
            {
                foreach (var key in saveModel.DelKeys)
                {
                    int taskId = int.Parse(key.ToString());
                    Dt_Task task = BaseDal.QueryFirst(x => x.TaskId == taskId);
                    if (task == null)
                            return response.Error("未找到任务信息");
                    task.NumberSsuances = 0;
                    task.Remark = "";
                    dt_Task.Add(task);
                }
                bool updatetask= BaseDal.UpdateData(dt_Task);
                if (updatetask)
                {
                    WriteLog.Write_Log("WMS_任务恢复", $"WMS_任务恢复", "修改成功", $"修改的数据：{dt_Task.ToJson()}");
                    return response.OK("所有任务处理成功");
                }
                else
                {
                    WriteLog.Write_Log("WMS_任务恢复", $"WMS_任务恢复", "修改失败", $"修改的数据：{dt_Task.ToJson()}");
                    return response.Error("处理失败，修改任务失败");
                }

                
            }
            catch (Exception ex)
            {
                WriteLog.Write_Log("WMS_任务恢复", $"WMS_任务恢复", "修改失败", $"修改的数据：{dt_Task.ToJson()}，失败原因：{ex.Message}");
                return response.Error($"WMS任务恢复错误：{ex.Message}");
            }
        }


        public virtual WebResponseContent UpdateData(SaveModel saveModel)
        {
            try
            {
                List<string>? list = UpdateIgnoreColOnExecute?.Invoke(saveModel);
                if (saveModel == null || saveModel.MainData == null || saveModel.MainData.Count == 0)//判断参数是否传入
                {
                    return WebResponseContent.Instance.Error("传参错误,参数不能为空");
                }
                string validResult = typeof(Dt_Task).ValidateDicInEntity(saveModel.MainData, false, TProperties, list?.ToArray() ?? null);

                if (!string.IsNullOrEmpty(validResult))
                {
                    return WebResponseContent.Instance.Error(validResult);
                }

                PropertyInfo keyPro = typeof(Dt_Task).GetKeyProperty();
                if (keyPro == null)
                {
                    return WebResponseContent.Instance.Error("请先设置主键");
                }

                Dt_Task entity = saveModel.MainData.DicToModel<Dt_Task>();
                Dt_Task Dt_Custask= BaseDal.QueryFirst(x=>x.TaskId==entity.TaskId);

                List<string> listCol = new List<string>();
                foreach (var item in saveModel.MainData)
                {
                    PropertyInfo? propertyInfo = typeof(Dt_Task).GetProperty(item.Key);
                    if (propertyInfo == null)
                    {
                        propertyInfo = typeof(Dt_Task).GetProperty(item.Key.FirstLetterToLower());
                        if (propertyInfo == null)
                        {
                            propertyInfo = typeof(Dt_Task).GetProperty(item.Key.FirstLetterToUpper());
                        }
                    }

                    listCol.Add(propertyInfo?.Name);
                }

                if (saveModel.DetailData == null || saveModel.DetailData.Count == 0)
                {
                    if (list != null)
                        listCol = listCol.Where(x => !list.Contains(x)).ToList();
                    bool result = BaseDal.UpdateData(entity, listCol, list);
                    WriteLog.Write_Log("WMS_任务修改", $"任务修改", $"任务编号:{entity.TaskId},托盘条码：{entity.PalletCode},是否成功：{result}", $"原来数据：{Dt_Custask.ToJson()}======>>>>>>修改后的数据：{entity.ToJson()}");
                    return WebResponseContent.Instance.OK();
                }

                if (typeof(Dt_Task).GetNavigatePro() == null)
                {
                    return WebResponseContent.Instance.Error("未配置导航属性");
                }

                Type detailType = typeof(Dt_Task).GetDetailType();
                MethodInfo? methodInfo = GetType().GetMethod("UpdateDataInculdesDetail");
                methodInfo = methodInfo?.MakeGenericMethod(new Type[] { detailType });
                object? obj = methodInfo?.Invoke(this, new object[] { entity, detailType, saveModel.DetailData, saveModel.DelKeys });
                return obj as WebResponseContent;
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
    
        


        //任务获取
        public List<Dt_Task> GetaskQueue(string deviceId)
        {
            return BaseDal.QueryData(x => x.Roadway == deviceId
                           && (x.TaskStatus == (int)InTaskStatusEnum.PLC_InFinish
                               || x.TaskStatus == (int)OutTaskStatusEnum.OutNew)
                           && x.NumberSsuances == 0)
               .OrderBy(x => x.Remark == null ? 0 : 1)
               .ToList();
            //return BaseDal.QueryData(x => x.Roadway == deviceId && (x.TaskStatus == (int)InTaskStatusEnum.PLC_InFinish || x.TaskStatus == (int)OutTaskStatusEnum.OutNew) && x.NumberSsuances==0);
        }

        //获取当前堆垛机执行的任务
        public bool CurrentTaskProgress(string deviceId)
        {
           int taskcount=BaseDal.QueryData(x => x.Roadway == deviceId && (x.TaskStatus == (int)InTaskStatusEnum.SC_IntExecuting || x.TaskStatus == (int)OutTaskStatusEnum.SC_OutExecuting || x.TaskStatus == (int)RelocationTaskStatusEnum.RelocationExecuting)).Count();
            if (taskcount == 0) return false;
            return true;
        }

        //获取堆垛机完成，下发输送线的任务
        public static List<string> OutSCList = new List<string>() { "1109", "1105", "1210", "1212", "1214" };
        public List<Dt_Task> GetaskQueuePLC()
        {
            return BaseDal.QueryData(x => x.TaskStatus == (int)OutTaskStatusEnum.SC_OutFinish && OutSCList.Contains(x.CurrentAddress));
        }

        //获取是否有移库的任务
        public Dt_Task GeRelocationTaskQueue(string LocationCode)
        {
            return BaseDal.QueryData(x => x.TaskStatus == (int)RelocationTaskStatusEnum.RelocationNew && x.CurrentAddress == LocationCode).FirstOrDefault();
        }

        public Dt_Task GeOutCuTaskQueue(string LocationCode)
        {
            return BaseDal.QueryData(x => x.TaskStatus == (int)OutTaskStatusEnum.OutNew && x.SourceAddress == LocationCode).FirstOrDefault();
        }

        public bool RelocationTaskProgress(string deviceId)
        {
            int taskcount = BaseDal.QueryData(x => x.Roadway == deviceId && (x.TaskStatus == (int)RelocationTaskStatusEnum.RelocationExecuting || x.TaskStatus == (int)RelocationTaskStatusEnum.RelocationNew) ).Count();
            if (taskcount == 0) return false;
            return true;
        }

        //仓库容量状态
        public WebResponseContent GetWarehouseCapacity()
        {
            return _locationInfoService.GetWarehouseCapacity();
        }

        //出入库类型分布
        public WebResponseContent GetInOutTypeStats()
        {
            return _task_HtyService.GetInOutTypeStats();
        }
        //流量情况统计

        public WebResponseContent GetTodayTrafficStats()
        {
            return _task_HtyService.GetTodayInOutStats();
        }
        //当前进行的任务
        public WebResponseContent GetCurrentTasks()
        {
            // 查询所以返回TaskNum，TaskType，CreateDate，TaskStatus，
            var tasks = BaseDal.QueryData()
                        .Select(t => new
                        {
                            WarehouseId = t.Roadway == "1" || t.Roadway == "2" ? 1 : 2,
                            PalletType = t.PalletType,
                            TaskNum = t.TaskId,
                            TaskType = t.TaskType,
                            CreateDate = t.CreateDate,
                            TaskStatus = t.TaskStatus,
                            TargetAddress = t.TargetAddress
                        })
                        .ToList();
            return WebResponseContent.Instance.OK("成功", tasks);
        }
        //总体进度
        public WebResponseContent GetWarehouseOperationStatistics()
        {
            /// <summary>
            /// 原料仓，总出入库任务数量，今日入库，今日出库，今日待完成，今日异常任务，成品仓，总出入库数量，今日入库，今日出库，今日待完成
            /// </summary>
            return _task_HtyService.GetWarehouseOperationStatistics();
        }

        public WebResponseContent GetTaskDestination(string targetAddress)
        {
            WebResponseContent content = new WebResponseContent();
            // 参数校验
            if (string.IsNullOrWhiteSpace(targetAddress))
            {
                return content.Error("目标地址不能为空");
            }
            try
            {
                // 查询数据
                var queryResult = BaseDal.QueryData(x => x.TargetAddress == targetAddress);
                // 判断查询结果
                if (queryResult == null || !queryResult.Any())
                {
                    return content.Error($"未找到目标地址为[{targetAddress}]的任务");
                }
                return content.OK($"有目标地址为[{targetAddress}]的任务，请拦截");
            }
            catch (Exception ex)
            {
                return content.Error($"获取任务目的地失败: {ex.Message}");
            }
        }
    }
}