using Edge.Core.Parser.BinaryParser.Util;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using ShengJu_CUT100_DES;
using ShengJu_CUT100_DES.MessageEntity.Incoming;
using ShengJu_CUT100_DES.MessageEntity.Outgoing;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;

namespace ShengJu_CUT100_DES_Test
{
    [TestClass]
    public class MessageTest
    {
        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 ReadModuleInfoRequest_TestMethod0()
        {
            var request = new ReadModuleInfoRequest();
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = new byte[] { 0x04, 0x01, 0x15, 0xE5 };
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void ReadModuleInfoRequest_TestMethod1()
        {
            var request = new ReadModuleInfoRequest();
            request.ModulePhysicalAddress = 2;
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = new byte[] { 0x04, 0x02, 0x15, 0xE4 };
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void ReadModuleInfoResponse_TestMethod0()
        {
            var raw = "20 01 15 00 43 55 54 31 30 30 2D 50 42 4F 43 20 56 31 2E 30 20 32 30 31 33 2D 30 35 2D 33 30 17".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as ReadModuleInfoResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.模块返回状态 == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.ModuleStateEnum.命令执行成功);
            Assert.AreEqual(true, actual.ModelAndVersion == "CUT100-PBOC V1.0 2013-05-30");
        }

        [TestMethod]
        public void FormatCardRequest_TestMethod0()
        {
            var request = new FormatCardRequest(Enumerable.Repeat<byte>(0x00, 16).ToArray(), Enumerable.Repeat<byte>(0xff, 16).ToArray());
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "24 01 B0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 3A".ToBytes();
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void FormatCardResponse_TestMethod0()
        {
            var raw = "05 01 B0 00 49".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as GenericSuccessResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.模块返回状态 == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.ModuleStateEnum.命令执行成功);
        }

        [TestMethod]
        public void FormatCardResponse_TestMethod1()
        {
            var raw = "06 01 B0 0A AE 90".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as GenericFailureResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.模块返回状态 == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.ModuleStateEnum.初始化CPU卡文件系统失败);
            Assert.AreEqual(true, actual.CpuCardState == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.CpuCardStateEnum.当前验证状态不允许执行请求的命令_or密钥错误_or权限不够);
        }

        [TestMethod]
        public void WriteAppFileRequest_TestMethod0()
        {
            var request = new WriteAppFileRequest(1, 0, Enumerable.Repeat<byte>(0x00, 16).ToArray(), Enumerable.Repeat<byte>(0xaa, 32).ToArray());
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "36 01 B1 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA D6".ToBytes();
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void WriteAppFileResponse_TestMethod0()
        {
            var raw = "05 01 B1 00 48".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as GenericSuccessResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.模块返回状态 == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.ModuleStateEnum.命令执行成功);
        }

        [TestMethod]
        public void ActivateATypeCardRequest_TestMethod0()
        {
            var request = new ActivateATypeCardRequest();
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "04 01 16 E4".ToBytes();
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void ActivateATypeCardResponse_TestMethod0()
        {
            var raw = "09 01 16 00 F6 65 34 49 07".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as ActivateATypeCardResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.模块返回状态 == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.ModuleStateEnum.命令执行成功);
            Assert.AreEqual(true, ValueEquals(actual.UID, "F6 65 34 49".ToBytes()));
        }

        [TestMethod]
        public void ReadAppFileRequest_TestMethod0()
        {
            var request = new ReadAppFileRequest(1, 0, Enumerable.Repeat<byte>(0x00, 16).ToArray());
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "16 01 B2 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 35".ToBytes();
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void ReadAppFileResponse_TestMethod0()
        {
            var raw = "25 01 B2 00 AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA E7".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as ReadAppFileResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.模块返回状态 == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.ModuleStateEnum.命令执行成功);
            Assert.AreEqual(true, ValueEquals(actual.Data, Enumerable.Repeat<byte>(0xAA, 32)));
        }


        [TestMethod]
        public void ModifyPredefinedFileKey_TestMethod0()
        {
            var request = new ModifyPredefinedFileKey(ModifyPredefinedFileKey.PredefinedFileKeyTypeEnum.文件1读密钥,
                Enumerable.Repeat<byte>(0x00, 16).ToArray(),
                Enumerable.Repeat<byte>(0xff, 16).ToArray());
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "25 01 B3 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff 35".ToBytes();
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void ReadAppDirsRequest_TestMethod0()
        {
            var request = new ReadAppDirsRequest(Enumerable.Repeat<byte>(0x00, 16).ToArray());
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "15 01 B8 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 30".ToBytes();
            Assert.AreEqual(true, ValueEquals(expect, actual));
        }

        [TestMethod]
        public void ReadAppDirsResponse_TestMethod0()
        {
            var raw = "0C 01 B8 00 02 01 10 00 F1 AD 00 89".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as ReadAppDirsResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.模块返回状态 == ShengJu_CUT100_DES.MessageEntity.IncomingMessageBase.ModuleStateEnum.命令执行成功);
            Assert.AreEqual(true, actual.DirCount == 2);
            Assert.AreEqual(true, actual.DirIds.Count == 2);
            Assert.AreEqual(true, ValueEquals(actual.DirIds[0], new byte[] { 0x01, 0x10, 0x00 }));
            Assert.AreEqual(true, ValueEquals(actual.DirIds[1], new byte[] { 0xF1, 0xAD, 0x00 }));
        }

        [TestMethod]
        public void SerializeBytes_TestMethod0()
        {
            int[] data0 = new int[] { 0 };
            var json0 = JsonSerializer.Serialize(data0);

            byte[] data1 = new byte[] { 0, 0 };
            var json1 = JsonSerializer.Serialize(data1);

            byte[] data2 = new byte[] { 0, 0, 0 };
            var json2 = JsonSerializer.Serialize(data2);

            byte[] data3 = new byte[] { 0, 0, 0, 0 };
            var json3 = JsonSerializer.Serialize(data3);
        }
    }
}