// --------------------------------------------------------------------------------------------------------------------
// <copyright company="KARL STORZ GmbH and Co. KG">
//   (c) 2011 KARL STORZ GmbH and Co. KG.
// </copyright>
// --------------------------------------------------------------------------------------------------------------------

namespace KS.OR1.DomainLayer.Export.Tests.JobManagement.Helper
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;

    using FluentAssertions;

    using KS.OR1.DomainLayer.Entities.Documentation;
    using KS.OR1.DomainLayer.Entities.Documentation.Enums;
    using KS.OR1.DomainLayer.Export.JobManagement.ExportJobs.Helper;
    using KS.OR1.Infrastructure;
    using KS.OR1.Infrastructure.Core.Services;
    using KS.OR1.Infrastructure.Persistency;

    using Moq;

    using Xunit;

    public class ExportTreatmentToFileSystemTests
    {
        private const string AnExportFolder = @"C:\export";
        private const string AFileLink = @"C:\export\file1.jpg";
        private const string AFileLinkThumbnail = @"C:\export\filethumb.jpg";

        private readonly Mock<IFileSystem> fileSystemMock;
        private readonly Mock<IFileExport> fileExportMock;
        private readonly Mock<ICancelableFileCopier> cancelableFileCopierMock;

        private readonly IExportTreatmentToFileSystem testee;

        public ExportTreatmentToFileSystemTests()
        {
            this.fileSystemMock = new Mock<IFileSystem>();
            this.fileExportMock = new Mock<IFileExport>();
            this.cancelableFileCopierMock = new Mock<ICancelableFileCopier>();

            this.fileSystemMock
                .Setup(fileSystem => fileSystem.DirectoryExists(It.IsAny<string>()))
                .Returns(false);

            this.testee = new ExportTreatmentToFileSystem(this.fileSystemMock.Object, this.fileExportMock.Object, this.cancelableFileCopierMock.Object);
        }

        [Fact]
        public void Export_WhenDataProvided_ThenExported()
        {
            var treatment = this.GetTreatment();

            this.testee.Export(treatment, AnExportFolder);
            
            this.fileExportMock
                .Verify(fileExport => fileExport.Export(treatment, Path.Combine(AnExportFolder, "TreatmentInfo.xml")));
        }

        [Fact]
        public void Export_WhenTreatmentHasArtifacts_ThenExportArtifacts()
        {
            var treatment = this.GetTreatmentWithArtifacts();

            this.testee.Export(treatment, AnExportFolder);

            var expectedDestination = Path.Combine(AnExportFolder, Path.GetFileName(AFileLink));
            var expectedThumbmnailDestination = Path.Combine(AnExportFolder, Path.GetFileName(AFileLinkThumbnail));
            
            this.cancelableFileCopierMock.Verify(
                asynchronousFileCopier => asynchronousFileCopier
                .BeginCopy(AFileLink, expectedDestination), 
                Times.Exactly(treatment.Artifacts.Count));
            
            this.fileSystemMock
                .Verify(fileSystem => fileSystem.Copy(AFileLinkThumbnail, expectedThumbmnailDestination), Times.Exactly(treatment.Artifacts.Count));
        }

        [Fact]
        public void Export_WhenExportPathDoesNotExists_ThenCreateDirectory()
        {
            var treatment = this.GetTreatment();
            this.fileSystemMock
                .Setup(fileSystem => fileSystem.DirectoryExists(AnExportFolder))
                .Returns(false);

            this.testee.Export(treatment, AnExportFolder);

            this.fileSystemMock
                .Verify(fileSystem => fileSystem.CreateDirectory(AnExportFolder));
        }

        [Fact]
        public void Export_WhenExportPathExists_ThenCreateDirectoryWithIncrementedNumber()
        {
            const string FirstIncrementedFolder = AnExportFolder + "_1";
            const string ExpectedExportFolder = AnExportFolder + "_2";
            var treatment = this.GetTreatment();
            this.DefineDirectoyExistence(AnExportFolder, true);
            this.DefineDirectoyExistence(FirstIncrementedFolder, true);
            this.DefineDirectoyExistence(ExpectedExportFolder, false);

            this.testee.Export(treatment, AnExportFolder);

            this.fileSystemMock
                .Verify(fileSystem => fileSystem.CreateDirectory(ExpectedExportFolder), Times.Once());
        }

        private void DefineDirectoyExistence(string path, bool isExiting)
        {
            this.fileSystemMock.Setup(fileSystem => fileSystem.DirectoryExists(path)).Returns(isExiting);
        }

        [Fact]
        public void Export_WhenTreatmentIsNull_ThenArgumentNullExceptionThrown()
        {
            this.testee
                .Invoking(exporter => exporter.Export(null, AnExportFolder))
                .ShouldThrow<ArgumentNullException>();
        }

        [Fact]
        public void Export_WhenPathIsNull_ThenArgumentNullExceptionThrown()
        {
            this.testee
                .Invoking(exporter => exporter.Export(this.GetTreatment(), null))
                .ShouldThrow<ArgumentNullException>();
        }

        [Fact]
        public void Export_WhenFilterProvided_ThenOnlyCertainArtifactsExported()
        {
            var treatment = this.GetTreatmentWithArtifacts();
            var filter = new List<Guid> { treatment.Artifacts.First().Id };

            this.testee.Export(treatment, AnExportFolder, filter);

            var expectedDestination = Path.Combine(AnExportFolder, Path.GetFileName(AFileLink));
            var expectedthumbnailDestination = Path.Combine(AnExportFolder, Path.GetFileName(AFileLinkThumbnail));

            this.fileSystemMock.Verify(
                fileSystem => fileSystem.Copy(AFileLinkThumbnail, expectedthumbnailDestination), Times.Once());
            this.cancelableFileCopierMock.Verify(
                asynchronousFileCopier => asynchronousFileCopier.BeginCopy(AFileLink, expectedDestination));
        }

        [Fact]
        public void Export_WhenExportIsRunningAndIsCanceled_ThenDeleteExportFolder()
        {
            this.cancelableFileCopierMock
                .Setup(cancelableFileCopier => cancelableFileCopier.BeginCopy(It.IsAny<string>(), It.IsAny<string>()))
                .Callback(() => this.testee.CancelExport());

            this.fileSystemMock.Setup(fileSystem => fileSystem.DirectoryExists(AnExportFolder)).Returns(true);

            var treatment = this.GetTreatmentWithArtifacts();

            this.testee.Export(treatment, AnExportFolder);

            this.fileSystemMock.Verify(fileSystem => fileSystem.DeleteDirectory(AnExportFolder));
        }

        [Fact]
        public void Export_WhenExportCanceled_ThenCallCancelOnAsynchronousCopier()
        {
            this.testee.CancelExport();

            this.cancelableFileCopierMock.Verify(asynchronousFileCopier => asynchronousFileCopier.CancelCopy());
        }

        [Fact]
        public void Export_WhenFilterIsEmptyList_ThenNoArtifactExported()
        {
            var treatment = this.GetTreatmentWithArtifacts();
            var filter = new List<Guid>();

            this.testee.Export(treatment, AnExportFolder, filter);

            this.fileSystemMock
                .Verify(fileSystem => fileSystem.Copy(It.IsAny<string>(), It.IsAny<string>()), Times.Never());
        }
        
        private Treatment GetTreatment()
        {
            return new Treatment
                {
                    Patient = new Patient("PatientFirstName", "PatientLastName", "PatientId", Sex.Female, DateTime.Now, "OtherPatientId", "Comment"),                    
                };
        }

        private Treatment GetTreatmentWithArtifacts()
        {
            var treatment = this.GetTreatment();
            treatment.AddArtifact(
                new Artifact
                    {
                        ArtifactType = ArtifactType.ImageArtifact(),
                        FileLink = AFileLink,
                        FileLinkThumbnail = AFileLinkThumbnail
                    });
            treatment.AddArtifact(
                new Artifact
                {
                    ArtifactType = ArtifactType.VideoArtifact(),
                    FileLink = AFileLink,
                    FileLinkThumbnail = AFileLinkThumbnail
                });
            return treatment;
        }
    }
}