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

namespace WIDESEAWCS_QuartzJob
{
    /// <summary>
    /// 自定义堆垛机
    /// </summary>
    [Description("高常温堆垛机")]
    public class SpeTemperatureStackerCrane : StackerCraneBase, IStackerCrane
    {
        #region Constants

        /// <summary>
        /// 设备等待间隔时间（毫秒）
        /// </summary>
        private const int WaitIntervalMs = 500;

        /// <summary>
        /// 设备等待超时时间基数（毫秒）
        /// </summary>
        private const int WaitTimeoutBaseMs = 6000;

        /// <summary>
        /// 设备等待超时时间倍数
        /// </summary>
        private const int WaitTimeoutMultiplier = 10;

        /// <summary>
        /// 设备等待总超时时间（毫秒）
        /// </summary>
        private static readonly int WaitTotalTimeoutMs = WaitTimeoutMultiplier * WaitTimeoutBaseMs;

        #endregion Constants

        #region Private Member

        /// <summary>
        /// 堆垛机通讯对象
        /// </summary>
        private BaseCommunicator _communicator;

        /// <summary>
        /// 堆垛机协议信息
        /// </summary>
        private readonly List<DeviceProDTO> _deviceProDTOs;

        /// <summary>
        /// 堆垛机协议明细信息
        /// </summary>
        private readonly List<DeviceProtocolDetailDTO> _deviceProtocolDetailDTOs;

        /// <summary>
        /// 设备编号
        /// </summary>
        public readonly string _deviceCode;

        /// <summary>
        /// 设备名称
        /// </summary>
        public readonly string _deviceName;

        /// <summary>
        /// 上一次任务号
        /// </summary>
        private int _lastTaskNum;

        private bool _isChecked = false;

        private bool _heartStart = true;

        private bool _isConnected = true;

        #endregion Private Member

        #region Public Member

        /// <summary>
        /// 通讯对象
        /// </summary>
        public BaseCommunicator Communicator => _communicator;

        /// <summary>
        /// 通讯协议信息
        /// </summary>
        public List<DeviceProDTO> DeviceProDTOs => _deviceProDTOs;

        /// <summary>
        /// 通讯协议明细信息
        /// </summary>
        public List<DeviceProtocolDetailDTO> DeviceProtocolDetailDTOs => _deviceProtocolDetailDTOs;

        /// <summary>
        /// 堆垛机状态
        /// </summary>
        public TemperatureStackerCraneStatus StackerCraneStatusValue => GetStackerCraneStatus();

        /// <summary>
        /// 堆垛机状态中文说明
        /// </summary>
        public string StackerCraneStatusDes => GetEnumDes(StackerCraneStatusValue);

        /// <summary>
        /// 手自动状态
        /// </summary>
        public TemperatureStackerCraneAutoStatus StackerCraneAutoStatusValue => GetStackerCraneAutoStatus();

        /// <summary>
        /// 作业状态
        /// </summary>
        public TemperatureStackerCraneWorkStatus StackerCraneWorkStatusValue => GetStackerCraneWorkStatus();

        /// <summary>
        /// 作业状态中文说明
        /// </summary>
        public string StackerCraneWorkStatusDes => GetEnumDes(StackerCraneWorkStatusValue);

        /// <summary>
        /// 上一次执行的任务号
        /// </summary>
        public int LastTaskNum => _lastTaskNum;

        /// <summary>
        /// 当前正在执行的任务号
        /// </summary>
        public int CurrentTaskNum => GetCurrentTaskNum();

        /// <summary>
        /// 上一次执行的任务类型
        /// </summary>
        public int? LastTaskType { get; set; } = null;

        /// <summary>
        /// 设备编号
        /// </summary>
        public string DeviceCode => _deviceCode;

        /// <summary>
        /// 设备名称
        /// </summary>
        public string DeviceName => _deviceName;

        /// <summary>
        /// 设备是否已连接
        /// </summary>
        public bool IsConnected => Communicator.IsConnected && _isConnected;

        /// <summary>
        /// 堆垛机任务命令
        /// </summary>
        public object StackerCraneTaskCommand { get; set; }

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

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

        #endregion Public Member

        #region Constructor Function

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="communicator">堆垛机通讯对象</param>
        /// <param name="deviceProDTOs">堆垛机协议信息</param>
        /// <param name="deviceProtocolDetailDTOs">堆垛机协议明细信息</param>
        /// <param name="deviceCode">设备编号</param>
        /// <param name="deviceName">设备名称</param>
        public SpeTemperatureStackerCrane(BaseCommunicator communicator, List<DeviceProDTO> deviceProDTOs, List<DeviceProtocolDetailDTO> deviceProtocolDetailDTOs, string deviceCode, string deviceName)
        {
            _communicator = communicator;
            _deviceProDTOs = deviceProDTOs;
            _deviceProtocolDetailDTOs = deviceProtocolDetailDTOs;
            _deviceCode = deviceCode;
            _deviceName = deviceName;
            CheckConnect();
        }

