using System;
using HslCommunication;
using HslCommunication.Profinet.Siemens;
using SlnMesnac.Common;

namespace SlnMesnac.Plc.Factory
{
    public class SiemensFactory:PlcAbsractFactory
    {
        
        private StringChange _stringChange;

        private const SiemensPLCS type = SiemensPLCS.S200Smart;

        private SiemensS7Net s7 = new SiemensS7Net(type);

        public SiemensFactory(StringChange stringChange)
        {
            _stringChange = stringChange;
        }
        
        public override bool IsConnected { get; set; }

        /// <summary>
        /// 建立连接
        /// </summary>
        /// <param name="iP"></param>
        /// <param name="port"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override bool Connect(string iP, int port)
        {
            try
            {
                s7.IpAddress = iP;
                s7.Port = 102;
                OperateResult connect = s7.ConnectServer();
                this.IsConnected = connect.IsSuccess;
                if (!connect.IsSuccess)
                {
                    throw new InvalidOperationException($"西门子S系列PLC连接失败:{connect.Message}");
                }

                return connect.IsSuccess;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"西门子S系列PLC连接异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override bool DisConnect()
        {
            try
            {
                OperateResult disConnect = s7.ConnectClose();
                this.IsConnected = false;
                if (!disConnect.IsSuccess)
                {
                    throw new InvalidOperationException($"西门子S系列PLC断开连接失败:{disConnect.Message}");
                }
                return disConnect.IsSuccess;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"西门子S系列PLC断开连接异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 根据地址读取指定长度数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override byte[] readValueByAddress(string address, int len)
        {
            try
            {
                OperateResult<byte[]> read = s7.Read(address, (ushort)(len));
                if (!read.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};读取指定长度数据失败：{read.Message}");
                }
                return _stringChange.ConvertFloatToINt(read.Content);
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};读取指定长度数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 根据地址读取int16数据
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override int readInt16ByAddress(string address)
        {
            try
            {
                OperateResult<short> read = s7.ReadInt16(address);
                if (!read.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};读取int16数据失败：{read.Content}");
                }
                return read.Content;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};读取int16数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 根据地址写入int16数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override bool writeInt16ByAddress(string address, int value)
        {
            try
            {
                OperateResult operateResult = s7.Write(address, Convert.ToInt16(value));
                if (!operateResult.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};写入int16数据失败：{operateResult.Message}");
                }
                return operateResult.IsSuccess;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};写入int16数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 通过PLC地址读取string类型数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override string readStringByAddress(string address, ushort length)
        {
            try
            {
                OperateResult<String> read = s7.ReadString(address, length);
                if (!read.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};读取string数据失败：{read.Content}");
                }
                return read.Content;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};读取string数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 通过PLC地址写入String类型数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override bool writeStringByAddress(string address, string value)
        {
            try
            {
                OperateResult operateResult = s7.Write(address, value);
                if (!operateResult.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};写入string数据失败：{operateResult.Message}");
                }
                return operateResult.IsSuccess;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};写入string数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 通过PLC地址读取Bool类型数据
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override bool readBoolByAddress(string address)
        {
            try
            {
                OperateResult<bool> read = s7.ReadBool(address);
                if (!read.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};读取bool数据失败：{read.Content}");
                }
                return read.Content;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};读取bool数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 通过PLC地址写入Bool类型数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override bool writeBoolByAddress(string address, bool value)
        {
            try
            {
                OperateResult operateResult = s7.Write(address, short.Parse(_stringChange.ParseToInt(value ? "1" : "0").ToString()));
                if (!operateResult.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};写入bool数据失败：{operateResult.Message}");
                }
                return operateResult.IsSuccess;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};写入bool数据异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 通过PLC地址写入Double类型数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public override bool writeDoubleByAddress(string address, int value)
        {
            try
            {
                OperateResult operateResult = s7.Write(address, Convert.ToDouble(value));
                if (!operateResult.IsSuccess)
                {
                    throw new InvalidOperationException($"根据地址:{address};写入double数据失败：{operateResult.Message}");
                }
                return operateResult.IsSuccess;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"根据地址:{address};写入double数据异常：{ex.Message}");
            }
        }
    }
}