using HslCommunication;
using HslCommunication.Core.Address;
using HslCommunication.Profinet.Siemens;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading;
using WIDESEA_Common;
using WIDESEA_Common.CutomerModel;
using WIDESEA_Core.Utilities;

namespace WIDESEA_WCS.WCSClient
{
    public class PLCClient
    {
        /// <summary>
        /// 西门子S7网络协议客户端
        /// </summary>
        public SiemensS7Net SiemensS7NetClient { get; set; }
        /// <summary>
        /// PLC连接对应的地址
        /// </summary>
        public List<DBItemGroup> PLCDBItems { get; set; }
        /// <summary>
        /// 连接PLC设备名称
        /// </summary>
        public string PLCName { get; set; }
        /// <summary>
        /// 连接PLC网络IP地址
        /// </summary>
        public string PLCIPAddress { get; set; }
        /// <summary>
        /// 连接PLC描述说明
        /// </summary>
        public string PLCDescription { get; set; }
        /// <summary>
        /// 连接PLC端口号(默认102)
        /// </summary>
        public int Port { get; set; } = 102;
        /// <summary>
        /// 
        /// </summary>
        public byte Rack { get; set; } = 0;
        /// <summary>
        /// 
        /// </summary>
        public byte Slot { get; set; } = 0;
        /// <summary>
        /// 连接PLC是否成功
        /// </summary>
        public bool IsConnected { get; set; } = false;
        /// <summary>
        /// 连接信息
        /// </summary>
        public string ConnectionMessage { get; set; }
        /// <summary>
        /// PLC信息设备类型
        /// </summary>
        public string plcinfo_equiptype { get; set; }

        /// <summary>
        /// 检测PLC的心跳包
        /// </summary>
        public bool heartFlag { get; set; } = true;

        /// <summary>
        /// 构造方法,实例化连接对象及PLC连接对应的地址
        /// </summary>
        /// <param name="SiemensPLCS">西门子PLC系列</param>
        public PLCClient(SiemensPLCS SiemensPLCS = SiemensPLCS.S1500)//此处固定使用了S1500，预计更改为根据数据库配置灵活使用
        {
            this.SiemensS7NetClient = new SiemensS7Net(SiemensPLCS);
            PLCDBItems = new List<DBItemGroup>();
        }

        /// <summary>
        /// PLC连接内置线程
        /// </summary>
        Thread Thread { get; set; }

        /// <summary>
        /// 内置线程是否运行
        /// </summary>
        bool isRun { get; set; }

        #region 内置线程 PING IP
        /// <summary>
        /// 内置线程 PING IP
        /// </summary>
        public void Start(Action action)
        {
            Thread = new Thread(() =>
            {
                while (isRun)
                {                    
                    Thread.Sleep(1000);
                    OperateResult<int> connectRead = SiemensS7NetClient.ReadInt32("DB500.436");
                    if (connectRead.IsSuccess)
                    {
                        if(!IsConnected)
                        {
                            Console.WriteLine($"【{SiemensS7NetClient.IpAddress}】PLC重连成功！");
                        }
                        IsConnected = true;
                        if(heartFlag)
                        {
                            if (WCSService.webServer.IsStarted)
                            {
                                Dictionary<string, string> heartData = new Dictionary<string, string>();
                                heartData.Add("IpAddress", SiemensS7NetClient.IpAddress);
                                heartData.Add("status", "on");
                                heartData.Add("currentDate", DateTimeHelper.GetFormatDateString());
                                string heartStr = JsonConvert.SerializeObject(heartData);
                                WCSService.webServer.PublishAllClientPayload(heartStr);
                            }
                        }
                        else
                        {
                            if (WCSService.webServer.IsStarted)
                            {
                                Dictionary<string, string> heartData = new Dictionary<string, string>();
                                heartData.Add("IpAddress", SiemensS7NetClient.IpAddress);
                                heartData.Add("status", "off");
                                heartData.Add("currentDate", DateTimeHelper.GetFormatDateString());
                                string heartStr = JsonConvert.SerializeObject(heartData);
                                WCSService.webServer.PublishAllClientPayload(heartStr);
                            }
                        }
                        heartFlag = !heartFlag;
                    }
                    else
                    {
                        IsConnected = false;
                       // Console.WriteLine($"【{SiemensS7NetClient.IpAddress}】PLC断开连接，并且在此重连");
                        Connect();
                        if (WCSService.webServer.IsStarted)
                        {
                            Dictionary<string, string> heartData = new Dictionary<string, string>();
                            heartData.Add("IpAddress", SiemensS7NetClient.IpAddress);
                            heartData.Add("status", "off");
                            heartData.Add("currentDate", DateTimeHelper.GetFormatDateString());
                            string heartStr = JsonConvert.SerializeObject(heartData);
                            WCSService.webServer.PublishAllClientPayload(heartStr);
                        }
                    }
                }

            });
            Thread.Start();
        }
        #endregion

