using System;
using System.Net;

namespace HalconTools
{
    public class LkSensorWrapper
    {
        public SerialportWrapper comPort;
        public const string READ_BOTH_HEAD_CMD = "M0";
        public const string READ_HEAD_A_CMD = "M1";
        public const string READ_HEAD_B_CMD = "M2";
        public const string CHANGE_PROGRAM_CMD = "PW,";
        public const string START_SYNCSTORING_CMD = "AS";
        public const string STOP_SYNCSTORING_CMD = "AP";
        public const string CLEAR_STORING_CMD = "AQ";
        public const string READ_STORING_CMD = "AO";
        public const int ONE_HEAD_RESULT_LEN = 12;
        public const int TWO_HEAD_RESULT_LEN = 21;
        public const int FIVE_RESULT_LEN = 48;
        public const int EIGHT_RESULT_LEN = 75;
        public const double TIMEOUT_SPAN = 3E7;

        public LkSensorWrapper()
        {
            comPort = new SerialportWrapper();
            comPort.Open(0, 9600, false);
        }

        public LkSensorWrapper(int index)
        {
            comPort = new SerialportWrapper();
            comPort.Open(index, 9600, false);
        }

        public LkSensorWrapper(string comName)
        {
            comPort = new SerialportWrapper();
            switch (comName)
            {
                case "COM1":
                    comPort.Open(0, 9600, false);
                    break;

                case "COM2":
                    comPort.Open(1, 9600, false);
                    break;

                case "COM3":
                    comPort.Open(2, 9600, false);
                    break;

                case "COM4":
                    comPort.Open(3, 9600, false);
                    break;

                case "COM5":
                    comPort.Open(4, 9600, false);
                    break;
            }
        }

        public void ComReadHead(int index, ref float value)
        {
            String measureCommand = "";

            if (1 == index)
            {
                measureCommand = READ_HEAD_A_CMD;
            }
            else if (2 == index)
            {
                measureCommand = READ_HEAD_B_CMD;
            }

            comPort.Send(measureCommand + "\r");
            comPort.Clear();

            DateTime startTime = DateTime.Now;
            while (comPort.builder.Length < ONE_HEAD_RESULT_LEN)
            {
                DateTime currentTime = DateTime.Now;
                if (currentTime.Ticks - startTime.Ticks > Convert.ToInt32(TIMEOUT_SPAN))
                {
                    break;
                }
            }

            string[] LkOutput = comPort.builder.ToString().Split(',');
            comPort.Clear();

            if (measureCommand.Equals(LkOutput[0]))
            {
                if (LkOutput[1].Contains("FFFF"))
                {
                    value = float.NegativeInfinity;
                }
                else
                {
                    value = Convert.ToSingle(LkOutput[1]);
                }
            }
            else
            {
                value = float.PositiveInfinity;
            }
        }

        public void ComReadHeads(ref float valueA, ref float valueB)
        {
            string measureCommand = READ_BOTH_HEAD_CMD;

            comPort.Send(measureCommand + "\r");
            comPort.Clear();

            DateTime startTime = DateTime.Now;
            while (comPort.builder.Length < TWO_HEAD_RESULT_LEN)
            {
                DateTime currentTime = DateTime.Now;
                if (currentTime.Ticks - startTime.Ticks > Convert.ToInt32(TIMEOUT_SPAN))
                {
                    break;
                }
            }

            string[] LkOutput = comPort.builder.ToString().Trim().Split(',');

            if (measureCommand.Equals(LkOutput[0]))
            {
                if (LkOutput[1].Contains("FFFF"))
                {
                    valueA = float.NegativeInfinity;
                }
                else
                {
                    valueA = Convert.ToSingle(LkOutput[1]);
                }
                if (LkOutput[2].Contains("FFFF"))
                {
                    valueB = float.NegativeInfinity;
                }
                else
                {
                    valueB = Convert.ToSingle(LkOutput[2]);
                }

            }
            else
            {
                valueA = float.PositiveInfinity;
                valueB = float.PositiveInfinity;
            }
        }

        public void ChoosePrgram(int progNo)
        {
            comPort.Send(CHANGE_PROGRAM_CMD + progNo.ToString() + "\r");
            comPort.Clear();
        }

        public void StartSyncStoring()
        {
            comPort.Send(START_SYNCSTORING_CMD + "\r");
            comPort.Clear();
        }

        public void StopSyncStoring()
        {
            comPort.Send(STOP_SYNCSTORING_CMD + "\r");
            comPort.Clear();

            DateTime startTime = DateTime.Now;
            while (comPort.builder.Length < 2)
            {
                DateTime currentTime = DateTime.Now;
                if (currentTime.Ticks - startTime.Ticks > Convert.ToInt32(TIMEOUT_SPAN))
                {
                    break;
                }
            }

            string[] LkOutput = comPort.builder.ToString().Trim().Split(',');

            if (LkOutput[0].Contains(STOP_SYNCSTORING_CMD))
            {
                return;
            }
            else
            {
                return;
            }
        }

        public void ClearStoring()
        {
            comPort.Send(CLEAR_STORING_CMD + "\r");
            comPort.Clear();
        }

