using OmronFinsTCP.Net;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using TFT_MelsecMcNet;

namespace PLCTool.Common
{
    public class FinsPLCConnection: IPLCConnection
    {
        private static string plcIp = ConfigurationManager.AppSettings["PLCIp"];
        private static string plcPort = ConfigurationManager.AppSettings["PLCPort"];
        private static  EtherNetPLC ENT = new EtherNetPLC();
        private static FinsPLCConnection instance;
        private static bool isConnect=false;
       

        private FinsPLCConnection() 
        {
            ConnectPLC();
        }

        public static FinsPLCConnection Instance
        {
            get
            {
                if ((!ENT.IsConnect))
                {
                    instance = new FinsPLCConnection();
                }
                return instance;
            }
        }


        public async Task<bool> IsConnectPLC()
        {
         
            //return ENT.IsConnect;
            short rb;
            short reSuc=-1;
            Func<short> func = () =>
            {
                return ENT.GetBitState(PlcMemory.CIO, "3321.10", out rb);
            };
            var workTask = Task.Run(() => func.Invoke());
            //读取CIO区判断PLC连接情况
         
            reSuc = workTask.Result;
            //读取成功
            if (reSuc == 0)
            {
                return true;
            }
            return false;

           
        }

        public async Task<bool> ConnectPLC()
        {
            try
            {
                var result=await Task.Run(() =>
                     ENT.Link(plcIp, short.Parse(plcPort), 500)
                );
          
                if (result == 0)
                {
                    isConnect = true;
                    return true;
                }
                else
                {
                   
                    isConnect = false;
                    return false;
                }
            }
            catch (Exception e)
            {
                ENT.Close();
                return false;
            }
          

        }
        public string ReadPlcObject(string address, VarType valueType)
        {
            string value = string.Empty; ;
            short rb;
            short reSuc = -1;
            if (isConnect == false)
            {
                return string.Empty;
            }
           
            switch (valueType)
            {
                case VarType.Bit:
                    try
                    {
                        if(address.Contains("w")|| address.Contains("W"))
                        {
                            string realAddr = address.Substring(1, address.Length - 1);
                            reSuc = ENT.GetBitState(PlcMemory.WR, realAddr, out rb);
                            //读取成功
                            if (reSuc == 0)
                            {
                                value = rb.ToString();
                            }
                        }
                        else
                        {
                            //读取CIO区
                            reSuc = ENT.GetBitState(PlcMemory.CIO, address, out rb);
                            //读取成功
                            if (reSuc == 0)
                            {
                                value = rb.ToString();
                            }
                        }
                       
                    }
                    catch(Exception ex)
                    {

                    }
                    break;
                case VarType.Byte:
                    break;
                case VarType.Word:
                    try
                    {
                        reSuc = ENT.ReadWord(PlcMemory.DM, short.Parse(address), out rb);
                        //读取成功
                        if (reSuc == 0)
                        {
                            value = rb.ToString();
                        }
                    }
                    catch (Exception ex)
                    {

                    }
                    break;
                case VarType.DWord:
                    break;
                case VarType.Int:
                    break;
                case VarType.DInt:
                    break;
                case VarType.Real:
                    break;

                default:
                    return null;
            }
            return value;
        }
        public bool WritePlcObject(string address, VarType valueType,string writeValue)
        {
            bool isSuccess=false;
            
            short reSuc = -1;
            if (isConnect == false)
            {
                return false;
            }
            try
            {
                switch (valueType)
                {
                    case VarType.Bit:
                    
                        BitState bit = BitState.OFF;
                        if (writeValue.Trim() == "1")
                        {
                            bit = BitState.ON;
                        }
                        else
                        {
                            if (writeValue.Trim() == "0")
                            {
                                bit = BitState.OFF;
                            }

                        }
                        if (address.Contains("w") || address.Contains("W"))
                        {
                            string realAddr = address.Substring(1, address.Length - 1);
                            reSuc = ENT.SetBitState(PlcMemory.WR, realAddr, bit);
                           
                        }
                        else
                        {
                            reSuc = ENT.SetBitState(PlcMemory.CIO, address, bit);
                        }
                       
                        //写成功
                        if (reSuc == 0)
                        {
                            isSuccess = true;
                        }
                        break;
                    case VarType.Byte:
                        break;
                    case VarType.Word:
                        short wValue = Convert.ToInt16(writeValue);
                        if (address.Contains("w") || address.Contains("W"))
                        {
                            string realAddr = address.Substring(1, address.Length - 1);
                            reSuc = ENT.WriteWord(PlcMemory.WR, short.Parse(realAddr), wValue);

                        }
                        else
                        {
                            reSuc = ENT.WriteWord(PlcMemory.DM, short.Parse(address), wValue);

                        }
                        
                        //写成功
                        if (reSuc == 0)
                        {
                            isSuccess = true;
                        }
                        break;
                    case VarType.DWord:
                        break;
                    case VarType.Int:
                        break;
                    case VarType.DInt:
                        break;
                    case VarType.Real:
                        break;

                }
            }
            catch(Exception ex )
            {

            }
            
            return isSuccess;
        }
        public bool ResetPLC(string address, VarType valueType, string writeValue)
        {
            bool isSuccess = false;

            short reSuc = -1;
            if (isConnect == false)
            {
                return false;
            }
            try
            {
                switch (valueType)
                {
                    case VarType.Bit:
                        BitState bit = BitState.OFF;
                        if (writeValue.Trim() == "1")
                        {
                            bit = BitState.ON;
                        }
                        else
                        {
                            if (writeValue.Trim() == "0")
                            {
                                bit = BitState.OFF;
                            }

                        }
                        reSuc = ENT.SetBitState(PlcMemory.CIO, address, bit);
                        //写成功
                        if (reSuc == 0)
                        {
                            isSuccess = true;
                        }
                        break;
                    case VarType.Byte:
                        break;
                    case VarType.Word:
                        short wValue = Convert.ToInt16(writeValue);
                        reSuc = ENT.WriteWord(PlcMemory.CIO, short.Parse(address), wValue);
                        //写成功
                        if (reSuc == 0)
                        {
                            isSuccess = true;
                        }
                        break;
                    case VarType.DWord:
                        break;
                    case VarType.Int:
                        break;
                    case VarType.DInt:
                        break;
                    case VarType.Real:
                        break;

                }
            }
            catch (Exception ex)
            {

            }

            return isSuccess;
        }
        private static object GetVariableValue(VarType varType, object var)
        {
            switch (varType)
            {
                case VarType.Bit:
                    return (bool)var;
                case VarType.Byte:
                    return (byte)var;
                case VarType.Word:
                    return (ushort)var;
                case VarType.DWord:
                    return (uint)var;
                case VarType.Int:
                    return (short)var;
                case VarType.DInt:
                    return (int)var;
                case VarType.Real:
                    return (float)var;
             
                default:
                    return null;
            }
        }

    }

    public enum VarType
    {
        /// <summary>
        ///  Bit variable type (bool)
        /// </summary>
        Bit,

        /// <summary>
        ///  Byte variable type (8 bits)
        /// </summary>
        Byte,

        /// <summary>
        /// Word variable type (16 bits, 2 bytes)
        /// </summary>
        Word,

        /// <summary>
        /// 
        /// </summary>
        DWord,

        /// <summary>
        ///  Int variable type (16 bits, 2 bytes)
        /// </summary>
        Int,

        /// <summary>
        /// DInt variable type (32 bits, 4 bytes)
        /// </summary>
        DInt,

        /// <summary>
        /// Real variable type (32 bits, 4 bytes)
        /// </summary>
        Real,

        

        /// <summary>
        /// Char Array / C-String variable type (variable)
        /// </summary>
        String,

      
    }
}