using System.IO;
using System.Threading.Tasks;
using Consul;
using Hangfire;
using MalwareMultiScan.Api.Services;
using MalwareMultiScan.Api.Services.Interfaces;
using MalwareMultiScan.Shared.Enums;
using MalwareMultiScan.Shared.Message;
using Mongo2Go;
using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.GridFS;
using Moq;
using NUnit.Framework;

namespace MalwareMultiScan.Tests.Api
{
    public class ScanResultServiceTest
    {
        private MongoDbRunner _mongoDbRunner;
        private IScanResultService _resultService;

        [SetUp]
        public void SetUp()
        {
            _mongoDbRunner = MongoDbRunner.Start(additionalMongodArguments: "--quiet");

            var connection = new MongoClient(_mongoDbRunner.ConnectionString);
            var database = connection.GetDatabase("Test");
            var gridFsBucket = new GridFSBucket(database);
            
            _resultService = new ScanResultService(
                database, gridFsBucket, 
                Mock.Of<IConsulClient>(), 
                Mock.Of<IBackgroundJobClient>());
        }

        [TearDown]
        public void TearDown()
        {
            _mongoDbRunner.Dispose();
        }

        [Test]
        public async Task TestFileStorageStoreObtain()
        {
            var originalData = new byte[] {0xDE, 0xAD, 0xBE, 0xEF};

            string fileId;

            await using (var dataStream = new MemoryStream(originalData))
            {
                fileId = await _resultService.StoreFile("test.txt", dataStream);
            }

            Assert.NotNull(fileId);

            Assert.IsNull(await _resultService.ObtainFile("wrong-id"));
            Assert.IsNull(await _resultService.ObtainFile(ObjectId.GenerateNewId().ToString()));

            await using var fileSteam = await _resultService.ObtainFile(fileId);

            var readData = new[]
            {
                (byte) fileSteam.ReadByte(),
                (byte) fileSteam.ReadByte(),
                (byte) fileSteam.ReadByte(),
                (byte) fileSteam.ReadByte()
            };

            Assert.That(readData, Is.EquivalentTo(originalData));
        }

        [Test]
        public async Task TestScanResultCreateGet()
        {
            var result = await _resultService.CreateScanResult(null);

            Assert.NotNull(result.Id);

            await _resultService.UpdateScanResultForBackend(
                result.Id, "dummy", new ScanResultMessage
                {
                    Duration = 100,
                    Status = ScanResultStatus.Succeeded,
                    Threats = new []{"Test"}
                });

            result = await _resultService.GetScanResult(result.Id);

            Assert.NotNull(result.Id);
            Assert.That(result.Results, Contains.Key("dummy"));

            var dummyResult = result.Results["dummy"];

            Assert.IsTrue(dummyResult.Status == ScanResultStatus.Succeeded);
            Assert.AreEqual(dummyResult.Duration, 100);
            Assert.IsNotEmpty(dummyResult.Threats);
            Assert.That(dummyResult.Threats, Is.EquivalentTo(new[] {"Test"}));
        }
    }
}