// -----------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
// -----------------------------------------------------------------------
using System;
using System.Linq;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Factories;
using System.ComponentModel.Composition.Hosting;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.UnitTesting;

namespace Tests.Integration
{
    [TestClass]
    public class RejectionTests
    {
        public interface IExtension
        {
            int Id { get; set; }
        }

        [Export]
        public class MyImporter
        {
            [ImportMany(AllowRecomposition = true)]
            public IExtension[] Extensions { get; set; }
        }

        [Export(typeof(IExtension))]
        public class Extension1 : IExtension
        {
            [Import("IExtension.IdValue")]
            public int Id { get; set; }
        }

        [Export(typeof(IExtension))]
        public class Extension2 : IExtension
        {
            [Import("IExtension.IdValue2")]
            public int Id { get; set; }
        }

        [TestMethod]
        public void Rejection_ExtensionLightUp_AddedViaBatch()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(
                typeof(MyImporter),
                typeof(Extension1),
                typeof(Extension2));

            var importer = container.GetExportedValue<MyImporter>();

            Assert.AreEqual(0, importer.Extensions.Length, "Should have 0 extensions");

            container.ComposeExportedValue<int>("IExtension.IdValue", 10);

            Assert.AreEqual(1, importer.Extensions.Length, "Should have 1 extension");
            Assert.AreEqual(10, importer.Extensions[0].Id);

            container.ComposeExportedValue<int>("IExtension.IdValue2", 20);

            Assert.AreEqual(2, importer.Extensions.Length, "Should have 2 extension");
            Assert.AreEqual(10, importer.Extensions[0].Id);
            Assert.AreEqual(20, importer.Extensions[1].Id);
        }

        public class ExtensionValues
        {
            [Export("IExtension.IdValue")]
            public int Value = 10;

            [Export("IExtension.IdValue2")]
            public int Value2 = 20;
        }

        [TestMethod]
        public void Rejection_ExtensionLightUp_AddedViaCatalog()
        {
            var ext1Cat = CatalogFactory.CreateAttributed(typeof(Extension1));
            var ext2Cat = CatalogFactory.CreateAttributed(typeof(Extension2));
            var hostCat = CatalogFactory.CreateAttributed(typeof(MyImporter));
            var valueCat = CatalogFactory.CreateAttributed(typeof(ExtensionValues));

            var catalog = new AggregateCatalog();
            catalog.Catalogs.Add(hostCat);

            var container = ContainerFactory.Create(catalog);

            var importer = container.GetExportedValue<MyImporter>();

            Assert.AreEqual(0, importer.Extensions.Length, "Should have 0 extensions");

            catalog.Catalogs.Add(ext1Cat);

            Assert.AreEqual(0, importer.Extensions.Length, "Should have 0 extensions after ext1 added without dependency");

            catalog.Catalogs.Add(ext2Cat);

            Assert.AreEqual(0, importer.Extensions.Length, "Should have 0 extensions after ext2 added without dependency");

            catalog.Catalogs.Add(valueCat);

            Assert.AreEqual(2, importer.Extensions.Length, "Should have 2 extension");
            Assert.AreEqual(10, importer.Extensions[0].Id);
            Assert.AreEqual(20, importer.Extensions[1].Id);
        }

        public interface IMissing { }
        public interface ISingle { }
        public interface IMultiple { }
        public interface IConditional { }
        public class SingleImpl : ISingle { }
        public class MultipleImpl : IMultiple { }

        public class NoImportPart
        {
            public NoImportPart()
            {
                SingleExport = new SingleImpl();
                MultipleExport1 = new MultipleImpl();
                MultipleExport2 = new MultipleImpl();
            }

            [Export]
            public ISingle SingleExport { private set; get; }

            [Export]
            public IMultiple MultipleExport1 { private set; get; }

            [Export]
            public IMultiple MultipleExport2 { private set; get; }
        }

        [Export]
        public class Needy
        {
            public Needy() { }

            [Import]
            public ISingle SingleImport { get; set; }
        }