        #region 连接PLC,将短连接切换成长连接模式
        /// <summary>
        /// 连接PLC
        /// </summary>
        public string Connect()
        {
            this.SiemensS7NetClient.IpAddress = PLCIPAddress;
            this.SiemensS7NetClient.Port = Port;
            this.SiemensS7NetClient.Rack = Rack;
            this.SiemensS7NetClient.Slot = Slot;
            this.SiemensS7NetClient.ConnectTimeOut = 2;
            this.SiemensS7NetClient?.ConnectClose();

            OperateResult result = this.SiemensS7NetClient.ConnectServer();
            isRun = true;

            if (!result.IsSuccess)
            {
                //WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{PLCName}连接失败{Environment.NewLine}错误信息：{result.Message}", PLCName);
                IsConnected = false;
                return $"连接失败,错误信息：{result.Message}";
            }
            else
            {
                IsConnected = true;

                //WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{PLCName}连接成功！", PLCName);
                return $"连接成功";
            }

        }
        #endregion

        #region 断开与PLC的连接,将短连接切换成长连接模式
        /// <summary>
        /// 断开与PLC的连接
        /// </summary>
        public void Disconnect()
        {
            this.SiemensS7NetClient?.ConnectClose();
            isRun = false;
            this.SiemensS7NetClient?.Dispose();
            WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：已断开与{PLCName}的连接！", PLCName);
        }
        #endregion

        #region 根据名称/描述读取PLC数据
        /// <summary>
        /// 根据名称/描述读取PLC数据
        /// </summary>
        /// <param name="itemName">名称/描述（数据库中plcdetail_name列）</param>
        /// <returns></returns>
        public virtual object ReadValue(string itemName)
        {
            lock (this.SiemensS7NetClient)
            {
                object result = null;
                DBItemGroup item = this.PLCDBItems.Where(x => x.ItemName == itemName).FirstOrDefault();
                if (item == null)
                    return -1;
                string itemAddress = item.ItemAddress;
                string itemDatatype = item.ItemDataType;
                try
                {
                    result = Read(itemAddress, itemDatatype);
                }
                catch (Exception ex)
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{Environment.NewLine}{PLCName}读取数据失败{Environment.NewLine}数据类型：{item.ItemDataType}，{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
                }
                try
                {
                    //WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{Environment.NewLine}{PLCName}读取数据{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：" + result, PLCName);
                }
                catch
                {

                }
                return result;
            }

        }
        #endregion

        #region 根据PLCDBItem读取PLC数据
        /// <summary>
        /// 根据PLCDBItem读取PLC数据
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public virtual object ReadValue(DBItemGroup item)
        {
            lock (this.SiemensS7NetClient)
            {
                object result = null;
                if (item == null)
                    return -1;
                string itemAddress = item.ItemAddress;
                string itemDatatype = item.ItemDataType;
                try
                {
                    result = Read(itemAddress, itemDatatype);
                }
                catch (Exception ex)
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{Environment.NewLine}{PLCName}读取数据失败{Environment.NewLine}数据类型：{item.ItemDataType}，{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
                }
                try
                {
                    //WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{Environment.NewLine}{PLCName}读取数据{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：" + result, PLCName);
                }
                catch
                {

                }
                return result;
            }

        }
        #endregion

