using HslCommunication;
using System;
using System.Collections.Generic;
using System.Text;
using WIDESEA_Common;
using WIDESEA_Common.LogEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core.EFDbContext;
using WIDESEA_Core.Utilities;
using WIDESEA_Entity.DomainModels;
using WIDESEA_Services;
using WIDESEA_Services.Repositories;
using WIDESEA_Services.Services;
using WIDESEA_WCS.WCSClient;

namespace WIDESEA_WCS.Jobs.ConveyorLine
{
    public class InboundLogic
    {


        /// <summary>
        /// 处理入库线的相关逻辑，空托入库和实托入库 
        /// </summary>
        /// <param name="taskWCSinfoRepository"></param>
        /// <param name="station"></param>
        /// <param name="client"></param>
        public static void DealWithInboundLogic(Dt_TaskWCSinfoRepository taskWCSinfoRepository, Dt_StationManager station, PLCClient client)
        {
            OperateResult<bool> normalResult = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_Line_DeviceNormal.ToString(), station.sm_stationNo);
            if (normalResult.IsSuccess)
            {
                bool isNormal = normalResult.Content;
                //说明设备工作正常
                if (isNormal)
                {
                    //读取逻辑控制值
                    OperateResult<Int16> logicResult = (OperateResult<Int16>)client.ReadValue(CLineInfoDBName.R_Line_Logic_InBound.ToString(), "Inbound");
                    //读取RFID值
                    OperateResult<UInt32> rfidResult1 = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_Barcode.ToString(), station.sm_stationNo);
                    //线体人工触发的确认信号
                    OperateResult<bool> confirmResult1 = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_Line_Confirm_OK.ToString(), station.sm_stationNo);
                    if (logicResult.IsSuccess && rfidResult1.IsSuccess && confirmResult1.IsSuccess)
                    {
                        string rfidValue = rfidResult1.Content.ToString();
                        Int16 logicValue = logicResult.Content;
                        bool confrimValue = confirmResult1.Content;
                        WCSService.RfidValue = rfidValue.ToString();

                        Dt_TaskWCSinfo wcsInfo = null;
                        //查找任务表中的入库任务
                        Dt_TaskWCSinfo _inWcsInfo = taskWCSinfoRepository.FindFirst(x =>
                        (x.wcstask_type == TaskType.TaskType_Empty_Pallet_Inbound.ToString() ||
                         x.wcstask_type == TaskType.TaskType_Box_Pallet_Inbound.ToString()) &&
                         x.wcstask_state == TaskState.TaskState_Assigned.ToString());

                        if (_inWcsInfo != null)
                        {
                            rfidValue = _inWcsInfo.wcstask_barcode;
                            //查找RFID对应的任务
                            wcsInfo = taskWCSinfoRepository.FindFirst(x =>
                                x.wcstask_barcode == rfidValue &&
                            (x.wcstask_type == TaskType.TaskType_Empty_Pallet_Inbound.ToString() ||
                                x.wcstask_type == TaskType.TaskType_Box_Pallet_Inbound.ToString()));
                            LogRecord.WriteLog(LogEnum.InBound,$"找到一条准备入库的任务，托盘号：【{rfidValue}】,线体按钮触发值：【{confrimValue}】");
                        }
                        else
                        {
                            //读取任务号值
                            OperateResult<UInt32> _taskRes = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station.sm_stationNo);
                            if (_taskRes.IsSuccess)
                            {
                                UInt32 tmpNum = _taskRes.Content;
                                wcsInfo = taskWCSinfoRepository.FindFirst(x =>
                                x.wcstask_taskNumber == tmpNum &&
                               (x.wcstask_type == TaskType.TaskType_Empty_Pallet_Inbound.ToString() ||
                                x.wcstask_type == TaskType.TaskType_Box_Pallet_Inbound.ToString()));
                            }
                        }
                        if ((logicValue == 1 || logicValue == 2) && wcsInfo != null && confrimValue == true)
                        {
                            //这里需要考虑该条任务的入库站台是否 ==> 已经开始了相对应站台的出库测量任务
                            List<Dt_TaskWCSinfo> tmpList = taskWCSinfoRepository.Find(x => 
                            x.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString() &&
                            x.wcstask_endLocation == wcsInfo.wcstask_endPoint &&
                            (x.wcstask_state == TaskState.TaskState_RGV_Received.ToString() ||
                            x.wcstask_state == TaskState.TaskState_RGV_Finished.ToString()));
                            if(tmpList.Count != 0)
                            {
                                LogRecord.WriteLog(LogEnum.InBound, $"::Wanring::=>托盘号：【{rfidValue}】对应入库任务的目的货位与出库测量任务：【{tmpList[0].wcstask_taskNumber}】发生冲突，向WMS申请新货位");
                                //说明不能入库原来层的货位，会冲突，在此向WMS申请请求更换其它层货位，恢复原来货位状态
                                WebResponseContent content = WMSApi.RequstNewLocationIdWhenConflict(wcsInfo.wcstask_barcode);
                                if (content.Status)
                                {
                                    LogRecord.WriteLog(LogEnum.InBound, $"托盘号：【{rfidValue}】，向WMS申请新货位【成功】，【目的站台、目的货位已更新】-新货位在其它日志处查看");
                                    Console.WriteLine("成功申请到了新的货位地址，WMS和WCS目的货位已更新，目的站台已更新！");
                                    //直接return，下个调度周期再来发任务
                                    return;
                                }
                                else
                                {
                                    LogRecord.WriteLog(LogEnum.InBound, $"::Error::托盘号：【{rfidValue}】，向WMS申请新货位【失败】，原因：{content.Message}");
                                }
                            }


                            //任务号--入库模式
                            bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_Line_TaskNumber_Inbound.ToString(), wcsInfo.wcstask_taskNumber);
                            //托盘号--入库模式
                            bool writeBarcode = client.WriteValue(CLineInfoDBName.W_Line_RFID_Inbound.ToString(), wcsInfo.wcstask_barcode);
                            //起始站台--入库模式
                            bool writeStartStation = client.WriteValue(CLineInfoDBName.W_Line_StartStation_Inbound.ToString(), wcsInfo.wcstask_startPoint);
                            //终点站台--入库模式
                            bool writeEndStation = client.WriteValue(CLineInfoDBName.W_Line_EndStation_Inbound.ToString(), wcsInfo.wcstask_endPoint);

