using HslCommunication;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using WIDESEA_Common;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Common.Tools;
using WIDESEA_Core.Utilities;
using WIDESEA_Entity.DomainModels;
using WIDESEA_Services;
using WIDESEA_Services.IRepositories;
using WIDESEA_Services.Repositories;
using WIDESEA_Services.Services;
using WIDESEA_WCS.WCSClient;

namespace WIDESEA_WCS.Jobs.ConveyorLine.InboundArea
{
    public partial class InboundAreaDispatch
    {
        public static string[] OutboundStationNo = new string[] { "50101", "50102", "50103", "50104", "50105", "50106", "50107"};

        //正常模式下的内容
        public static void OutboundStationAction(IDt_TaskWCSinfoRepository taskWCSinfoRepository, IDt_TaskRGVinfoRepository taskRGVinfoRepository, PLCClient client)
        {
            foreach (var item in OutboundStationNo)
            {
                bool flag = bool.Parse(client.ReadValue(CLineInfoDBName.R_Line_LoadSleep.ToString(), item).ToString());
                if (!flag)
                    continue;
                OutboundLineTaskComplete(taskWCSinfoRepository, taskRGVinfoRepository, client, item, false);
            }
        }


        //应急模式下的内容
        public static void OutboundStationAction_YJ(IDt_TaskWCSinfoRepository taskWCSinfoRepository, IDt_TaskRGVinfoRepository taskRGVinfoRepository,
            PLCClient client, bool leftState)
        {
            if (leftState)
            {
                foreach (var item in OutboundStationNo)
                {
                    bool flag = bool.Parse(client.ReadValue(CLineInfoDBName.R_Line_LoadSleep.ToString(), item).ToString());
                    if (!flag)
                        continue;
                    OutboundLineTaskComplete(taskWCSinfoRepository, taskRGVinfoRepository, client, item, false);//true
                }
            }
            else
            {
                foreach (var item in InboundStationNo)
                {
                    bool flag = bool.Parse(client.ReadValue(CLineInfoDBName.R_Line_LoadSleep.ToString(), item).ToString());
                    if (!flag)
                        continue;
                    OutboundLineTaskComplete(taskWCSinfoRepository, taskRGVinfoRepository, client, item, true);
                }
            }
        }

