using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using NUnit.Framework;
using Newtonsoft.Json;
using Pithos.Network;

namespace Pithos.Core.Test
{
    [TestFixture]
    public class SignatureTest
    {

        [Test]
        public void TestCreate()
        {
            var hasher = HashAlgorithm.Create("sha256");
            Assert.IsNotNull(hasher);
        }

        [Test]
        public void TestHashmapCreation()
        {
            var file = "e:\\pithos\\vlc-1.1.11-win32.exe";

            decimal blockSize = 4*1024*1024;

            var fileSize = new FileInfo(file).Length;
            var numBlocks = decimal.Ceiling(fileSize/blockSize);

            var md5 = Signature.CalculateMD5(file);            

            var hash1 = Signature.CalculateTreeHashAsync(file, (int) blockSize,"sha256").Result;
            Assert.IsNotNull(hash1.Hashes);
            Assert.AreEqual(numBlocks, hash1.Hashes.Count());

            var topHash = hash1.TopHash;
            var hashString = BytesToStr(topHash);

            var stringHashes = (from hash in hash1.Hashes
                               select BytesToStr(hash)).ToList();
            var hashes = JsonConvert.SerializeObject(stringHashes);
            Assert.IsNotNull(topHash);
        }
        
        [Test]
        public void TestHashmapStorage()
        {
            var file = "e:\\pithos\\vlc-1.1.11-win32.exe";

            decimal blockSize = 4*1024*1024;

            var fileSize = new FileInfo(file).Length;
            var numBlocks = decimal.Ceiling(fileSize/blockSize);

            var md5 = Signature.CalculateMD5(file);

            var hash1 = Signature.CalculateTreeHashAsync(file, (int) blockSize, "sha256").Result;
            hash1.FileId = Guid.NewGuid();
            var task = hash1.Save(@"e:\")
                .ContinueWith(_ => TreeHash.LoadTreeHash(@"e:\", hash1.FileId)).Unwrap();            
            task.ContinueWith(t =>
            {                
                var hash = t.Result;
                Assert.AreEqual(hash1.Hashes, hash.Hashes.ToArray());
                int i = 0;
            }).Wait();
        }

        public static string BytesToStr(byte[] bytes)
        {
            var str = new StringBuilder();

            foreach (byte t in bytes)
                str.AppendFormat("{0:X2}", t);
            
            return str.ToString();
        }


        [Test]
        public void TestTopHashEmpty()
        {
            using (var hasher = HashAlgorithm.Create("sha256"))
            {
                var hashEmpty = hasher.ComputeHash(new byte[] {});                

                var empty = new List<byte[]>();
                var hash = Signature.CalculateTopHash(empty,"sha256");
                Assert.IsNull(hash);
            }
        }

        [Test]
        public void TestHashMapsEqual()
        {

            CloudFilesClient client = new CloudFilesClient();
            client.AuthenticationUrl = @"https://pithos.dev.grnet.gr";
            client.UsePithos = true;
            var account = "890329@vho.grnet.gr";
            client.Authenticate(account, "24989dce4e0fcb072f8cb60c8922be19");
            var fileName = @"vlc-1.1.11-win32.exe";
            var localHash= Signature.CalculateTreeHashAsync(Path.Combine(@"e:\pithos\", fileName), 4 * 1024 * 1024, "sha256").Result;
            var upHash= client.GetHashMap(fileName, account, "pithos").Result;

            Assert.AreEqual(upHash.TopHash, localHash.TopHash);

            Assert.AreEqual(upHash.Hashes,localHash.Hashes);
        }
        
        [Test]
        public void TestAsyncEquivalence()
        {

            var fileName = @"vlc-1.1.11-win32.exe";
            var syncHash= Signature.CalculateTreeHash(Path.Combine(@"e:\pithos\", fileName), 4 * 1024 * 1024, "sha256");
            var asyncHash = Signature.CalculateTreeHashAsync(Path.Combine(@"e:\pithos\", fileName), 4 * 1024 * 1024, "sha256")
                .Result;

            Assert.AreEqual(syncHash.TopHash, asyncHash.TopHash);

            Assert.AreEqual(syncHash.Hashes,asyncHash.Hashes);
        }
    }

}