        #endregion Constructor Function

        #region Private Method

        private object GetStatus(string protocolParamType)
        {
            if (!Communicator.IsConnected)
            {
                return StackerCraneStatus.Unkonw.ToString();
            }

            List<DeviceProDTO> devicePros = _deviceProDTOs.Where(x => x.DeviceProParamType == protocolParamType).ToList();
            if (devicePros.Count == 0)
            {
                throw new Exception($"未获取到协议信息，协议参数类型：{protocolParamType}");
            }

            foreach (var devicePro in devicePros)
            {
                object readStatus = Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);

                DeviceProtocolDetailDTO? deviceProtocolDetail = _deviceProtocolDetailDTOs.FirstOrDefault(
                    x => x.DeviceProParamName == devicePro.DeviceProParamType
                    && x.ProtocalDetailValue.Equals(readStatus.ToString()));

                if (deviceProtocolDetail != null)
                {
                    return Convert.ToInt32(readStatus);
                }
            }

            return StackerCraneStatus.Unkonw.ToString();
        }

        /// <summary>
        /// 获取堆垛机设备状态
        /// </summary>
        /// <returns></returns>
        private TemperatureStackerCraneStatus GetStackerCraneStatus()
        {
            return (TemperatureStackerCraneStatus)GetStatus(nameof(TemperatureStackerCraneStatus));
        }

        /// <summary>
        /// 获取堆垛机手自动状态
        /// </summary>
        /// <returns></returns>
        private TemperatureStackerCraneAutoStatus GetStackerCraneAutoStatus()
        {
            return (TemperatureStackerCraneAutoStatus)GetStatus(nameof(TemperatureStackerCraneWorkStatus));
        }

        /// <summary>
        /// 获取堆垛机工作状态
        /// </summary>
        /// <returns></returns>
        private TemperatureStackerCraneWorkStatus GetStackerCraneWorkStatus()
        {
            return (TemperatureStackerCraneWorkStatus)GetStatus(nameof(TemperatureStackerCraneWorkStatus));
        }