        #region 根据设备编号读取PLC数据
        /// <summary>
        /// 根据设备编号读取PLC数据
        /// </summary>
        /// <param name="equipNum">设备编号</param>
        /// <returns>json字符串</returns>
        public object ReadValues(string equipNum)
        {
            lock (this.SiemensS7NetClient)
            {
                object result = null;
                Dictionary<string, object> keyValuePairs = new Dictionary<string, object>();
                List<DBItemGroup> items = this.PLCDBItems.Where(x => x.EquipNum == equipNum).ToList();
                for (int i = 0; i < items.Count(); i++)
                {
                    keyValuePairs.Add(items[i].ItemName, ReadValue(items[i].ItemName));
                }
                result = JsonConvert.SerializeObject(keyValuePairs);
                return result;
            }

        }
        #endregion

        #region 根据名称/描述读取PLC数据返回设备编号和值的JSON字符串
        /// <summary>
        /// 根据名称/描述读取PLC数据返回设备编号和值的JSON字符串
        /// </summary>
        /// <param name="itemName">名称/描述（数据库中plcdetail_name列）</param>
        /// <returns>json字符串</returns>
        public string ReadValuesByItemName(string itemName)
        {
            lock (this.SiemensS7NetClient)
            {
                string result = null;
                Dictionary<string, object> keyValuePairs = new Dictionary<string, object>();
                List<DBItemGroup> items = this.PLCDBItems.Where(x => x.ItemName == itemName).ToList();
                for (int i = 0; i < items.Count(); i++)
                {
                    keyValuePairs.Add(items[i].EquipNum, ReadValue(items[i]));
                }
                result = JsonConvert.SerializeObject(keyValuePairs);
                return result;
            }

        }
        #endregion

        #region 根据名称/描述和设备编号读取PLC数据
        /// <summary>
        /// 根据名称/描述和设备编号读取PLC数据
        /// </summary>
        /// <param name="itemName">名称/描述（数据库中plcdetail_name列）</param>
        /// <param name="equipNum">设备编号</param>
        /// <returns></returns>
        public virtual object ReadValue(string itemName, string equipNum)
        {
            lock (this.SiemensS7NetClient)
            {
                object result = null;
                DBItemGroup item = this.PLCDBItems.Where(x => x.ItemName == itemName && x.EquipNum == equipNum).FirstOrDefault();
                if (item == null)
                {
                    try
                    {
                        WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{Environment.NewLine}{PLCName}读取数据{Environment.NewLine}{Environment.NewLine}({equipNum})：未在协议找到编号{equipNum}的地址", PLCName);
                    }
                    catch
                    {

                    }
                    throw new Exception($"未在协议找到编号{equipNum}的地址");
                }

                string itemAddress = item.ItemAddress;
                string itemDatatype = item.ItemDataType;
                try
                {
                    result = Read(itemAddress, itemDatatype);
                }
                catch (Exception ex)
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{Environment.NewLine}{PLCName}读取数据失败{Environment.NewLine}数据类型：{item.ItemDataType}，{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
                }
                try
                {
                    //WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{Environment.NewLine}{PLCName}读取数据{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：" + result, PLCName);
                }
                catch
                {

                }
                return result;
            }

        }
        #endregion