        [TestMethod]
        public void Rejection_Resurrection()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy));

            var exports1 = container.GetExportedValues<Needy>();

            Assert.AreEqual(0, exports1.Count(), "Catalog entry should be rejected");

            container.ComposeParts(new NoImportPart());

            var exports2 = container.GetExportedValues<Needy>();
            Assert.AreEqual(1, exports2.Count(), "Catalog entry should be ressurrected");
        }

        [TestMethod]
        public void Rejection_BatchSatisfiesBatch()
        {
            var container = ContainerFactory.Create();
            var needy = new Needy();
            container.ComposeParts(needy, new NoImportPart());
            Assert.IsInstanceOfType(needy.SingleImport, typeof(SingleImpl), "Import not satisifed as expected");
        }

        [TestMethod]
        public void Rejection_BatchSatisfiesBatchReversed()
        {
            var container = ContainerFactory.Create();
            var needy = new Needy();
            container.ComposeParts(new NoImportPart(), needy);
            Assert.IsInstanceOfType(needy.SingleImport, typeof(SingleImpl), "Import not satisifed as expected");
        }

        [TestMethod]
        public void Rejection_CatalogSatisfiesBatch()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(NoImportPart));
            var needy = new Needy();
            container.ComposeParts(needy);
            Assert.IsInstanceOfType(needy.SingleImport, typeof(SingleImpl), "Import not satisifed as expected");
        }

        [TestMethod]
        public void Rejection_TransitiveDependenciesSatisfied()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy), typeof(NoImportPart));
            var needy = container.GetExportedValue<Needy>();
            Assert.IsNotNull(needy);
            Assert.IsInstanceOfType(needy.SingleImport, typeof(SingleImpl), "Import not satisifed as expected");
        }

        [TestMethod]
        public void Rejection_TransitiveDependenciesUnsatisfied_ShouldThrowCardinalityMismatch()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy), typeof(MissingImportPart));

            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>
                container.GetExportedValue<Needy>());
        }

        public class MissingImportPart : NoImportPart
        {
            [Import]
            public IMissing MissingImport { set; get; }
        }

        [TestMethod]
        public void Rejection_BatchRevert()
        {
            var container = ContainerFactory.Create();

            ExceptionAssert.Throws<ChangeRejectedException>(() =>
                container.ComposeParts(new MissingImportPart()));
        }

        [TestMethod]
        public void Rejection_DefendPromisesOnceMade()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy));

            var addBatch = new CompositionBatch();
            var removeBatch = new CompositionBatch();
            var addedPart = addBatch.AddPart(new NoImportPart());
            removeBatch.RemovePart(addedPart);

            // Add then remove should be fine as long as exports aren't used yet.
            container.Compose(addBatch);
            container.Compose(removeBatch);

            // Add the dependencies
            container.Compose(addBatch);

            // Retrieve needy which uses an export from addedPart
            var export = container.GetExportedValue<Needy>();

            // Should not be able to remove the addedPart because someone depends on it.
            ExceptionAssert.Throws<ChangeRejectedException>(() =>
                container.Compose(removeBatch));
        }

        [TestMethod]
        public void Rejection_DefendPromisesLazily()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy));

            // Add the missing dependency for Needy
            container.ComposeParts(new NoImportPart());

            // This change should succeed since the component "Needy" hasn't been fully composed
            // and one way of satisfying its needs is as good ask another
            var export = container.GetExport<Needy>();

            // Cannot add another import because it would break existing promised compositions
            ExceptionAssert.Throws<ChangeRejectedException>(() =>
                container.ComposeParts(new NoImportPart()));

            // Instansitate the object
            var needy = export.Value;

            // Cannot add another import because it would break existing compositions
            ExceptionAssert.Throws<ChangeRejectedException>(() =>
                container.ComposeParts(new NoImportPart()));
        }


        [TestMethod]
        public void Rejection_SwitchPromiseFromManualToCatalog()
        {
            // This test shows how the priority list in the AggregateCatalog can actually play with 
            // the rejection work. Until the actual object is actually pulled on and satisfied the 
            // promise can be moved around even for not-recomposable imports but once the object is 
            // pulled on it is fixed from that point on.

            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy), typeof(NoImportPart));

            // Add the missing dependency for Needy
            container.ComposeParts(new NoImportPart());

            // This change should succeed since the component "Needy" hasn't been fully composed
            // and one way of satisfying its needs is as good as another
            var export = container.GetExport<Needy>();

            // Adding more exports doesn't fail because we push the promise to use the NoImportPart from the catalog
            // using the priorities from the AggregateExportProvider
            container.ComposeParts(new NoImportPart());

            // Instansitate the object
            var needy = export.Value;

            // Cannot add another import because it would break existing compositions
            ExceptionAssert.Throws<ChangeRejectedException>(() =>
                container.ComposeParts(new NoImportPart()));
        }

        public interface ILoopA { }
        public interface ILoopB { }

        [Export(typeof(ILoopA))]
        public class LoopA1 : ILoopA
        {
            [Import]
            public ILoopB LoopB { set; get; }
        }

        [Export(typeof(ILoopA))]
        public class LoopA2 : ILoopA
        {
            [Import]
            public ILoopB LoopB { set; get; }
        }

        [Export(typeof(ILoopB))]
        public class LoopB1 : ILoopB
        {
            [Import]
            public ILoopA LoopA { set; get; }
        }

        [Export(typeof(ILoopB))]
        public class LoopB2 : ILoopB
        {
            [Import]
            public ILoopA LoopA { set; get; }
        }

        // This is an interesting situation.  There are several possible self-consistent outcomes:
        // - All parts involved in the loop are rejected
        // - A consistent subset are not rejected (exactly one of LoopA1/LoopA2 and one of LoopB1/LoopB2
        //
        // Both have desireable and undesirable characteristics.  The first case is non-discriminatory but
        // rejects more parts than are necessary, the second minimizes rejection but must choose a subset
        // on somewhat arbitary grounds.
        [TestMethod]
        public void Rejection_TheClemensLoop()
        {
            var catalog = new TypeCatalog(new Type[] { typeof(LoopA1), typeof(LoopA2), typeof(LoopB1), typeof(LoopB2) });
            var container = new CompositionContainer(catalog);
            var exportsA = container.GetExportedValues<ILoopA>();
            var exportsB = container.GetExportedValues<ILoopB>();

            // These assertions would prove solution one
            Assert.AreEqual(0, exportsA.Count(), "Catalog ILoopA entries should be rejected");
            Assert.AreEqual(0, exportsB.Count(), "Catalog ILoopB entries should be rejected");

            // These assertions would prove solution two
            //Assert.AreEqual(1, exportsA.Count, "Only noe ILoopA entry should not be rejected");
            //Assert.AreEqual(1, exportsB.Count, "Only noe ILoopB entry should not be rejected");
        }

        public interface IWorkItem
        {
            string Id { get; set; }
        }

        [Export]
        public class AllWorkItems
        {
            [ImportMany(AllowRecomposition = true)]
            public Lazy<IWorkItem>[] WorkItems { get; set; }
        }

        [Export(typeof(IWorkItem))]
        public class WorkItem : IWorkItem
        {
            [Import("WorkItem.Id", AllowRecomposition = true)]
            public string Id { get; set; }
        }

        public class Ids
        {
            [Export("WorkItem.Id")]
            public string Id = "MyId";

        }

        [TestMethod]
        public void AppliedStateNotCompleteedYet()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(AllWorkItems));

            container.ComposeExportedValue<string>("WorkItem.Id", "A");

            var workItems = container.GetExportedValue<AllWorkItems>();

            Assert.AreEqual(0, workItems.WorkItems.Length);

            container.ComposeParts(new WorkItem());

            Assert.AreEqual(1, workItems.WorkItems.Length);
            Assert.AreEqual("A", workItems.WorkItems[0].Value.Id);
        }

        [Export]
        public class ClassWithMissingImport
        {
            [Import]
            private string _importNotFound = null;
        }

        [TestMethod]
        public void AppliedStateStored_ShouldRevertStateOnFailure()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(AllWorkItems), typeof(WorkItem), typeof(Ids));

            var workItems = container.GetExportedValue<AllWorkItems>();

            Assert.AreEqual(1, workItems.WorkItems.Length);

            var batch = new CompositionBatch();

            batch.AddExportedValue("WorkItem.Id", "B");
            batch.AddPart(new ClassWithMissingImport());

            ExceptionAssert.Throws<ChangeRejectedException>(() =>
                container.Compose(batch));

            Assert.AreEqual("MyId", workItems.WorkItems[0].Value.Id);
        }

        [Export]
        public class OptionalImporter
        {
            [Import(AllowDefault = true)]
            public ClassWithMissingImport Import { get; set; }
        }

        [TestMethod]
        public void OptionalImportWithMissingDependency_ShouldRejectAndComposeFine()
        {
            var container = ContainerFactory.CreateWithAttributedCatalog(typeof(OptionalImporter), typeof(ClassWithMissingImport));

            var importer = container.GetExportedValue<OptionalImporter>();

            Assert.IsNull(importer.Import);
        }

        [Export]
        public class PartA
        {
            [Import(AllowDefault = true, AllowRecomposition = true)]
            public PartB ImportB { get; set; }
        }

        [Export]
        public class PartB
        {
            [Import]
            public PartC ImportC { get; set; }
        }

        [Export]
        public class PartC
        {
            [Import]
            public PartB ImportB { get; set; }
        }

        [TestMethod]
        [WorkItem(684510)]
        public void PartAOptionalDependsOnPartB_PartBGetAddedLater()
        {
            var container = new CompositionContainer(new TypeCatalog(typeof(PartC), typeof(PartA)));
            var partA = container.GetExportedValue<PartA>();

            Assert.IsNull(partA.ImportB);

            var partB = new PartB();
            container.ComposeParts(partB);

            Assert.AreEqual(partA.ImportB, partB);
            Assert.IsNotNull(partB.ImportC);
        }

        [Export]
        public class PartA2
        {
            [Import(AllowDefault = true, AllowRecomposition = true)]
            public PartB ImportB { get; set; }

            [Import(AllowDefault = true, AllowRecomposition = true)]
            public PartC ImportC { get; set; }
        }

        [TestMethod]
        [WorkItem(684510)]
        public void PartAOptionalDependsOnPartBAndPartC_PartCGetRecurrected()
        {
            var container = new CompositionContainer(new TypeCatalog(typeof(PartA2), typeof(PartB)));
            var partA = container.GetExportedValue<PartA2>();

            Assert.IsNull(partA.ImportB);
            Assert.IsNull(partA.ImportC);

            var partC = new PartC();
            container.ComposeParts(partC);

            Assert.AreEqual(partA.ImportB, partC.ImportB);
            Assert.AreEqual(partA.ImportC, partC);
        }
    }
}