using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using PLCCommunication;
using HslCommunication.Profinet.Siemens;
using HslCommunication;
using PLCCommunication.Common;
using HslCommunication.Profinet.Delta;

namespace PLCCommunication.Impl
{
    /// <summary>
    /// PLC通信服务 SiemensS7 smart200 实现
    /// </summary>
    internal class DeltaCommunicationService : IPLCCommunicationService
    {
        private DeltaTcpNet deltaTcpNet = null;

        /// <summary>
        /// 是否已连接
        /// </summary>
        public bool isConnected { get; private set; }

        public DeltaCommunicationService()
        {
            deltaTcpNet = new DeltaTcpNet();
            deltaTcpNet.Series = DeltaSeries.AS;
            deltaTcpNet.ConnectTimeOut = 3000;
        }

        #region 同步
        /// <summary>
        /// 连接PLC（长连接）
        /// </summary>
        /// <param name="address"></param>
        /// <param name="port"></param>
        public PLCResult Connection(string address, int port = 0)
        {
            deltaTcpNet.IpAddress = address;
            if (port > 0)
            {
                deltaTcpNet.Port = port;
            }
            var operateResult = deltaTcpNet.ConnectServer();
            var result = ConvertResult(operateResult);
            if (result.IsSuccess)
            {
                isConnected = true;
            }
            return result;
        }

