using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Edge.Core.Parser.BinaryParser.Util;
using Wayne_Pump_Dart.MessageEntity;
using Wayne_Pump_Dart.MessageEntity.Incoming;
using Wayne_Pump_Dart.MessageEntity.Outgoing;

namespace Test_Wayne_Pump_Dart
{
    [TestClass]
    public class UnitTest1
    {
        public static bool ValueEquals(IEnumerable<byte> array1, IEnumerable<byte> array2)
        {
            if (array1 == null && array2 == null)
            {
                return true;
            }

            if ((array1 == null) || (array2 == null))
            {
                return false;
            }

            if (array1.Count() != array2.Count())
            {
                return false;
            }
            if (array1.Equals(array2))
            {
                return true;
            }
            else
            {
                for (int Index = 0; Index < array1.Count(); Index++)
                {
                    if (!Equals(array1.ElementAt(Index), array2.ElementAt(Index)))
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        [TestMethod]
        public void Poll_TestMethod1()
        {
            var expected = new byte[] { 0x50, 0x29, 0xFA };
            Poll pollRequest = new Poll(0x50, 9);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(pollRequest);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void Poll_TestMethod2()
        {
            var expected = new byte[] { 0x60, 0x29, 0xFA };
            Poll pollRequest = new Poll(0x60, 9);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(pollRequest);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void Poll_TestMethod3()
        {
            var expected = new byte[] { 0x6F, 0x2A, 0xFA };
            Poll pollRequest = new Poll(0x6F, 10);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(pollRequest);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void ACK_TestMethod1()
        {
            var expected = new byte[] { 0x50, 0xC9, 0xFA };
            var request = new ACK(0x50, 9);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void ACK_TestMethod2()
        {
            var expected = new byte[] { 0x61, 0xCB, 0xFA };
            var request = new ACK(0x61, 11);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void Mixed_Serialize_and_Deserial_TestMethod0()
        {
            bool exceptionHit = false;
            int executionCount = 0;
            int concurrentMax = 5000;
            int maxTimeWaitTestToFinish = 15000;// ms
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var raw = new byte[] { 0x60, 0x70, 0xFA };
            var expected = new byte[] { 0x50, 0x39, 0x01, 0x01, 0x00, 0x9C, 0xC0, 0x03, 0xFA };
            for (int i = 0; i < concurrentMax; i++)
            {
                ThreadPool.QueueUserWorkItem(_ =>
                {
                    Interlocked.Increment(ref executionCount);
                    try
                    {

                        lock (raw)
                        {
                            var actual = p.Deserialize(raw) as MessageBase;
                            Assert.AreEqual(true, actual.Adrs == 0x60);
                            Assert.AreEqual(true, actual.BlockSeqNumber == 0);
                        }

                    }
                    catch (Exception exx) { exceptionHit = true; }
                });
                ThreadPool.QueueUserWorkItem(_ =>
                {
                    Interlocked.Increment(ref executionCount);
                    try
                    {

                        lock (expected)
                        {
                            var request = new ReturnStatusRequest(0x50, 9);
                            var actual = p.Serialize(request);
                            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
                        }
                    }
                    catch (Exception exx) { exceptionHit = true; }
                });
            }

            int waitedTime = 0;
            while (executionCount < concurrentMax * 2)
            {
                Thread.Sleep(100);
                waitedTime += 100;
                if (waitedTime > maxTimeWaitTestToFinish)
                    break;
            }

            Assert.AreEqual(true, executionCount >= concurrentMax * 2, "test did not finished correctly");

            Assert.AreEqual(true, exceptionHit == false, "should never have exception when concurrent serial and deserailzie messages");
        }

        [TestMethod]
        public void EOT_TestMethod1()
        {
            var raw = new byte[] { 0x61, 0x70, 0xFA };
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Deserialize(raw) as MessageBase;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.ControlCharacter == ControlCharacter.EOT);
        }

        [TestMethod]
        public void Scratch_TestMethod1()
        {
            var raw = new byte[] { 0x50, 0x36, 0x02, 0x08, 0x00, 0x09, 0x99, 0x00, 0x00, 0x38, 0x86, 0x11, 0x03, 0x04, 0x00, 0x38, 0x90, 0x11, 0x01, 0x01, 0x05, 0xF7, 0x6D, 0x03, 0xFA };
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Deserialize(raw) as MessageBase;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.ControlCharacter == ControlCharacter.DATA);
        }
        [TestMethod]
        public void Scratch_TestMethod2()
        {
            var raw = new byte[] { 0x55, 0x34, 0x02, 0x08, 0x03, 0x22, 0x41, 0x27, 0x11, 0x44, 0x56, 0x50, 0xE3, 0x42, 0x03, 0xFA };
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Deserialize(raw) as MessageBase;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.ControlCharacter == ControlCharacter.DATA);
        }



        //[TestMethod]
        //public void Escape0xFA_TestMethod0()
        //{
        //    var raw = new byte[] { 0x50, 0x39, 0x01, 0x01, 0x00, 0x10, 0xFA, 0xC0, 0x03, 0xFA };
        //    Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
        //    var request = p.Deserialize(raw) as ReturnStatusRequest;
        //    Assert.AreEqual(true, request != null);
        //    Assert.AreEqual(true, request.BlockSeqNumber == 9);
        //}

        [TestMethod]
        public void ReturnStatusRequest_TestMethod1()
        {
            var expected = new byte[] { 0x50, 0x39, 0x01, 0x01, 0x00, 0x9C, 0xC0, 0x03, 0xFA };
            var request = new ReturnStatusRequest(0x50, 9);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void ReturnStatusRequest_TestMethod2()
        {
            var expected = new byte[] { 0x58, 0x3A, 0x01, 0x01, 0x00, 0x7D, 0x45, 0x03, 0xFA };
            var request = new ReturnStatusRequest(0x58, 0x0A);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void AllowedNozzleNumbersRequest_TestMethod1()
        {
            var expected = new byte[] { 0x50, 0x39, 0x02, 0x02, 0x01, 0x02, 0xB0, 0x7C, 0x03, 0xFA };
            var request = new AllowedNozzleNumbersRequest(0x50, 9, new byte[] { 1, 2 });
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void AllowedNozzleNumbersRequest_TestMethod2()
        {
            var expected = new byte[] { 0x59, 0x39, 0x02, 0x03, 0x01, 0x02, 0x04, 0xE4, 0x8B, 0x03, 0xFA };
            var request = new AllowedNozzleNumbersRequest(0x59, 9, new byte[] { 1, 2, 4 });
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void AuthorizeRequest_TestMethod1()
        {
            var expected = new byte[] { 0x50, 0x39, 0x01, 0x01, 0x06, 0x1C, 0xC2, 0x03, 0xFA };
            var request = new AuthorizeRequest(0x50, 9);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void AuthorizeRequest_TestMethod2()
        {
            var expected = new byte[] { 0x50, 0x3B, 0x01, 0x01, 0x06, 0x1D, 0x7A, 0x03, 0xFA };
            var request = new AuthorizeRequest(0x50, 0x0B);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetAmountRequestTestMethod1()
        {
            var expected = new byte[] { 0x50, 0x39, 0x04, 0x04,
                0x00, 0x00, 0x11, 0x22,
                0xD0, 0x32, 0x03, 0xFA };
            var request = new PresetAmountRequest(0x50, 9, 1122);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetAmountRequest_TestMethod2()
        {
            var expected = new byte[] { 0x50, 0x39, 0x04, 0x04,
                0x12, 0x34, 0x56, 0x78,
                0x27, 0x4F, 0x03, 0xFA };
            var request = new PresetAmountRequest(0x50, 9, 12345678);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetAmountRequest_TestMethod3()
        {
            var expected = new byte[] { 0x50, 0x39, 0x04, 0x04,
                0x12, 0x00, 0x06, 0x70,
                0x5B, 0x47, 0x03, 0xFA };
            var request = new PresetAmountRequest(0x50, 9, 12000670);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PriceUpdateRequest_TestMethod1()
        {
            var expected = new byte[] { 0x50, 0x39, 0x05, 0x09,
                0x00, 0x00, 0x01,
                0x00, 0x00, 0x02,
                0x00, 0x00, 0x03,
                0x0C, 0x96, 0x03, 0xFA };
            var request = new PriceUpdateRequest(0x50, 9, new int[] { 1, 2, 3 });
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PriceUpdateRequest_TestMethod2()
        {
            var expected = new byte[] { 0x50, 0x39, 0x05, 0x09,
                0x00, 0x00, 0x21,
                0x00, 0x00, 0x22,
                0x00, 0x00, 0x23,
                0x27, 0x4C, 0x03, 0xFA };
            var request = new PriceUpdateRequest(0x50, 9, new int[] { 21, 22, 23 });
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PriceUpdateRequest_TestMethod3()
        {
            var expected = new byte[] { 0x50, 0x39, 0x05, 0x03,
                0x00, 0x98, 0x93,
                0xB2, 0x85, 0x03, 0xFA };
            var request = new PriceUpdateRequest(0x50, 9, new int[] { 09893 });
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PriceUpdateRequest_TestMethod4()
        {
            var expected = new byte[] { 0x50, 0x39, 0x05, 0x06,
                0x12, 0x34, 0x56,
                0x23, 0x45, 0x67,
                0xBA, 0xA1, 0x03, 0xFA };
            var request = new PriceUpdateRequest(0x50, 9, new int[] { 123456, 234567 });
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void PriceUpdateRequest_TestMethod5()
        {
            var expected = new byte[] { 0x50, 0x39, 0x05, 0x0C,
                0x12, 0x34, 0x56,
                0x23, 0x45, 0x67,
                0x34, 0x56, 0x78,
                0x45, 0x67, 0x89,
                0x11, 0xD2, 0x03, 0xFA };
            var request = new PriceUpdateRequest(0x50, 9, new int[] { 123456, 234567, 345678, 456789 });
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void ReadTotalizerRequest_TestMethod0()
        {
            var expected = new byte[] { 0x50, 0x32,
                0x65,0x01,0x02,
                0x5E,0x10,0xFA,
                0x03,0xFA};
            var request = new RequestTotalVolumeCountersRequest(0x50, 2, 2);
            Wayne_Pump_Dart.Parser p = new Wayne_Pump_Dart.Parser();
            var actual = p.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expected, actual), actual.ToHexLogString());
        }

        [TestMethod]
        public void NozzleStatusAndFillingPrice_TransactionData_TestMethod1()
        {
            var transactionData
                = new NozzleStatusAndFillingPrice_TransactionData(new TransactionData()
                {
                    TransactionNumber = 0x03,
                    RawData = new List<byte>() { 0x00, 0x22, 0x22, 0x02 }
                });
            Assert.AreEqual(true, transactionData.FillingPrice == 2222);
            Assert.AreEqual(true, transactionData.Status.Key == 2);
            Assert.AreEqual(true, transactionData.Status.Value == NozzleStatusAndFillingPrice_TransactionData.NozzleStatus.IN);
        }

        [TestMethod]
        public void NozzleStatusAndFillingPrice_TransactionData_TestMethod2()
        {
            var transactionData
                = new NozzleStatusAndFillingPrice_TransactionData(new TransactionData()
                {
                    TransactionNumber = 0x03,
                    RawData = new List<byte>() { 0x00, 0x22, 0x22, 0x12 }
                });
            Assert.AreEqual(true, transactionData.FillingPrice == 2222);
            Assert.AreEqual(true, transactionData.Status.Key == 2);
            Assert.AreEqual(true, transactionData.Status.Value
                == NozzleStatusAndFillingPrice_TransactionData.NozzleStatus.OUT);
        }


        [TestMethod]
        public void TotalCounters_TransactionData_TransactionData_TestMethod1()
        {
            var transactionData
                = new TotalCounters_TransactionData(new TransactionData()
                {
                    TransactionNumber = 0x65,
                    Length = 0x10,
                    RawData = new List<byte>() { 0x01, 0x00, 0x00, 0x23, 0x56, 0x43, 0x00, 0x00, 0x23, 0x56, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00 }
                });
            Assert.AreEqual(true, transactionData.LogicalNozzleNumber == 1);
            Assert.AreEqual(true, transactionData.TotalValue == 235643);
            Assert.AreEqual(true, transactionData.Meter1_TotalValue_Or_NumberOfFill == 235643);
            Assert.AreEqual(true, transactionData.Meter2_TotalValue == 0);
        }

        [TestMethod]
        public void TotalCounters_TransactionData_TransactionData_TestMethod2()
        {
            var transactionData
                = new TotalCounters_TransactionData(new TransactionData()
                {
                    TransactionNumber = 0x65,
                    Length = 0x10,
                    RawData = new List<byte>() { 0x09, 0x12, 0x34, 0x23, 0x56, 0x43, 0x00, 0x00, 0x23, 0x56, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00 }
                });
            Assert.AreEqual(true, transactionData.LogicalNozzleNumber == 9);
            Assert.AreEqual(true, transactionData.TotalValue == 1234235643);
            Assert.AreEqual(true, transactionData.Meter1_TotalValue_Or_NumberOfFill == 235643);
            Assert.AreEqual(true, transactionData.Meter2_TotalValue == 0);
        }
    }
}