using Edge.Core.Parser.BinaryParser.Util;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using ShengJuDesFireEv1CpuCardKeyLoader;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace KeyLoad_Test
{
    [TestClass]
    public class ShengJuDesFireEv1CpuCardKeyLoaderUnitTest
    {
        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 EncryptStringTestMethod1()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            string dataPlainText = "helloworld";
            var encryptedBytes = keyLoader.EncryptString(dataPlainText);
            Assert.IsNotNull(encryptedBytes);
            Assert.IsTrue(encryptedBytes.Length > 0);
            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            Assert.IsNotNull(decryptedBytes);
            Assert.IsTrue(decryptedBytes.Length > 0);
            Assert.IsTrue(ValueEquals(SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(dataPlainText)), decryptedBytes));
        }

        [TestMethod]
        public void EncryptStringTestMethod2()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            string dataPlainText = "12 helloworld4567^&$%#SFWE@#";
            var encryptedBytes = keyLoader.EncryptString(dataPlainText);
            Assert.IsNotNull(encryptedBytes);
            Assert.IsTrue(encryptedBytes.Length > 0);
            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            Assert.IsNotNull(decryptedBytes);
            Assert.IsTrue(decryptedBytes.Length > 0);
            Assert.IsTrue(ValueEquals(SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(dataPlainText)), decryptedBytes));
        }

        [TestMethod]
        public void EncryptStringTestMethod3()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            string dataPlainText = "12 helloworld4567^&$%#SFWE@#7、USB头为公头，可直接连接电脑USB口";
            var encryptedBytes = keyLoader.EncryptString(dataPlainText);
            Assert.IsNotNull(encryptedBytes);
            Assert.IsTrue(encryptedBytes.Length > 0);
            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            Assert.IsNotNull(decryptedBytes);
            Assert.IsTrue(decryptedBytes.Length > 0);
            Assert.IsTrue(ValueEquals(SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(dataPlainText)), decryptedBytes));
        }

        [TestMethod]
        public void ManualExtracCardKeyTestMethod1()
        {
            string dataPlainText = "nullable_string_sample";
            var cardKeyExtractByManual = SHA256Managed.Create().ComputeHash(Encoding.UTF8.GetBytes(dataPlainText)).Select(b => b.ToString()).Aggregate((acc, n) => acc + ", " + n);

            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            var cardKeyExtractByDecrypt = keyLoader.Decrypt(
                Convert.FromBase64String("iczuc2nVu+S1dVOHiOVEZFyb52rdW5GSHfIp80VVicSYBZp/sbCSJ0ldYJkjv8tf+nszFVWmrPj/OM/YvUchVQ=="),
                new byte[] { 0x9C, 0x56, 0x13, 0x9A, 0x9D, 0xA7 }.Concat(Enumerable.Range(0, 16 - 6).Select(i => (byte)i)).ToArray()).Select(b => b.ToString()).Aggregate((acc, n) => acc + ", " + n);
            Assert.AreEqual(cardKeyExtractByManual, cardKeyExtractByDecrypt);
        }

        [TestMethod]
        public void EncryptStringTestMethod4()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            byte[] data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            var encryptedBytes = keyLoader.EncryptString(Convert.ToBase64String(data));
            Assert.IsNotNull(encryptedBytes);
            Assert.IsTrue(encryptedBytes.Length > 0);
            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            Assert.IsNotNull(decryptedBytes);
            Assert.IsTrue(decryptedBytes.Length > 0);
            Assert.IsTrue(ValueEquals(SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(Convert.ToBase64String(data))), decryptedBytes));
        }

        [TestMethod]
        public void EncryptStringTestMethod5()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            string rootKeyPlainText = "helloworld";
            var rootKeyEncryptedBytes = keyLoader.EncryptString(rootKeyPlainText);
            Assert.IsTrue(rootKeyPlainText != Encoding.UTF8.GetString(rootKeyEncryptedBytes));
            var keySet = keyLoader.Get(new EncryptedBase64KeySet()
            {
                RootKey = Convert.ToBase64String(rootKeyEncryptedBytes),
            });
            Assert.IsNotNull(keySet);
            Assert.IsNotNull(keySet.RootKey);
            Assert.IsTrue(keySet.RootKey.Length > 0);
            Assert.IsTrue(ValueEquals(keySet.RootKey, SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(rootKeyPlainText))));
        }

        [TestMethod]
        public void EncryptBytesTestMethod1()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            byte[] data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            var encryptedBytes = keyLoader.EncryptBytes(data);
            Assert.IsNotNull(encryptedBytes);
            Assert.IsTrue(encryptedBytes.Length > 0);
            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            Assert.IsNotNull(decryptedBytes);
            Assert.IsTrue(decryptedBytes.Length > 0);
            Assert.IsTrue(ValueEquals(SHA256.Create().ComputeHash(data), decryptedBytes));
        }

        [TestMethod]
        public void EncryptBytesTestMethod2()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            byte[] data = new byte[] { 255, 2, 3, 4, 5, 6, 7, 8, 9, 10, 255, 2, 3, 4, 5, 6, 7, 8, 9, 10, 255, 2, 3, 4, 5, 6, 7, 8, 9, 10, 255, 2, 3, 4, 5, 6, 7, 8, 9, 10, 255, 2, 3, 4, 5, 6, 7, 8, 9, 10, 255, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            var encryptedBytes = keyLoader.EncryptBytes(data);
            Assert.IsNotNull(encryptedBytes);
            Assert.IsTrue(encryptedBytes.Length > 0);
            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            Assert.IsNotNull(decryptedBytes);
            Assert.IsTrue(decryptedBytes.Length > 0);
            Assert.IsTrue(ValueEquals(SHA256.Create().ComputeHash(data), decryptedBytes));
        }

        [TestMethod]
        public void DecryptStringTestMethod1()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            string encryptingStr = "helloworld0helloworld1helloworld2helloworld3helloworld4helloworld5";
            var encryptedBytes = keyLoader.EncryptString(encryptingStr, false);
            Assert.IsTrue(encryptingStr != Encoding.UTF8.GetString(encryptedBytes));

            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            var decryptedString = Encoding.UTF8.GetString(decryptedBytes);
            Assert.IsTrue(decryptedString == encryptingStr);
        }

        [TestMethod]
        public void DecryptStringTestMethod2()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            byte[] encryptingBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
            var encryptedBytes = keyLoader.EncryptBytes(encryptingBytes, false);
            Assert.IsTrue(!ValueEquals(encryptingBytes, encryptedBytes));

            var decryptedBytes = keyLoader.Decrypt(encryptedBytes);
            Assert.AreEqual(encryptingBytes.Length, decryptedBytes.Length, "actual hex: " + decryptedBytes.ToHexLogString());
            Assert.IsTrue(ValueEquals(encryptingBytes, decryptedBytes));
            //HyzLE00CvI9KZMwoISwlLSlxsYN6lkeNxDozEXgzx+8JzZftkCa0x+mw9dfUNIj1
        }

        [TestMethod]
        public void DecryptBase64StringTestMethod1()
        {
            var keyLoader = new LocalNetworkMacBasedEncryptionKeyLoader(NullLogger.Instance);
            string encryptedBase64Str = "taEIFt/feuqBltCgFU3Dy6Y2PjtndTDLUyRulkAQRaQWzulE9vU2AHNEUf7qWdNc";

            var decryptedBytes = keyLoader.Decrypt(Convert.FromBase64String(encryptedBase64Str));
            Assert.AreEqual(Encoding.UTF8.GetString(decryptedBytes), "nullable_string_sample");
        }
    }
}