using HslCommunication;
using System.ComponentModel;
using System.Reflection;
using WIDESEAWCS_Communicator;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.StackerCrane;
using WIDESEAWCS_QuartzJob.StackerCrane.Enum;

namespace WIDESEAWCS_Tasks.StackerCraneJob
{
    public class GetStackerObject
    {
        private SpeStackerCrane _speStackerCrane;

        public GetStackerObject(SpeStackerCrane speStackerCrane)
        {
            _speStackerCrane = speStackerCrane;
        }
        /// <summary>
        /// 设备状态
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public RgvEquipmentStatus RgvCraneStatusValue => GetRgvCraneStatus();

        /// <summary>
        /// 工作模式（1联机 0脱机）
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public RgvCraneAutoStatus RgvCraneAutoStatusValue => GetRgvCraneAutoStatus();

        /// <summary>
        /// 工作状态
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public RgvWorkStatus RgvCraneWorkStatusValue => GetRgvCraneWorkStatus();

        /// <summary>
        /// 作业状态
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public RgvJobCraneStatus StaclerkJobJobStatusValue => GetRgvJobCraneWorkStatus();

        /// <summary>
        /// 任务完成
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public StackerCraneTaskCompleted StackerCraneTaskCompletedValue => GetStackerCraneTaskCompleted();

        /// <summary>
        /// 作业命令
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public int WorkCommandValue() => _speStackerCrane.GetValue<RgvCraneDBName, short>(RgvCraneDBName.WorkCommand);

        /// <summary>
        /// 获取RGV设备状态
        /// </summary>
        /// <returns></returns>
        private RgvEquipmentStatus GetRgvCraneStatus()
        {
            return Enum.Parse<RgvEquipmentStatus>(GetStatus(nameof(RgvEquipmentStatus)));
        }

        /// <summary>
        /// 获取rgv手自动状态
        /// </summary>
        /// <returns></returns>
        private RgvCraneAutoStatus GetRgvCraneAutoStatus()
        {
            return Enum.Parse<RgvCraneAutoStatus>(GetStatus(nameof(RgvCraneAutoStatus)));
        }

        /// <summary>
        /// 获取rgv工作状态
        /// </summary>
        /// <returns></returns>
        private RgvWorkStatus GetRgvCraneWorkStatus()
        {
            return Enum.Parse<RgvWorkStatus>(GetStatus(nameof(RgvWorkStatus)));
        }

        /// <summary>
        /// 获取rgv作业状态
        /// </summary>
        /// <returns></returns>
        private RgvJobCraneStatus GetRgvJobCraneWorkStatus()
        {
            return Enum.Parse<RgvJobCraneStatus>(GetStatus(nameof(RgvJobCraneStatus)));
        }

        /// <summary>
        /// 获取堆垛机任务状态
        /// </summary>
        /// <returns></returns>
        private StackerCraneTaskCompleted GetStackerCraneTaskCompleted()
        {
            return Enum.Parse<StackerCraneTaskCompleted>(GetStatus(nameof(StackerCraneTaskCompleted)));
        }

        private string GetEnumDes<T>(T value) where T : Enum
        {
            FieldInfo? fieldInfo = typeof(T).GetField(value.ToString());
            if (fieldInfo != null)
            {
                DescriptionAttribute? descriptionAttribute = fieldInfo.GetCustomAttribute<DescriptionAttribute>();
                if (descriptionAttribute != null)
                {
                    return descriptionAttribute.Description;
                }
                return "未定义";
            }
            return "未知";
        }

        private string GetStatus(string protocolParamType)
        {
            List<DeviceProDTO> devicePros = _speStackerCrane.DeviceProDTOs.Where(x => x.DeviceProParamType == protocolParamType).ToList();
            if (devicePros.Count == 0)
            {
                throw new Exception("未获取到协议信息");
            }
            for (int i = 0; i < devicePros.Count; i++)
            {
                object readStatus = _speStackerCrane.Communicator.ReadAsObj(devicePros[i].DeviceProAddress, devicePros[i].DeviceDataType);
                DeviceProtocolDetailDTO? deviceProtocolDetail = _speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePros[i].DeviceProParamName) ?? throw new Exception();
                deviceProtocolDetail = _speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePros[i].DeviceProParamType && x.ProtocalDetailValue.Equals(readStatus.ToString()));
                if (deviceProtocolDetail != null)
                {
                    return deviceProtocolDetail.ProtocolDetailType;
                }
                return StackerCraneStatus.Unkonw.ToString();
            }
            return StackerCraneStatus.Unkonw.ToString();
        }

        /// <summary>
        /// 堆垛机任务完成事件
        /// </summary>
        public event EventHandler<StackerCraneTaskCompletedEventArgs> StackerCraneTaskCompletedEventHandler;


        /// <summary>
        /// 堆垛机完成事件是否已订阅
        /// </summary>
        public bool IsEventSubscribed => StackerCraneTaskCompletedEventHandler != null;


        private bool _isChecked = false;

        /// <summary>
        /// 监测堆垛机任务是否完成
        /// </summary>
        public void CheckStackerCraneTaskCompleted()
        {
            if (_isChecked)
                return;

            Task.Run(() =>
            {
                _isChecked = true;
                try
                {
                    DeviceProDTO? devicePro = _speStackerCrane.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(StackerCraneTaskCompleted));
                    if (devicePro != null)
                    {
                        DeviceProtocolDetailDTO? deviceProtocolDetail = _speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePro.DeviceProParamName && x.ProtocolDetailType == StackerCraneTaskCompleted.WorkCompleted.ToString());
                        if (deviceProtocolDetail != null)
                        {
                            OperateResult<TimeSpan> operateResult = new OperateResult<TimeSpan>();
                            TypeCode typeCode = SiemensDBDataType.GetTypeCode(devicePro.DeviceDataType);
                            switch (typeCode)
                            {
                                case TypeCode.Boolean:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToBoolean(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.Byte:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToByte(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.Int16:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToInt16(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.Int32:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToInt32(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.UInt16:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToUInt16(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.UInt32:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToUInt32(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                default:
                                    break;
                            }
                            int taskNum = _speStackerCrane.CurrentTaskNum;
                            if (operateResult.IsSuccess)
                            {
                                StackerCraneTaskCompletedEventArgs args = new(taskNum);
                                StackerCraneTaskCompletedEventHandler?.Invoke(_speStackerCrane, args);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {

                }
                finally
                {
                    _isChecked = false;
                }
            });
        }

        public bool SendCommand(RgvCraneTaskCommand command)
        {
            try
            {
                if(_speStackerCrane.IsConnected)
                {
                    _speStackerCrane.SetValue(RgvCraneDBName.TaskNo, command.TaskNo);
                    _speStackerCrane.SetValue(RgvCraneDBName.WorkType, command.WorkType);
                    _speStackerCrane.SetValue(RgvCraneDBName.GoodsType, command.GoodsType);
                    _speStackerCrane.SetValue(RgvCraneDBName.StartPos, command.StartPos);
                    _speStackerCrane.SetValue(RgvCraneDBName.EndPos, command.EndPos);
                    return true;
                }
                return false;

            }
            catch (Exception ex)
            {
                return false;
            }
        }
    }
}