        /// <summary>
        /// 出库RGV完成
        /// </summary>
        /// <param name="taskWCSinfoRepository"></param>
        /// <param name="client"></param>
        /// <param name="station"></param>
        private static void OutboundLineTaskComplete(IDt_TaskWCSinfoRepository taskWCSinfoRepository, IDt_TaskRGVinfoRepository taskRGVinfoRepository,
            PLCClient client, string station, bool yjState)
        {
            try
            {
                string lineCode = yjState ? "Outbound_E_YJ" : "Outbound_E";
                string rfidResult = client.ReadValue(CLineInfoDBName.W_Line_Barcode.ToString(), lineCode).ToString();
                Dt_TaskWCSinfo taskWCSinfo = null;
                if (!string.IsNullOrEmpty(rfidResult) && !"0".Equals(rfidResult))
                    taskWCSinfo = taskWCSinfoRepository.FindFirst(r => r.wcstask_barcode == rfidResult);
                else //找对应任务类型：TaskType_Empty_Pallet_Outbound，并且状态为TaskState_RGV_Finished的任务
                    taskWCSinfo = taskWCSinfoRepository.FindFirst(x =>
                   (x.wcstask_type == TaskType.TaskType_Empty_Pallet_Outbound.ToString() || x.wcstask_type == TaskType.TaskType_Box_Pallet_Outbound.ToString()
                   || x.wcstask_type == TaskType.TaskType_CheckOutbound.ToString()) &&
                   x.wcstask_state == TaskState.TaskState_RGV_Finished.ToString() && x.wcstask_startPoint.Contains(station));


                if (null == taskWCSinfo)
                {
                    ChangeLayerAction(taskWCSinfoRepository, taskRGVinfoRepository, client, station, yjState);
                    return;
                }

                //读取逻辑控制值  查看线体状态，准备给线体下发任务信息
                int logicValue = int.Parse(client.ReadValue(CLineInfoDBName.R_Line_Logic.ToString(), lineCode).ToString());

                //说明工位在等待调度，准备下发任务
                if (logicValue == 1 || logicValue == 2)
                {
                    if (!taskWCSinfo.wcstask_state.Contains("Executing"))
                    {
                        WriteTaskInfo.WriteTaskInfoAction(taskWCSinfo, client, lineCode);
                    }
                }
                rfidResult = client.ReadValue(CLineInfoDBName.W_Line_Barcode.ToString(), lineCode).ToString();
                if (!taskWCSinfo.wcstask_barcode.Equals(rfidResult))
                    return;
                logicValue = int.Parse(client.ReadValue(CLineInfoDBName.R_Line_Logic.ToString(), lineCode).ToString());
                //说明站台已经收到任务数据，等待WCS的启动指令
                if (logicValue == 3)
                {
                    //启动任务
                    client.WriteValue(CLineInfoDBName.W_Line_Logic.ToString(), lineCode, 1);
                }
                else if (logicValue == 4 || logicValue == 5)
                {
                    string state = string.Empty;
                    if (taskWCSinfo.wcstask_type == TaskType.TaskType_Empty_Pallet_Outbound.ToString())
                        state = TaskState.TaskState_Empty_Out_Line_Executing.ToString();
                    else if (taskWCSinfo.wcstask_type == TaskType.TaskType_Box_Pallet_Outbound.ToString()
                        || taskWCSinfo.wcstask_type == TaskType.TaskType_CheckOutbound.ToString())
                        state = TaskState.TaskState_Box_Out_Line_Executing.ToString();
                    else if (taskWCSinfo.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString())
                        state = TaskState.TaskState_Measure_Out_Line_Executing.ToString();

                    if (taskWCSinfo.wcstask_state == state)
                        return;

                    WebResponseContent content = WMSApi.PostTaskStateToWMS(taskWCSinfo.wcstask_barcode, state);
                    string str = string.Empty;
                    if (content.Status)
                    {
                        taskWCSinfo.wcstask_state = state;
                        taskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                        taskWCSinfoRepository.Update(taskWCSinfo, true);

                        str = $" { DateTime.Now }上报WMS更新任务状态成功{state}，托盘号:{taskWCSinfo.wcstask_barcode},任务号：{ taskWCSinfo.wcstask_taskNumber}";
                    }
                    else
                        str = $" { DateTime.Now }上报WMS更新任务状态失败{state}，托盘号:{taskWCSinfo.wcstask_barcode},任务号：{ taskWCSinfo.wcstask_taskNumber},原因:{content.Message}";

                    WriteLog.Info(station).Write(str, station);


                }
            }
            catch (Exception ex)
            {
                WriteLog.Info(station).Write($"{ DateTime.Now }出库站台调度失败:{ex.Message}", station);
            }
        }

        private static void ChangeLayerAction(IDt_TaskWCSinfoRepository taskWCSinfoRepository, IDt_TaskRGVinfoRepository taskRGVinfoRepository,
            PLCClient client, string station, bool yjState)
        {
            try
            {
                string lineCode = yjState ? "ChangeLayer_YJ" : "ChangeLayer";
                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)
                {
                    int logicValue = int.Parse(client.ReadValue(CLineInfoDBName.R_Line_Logic.ToString(), lineCode).ToString());
                    //说明工位在等待调度，准备下发任务
                    if (logicValue == 1 || logicValue == 2)
                    {
                        if (!moveTask.wcstask_state.Contains("Executing"))
                        {
                            WriteTaskInfo.WriteTaskInfoAction(moveTask, client, lineCode);
                        }
                    }
                    else if (logicValue == 3)//说明站台已经收到任务数据，等待WCS的启动指令
                    {
                        client.WriteValue(CLineInfoDBName.W_Line_Logic.ToString(), lineCode, 1);
                    }
                    else 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;
                    rgvInfo.rgvtask_areaCode = "InboundArea";
                    taskRGVinfoRepository.Add(rgvInfo, true);

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

            }
            catch (Exception ex)
            {
                WriteLog.Info(station).Write($"{ DateTime.Now }移库出库站台调度失败:{ex.Message}", station);
            }
        }
    }
}