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_WCS.WCSClient;

namespace WIDESEA_WCS.Jobs.ConveyorLine.Logic
{
    public class PalletOutboundLogic
    {

        /// <summary>
        /// 处理空托出库的线体逻辑
        /// </summary>
        /// <param name="taskNumber"></param>
        /// <param name="dbContext"></param>
        /// <param name="client"></param>
        public static void DealWithPalletOutboundLogic(VOLContext dbContext, PLCClient client, string station)
        {
            try
            {
                Dt_TaskWCSinfoRepository taskWCSinfoRepository = new Dt_TaskWCSinfoRepository(dbContext);

                Dt_TaskRGVinfoRepository taskRGVinfoRepository = new Dt_TaskRGVinfoRepository(dbContext);
                //找对应任务类型：TaskType_Empty_Pallet_Outbound，并且状态为TaskState_RGV_Finished的任务
                Dt_TaskWCSinfo palletOutTask = 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_RGV_Finished.ToString() &&
                    x.wcstask_startPoint.Contains(station));
                if (palletOutTask == null)
                {
                    Dt_TaskWCSinfo moveTask = taskWCSinfoRepository.FindFirst(x => x.wcstask_startPoint.Contains(station) &&
                   x.wcstask_type == TaskType.TaskType_MoveOutbound.ToString() && x.wcstask_state == TaskState.TaskState_RGV_Finished.ToString());
                    if (null != moveTask)
                    {
                        OperateResult<Int16> logicResult = (OperateResult<Int16>)client.ReadValue(CLineInfoDBName.R_Line_Logic_Outbound_Change.ToString(), "ChangeLay");
                        if (logicResult.IsSuccess)
                        {
                            Int16 logicValue = logicResult.Content;
                            //说明工位在等待调度，准备下发任务
                            if (logicValue == 1 || logicValue == 2)
                            {
                                if (!moveTask.wcstask_state.Contains("Executing"))
                                {
                                    client.WriteValue(CLineInfoDBName.W_TaskNumber_Outbound_Change.ToString(), moveTask.wcstask_taskNumber);
                                    client.WriteValue(CLineInfoDBName.W_RFID_Outbound_Change.ToString(), moveTask.wcstask_barcode);
                                    client.WriteValue(CLineInfoDBName.W_StartStation_Outbound_Change.ToString(), moveTask.wcstask_startPoint);
                                    client.WriteValue(CLineInfoDBName.W_EndStation_Outbound_Change.ToString(), moveTask.wcstask_endPoint);
                                }
                            }
                            //说明站台已经收到任务数据，等待WCS的启动指令
                            if (logicValue == 3)
                            {
                                client.WriteValue(CLineInfoDBName.W_Line_Logic_Outbound_Change.ToString(), 1);
                            }
                            if (logicValue == 4 || logicValue == 5)
                            {
                                moveTask.wcstask_state = TaskState.TaskState_MoveOutbound_Line_Executing.ToString();
                                moveTask.wcstask_dispatcherTime = DateTime.Now;
                                taskWCSinfoRepository.Update(moveTask, true);
                            }
                        }
                    }

                    Dt_TaskWCSinfo moveInTask = taskWCSinfoRepository.FindFirst(x => x.wcstask_endPoint.Contains(station) &&
                     x.wcstask_type == TaskType.TaskType_MoveOutbound.ToString() && x.wcstask_state == TaskState.TaskState_MoveOutbound_Line_Executing.ToString());
                    if (null != moveInTask)
                    {
                        if (taskRGVinfoRepository.Exists(r => r.rgvtask_barCode == moveInTask.wcstask_barcode))
                            return;
                        //在此生成RGV任务
                        Dt_TaskRGVinfo rgvInfo = new Dt_TaskRGVinfo();
                        rgvInfo.rgvtask_taskId = WIDESEA_Services.Services.GetTaskNumber.GetRgvTaskNumber(taskRGVinfoRepository).ToString();
                        rgvInfo.rgvtask_taskType = RGVTaskType.RgvTaskType_Inbound.ToString();
                        rgvInfo.rgvtask_taskStatus = RGVTaskState.RgvTaskState_Wait_Send.ToString();
                        rgvInfo.rgvtask_priorityCode = moveInTask.wcstask_grade.ToString();
                        rgvInfo.rgvtask_startNode = moveInTask.wcstask_endPoint;
                        rgvInfo.rgvtask_endNode = moveInTask.wcstask_endLocation;
                        rgvInfo.rgvtask_wcsTaskNumber = moveInTask.wcstask_taskNumber;
                        rgvInfo.rgvtask_barCode = moveInTask.wcstask_barcode;
                        rgvInfo.rgvtask_msgTime = DateTime.Now;
                        taskRGVinfoRepository.Add(rgvInfo, true);

                        moveInTask.wcstask_state = TaskState.TaskState_MoveOutbound_Line_Finished.ToString();
                        moveInTask.wcstask_dispatcherTime = DateTime.Now;
                        taskWCSinfoRepository.Update(moveInTask, true);
                    }

                    return;
                }

                int taskNumber = palletOutTask.wcstask_taskNumber;
                Dt_TaskWCSinfo taskWCSinfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_taskNumber == taskNumber);
                if (taskWCSinfo != null)
                {
                    //查看线体状态，准备给线体下发任务信息
                    //读取逻辑控制值
                    OperateResult<Int16> logicResult = (OperateResult<Int16>)client.ReadValue(CLineInfoDBName.R_Line_Logic_Outbound_Empty.ToString(), "Outbound_E");
                    if (logicResult.IsSuccess)
                    {
                        Int16 logicValue = logicResult.Content;
                        //说明工位在等待调度，准备下发任务
                        if (logicValue == 1 || logicValue == 2)
                        {
                            if (!taskWCSinfo.wcstask_state.Contains("Executing"))
                            {
                                //任务号--空托出库模式
                                bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_TaskNumber_Outbound_Empty.ToString(), taskWCSinfo.wcstask_taskNumber);
                                //托盘号--空托出库模式
                                bool writeBarcode = client.WriteValue(CLineInfoDBName.W_RFID_Outbound_Empty.ToString(), taskWCSinfo.wcstask_barcode);
                                //起始站台--空托出库模式
                                bool writeStartStation = client.WriteValue(CLineInfoDBName.W_StartStation_Outbound_Empty.ToString(), taskWCSinfo.wcstask_startPoint);
                                //终点站台--空托出库模式
                                bool writeEndStation = client.WriteValue(CLineInfoDBName.W_EndStation_Outbound_Empty.ToString(), taskWCSinfo.wcstask_endPoint);

                                if (writeTaskNumber == true && writeBarcode == true &&
                                    writeStartStation == true && writeEndStation == true)
                                {
                                    LogRecord.WriteLog(LogEnum.OutBound, $"{DateTime.Now}=>Success => 【空托出库】给站台：【{taskWCSinfo.wcstask_startPoint}】,写到任务号：【{taskWCSinfo.wcstask_taskNumber}】，托盘号：【{taskWCSinfo.wcstask_barcode}】，终点：【{taskWCSinfo.wcstask_endPoint}】");

                                    Console.WriteLine($"{DateTime.Now}=>Success => 【空托出库】给站台：【{taskWCSinfo.wcstask_startPoint}】,写到任务号：【{taskWCSinfo.wcstask_taskNumber}】，托盘号：【{taskWCSinfo.wcstask_barcode}】，终点：【{taskWCSinfo.wcstask_endPoint}】");
                                }
                                else
                                {
                                    LogRecord.WriteLog(LogEnum.OutBound, $"{DateTime.Now}=>::Failed:: => 【空托出库】给站台：【{taskWCSinfo.wcstask_startPoint}】,写到任务号：【{taskWCSinfo.wcstask_taskNumber}】，托盘号：【{taskWCSinfo.wcstask_barcode}】，终点：【{taskWCSinfo.wcstask_endPoint}】");

                                    Console.WriteLine($"{DateTime.Now}=>::Failed:: => 【空托出库】给站台：【{taskWCSinfo.wcstask_startPoint}】,写到任务号：【{taskWCSinfo.wcstask_taskNumber}】，托盘号：【{taskWCSinfo.wcstask_barcode}】，终点：【{taskWCSinfo.wcstask_endPoint}】");
                                }
                            }
                        }
                        //说明站台已经收到任务数据，等待WCS的启动指令
                        else if (logicValue == 3)
                        {
                            //启动任务
                            bool startTask = client.WriteValue(CLineInfoDBName.W_Line_Logic_Outbound_Empty.ToString(), 1);
                            if (startTask)
                            {
                                LogRecord.WriteLog(LogEnum.OutBound, $"Success=> 【空托出库】启动任务成功，任务号：【{taskWCSinfo.wcstask_taskNumber}】");

                                Console.WriteLine($"Success=> 【空托出库】启动任务成功，任务号：【{taskWCSinfo.wcstask_taskNumber}】");
                            }
                            else
                            {
                                LogRecord.WriteLog(LogEnum.OutBound, $"{DateTime.Now}=>Failed=> 【空托出库】启动任务失败，任务号：【{taskWCSinfo.wcstask_taskNumber}】");

                                Console.WriteLine($"{DateTime.Now}=>Failed=> 【空托出库】启动任务失败，任务号：【{taskWCSinfo.wcstask_taskNumber}】");
                            }
                        }
                        else if (logicValue == 4 || logicValue == 5)
                        {
                            int station1 = int.Parse(taskWCSinfo.wcstask_startPoint);
                            OperateResult<UInt32> rfidResult_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_Barcode.ToString(), station1.ToString());
                            OperateResult<UInt32> taskRes_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station1.ToString());
                            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_Outbound.ToString() &&
                                                x.wcstask_state == TaskState.TaskState_RGV_Finished.ToString() &&
                                                x.wcstask_taskNumber == _tasknum &&
                                                x.wcstask_barcode == _rfid.ToString());
                                if (_tmpTask != null)
                                {
                                    //启动成功后，在此更新任务状态、上报WMS任务状态
                                    WebResponseContent content = WMSApi.PostTaskStateToWMS(
                                        taskWCSinfo.wcstask_barcode,
                                        TaskState.TaskState_Empty_Out_Line_Executing.ToString());
                                    if (content.Status)
                                    {
                                        taskWCSinfo.wcstask_state = TaskState.TaskState_Empty_Out_Line_Executing.ToString();
                                        taskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                                        taskWCSinfoRepository.Update(taskWCSinfo, true);

                                        LogRecord.WriteLog(LogEnum.OutBound, $"{DateTime.Now}=>Success=> 【空托出库】上报WMS更新任务状态成功【TaskState_Empty_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】");

                                        Console.WriteLine($"{DateTime.Now}=>Success=> 【空托出库】上报WMS更新任务状态成功【TaskState_Empty_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】");
                                    }
                                    else
                                    {
                                        LogRecord.WriteLog(LogEnum.OutBound, $"{DateTime.Now}=>Failed=> 【空托出库】上报WMS更新任务状态出错【TaskState_Empty_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】，原因：{content.Message}");

                                        Console.WriteLine($"{DateTime.Now}=>Failed=> 【空托出库】上报WMS更新任务状态出错【TaskState_Empty_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】，原因：{content.Message}");
                                    }
                                }
                                else
                                {
                                    _tmpTask = taskWCSinfoRepository.FindFirst(x =>
                                                x.wcstask_type == TaskType.TaskType_Box_Pallet_Outbound.ToString() &&
                                                x.wcstask_state == TaskState.TaskState_RGV_Finished.ToString() &&
                                                x.wcstask_taskNumber == _tasknum &&
                                                x.wcstask_barcode == _rfid.ToString());
                                    if (_tmpTask != null)
                                    {
                                        //启动成功后，在此更新任务状态、上报WMS任务状态
                                        WebResponseContent content = WMSApi.PostTaskStateToWMS(
                                            taskWCSinfo.wcstask_barcode,
                                            TaskState.TaskState_Box_Out_Line_Executing.ToString());
                                        if (content.Status)
                                        {
                                            taskWCSinfo.wcstask_state = TaskState.TaskState_Box_Out_Line_Executing.ToString();
                                            taskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                                            taskWCSinfoRepository.Update(taskWCSinfo, true);

                                            LogRecord.WriteLog(LogEnum.OutBound, $"{DateTime.Now}=>Success=> 【轴承出库】上报WMS更新任务状态成功【TaskState_Box_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】");

                                            Console.WriteLine($"{DateTime.Now}=>Success=> 【空托出库】上报WMS更新任务状态成功【TaskState_Box_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】");
                                        }
                                        else
                                        {
                                            LogRecord.WriteLog(LogEnum.OutBound, $"{DateTime.Now}=>Failed=> 【轴承出库】上报WMS更新任务状态出错【TaskState_Box_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】，原因：{content.Message}");

                                            Console.WriteLine($"{DateTime.Now}=>Failed=> 【空托出库】上报WMS更新任务状态出错【TaskState_Box_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】，原因：{content.Message}");
                                        }
                                    }
                                }
                            }

                            //清除测量出库模式下发的数据
                            //bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_TaskNumber_Outbound_Empty.ToString(), 0);
                            //bool writeBarcode = client.WriteValue(CLineInfoDBName.W_RFID_Outbound_Empty.ToString(), 0);
                            //bool writeStartStation = client.WriteValue(CLineInfoDBName.W_StartStation_Outbound_Empty.ToString(), 0);
                            //bool writeEndStation = client.WriteValue(CLineInfoDBName.W_EndStation_Outbound_Empty.ToString(), 0);
                            //bool writelogicValue = client.WriteValue(CLineInfoDBName.W_Line_Logic_Outbound_Empty.ToString(), 0);
                        }

                    }
                }
                else
                {
                    Console.WriteLine($"::Error::=> 【空托出库】空托出库任务，没有找到任务号对应的任务：{taskNumber}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"::Error::=> 空托出库任务，当穿梭车放货后的处理逻辑出现异常：{ex.Message}");
            }
        }


    }
}