        #region 将数据写入到PLC中
        /// <summary>
        /// 将数据写入到PLC中
        /// </summary>
        /// <param name="itemName">名称/描述（数据库中plcdetail_name列）</param>
        /// <param name="value">写入的值</param>
        /// <returns></returns>
        public virtual bool WriteValue(string itemName, object value)
        {
            lock (this.SiemensS7NetClient)
            {
                OperateResult operateResult = new OperateResult(); ;
                bool result = false;
                string writeResult = "";
                DBItemGroup item = this.PLCDBItems.Where(x => x.ItemName == itemName).FirstOrDefault();
                if (item == null)
                    return false;
                string itemAddress = item.ItemAddress;
                string itemDatatype = item.ItemDataType;
                try
                {
                    operateResult = Write(itemAddress, itemDatatype, value);
                    result = operateResult.IsSuccess;
                    writeResult = result ? "成功" : $"失败:{operateResult.Message}";
                }
                catch (Exception ex)
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：时间:{DateTime.Now},{PLCName}写入数据失败{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
                }
                try
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：时间:{DateTime.Now},{PLCName}写入数据{writeResult}{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：" + value, PLCName);
                }
                catch
                {

                }
                return result;
            }
        }
        #endregion

        #region 将数据写入到PLC中
        /// <summary>
        /// 将数据写入到PLC中
        /// </summary>
        /// <param name="itemName">名称/描述（数据库中plcdetail_name列）</param>
        /// <param name="value">写入的值</param>
        /// <returns></returns>
        public virtual bool WriteValue(string itemName, string equipNum, object value)
        {
            lock (this.SiemensS7NetClient)
            {
                OperateResult operateResult = new OperateResult(); ;
                bool result = false;
                string writeResult = "";
                DBItemGroup item = this.PLCDBItems.Where(x => x.ItemName == itemName && x.EquipNum == equipNum).FirstOrDefault();
                if (item == null)
                    return false;
                string itemAddress = item.ItemAddress;
                string itemDatatype = item.ItemDataType;
                try
                {
                    for (int i = 0; i < 3; i++)
                    {
                        operateResult = Write(itemAddress, itemDatatype, value);
                        Thread.Sleep(33);
                        //flag = ReadValue(item).ToString();
                        //if (!value.ToString().Equals(flag))
                        //{
                        //    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：时间:{DateTime.Now},{PLCName}写入数据失败{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：要写入的数据与读取的数据不符,读取数据:{flag},写入数据:{value}", PLCName);
                        //    return false;
                        //}

                        result = operateResult.IsSuccess;
                        if (result)
                            break;
                    }
                    //writeResult = operateResult.IsSuccess ? "成功" : $"失败:{operateResult.Message}";
                }
                catch (Exception ex)
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：时间:{DateTime.Now},{PLCName}写入数据失败{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
                }
                try
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：时间:{DateTime.Now},{PLCName}写入数据{writeResult}{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：" + value, PLCName);
                }
                catch
                {

                }
                return result;
            }
        }
        #endregion

        #region 批量写入数据
        /// <summary>
        /// 批量写入数据（数据类型必须一致）
        /// </summary>
        /// <param name="adress">DB块起始地址</param>
        /// <param name="type">数据类型</param>
        /// <param name="value">写入的值</param>
        /// <returns></returns>
        public OperateResult WriteArray(string adress, string type, object[] value)
        {
            OperateResult result = new OperateResult();
            try
            {
                switch (type.ToLower())
                {
                    case "int":
                        ushort[] tmp = new ushort[value.Length];
                        for (int i = 0; i < value.Length; i++)
                        {
                            tmp[i] = Convert.ToUInt16(value[i]);
                        }

                        result = this.SiemensS7NetClient.Write(adress, tmp);
                        break;
                    case "dint":
                        //result = this.SiemensS7NetClient.Write(adress, value as byte[]);
                        break;
                    case "char":
                        string temp = value.ToString();
                        byte[] writeData = Encoding.Default.GetBytes(temp);
                        result = this.SiemensS7NetClient.Write(adress, writeData);
                        break;
                    case "bool":
                        //result = this.SiemensS7NetClient.Write(adress, value);
                        break;
                }
            }
            catch (Exception ex)
            {
                WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{PLCName}写入数据失败{Environment.NewLine}数据类型：{type}{Environment.NewLine}{adress}：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
            }
            return result;
        }
        /// <summary>
        /// 按操作符类型写数组
        /// </summary>
        /// <param name="itemOperatorType">操作类型</param>
        /// <param name="value">写入的数组</param>
        /// <returns></returns>
        public bool WriteArrayByOperatorType(string itemOperatorType, object[] value)
        {
            bool result = false;
            try
            {
                OperateResult operateResult = new OperateResult(); ;
                string writeResult = "";
                DBItemGroup item = this.PLCDBItems.Where(x => x.ItemOperatorType == itemOperatorType).OrderBy(x => x.EquipNum).OrderBy(r => r.ItemAddress).FirstOrDefault();
                if (item == null)
                    return false;
                string itemAddress = item.ItemAddress;
                string itemDatatype = item.ItemDataType;
                try
                {
                    operateResult = WriteArray(itemAddress, itemDatatype, value);
                    result = operateResult.IsSuccess;
                    writeResult = result ? "成功" : $"失败:{operateResult.Message}";
                }
                catch (Exception ex)
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：时间:{DateTime.Now},{PLCName}写入数据失败{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
                }
            }
            catch (Exception ex)
            {
                WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：时间:{DateTime.Now},{PLCName}写入数据失败{Environment.NewLine}错误信息：{ex.Message}", PLCName);
            }
            return result;
        }
        #endregion

