using System;
using HighWayIot.Log4net;
using HslCommunication;
using HslCommunication.Profinet.Melsec;

namespace HighWayIot.Plc
{
    public class PlcConnect
    {
        private static readonly Lazy<PlcConnect> lazy = new Lazy<PlcConnect>(() => new PlcConnect());

        public static PlcConnect Instance
        {
            get
            {
                return lazy.Value;
            }
        }

        private static LogHelper logHelper = LogHelper.Instance;

        /// <summary>
        /// 静态懒加载MelsecMcNet
        /// </summary>
        private static readonly MelsecMcNet MelsecInstance = new PlcConnect().CreateAb();

        private PlcConnect()
        {

        }

        /// <summary>
        /// 初始化三菱的服务器
        /// </summary>
        /// <returns></returns>
        private MelsecMcNet CreateAb()
        {
            string Ip = "192.168.0.7";
            MelsecMcNet plc = new MelsecMcNet();
            try
            {
                plc.CommunicationPipe = new HslCommunication.Core.Pipe.PipeTcpNet(Ip, 2001)
                {
                    ConnectTimeOut = 1000,    // 连接超时时间，单位毫秒
                    SleepTime = 0,
                    SocketKeepAliveTime = -1,
                    IsPersistentConnection = true,
                };
                var reslt = plc.ConnectServer();
                logHelper.Info($"Plc连接 信息：[{reslt.Message}] 是否成功：[{reslt.IsSuccess.ToString()}] 错误代码：[{reslt.ErrorCode}]");
                if (!reslt.IsSuccess)
                {
                    logHelper.Info("链接失败:"+reslt.Message);
                }
            }
            catch (Exception ex)
            {
                logHelper.Error("初始化PLC服务器发生错误！", ex);
            }

            return plc;
        }

        /// <summary>
        /// plc 是不是保持链接
        /// </summary>
        public static bool IsConnect
        {
            get
            {
                if (MelsecInstance == null) return false;
                var result = MelsecInstance.IpAddress;
                logHelper.Info($"PLCIP：[{result}]");
                return !string.IsNullOrEmpty(result);
            }
        }

        /// <summary>
        /// 写入数据
        /// </summary>
        /// <param name="address">地址</param>
        /// <param name="value">值</param>
        /// <param name="type">数据类型</param>
        /// <returns></returns>
        public static OperateResult PlcWrite(string address, object value, DataTypeEnum type)
        {
            var result = new OperateResult() { IsSuccess = false };
            try
            {
                switch (type)
                {
                    case DataTypeEnum.Bool:
                        result = MelsecInstance.Write(address, Convert.ToBoolean(value));
                        break;
                    //case DataTypeEnum.Byte:
                    //    result = Instance.Write(address, Convert.ToByte(value));
                    //    break;
                    case DataTypeEnum.Int16:
                        result = MelsecInstance.Write(address, Convert.ToInt16(value));
                        break;
                    case DataTypeEnum.UInt16:
                        result = MelsecInstance.Write(address, Convert.ToUInt16(value));
                        break;
                    case DataTypeEnum.Int32:
                        result = MelsecInstance.Write(address, Convert.ToInt32(value));
                        break;
                    case DataTypeEnum.UInt32:
                        result = MelsecInstance.Write(address, Convert.ToUInt32(value));
                        break;
                    case DataTypeEnum.Int64:
                        result = MelsecInstance.Write(address, Convert.ToInt64(value));
                        break;
                    case DataTypeEnum.UInt64:
                        result = MelsecInstance.Write(address, Convert.ToUInt64(value));
                        break;
                    case DataTypeEnum.Float:
                        result = MelsecInstance.Write(address, Convert.ToSingle(value));
                        break;
                    case DataTypeEnum.Double:
                        result = MelsecInstance.Write(address, Convert.ToDouble(value));
                        break;
                    default:
                        throw new ArgumentException($"Unsupported data type: {type}");
                }
                logHelper.PlcLog($"Read address:[{address}] value:[{value}] type:[{type.ToString()}] result:[{result.IsSuccess}]");
            }
            catch (Exception ex)
            {
                logHelper.Error("PLC写入数据发生错误！", ex);
            }
            return result;
        }

        /// <summary>
        /// 读取bool
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static bool ReadBool(string address)
        {
            OperateResult<bool> result = new OperateResult<bool>();
            try
            {
                result = MelsecInstance.ReadBool(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Bool发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取Int16
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static short ReadInt16(string address)
        {
            OperateResult<short> result = new OperateResult<short>();
            try
            {
                result = MelsecInstance.ReadInt16(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Int16发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取UInt16
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static ushort ReadUInt16(string address)
        {
            OperateResult<ushort> result = new OperateResult<ushort>();
            try
            {
                result = MelsecInstance.ReadUInt16(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Int16发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取Int32
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static int ReadInt32(string address)
        {
            OperateResult<int> result = new OperateResult<int>();
            try
            {
                result = MelsecInstance.ReadInt32(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Int16发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取UInt32
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static uint ReadUInt32(string address)
        {
            OperateResult<uint> result = new OperateResult<uint>();
            try
            {
                result = MelsecInstance.ReadUInt32(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Int16发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取Int64
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static long ReadInt64(string address)
        {
            OperateResult<long> result = new OperateResult<long>();
            try
            {
                result = MelsecInstance.ReadInt64(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Int16发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取UInt64
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static ulong ReadUInt64(string address)
        {
            OperateResult<ulong> result = new OperateResult<ulong>();
            try
            {
                result = MelsecInstance.ReadUInt64(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Int16发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取Float
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static float ReadFloat(string address)
        {
            OperateResult<float> result = new OperateResult<float>();
            try
            {
                result = MelsecInstance.ReadFloat(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Float发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }

        /// <summary>
        /// 读取Double
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static double ReadDouble(string address)
        {
            OperateResult<double> result = new OperateResult<double>();
            try
            {
                result = MelsecInstance.ReadDouble(address);
            }
            catch (Exception ex)
            {
                logHelper.Error($"PLC读取Double发生错误！address:[{address}]", ex);
                return default;
            }
            if (!result.IsSuccess)
            {
                return default;
            }
            return result.Content;
        }
    }
}