using System;
using System.Linq;
using System.Threading.Tasks;
using PLCCommunication;
using PLCCommunication.PLCType.Siemens;
using PLCCommunication.Common;
using System.ComponentModel.Composition;
using System.Net;
using PLCCommunication.Common.DataConvert;

namespace PLC
{
    /// <summary>
    /// 西门子S7协议通讯（S7-1200/S7-300/S7-400/S7-200SMART）
    /// </summary>
    [Export("SiemensS7", typeof(PlcReadWriteBase))]
    public class SiemensS7 : PlcReadWriteBase
    {
        private SiemensS7Net siemensS7Net = null;

        public SiemensS7(int pid, string pname, IPEndPoint iep, int timeout = 10)
            : base(pid, pname, iep, timeout)
        {
            siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200);
            siemensS7Net.IpAddress = iep.Address.ToString();
            siemensS7Net.Port = iep.Port;
            siemensS7Net.ByteTransform.DataFormat = DataFormat.CDAB;
            siemensS7Net.ConnectTimeOut = 2000;
            siemensS7Net.ReceiveTimeOut = 2000;
            IsConnected = false;
        }

        public override bool Connect(ref string msg)
        {
            try
            {
                if (!IsConnected)
                {
                    JYResult connect = siemensS7Net.ConnectServer();
                    if (connect.IsSuccess)
                    {
                        IsConnected = true;
                        msg = "连接成功";
                        return true;
                    }
                    
                    msg = connect.Message;
                    
                }
            }
            catch (Exception ex)
            {
                msg = ex.Message;
            }
            return false;
        }

        public override bool Disconnect()
        {
            if (IsConnected)
            {
                siemensS7Net.ConnectClose();
                IsConnected = false;
            }
            return true;
        }

        public override bool ReadBool(string address)
        {
            JYResult<bool> result = siemensS7Net.ReadBool(address);
            return result.IsSuccess ? result.Content : false;
        }

        public override short ReadInt16(string address)
        {
            JYResult<short> result = siemensS7Net.ReadInt16(address);
            return result.IsSuccess ? result.Content : (short)0;
        }

        public override async Task<JYResult<short>> ReadInt16Async(string address)
        {
            return await siemensS7Net.ReadInt16Async(address);
        }

        public override short[] ReadArrInt16(string address, ushort length)
        {
            JYResult<short[]> result = siemensS7Net.ReadInt16(address, length);
            return result.IsSuccess ? result.Content : null;
        }

        public override async Task<JYResult<short[]>> ReadArrInt16Async(string address, ushort length)
        {
            return await siemensS7Net.ReadInt16Async(address, length);
        }

        public override int ReadInt32(string address)
        {
            JYResult<int> result = siemensS7Net.ReadInt32(address);
            return result.IsSuccess ? result.Content : 0;
        }

        public override float ReadFloat(string address)
        {
            JYResult<float> result = siemensS7Net.ReadFloat(address);
            return result.IsSuccess ? result.Content : 0.0f;
        }

        public override float[] ReadArrFloat(string address, ushort length = 0)
        {
            JYResult<float[]> result = siemensS7Net.ReadFloat(address, length);
            return result.IsSuccess ? result.Content : null;
        }

        public override async Task<JYResult<int>> ReadInt32Async(string address)
        {
            return await siemensS7Net.ReadInt32Async(address);
        }

        public override async Task<JYResult<float[]>> ReadArrFloatAsync(string address, ushort length)
        {
            return await siemensS7Net.ReadFloatAsync(address, length);
        }


        /// <summary>
        /// 统一读取
        /// </summary>
        public override T ReadValue<T>(string address, DataType type, ushort length = 0)
        {
            object obj = null;
            try
            {
                switch (type)
                {
                    case DataType.Bool:
                        obj = siemensS7Net.ReadBool(address).Content;
                        break;
                    case DataType.Short:
                        obj = siemensS7Net.ReadInt16(address).Content;
                        break;
                    case DataType.Int:
                        obj = siemensS7Net.ReadInt32(address).Content;
                        break;
                    case DataType.Float:
                        obj = siemensS7Net.ReadFloat(address).Content;
                        break;
                    case DataType.Double:
                        obj = siemensS7Net.ReadDouble(address).Content;
                        break;
                    case DataType.String:
                        obj = siemensS7Net.ReadString(address, length).Content;
                        break;

                    case DataType.ArrByte:
                        obj = ReadArrByteFromPlc(address, length);
                        break;

                    case DataType.ArrFloat:
                        obj = siemensS7Net.ReadFloat(address, length).Content;
                        break;
                    case DataType.ArrShort:
                        obj = siemensS7Net.ReadInt16(address, length).Content;
                        break;
                    case DataType.ArrUshort:
                        obj = siemensS7Net.ReadUInt16(address, length).Content;
                        break;
                    case DataType.ArrInt:
                        obj = siemensS7Net.ReadInt32(address, length).Content;
                        break;
                    case DataType.ArrUint:
                        obj = siemensS7Net.ReadUInt32(address, length).Content;
                        break;
                }
                return (T)obj;
            }
            catch
            {
                return default;
            }
        }


        private byte[] ReadArrByteFromPlc(string address, ushort length)
        {
            short[] shorts = ReadArrInt16(address, length);
            if (shorts == null) return null;

            byte[] bytes = new byte[shorts.Length * 2];
            Buffer.BlockCopy(shorts, 0, bytes, 0, bytes.Length);
            return bytes;
        }

        public override bool WriteBool(string address, bool value)
        {
            JYResult result = siemensS7Net.Write(address, value);
            return result.IsSuccess;
        }

        public override bool WriteInt16(string address, short value)
        {
            JYResult result = siemensS7Net.Write(address, value);
            return result.IsSuccess;
        }

        public override bool WriteInt32(string address, int value)
        {
            JYResult result = siemensS7Net.Write(address, value);
            return result.IsSuccess;
        }

        public override bool WriteFloat(string address, float value)
        {
            JYResult result = siemensS7Net.Write(address, value);
            return result.IsSuccess;
        }

        public override JYResult WriteValue(string address, object value, DataType type = DataType.Short)
        {
            JYResult result = new JYResult();
            try
            {
                switch (type)
                {
                    case DataType.Bool:
                        result = siemensS7Net.Write(address, (bool)value);
                        break;
                    case DataType.Short:
                        result = siemensS7Net.Write(address, (short)value);
                        break;
                    case DataType.Int:
                        result = siemensS7Net.Write(address, (int)value);
                        break;
                    case DataType.Float:
                        result = siemensS7Net.Write(address, (float)value);
                        break;
                    case DataType.Double:
                        result = siemensS7Net.Write(address, (double)value);
                        break;
                    case DataType.String:
                        result = siemensS7Net.Write(address, value.ToString());
                        break;
                    case DataType.ArrShort:
                        result = siemensS7Net.Write(address, (short[])value);
                        break;
                    case DataType.ArrUshort:
                        result = siemensS7Net.Write(address, (ushort[])value);
                        break;
                    case DataType.ArrByte:
                        result = siemensS7Net.Write(address, (byte[])value);
                        break;
                    case DataType.ArrFloat:
                        result = siemensS7Net.Write(address, (float[])value);
                        break;
                }
                return result;
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.Message = ex.Message;
                return result;
            }
        }
    }
}