        #region 批量读取数据
        /// <summary>
        /// 批量读取数据（数据类型必须一致）
        /// </summary>
        /// <param name="adress">DB块起始地址</param>
        /// <param name="type">数据类型</param>
        /// <param name="length">读取长度</param>
        /// <returns></returns>
        public object ReadArray(string adress, string type, int length)
        {
            object result = -1; ;
            try
            {
                switch (type.ToLower())
                {
                    case "int":
                        result = this.SiemensS7NetClient.ReadUInt16(adress, Convert.ToUInt16(length)).Content;
                        break;
                    case "dint":
                        result = this.SiemensS7NetClient.ReadUInt32(adress, Convert.ToUInt16(length)).Content;
                        break;
                    case "char":
                        byte[] temps = this.SiemensS7NetClient.Read(adress, Convert.ToUInt16(length)).Content;
                        result = Encoding.Default.GetString(temps).ToCharArray();
                        break;
                    case "bool":
                        result = this.SiemensS7NetClient.ReadBool(adress, Convert.ToUInt16(length)).Content;
                        break;
                    case "byte":
                        break;
                }
            }
            catch (Exception ex)
            {

                WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{Environment.NewLine}{PLCName}读取数据失败{Environment.NewLine}数据类型：{type}，{adress}：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
            }
            return result;
        }
        #endregion

        #region 批量读取数据(改)著:曾南阳
        /// <summary>
        /// 批量读取数据（根据数据库配置批量读取）
        /// </summary>
        /// <param name="itemName">名称描述</param>
        /// <param name="equipNum">设备编号</param>
        /// <param name="length">读取长度</param>
        /// <returns></returns>
        public object ReadArrays(string itemName, string equipNum, int length)
        {
            lock (this.SiemensS7NetClient)
            {
                object result = null;
                DBItemGroup item = this.PLCDBItems.Where(x => x.ItemName == itemName && x.EquipNum == equipNum).FirstOrDefault();
                if (item == null)
                {
                    try
                    {
                        WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{Environment.NewLine}{PLCName}读取数据{Environment.NewLine}{Environment.NewLine}({equipNum})：未在协议找到编号{equipNum}的地址", PLCName);
                    }
                    catch
                    {

                    }
                    throw new Exception($"未在协议找到编号{equipNum}的地址");
                }

                string itemAddress = item.ItemAddress;
                string itemDatatype = item.ItemDataType;
                try
                {
                    result = Read(itemAddress, itemDatatype, length);
                }
                catch (Exception ex)
                {
                    WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{Environment.NewLine}{PLCName}读取数据失败{Environment.NewLine}数据类型：{item.ItemDataType}，{item.Remark}({itemAddress})：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
                }
                try
                {
                    //WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{Environment.NewLine}{PLCName}读取数据{Environment.NewLine}数据类型：{item.ItemDataType}{Environment.NewLine}{item.Remark}({itemAddress})：" + result, PLCName);
                }
                catch
                {

                }
                return result;
            }
        }
        #endregion