        /// <summary>
        /// 获取枚举说明
        /// </summary>
        /// <typeparam name="T">枚举泛型</typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        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 int GetCurrentTaskNum()
        {
            DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CurrentTaskNum));
            return devicePro == null ? throw new Exception($"读取当前任务号错误,未获取到协议信息,请检查配置参数名称是否配置,且配置为{nameof(CurrentTaskNum)}") : (int)Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);
        }

        private void CheckConnect()
        {
            Task.Run(() =>
            {
                while (_heartStart)
                {
                    try
                    {
                        DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault();
                        if (devicePro == null)
                        {
                            _isConnected = false;
                        }
                        else
                        {
                            Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);
                            _isConnected = true;
                        }
                    }
                    catch (Exception ex)
                    {
                        _isConnected = false;
                    }
                    Thread.Sleep(500);
                }
            });
        }

        #endregion Private Method

        #region Public Method

        /// <summary>
        /// 获取堆垛机状态
        /// </summary>
        public T GetStackerCraneStatus<T>() where T : notnull, Enum
        {
            return (T)GetStatus(typeof(T).Name);
        }

        /// <summary>
        /// 释放对象
        /// </summary>
        public void Dispose()
        {
            _heartStart = false;
            _communicator.Dispose();
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 根据参数名称读取堆垛机对应的数据。
        /// </summary>
        /// <typeparam name="TEnum">参数名称枚举类型。</typeparam>
        /// <typeparam name="TResult">读取结果的返回值类型。</typeparam>
        /// <param name="value">参数名称。</param>
        /// <returns>返回读取到的数据。</returns>
        /// <exception cref="Exception"></exception>
        public TResult GetValue<TEnum, TResult>(TEnum value) where TEnum : Enum
        {
            if (!IsConnected) throw new Exception($"通讯连接错误，请检查网络");
            DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == value.ToString());
            return devicePro == null ? throw new Exception($"读取数据错误,未在协议信息里面找到参数{value.ToString()}") : (TResult)Communicator.ReadAsObj(devicePro.DeviceProAddress, devicePro.DeviceDataType);
        }

        /// <summary>
        /// 心跳
        /// </summary>
        public void Heartbeat()
        {
        }

        /// <summary>
        /// 发送任务命令
        /// </summary>
        /// <param name="command">任务命令</param>
        /// <returns></returns>
        public bool SendCommand<T>(T command) where T : IDataTransfer, new()
        {
            if (Communicator is SiemensS7)
            {
                if (!IsConnected) throw new Exception($"通讯连接错误，请检查网络");
                DeviceProDTO? devicePro = _deviceProDTOs.Where(x => x.DeviceProParamType == nameof(DeviceCommand)).OrderBy(x => x.DeviceProOffset).FirstOrDefault();
                if (devicePro == null)
                {
                    return false;
                }
                if (Communicator.WriteCustomer(devicePro.DeviceProAddress, command))
                {
                    StackerCraneTaskCommand = command;
                    //CheckStackerCraneTaskCompleted();
                    return true;
                }
                return false;
            }
            else
            {
                throw new Exception("暂不支持除西门子之外的PLC");
            }
        }

        /// <summary>
        /// 监测堆垛机任务是否完成(防止任务完成事件监测超时，定义手动触发功能)
        /// </summary>
        public void CheckStackerCraneTaskCompleted()
        {
            if (_isChecked)
                return;

            Task.Run(() =>
            {
                _isChecked = true;
                try
                {
                    DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(FormationStackerCraneTaskCompletionStatus));
                    if (devicePro == null)
                        return;

                    DeviceProtocolDetailDTO? deviceProtocolDetail = _deviceProtocolDetailDTOs.FirstOrDefault(
                        x => x.DeviceProParamName == devicePro.DeviceProParamName
                        && x.ProtocolDetailType == FormationStackerCraneTaskCompletionStatus.NormalCompleted.ToString());

                    if (deviceProtocolDetail == null)
                        return;

                    OperateResult<TimeSpan> operateResult = WaitForCompletion(devicePro, deviceProtocolDetail);

                    if (operateResult.IsSuccess)
                    {
                        int taskNum = CurrentTaskNum;
                        StackerCraneTaskCompletedEventArgs args = new(taskNum);
                        StackerCraneTaskCompletedEventHandler?.Invoke(this, args);
                        _lastTaskNum = taskNum;
                    }
                }
                catch (Exception ex)
                {
                    // TODO: 添加日志记录
                }
                finally
                {
                    _isChecked = false;
                }
            });
        }

        /// <summary>
        /// 等待任务完成信号
        /// </summary>
        private OperateResult<TimeSpan> WaitForCompletion(DeviceProDTO devicePro, DeviceProtocolDetailDTO deviceProtocolDetail)
        {
            TypeCode typeCode = SiemensDBDataType.GetTypeCode(devicePro.DeviceDataType);

            return typeCode switch
            {
                TypeCode.Boolean => Communicator.Wait(devicePro.DeviceProAddress, WaitIntervalMs, WaitTotalTimeoutMs,
                    Convert.ToBoolean(deviceProtocolDetail.ProtocalDetailValue)),

                TypeCode.Byte => Communicator.Wait(devicePro.DeviceProAddress, WaitIntervalMs, WaitTotalTimeoutMs,
                    Convert.ToByte(deviceProtocolDetail.ProtocalDetailValue)),

                TypeCode.Int16 => Communicator.Wait(devicePro.DeviceProAddress, WaitIntervalMs, WaitTotalTimeoutMs,
                    Convert.ToInt16(deviceProtocolDetail.ProtocalDetailValue)),

                TypeCode.Int32 => Communicator.Wait(devicePro.DeviceProAddress, WaitIntervalMs, WaitTotalTimeoutMs,
                    Convert.ToInt32(deviceProtocolDetail.ProtocalDetailValue)),

                TypeCode.UInt16 => Communicator.Wait(devicePro.DeviceProAddress, WaitIntervalMs, WaitTotalTimeoutMs,
                    Convert.ToUInt16(deviceProtocolDetail.ProtocalDetailValue)),

                TypeCode.UInt32 => Communicator.Wait(devicePro.DeviceProAddress, WaitIntervalMs, WaitTotalTimeoutMs,
                    Convert.ToUInt32(deviceProtocolDetail.ProtocalDetailValue)),

                _ => new OperateResult<TimeSpan>()
            };
        }

        /// <summary>
        /// 根据参数名称写入堆垛机对应的数据。
        /// </summary>
        /// <typeparam name="TEnum">参数名称枚举类型。</typeparam>
        /// <typeparam name="TValue">要写入的数据类型。</typeparam>
        /// <param name="enum">参数名称。</param>
        /// <param name="value">要写入的数据。</param>
        /// <returns>返回写入成功或失败</returns>
        /// <exception cref="Exception"></exception>
        public bool SetValue<TEnum, TValue>(TEnum @enum, TValue value)
            where TEnum : Enum
            where TValue : notnull
        {
            if (!IsConnected) throw new Exception($"通讯连接错误，请检查网络");
            DeviceProDTO? devicePro = _deviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == @enum.ToString());
            return devicePro == null ? throw new Exception($"写入数据错误,未在协议信息里面找到参数{value.ToString()}") : Communicator.WriteObj(devicePro.DeviceProAddress, devicePro.DeviceDataType, value);
        }

        #endregion Public Method
    }
}