                            if (writeTaskNumber == true && writeBarcode == true &&
                                writeStartStation == true && writeEndStation == true)
                            {
                                Console.WriteLine($"{DateTime.Now}=>Success => 给站台：【{station.sm_stationNo}】,写到任务号：【{wcsInfo.wcstask_taskNumber}】，托盘号：【{wcsInfo.wcstask_barcode}】，终点：【{wcsInfo.wcstask_endPoint}】");

                                string str = $"将托盘号：【{wcsInfo.wcstask_barcode}】对应任务信息写给线体【成功】！\n\r " +
                                    $"任务号：{wcsInfo.wcstask_taskNumber} \n\r " +
                                    $"托盘号：{wcsInfo.wcstask_barcode} \n\r " +
                                    $"起始站台：{wcsInfo.wcstask_startPoint} \n\r " +
                                    $"终点站台：{wcsInfo.wcstask_endPoint}";
                                LogRecord.WriteLog(LogEnum.InBound, str);
                            }
                            else
                            {
                                Console.WriteLine($"{DateTime.Now}=>::Failed:: => 给站台：【{station.sm_stationNo}】,写到任务号：【{wcsInfo.wcstask_taskNumber}】，托盘号：【{wcsInfo.wcstask_barcode}】，终点：【{wcsInfo.wcstask_endPoint}】");

                                string str = $"::Error::=>将托盘号：【{wcsInfo.wcstask_barcode}】对应任务信息写给线体【失败】！\n\r " +
                                    $"任务号：{wcsInfo.wcstask_taskNumber} \n\r " +
                                    $"托盘号：{wcsInfo.wcstask_barcode} \n\r " +
                                    $"起始站台：{wcsInfo.wcstask_startPoint} \n\r " +
                                    $"终点站台：{wcsInfo.wcstask_endPoint}";
                                LogRecord.WriteLog(LogEnum.InBound, str);
                            }
                        }
                        //说明站台已经收到任务数据，等待WCS的启动指令
                        else if (logicValue == 3 && wcsInfo != null)
                        {
                            LogRecord.WriteLog(LogEnum.InBound, "读取到【20101】逻辑值为3，表明任务数据已收到，WCS准备发送启动指令");
                            //启动任务
                            bool startTask = client.WriteValue(CLineInfoDBName.W_Line_Logic_InBound.ToString(), 1);
                            //入空托的时候，默认是托盘号核验一致
                            bool checkFlag = client.WriteValue(CLineInfoDBName.W_Line_RFID_Done.ToString(), station.sm_stationNo, true);
                            if (startTask && checkFlag)
                            {
                                LogRecord.WriteLog(LogEnum.InBound, "给【20101】写入启动信号【成功】！");
                                Console.WriteLine($"Success=> 启动任务成功，任务号：【{wcsInfo.wcstask_taskNumber}】");
                            }
                            else
                            {
                                LogRecord.WriteLog(LogEnum.InBound, "::Error::=> 给【20101】写入启动信号【失败】！");
                                Console.WriteLine($"{DateTime.Now}=>Failed=> 启动任务失败，任务号：【{wcsInfo.wcstask_taskNumber}】");
                            }
                        }
                        else if (logicValue == 4 || logicValue == 5)
                        {
                            //入空托的时候，默认是托盘号核验一致
                            bool checkFlag = client.WriteValue(CLineInfoDBName.W_Line_RFID_Done.ToString(), station.sm_stationNo, true);

                            //读取RFID值，防止在logicValue == 3时更新任务状态失败
                            //是因为出现过写入启动信号，返回值是false，但是线体确又已经收到了启动信号，所以打了这个补丁
                            OperateResult<UInt32> rfidResult_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_Barcode.ToString(), station.sm_stationNo);
                            OperateResult<UInt32> taskRes_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station.sm_stationNo);
                            if (rfidResult_.IsSuccess && taskRes_.IsSuccess)
                            {
                                UInt32 _rfid = rfidResult_.Content;
                                UInt32 _tasknum = taskRes_.Content;
                                Dt_TaskWCSinfo _tmpTask = taskWCSinfoRepository.FindFirst(x =>
                                            (x.wcstask_type == TaskType.TaskType_Empty_Pallet_Inbound.ToString() ||
                                             x.wcstask_type == TaskType.TaskType_Box_Pallet_Inbound.ToString()) &&
                                             x.wcstask_state == TaskState.TaskState_Assigned.ToString() && 
                                             x.wcstask_taskNumber == _tasknum && 
                                             x.wcstask_barcode == _rfid.ToString());
                                if (_tmpTask != null)
                                {
                                    //启动成功后，在此更新任务状态、上报WMS任务状态
                                    WebResponseContent content = WMSApi.PostTaskStateToWMS(rfidValue.ToString(), TaskState.TaskState_ConveyorLineExecuting.ToString());
                                    if (content.Status)
                                    {
                                        wcsInfo.wcstask_state = TaskState.TaskState_ConveyorLineExecuting.ToString();
                                        wcsInfo.wcstask_dispatcherTime = DateTime.Now;
                                        taskWCSinfoRepository.Update(wcsInfo, true);
                                        Console.WriteLine($"{DateTime.Now}=>Success=> 上报WMS更新任务状态成功【TaskState_ConveyorLineExecuting】，任务号：【{wcsInfo.wcstask_taskNumber}】");

                                        LogRecord.WriteLog(LogEnum.InBound, $"::Wanring::=> 将托盘号：【{rfidValue}】对应的任务，上报WMS更新任务状态【成功】！更新为：TaskState_ConveyorLineExecuting，此处为更新补发！！");
                                    }
                                    else
                                    {
                                        Console.WriteLine($"{DateTime.Now}=>Failed=> 上报WMS更新任务状态出错【TaskState_ConveyorLineExecuting】，任务号：【{wcsInfo.wcstask_taskNumber}】，原因：{content.Message}");

                                        LogRecord.WriteLog(LogEnum.InBound, $"::Error::将托盘号：【{rfidValue}】对应的任务，上报WMS更新任务状态【失败】！更新为：TaskState_ConveyorLineExecuting，此处为更新补发！！原因：{content.Message}");
                                    }
                                }
                            }


                            //清除入库模式下发的数据
                            bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_Line_TaskNumber_Inbound.ToString(), 0);
                            bool writeBarcode = client.WriteValue(CLineInfoDBName.W_Line_RFID_Inbound.ToString(), 0);
                            bool writeStartStation = client.WriteValue(CLineInfoDBName.W_Line_StartStation_Inbound.ToString(), 0);
                            bool writeEndStation = client.WriteValue(CLineInfoDBName.W_Line_EndStation_Inbound.ToString(), 0);
                            bool writelogicValue = client.WriteValue(CLineInfoDBName.W_Line_Logic_InBound.ToString(), 0);

                            if(writeTaskNumber && writeBarcode && writeStartStation && writeEndStation && writelogicValue)
                            {
                                LogRecord.WriteLog(LogEnum.InBound, $"清除站台【20101】的任务信息成功！");
                            }
                            else
                            {
                                LogRecord.WriteLog(LogEnum.InBound, $"::Error::=> 清除站台【20101】的任务信息失败！");
                            }
                        }
                    }


                    //此处校验空托出库的任务在库存中的托盘码和工位RFID读取到的托盘码是否一致
                    OperateResult<UInt32> taskRes = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station.sm_stationNo);
                    if (taskRes.IsSuccess)
                    {
                        UInt32 taskNum = taskRes.Content;
                        //查找任务表中的空托入库任务 、 轴承出库
                        Dt_TaskWCSinfo emptyOutWcsInfo = taskWCSinfoRepository.FindFirst(x =>
                        (x.wcstask_type == TaskType.TaskType_Empty_Pallet_Outbound.ToString() || 
                        x.wcstask_type == TaskType.TaskType_Box_Pallet_Outbound.ToString()) &&
                        (x.wcstask_state == TaskState.TaskState_Empty_Out_Line_Executing.ToString() ||
                        x.wcstask_state == TaskState.TaskState_Box_Out_Line_Executing.ToString()) &&
                        x.wcstask_taskNumber == taskNum);
                        if (emptyOutWcsInfo != null)
                        {
                            //在此完成该空托出库任务
                            WebResponseContent content = taskWCSinfoRepository.DbContextBeginTransaction(() =>
                            {
                                WebResponseContent transContent = new WebResponseContent();
                                try
                                {
                                    //上报WMS任务完成
                                    transContent = WMSApi.TellWmsTaskFinished(emptyOutWcsInfo.wcstask_barcode);
                                    if (transContent.Status)
                                    {
                                        //移动任务到历史表
                                        Dt_TaskWCSinfo_HtyRepository taskWCSinfo_HtyRepository = new Dt_TaskWCSinfo_HtyRepository(taskWCSinfoRepository.DbContext);
                                        emptyOutWcsInfo.wcstask_state = TaskState.TaskState_Finished.ToString();
                                        CommonFunction.AddWcsTaskToHistory(emptyOutWcsInfo, taskWCSinfoRepository, taskWCSinfo_HtyRepository);
                                    }
                                    else
                                    {
                                        throw new Exception($"上报WMS任务完成出错，原因：【{transContent.Message}】");
                                    }

                                    transContent.OK();
                                }
                                catch(Exception ex)
                                {
                                    transContent.Error(ex.Message);
                                }

                                return transContent;
                            });
                            if (!content.Status)
                            {
                                Console.WriteLine($"::Error::=> 空托盘任务：【{emptyOutWcsInfo.wcstask_taskNumber}】完成出错，原因：{content.Message}");
                            }
                        }
                    }

                }
                else
                {
                    Console.WriteLine($"::Error::读取到【20101】站台工作异常！！");
                    LogRecord.WriteLog(LogEnum.InBound, $"::Error::读取到【20101】站台工作异常！！");
                }
            }
        }


        /// <summary>
        /// 当入库任务完成时候的逻辑处理 
        /// </summary>
        /// <param name="taskWCSinfoRepository"></param>
        /// <param name="station"></param>
        /// <param name="client"></param>
        public static void DealWithInboundFinishedLogic(Dt_TaskWCSinfoRepository taskWCSinfoRepository, Dt_TaskRGVinfoRepository taskRGVinfoRepository, Dt_StationManager station, PLCClient client)
        {
            OperateResult<UInt32> taskRes = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station.sm_stationNo);
            OperateResult<UInt32> rfidRes = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_Barcode.ToString(), station.sm_stationNo);
            if (taskRes.IsSuccess && rfidRes.IsSuccess)
            {
                UInt32 taskNumber = taskRes.Content;
                UInt32 rfidValue = rfidRes.Content;

                Dt_TaskWCSinfo wcsInfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_taskNumber == taskNumber);
                if (wcsInfo != null && 
                    (wcsInfo.wcstask_state != TaskState.TaskState_ConveyorLineFinish.ToString() &&
                    wcsInfo.wcstask_state != TaskState.TaskState_RGV_Received.ToString()))
                {
                    //空托和实托的入库
                    if (wcsInfo.wcstask_type == TaskType.TaskType_Box_Pallet_Inbound.ToString() ||
                       wcsInfo.wcstask_type == TaskType.TaskType_Empty_Pallet_Inbound.ToString())
                    {
                        OperateResult<Int16> logicRes = (OperateResult<Int16>)client.ReadValue(CLineInfoDBName.R_Line_Logic_InBound.ToString(), "Inbound");
                        if (logicRes.IsSuccess)
                        {
                            Int16 logicValue = logicRes.Content;

                            Console.WriteLine($"在站台：【{station.sm_stationNo}】检测到入库任务到达目的站台，任务号：【{taskNumber}】，托盘号：【{rfidValue}】");
                            LogRecord.WriteLog(LogEnum.InBound,$"在站台：【{station.sm_stationNo}】检测到入库任务到达目的站台，任务号：【{taskNumber}】，托盘号：【{rfidValue}】");

                            //检查任务的目的货位的层数是否和站台层数一致
                            string toLayer = wcsInfo.wcstask_endLocation.Substring(0, 2);
                            string stationLayer = station.sm_stationNo.Substring(3, 2);
                            if (toLayer == stationLayer)
                            {
                                //到达入库口，在此更新任务状态、上报WMS任务状态
                                WebResponseContent content = WMSApi.PostTaskStateToWMS(rfidValue.ToString(), TaskState.TaskState_ConveyorLineFinish.ToString());
                                if (content.Status)
                                {
                                    wcsInfo.wcstask_state = TaskState.TaskState_ConveyorLineFinish.ToString();
                                    wcsInfo.wcstask_dispatcherTime = DateTime.Now;
                                    taskWCSinfoRepository.Update(wcsInfo, true);
                                    Console.WriteLine($"Success=> 上报WMS更新任务状态成功【TaskState_ConveyorLineFinish】，任务号：【{wcsInfo.wcstask_taskNumber}】");

                                    LogRecord.WriteLog(LogEnum.InBound, $"站台：【{station.sm_stationNo}】检测到入库任务到达目的站台，任务号：【{taskNumber}】，托盘号：【{rfidValue}】,上报WMS更新任务状态成功【TaskState_ConveyorLineFinish】");

                                    Dt_TaskRGVinfo _tmpRgvInfo = taskRGVinfoRepository.FindFirst(x => x.rgvtask_barCode == wcsInfo.wcstask_barcode);
                                    if(_tmpRgvInfo == null)
                                    {
                                        //在此生成RGV任务
                                        Dt_TaskRGVinfo rgvInfo = new Dt_TaskRGVinfo();
                                        rgvInfo.rgvtask_taskId = GetTaskNumber.GetRgvTaskNumber(taskRGVinfoRepository).ToString();
                                        rgvInfo.rgvtask_taskType = RGVTaskType.RgvTaskType_Inbound.ToString();
                                        rgvInfo.rgvtask_taskStatus = RGVTaskState.RgvTaskState_Wait_Send.ToString();
                                        rgvInfo.rgvtask_priorityCode = wcsInfo.wcstask_grade.ToString();
                                        rgvInfo.rgvtask_startNode = station.sm_stationNo;
                                        rgvInfo.rgvtask_endNode = wcsInfo.wcstask_endLocation;
                                        rgvInfo.rgvtask_wcsTaskNumber = wcsInfo.wcstask_taskNumber;
                                        rgvInfo.rgvtask_barCode = wcsInfo.wcstask_barcode;
                                        rgvInfo.rgvtask_msgTime = DateTime.Now;
                                        taskRGVinfoRepository.Add(rgvInfo, true);

                                        Console.WriteLine($"站台：【{station.sm_stationNo}】检测到入库任务到达目的站台，任务号：【{taskNumber}】，托盘号：【{rfidValue}】,上报WMS后，生成了穿梭测对应的入库任务，穿梭车任务为：【{rgvInfo.rgvtask_taskId}】");

                                        LogRecord.WriteLog(LogEnum.InBound, $"站台：【{station.sm_stationNo}】检测到入库任务到达目的站台，任务号：【{taskNumber}】，托盘号：【{rfidValue}】,上报WMS后，生成了穿梭测对应的入库任务");
                                    }
                                    else
                                    {
                                        //说明该托盘对应的RGV任务刚已经添加过了，因为托盘在入库工位停留，穿梭车过来取需要时间
                                    }
                                }
                                else
                                {
                                    Console.WriteLine($"Failed=> 上报WMS更新任务状态出错【TaskState_ConveyorLineExecuting】，任务号：【{wcsInfo.wcstask_taskNumber}】，原因：{content.Message}");

                                    LogRecord.WriteLog(LogEnum.InBound, $"::Error::=> 站台：【{station.sm_stationNo}】检测到入库任务到达目的站台，任务号：【{taskNumber}】，托盘号：【{rfidValue}】,上报WMS更新任务状态失败【TaskState_ConveyorLineFinish】，原因：{content.Message}");
                                }
                            }
                            else
                            {
                                Console.WriteLine("::Error::=> 任务的目的货位的层数是否和站台层数不一致！！");
                                LogRecord.WriteLog(LogEnum.InBound, $"::Error::=> 在站台：【{station.sm_stationNo}】检测到入库任务到达目的站台，任务号：【{taskNumber}】，托盘号：【{rfidValue}】,任务的目的货位的层数是否和站台层数不一致！！");
                            }
                        }
                    }
                    //测量回库
                    else if (wcsInfo.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Back.ToString() &&
                        wcsInfo.wcstask_state == TaskState.TaskState_Measure_Back_Line_Executing.ToString())
                    {
                        OperateResult<Int16> logicRes = (OperateResult<Int16>)client.ReadValue(CLineInfoDBName.R_Line_Logic_InBound.ToString(), "Inbound");
                        if (logicRes.IsSuccess)
                        {
                            Int16 logicValue = logicRes.Content;

                            //检查任务的目的货位的层数是否和站台层数一致 050301
                            string toLayer = wcsInfo.wcstask_endLocation.Substring(0, 2);
                            string stationLayer = station.sm_stationNo.Substring(3, 2);
                            if (toLayer == stationLayer)
                            {
                                //到达入库口，在此更新任务状态、上报WMS任务状态
                                WebResponseContent content = WMSApi.PostTaskStateToWMS(rfidValue.ToString(), TaskState.TaskState_Measure_Back_Line_Finished.ToString());
                                if (content.Status)
                                {
                                    wcsInfo.wcstask_state = TaskState.TaskState_Measure_Back_Line_Finished.ToString();
                                    wcsInfo.wcstask_dispatcherTime = DateTime.Now;
                                    taskWCSinfoRepository.Update(wcsInfo, true);
                                    Console.WriteLine($"Success=> 上报WMS更新任务状态成功【TaskState_Measure_Back_Line_Finished】，任务号：【{wcsInfo.wcstask_taskNumber}】");

                                    //在此生成RGV任务
                                    Dt_TaskRGVinfo rgvInfo = new Dt_TaskRGVinfo();
                                    rgvInfo.rgvtask_taskId = GetTaskNumber.GetRgvTaskNumber(taskRGVinfoRepository).ToString();
                                    rgvInfo.rgvtask_taskType = RGVTaskType.RgvTaskType_Inbound.ToString();
                                    rgvInfo.rgvtask_taskStatus = RGVTaskState.RgvTaskState_Wait_Send.ToString();
                                    rgvInfo.rgvtask_priorityCode = wcsInfo.wcstask_grade.ToString();
                                    rgvInfo.rgvtask_startNode = station.sm_stationNo;
                                    rgvInfo.rgvtask_endNode = wcsInfo.wcstask_endLocation;
                                    rgvInfo.rgvtask_wcsTaskNumber = wcsInfo.wcstask_taskNumber;
                                    rgvInfo.rgvtask_barCode = wcsInfo.wcstask_barcode;
                                    rgvInfo.rgvtask_msgTime = DateTime.Now;
                                    taskRGVinfoRepository.Add(rgvInfo, true);
                                }
                                else
                                {
                                    Console.WriteLine($"Failed=> 上报WMS更新任务状态出错【TaskState_Measure_Back_Line_Finished】，任务号：【{wcsInfo.wcstask_taskNumber}】，原因：{content.Message}");
                                }
                            }
                        }
                    }
                }
            }

            //上面已经有了这个逻辑，当初为什么在这里又写了一次？ 暂时保留

            //if (rfidRes.IsSuccess)
            //{
            //    string rfidValue = rfidRes.Content.ToString();
            //    Dt_TaskWCSinfo taskWCSinfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_barcode == rfidValue && x.wcstask_state == TaskState.TaskState_Measure_Back_Line_Executing.ToString());
            //    if(taskWCSinfo != null)
            //    {
            //        WebResponseContent content = WMSApi.PostTaskStateToWMS(rfidValue, TaskState.TaskState_Measure_Back_Line_Finished.ToString());
            //        if (content.Status)
            //        {
            //            taskWCSinfo.wcstask_state = TaskState.TaskState_Measure_Back_Line_Finished.ToString();
            //            taskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
            //            taskWCSinfoRepository.Update(taskWCSinfo, true);

            //            //在此生成RGV任务、让轴承回到原来的位置
            //            Dt_TaskRGVinfo rgvInfo = new Dt_TaskRGVinfo();
            //            rgvInfo.rgvtask_taskId = GetTaskNumber.GetRgvTaskNumber(taskRGVinfoRepository).ToString();
            //            rgvInfo.rgvtask_taskType = RGVTaskType.RgvTaskType_Inbound.ToString();
            //            rgvInfo.rgvtask_taskStatus = RGVTaskState.RgvTaskState_Wait_Send.ToString();
            //            rgvInfo.rgvtask_priorityCode = taskWCSinfo.wcstask_grade.ToString();
            //            rgvInfo.rgvtask_startNode = station.sm_stationNo;
            //            rgvInfo.rgvtask_endNode = taskWCSinfo.wcstask_endLocation;
            //            rgvInfo.rgvtask_wcsTaskNumber = taskWCSinfo.wcstask_taskNumber;
            //            rgvInfo.rgvtask_barCode = taskWCSinfo.wcstask_barcode;
            //            rgvInfo.rgvtask_msgTime = DateTime.Now;
            //            taskRGVinfoRepository.Add(rgvInfo, true);
            //        }
            //        else
            //        {
            //            Console.WriteLine($"上报WMS，将测量【回库】任务状态修改为：【TaskState_Measure_Back_Line_Executing】出错，原因：{content.Message}");
            //        }
            //    }
            //}
        }
    }
}