        public void ReadStoring(ref float valueA, ref float valueB)
        {
            string measureCommand = READ_STORING_CMD;

            comPort.Send(measureCommand + ",01\r");
            comPort.Clear();

            DateTime startTime = DateTime.Now;
            while (comPort.builder.Length < EIGHT_RESULT_LEN)
            {
                DateTime currentTime = DateTime.Now;
                if (currentTime.Ticks - startTime.Ticks > Convert.ToInt32(TIMEOUT_SPAN))
                {
                    break;
                }
            }

            string[] LkOutput = comPort.builder.ToString().Trim().Split(',');

            if (measureCommand.Equals(LkOutput[0]))
            {
                if (LkOutput.Length < 2)
                    return;

                if (LkOutput[1].Contains("FFFF"))
                {
                    valueA = float.NegativeInfinity;
                }
                else
                {
                    valueA = Convert.ToSingle(LkOutput[1]);
                }
                if (LkOutput[2].Contains("FFFF"))
                {
                    valueB = float.NegativeInfinity;
                }
                else
                {
                    valueB = Convert.ToSingle(LkOutput[2]);
                }

            }
            else
            {
                valueA = float.PositiveInfinity;
                valueB = float.PositiveInfinity;
            }
        }
    }

    public class HlSensorWrapper
    {
        public SerialportWrapper comPort;
        public const string READ_BOTH_HEAD_CMD = "%EE#RMA5**";
        public const string READ_HEAD_A_CMD = "%EE#RMD3**";
        public const string READ_HEAD_B_CMD = "%EE#RMD4**";
        public const string READ_ONE_HEAD_REPLY = "%EE$RMD";
        public const string READ_TWO_HEADS_REPLY = "%EE$RMA";
        public const int ONE_HEAD_RESULT_LEN = 21;
        public const int TWO_HEAD_RESULT_LEN = 32;
        public const int HEAD_A_RESULT_STARTINDEX = 7;
        public const int HEAD_B_RESULT_STARTINDEX = 18;
        public const int HEAD_RESULT_LENGTH = 11;
        public const double TIMEOUT_SPAN = 3E7;

        public HlSensorWrapper()
        {
            comPort = new SerialportWrapper();
            comPort.Open(0, 115200, false);
        }

        public void ComReadHead(int index, ref float value)
        {
            String measureCommand = "";

            if (1 == index)
            {
                measureCommand = READ_HEAD_A_CMD;
            }
            else if (2 == index)
            {
                measureCommand = READ_HEAD_B_CMD;
            }

            comPort.Send(measureCommand + "\r");
            comPort.Clear();

            DateTime startTime = DateTime.Now;
            while (comPort.builder.Length < ONE_HEAD_RESULT_LEN)
            {
                DateTime currentTime = DateTime.Now;
                if (currentTime.Ticks - startTime.Ticks > Convert.ToInt32(TIMEOUT_SPAN))
                {
                    break;
                }
            }

            string HlOutput = comPort.builder.ToString().Trim();
            comPort.Clear();

            if (HlOutput.Contains(READ_ONE_HEAD_REPLY))
            {
                if (HlOutput.Contains("FFFF"))
                {
                    value = float.NegativeInfinity;
                }
                else
                {
                    value = Convert.ToSingle(HlOutput.Substring(HEAD_A_RESULT_STARTINDEX, HEAD_RESULT_LENGTH));
                }
            }
            else
            {
                value = float.PositiveInfinity;
            }
        }

        public void ComReadHeads(ref float valueA, ref float valueB)
        {
            string measureCommand = READ_BOTH_HEAD_CMD;

            comPort.Send(measureCommand + "\r");
            comPort.Clear();

            DateTime startTime = DateTime.Now;
            while (comPort.builder.Length < TWO_HEAD_RESULT_LEN)
            {
                DateTime currentTime = DateTime.Now;
                if (currentTime.Ticks - startTime.Ticks > Convert.ToInt32(TIMEOUT_SPAN))
                {
                    break;
                }
            }

            string[] HlOutput = comPort.builder.ToString().Trim().Split(',');

            if (HlOutput[0].Contains(READ_TWO_HEADS_REPLY))
            {
                valueA = Convert.ToSingle(HlOutput[0].Substring(HEAD_A_RESULT_STARTINDEX, HEAD_RESULT_LENGTH));
                valueB = Convert.ToSingle(HlOutput[0].Substring(HEAD_B_RESULT_STARTINDEX, HEAD_RESULT_LENGTH));
            }
            else
            {
                valueA = float.PositiveInfinity;
                valueB = float.PositiveInfinity;
            }
        }
    }

    public class ZwSensorWrapper
    {
        public SocketTools st;
        public IPAddress remoteIpAddr;
        public int remotePort;
        public const string READ_HEAD_A_CMD = "M";
        public const string READ_ERROR_REPLY = "ER";
        public const string READ_INVALID_REPLY = "----";
        public const int ONE_HEAD_RESULT_LEN = 21;
        public const int TWO_HEAD_RESULT_LEN = 32;
        public const int HEAD_A_RESULT_STARTINDEX = 7;
        public const int HEAD_B_RESULT_STARTINDEX = 18;
        public const int HEAD_RESULT_LENGTH = 11;
        public const double TIMEOUT_SPAN = 3E7;

        public ZwSensorWrapper(string remoteIpAddr, int remotePort)
        {
            this.remoteIpAddr = IPAddress.Parse(remoteIpAddr);
            this.remotePort = remotePort;

            st = new SocketTools(9600, this.remotePort, this.remoteIpAddr, new System.Net.IPAddress(0));
        }

        public void ComReadHead(int index, ref float value)
        {
            string str = "";

            str = READ_HEAD_A_CMD + "\r";

            st.SendAndReceiveMessage(remoteIpAddr, 9600, ref str);

            if (!str.Contains(READ_ERROR_REPLY))
            {
                if (str.Contains(READ_INVALID_REPLY))
                {
                    value = float.NegativeInfinity;
                }
                else
                {
                    value = Convert.ToSingle(str) / 1000000;
                }
            }
            else
            {
                value = float.PositiveInfinity;
            }
        }

        public void ComReadHeads(ref float valueA, ref float valueB)
        {
            ComReadHead(0, ref valueA);
            valueB = valueA;
        }

    }
}