        #region 根据名称/描述读取指定长度的bool数组
        /// <summary>
        /// 根据名称/描述读取指定长度的bool数组
        /// </summary>
        /// <param name="itemName">起始地址名称/描述（数据库中plcdetail_name列）</param>
        /// <param name="length">读取的长度信息</param>
        /// <param name="equipNum">设备编号</param>
        /// <returns></returns>
        public OperateResult<bool[]> ReadBool(string itemName, ushort length, string equipNum)
        {
            string address = this.PLCDBItems.Where(x => x.ItemName == itemName && x.EquipNum == equipNum).FirstOrDefault().ItemAddress;
            OperateResult<S7AddressData> operateResult = S7AddressData.ParseFrom(address);
            bool flag = !operateResult.IsSuccess;
            OperateResult<bool[]> result;
            if (flag)
            {
                result = OperateResult.CreateFailedResult<bool[]>(operateResult);
            }
            else
            {
                ushort length2 = (ushort)((operateResult.Content.AddressStart + (int)length - 1) / 8 - operateResult.Content.AddressStart / 8 + 1);
                int num = operateResult.Content.AddressStart % 8;
                operateResult.Content.AddressStart = operateResult.Content.AddressStart - num;
                operateResult.Content.Length = length2;
                OperateResult<byte[]> operateResult2 = this.SiemensS7NetClient.Read(new S7AddressData[]
                {
            operateResult.Content
                });
                bool flag2 = !operateResult2.IsSuccess;
                if (flag2)
                {
                    result = OperateResult.CreateFailedResult<bool[]>(operateResult2);
                }
                else
                {
                    result = OperateResult.CreateFailedResult<bool[]>(operateResult2);
                    //result = OperateResult.CreateSuccessResult<bool[]>(operateResult2.Content.ToBoolArray().SelectMiddle(num, (int)length));
                    //WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Info：{Environment.NewLine}{PLCName}读取数据{Environment.NewLine}数据类型：bool{Environment.NewLine}状态({address},长度:{length})：" + JsonConvert.SerializeObject(result.Content), PLCName);
                }
            }
            return result;
        }
        #endregion

