using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;
using System.Collections.Generic;
using Wayne_VaporRecoveryDataCollectorBoard;
using Edge.Core.Parser.BinaryParser.Util;

namespace Wayne_VaporRecoveryDataCollectorBoard_Test
{
    [TestClass]
    public class StateMachineMessageCutterUnitTest
    {
        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 ShouldCutTest1()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            var rawRealCompleteMsg = new byte[] { 1, 0x68, 3, 4, 3, 5, 0, 8, 0xA0, 0x16 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(1)));
        }

        [TestMethod]
        public void ShouldCutTest2()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            var rawRealCompleteMsg = new byte[] { 1, 0x68, 3, 4, 3, 5, 0, 8, 0xA0, 0x16 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(1)));

            // feed again
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(1)));
        }

        [TestMethod]
        public void ShouldCutTest3()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 5, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 0);
            Assert.AreEqual(true, msg == null);
        }

        [TestMethod]
        public void ShouldCutTest4()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0x68, 3, 4, 3, 5, 0, 8, 0xA0, 0x16 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(7)));
        }


        [TestMethod]
        public void ShouldCutTest6()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0x68, 3, 4, 3, 5, 0, 8, 0xA0, 17 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 0);
        }


        [TestMethod]
        public void ShouldCutTest7()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            List<byte[]> msg = new List<byte[]>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg.Add(cutter.Message);
            };

            var rawRealCompleteMsg = new byte[] { 11, 22, 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0x68, 3, 4, 3, 5, 0, 8, 0xA0, 0x16,
                0xFA, 0x68, 3, 4, 3, 5, 0, 11, 0xA0, 0x16, };
            var validMsg0 = new byte[] { 0x68, 3, 4, 3, 5, 0, 8, 0xA0, 0x16 };
            var validMsg1 = new byte[] { 0x68, 3, 4, 3, 5, 0, 11, 0xA0, 0x16, };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(msg[0], validMsg0));
            Assert.AreEqual(true, ValueEquals(msg[1], validMsg1));
        }

        [TestMethod]
        public void ShouldCutTest8()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            var rawRealCompleteMsg = "68 06 00 00 16".ToBytes();

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
        }

    }
}