        /// <summary>
        /// 关闭连接PLC（长连接）
        /// </summary>
        public PLCResult ColseConnection()
        {
            var operateResult = deltaTcpNet.ConnectClose();
            var result = ConvertResult(operateResult);
            if (result.IsSuccess)
            {
                isConnected = false;
            }
            return result;
        }
        /// <summary>
        /// 读取指定地址的byte[]值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public PLCResult<byte[]> ReadBytes(string address, ushort length)
        {
            var operateResult = deltaTcpNet.Read(address, length);
            var result = ConvertResult(operateResult);
            return result;
        }
        /// <summary>
        /// 读取指定地址的bool值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public PLCResult<bool> ReadBool(string address)
        {
            var operateResult = deltaTcpNet.ReadBool(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的byte值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public PLCResult<byte> ReadByte(string address)
        {
          throw new NotImplementedException();
        }

        /// <summary>
        /// 读取指定地址的Int16值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public PLCResult<short> ReadInt16(string address)
        {
            var operateResult = deltaTcpNet.ReadInt16(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的Int32值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public PLCResult<int> ReadInt32(string address)
        {
            var operateResult = deltaTcpNet.ReadInt32(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的long值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public PLCResult<long> ReadLong(string address)
        {
            var operateResult = deltaTcpNet.ReadInt64(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的Float值
        /// </summary>
        /// <returns></returns>
        public PLCResult<float> ReadFloat(string address)
        {
            var operateResult = deltaTcpNet.ReadFloat(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的double值
        /// </summary>
        /// <returns></returns>
        public PLCResult<double> ReadDouble(string address)
        {
            var operateResult = deltaTcpNet.ReadDouble(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入bool值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public PLCResult Write(string address, bool value)
        {
            var operateResult = deltaTcpNet.Write(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入byte值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public PLCResult Write(string address, byte value)
        {
            var operateResult = deltaTcpNet.Write(address, value);
            var result = ConvertResult(operateResult);
            return result;

        }

        /// <summary>
        /// 写入Int16值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public PLCResult Write(string address, Int16 value)
        {
            var operateResult = deltaTcpNet.Write(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入Int32值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public PLCResult Write(string address, Int32 value)
        {
            var operateResult = deltaTcpNet.Write(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入float值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public PLCResult Write(string address, float value)
        {
            var operateResult = deltaTcpNet.Write(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入double值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public PLCResult Write(string address, double value)
        {
            var operateResult = deltaTcpNet.Write(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入long值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public PLCResult Write(string address, long value)
        {
            var operateResult = deltaTcpNet.Write(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        #endregion

        #region 异步
        /// <summary>
        /// 连接PLC（长连接）
        /// </summary>
        /// <param name="address"></param>
        /// <param name="port"></param>
        public async Task<PLCResult> ConnectionAsync(string address, int port = 0)
        {
            deltaTcpNet.IpAddress = address;
            if (port > 0)
            {
                deltaTcpNet.Port = port;
            }
            var operateResult = await deltaTcpNet.ConnectServerAsync();
            var result = ConvertResult(operateResult);
            if (operateResult.IsSuccess)
            {
                isConnected = true;
            }
            return result;
        }

        /// <summary>
        /// 关闭连接PLC（长连接）
        /// </summary>
        public async Task<PLCResult> ColseConnectionAsyn()
        {
            var operateResult = await deltaTcpNet.ConnectCloseAsync();
            var result = ConvertResult(operateResult);
            if (operateResult.IsSuccess)
            {
                isConnected = false;
            }
            return result;
        }
        /// <summary>
        /// 读取指定地址的byte[]值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public async Task<PLCResult<byte[]>> ReadBytesAsync(string address, ushort length)
        {
            var operateResult = await deltaTcpNet.ReadAsync(address, length);
            var result = ConvertResult(operateResult);
            return result;
        }
        /// <summary>
        /// 读取指定地址的bool值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public async Task<PLCResult<bool>> ReadBoolAsync(string address)
        {
            var operateResult = await deltaTcpNet.ReadBoolAsync(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的byte值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public async Task<PLCResult<byte>> ReadByteAsync(string address)
        {
           throw new NotImplementedException();
        }

        /// <summary>
        /// 读取指定地址的Int16值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public async Task<PLCResult<short>> ReadInt16Async(string address)
        {
            var operateResult = await deltaTcpNet.ReadInt16Async(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的Int32值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public async Task<PLCResult<int>> ReadInt32Async(string address)
        {
            var operateResult = await deltaTcpNet.ReadInt32Async(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的long值
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public async Task<PLCResult<long>> ReadLongAsync(string address)
        {
            var operateResult = await deltaTcpNet.ReadInt64Async(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的Float值
        /// </summary>
        /// <returns></returns>
        public async Task<PLCResult<float>> ReadFloatAsync(string address)
        {
            var operateResult = await deltaTcpNet.ReadFloatAsync(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 读取指定地址的double值
        /// </summary>
        /// <returns></returns>
        public async Task<PLCResult<double>> ReadDoubleAsync(string address)
        {
            var operateResult = await deltaTcpNet.ReadDoubleAsync(address);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入bool值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public async Task<PLCResult> WriteAsync(string address, bool value)
        {
            var operateResult = await deltaTcpNet.WriteAsync(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入byte值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public async Task<PLCResult> WriteAsync(string address, byte value)
        {

            var operateResult = await deltaTcpNet.WriteAsync(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入Int16值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public async Task<PLCResult> WriteAsync(string address, Int16 value)
        {
            var operateResult = await deltaTcpNet.WriteAsync(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入Int32值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public async Task<PLCResult> WriteAsync(string address, Int32 value)
        {
            var operateResult = await deltaTcpNet.WriteAsync(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入float值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public async Task<PLCResult> WriteAsync(string address, float value)
        {
            var operateResult = await deltaTcpNet.WriteAsync(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入double值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public async Task<PLCResult> WriteAsync(string address, double value)
        {
            var operateResult = await deltaTcpNet.WriteAsync(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        /// <summary>
        /// 写入long值
        /// </summary>
        /// <param name="address">写入地址</param>
        /// <param name="value"></param>
        public async Task<PLCResult> WriteAsync(string address, long value)
        {
            var operateResult = await deltaTcpNet.WriteAsync(address, value);
            var result = ConvertResult(operateResult);
            return result;
        }

        #endregion


        /// <summary>
        /// 转换 result （将框架结果结构转换成当前程序结果结构）
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>

        private PLCResult ConvertResult(OperateResult result)
        {
            var retResult = ModelTools.PubClone<OperateResult, PLCResult>.Trans(result);
            return retResult;
        }

        /// <summary>
        /// 转换 result （将框架结果结构转换成当前程序结果结构）
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>

        private PLCResult<T> ConvertResult<T>(OperateResult<T> result)
        {
            var retResult = ModelTools.PubClone<OperateResult<T>, PLCResult<T>>.Trans(result);
            retResult.Content = result.Content;
            return retResult;
        }
    }
}