        #region 根据DB地址及类型读取数据，最根本读取方法
        /// <summary>
        /// 根据DB地址及类型读取数据
        /// </summary>
        /// <param name="adress">DB地址(DB块+.+偏移量)</param>
        /// <param name="type">数据类型(int/dint/string/bool)</param>
        /// <returns></returns>
        public object Read(string adress, string type)
        {
            object result = -1; ;
            try
            {
                switch (type.ToLower())
                {
                    case "int":
                        result = this.SiemensS7NetClient.ReadInt16(adress).Content;
                        break;
                    case "dint":
                        result = this.SiemensS7NetClient.ReadUInt32(adress).Content;
                        break;
                    case "string":
                        OperateResult<string> operateResult = this.SiemensS7NetClient.ReadString(adress);
                        operateResult.Content = operateResult.Content?.Replace("\\", "")?.Replace("\0", "")?.Replace("\u0014", "");
                        result = operateResult == null ? null : operateResult;
                        break;
                    case "bool":
                        result = this.SiemensS7NetClient.ReadBool(adress).Content;
                        break;
                    case "byte":
                        result = this.SiemensS7NetClient.ReadByte(adress).Content;
                        break;
                    case "word":
                        result = this.SiemensS7NetClient.ReadUInt16(adress).Content;
                        break;
                    default:
                        throw new Exception($"未找到该数据类型:{type}");
                        //break;
                }
            }
            catch (Exception ex)
            {
                StackTrace stackTrace = new StackTrace();
                StackFrame[] stackFrames = stackTrace.GetFrames();
                string str = "";
                foreach (var item in stackFrames)
                {
                    str += "方法名:" + item.GetMethod().Name + ",行号:" + item.GetFileLineNumber() + ",文件名:" + item.GetFileName() + Environment.NewLine;
                }
                WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{Environment.NewLine}{PLCName}读取数据失败{Environment.NewLine}数据类型：{type}，{adress}：{Environment.NewLine}错误信息：{ex.Message},{str}", PLCName);
            }
            return result;
        }
        #endregion
        #region 根据DB地址及类型批量读取数据，最根本读取方法
        /// <summary>
        /// 根据DB地址及类型批量读取数据
        /// </summary>
        /// <param name="adress">DB地址(DB块+.+偏移量)</param>
        /// <param name="type">数据类型(int/dint/string/bool)</param>
        /// <returns></returns>
        public object Read(string adress, string type, int length)
        {
            object result = -1; ;
            try
            {
                switch (type.ToLower())
                {
                    case "int":
                        result = this.SiemensS7NetClient.ReadUInt16(adress, Convert.ToUInt16(length)).Content;
                        break;
                    case "dint":
                        result = this.SiemensS7NetClient.ReadUInt32(adress, Convert.ToUInt16(length)).Content;
                        break;
                    case "char":
                        byte[] temps = this.SiemensS7NetClient.Read(adress, Convert.ToUInt16(length)).Content;
                        result = Encoding.Default.GetString(temps).ToCharArray();
                        break;
                    case "bool":
                        result = this.SiemensS7NetClient.ReadBool(adress, Convert.ToUInt16(length)).Content;
                        break;
                    case "word":
                        result = this.SiemensS7NetClient.ReadUInt16(adress, Convert.ToUInt16(length)).Content;
                        break;
                    default:
                        throw new Exception($"未找到该数据类型:{type}");
                }
            }
            catch (Exception ex)
            {
                StackTrace stackTrace = new StackTrace();
                StackFrame[] stackFrames = stackTrace.GetFrames();
                string str = "";
                foreach (var item in stackFrames)
                {
                    str += "方法名:" + item.GetMethod().Name + ",行号:" + item.GetFileLineNumber() + ",文件名:" + item.GetFileName() + Environment.NewLine;
                }
                WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{Environment.NewLine}{PLCName}读取数据失败{Environment.NewLine}数据类型：{type}，{adress}：{Environment.NewLine}错误信息：{ex.Message},{str}", PLCName);
            }
            return result;
        }
        #endregion

        #region 根据DB地址及类型写入数据，最根本写入方法
        /// <summary>
        /// 根据DB地址及类型写入数据
        /// </summary>
        /// <param name="adress">DB地址(DB块+.+偏移量)</param>
        /// <param name="type">数据类型(int/dint/string/bool)</param>
        /// <param name="value">写入的值</param>
        /// <returns>返回成功或失败</returns>
        public OperateResult Write(string adress, string type, object value)
        {
            OperateResult result = new OperateResult();
            try
            {
                switch (type.ToLower())
                {
                    case "int":
                        result = this.SiemensS7NetClient.Write(adress, Convert.ToInt16(value));
                        break;
                    case "dint":
                        result = this.SiemensS7NetClient.Write(adress, Convert.ToUInt32(value));
                        break;
                    case "string":
                        //string[] adressTmp = adress.Split('.');
                        result = this.SiemensS7NetClient.Write(adress, value.ToString());
                        break;
                    case "bool":
                        result = this.SiemensS7NetClient.Write(adress, Convert.ToBoolean(value));
                        break;
                    case "byte":
                        {
                            byte[] by = { Convert.ToByte(value) };
                            result = this.SiemensS7NetClient.Write(adress, by);
                        }
                        break;

                    default:
                        throw new Exception($"未找到该数据类型:{type}");
                }
            }
            catch (Exception ex)
            {
                WIDESEA_Common.Tools.WriteLog.GetLog(PLCName).Write($"Error：{PLCName}写入数据失败{Environment.NewLine}数据类型：{type}{Environment.NewLine}{adress}：{Environment.NewLine}错误信息：{ex.Message}", PLCName);
            }
            return result;
        }
        #endregion 
    }
}