using System;

using StructureMap;

public class Program

{

    public static void Main()

    {

        // Our goal is to configure the container such that when

        // a LocalizationContext is getting resolved, it receives an

        // instance of a SomeDependency class, but when FancyLocalizationContext

        // is resolved, it receives a FancyDependency

        //

        // This configuration doesn't accomplish this because the second

        // call to .Use<>() makes FancyDependency the default "plugged type"

        // for the "plugin type" ISomeDependency (plugged type/plugin type is

        // StructureMap jargon).

        var incorrectContainer = new Container(_ => {

            _.For<LocalizationContext>().Use<LocalizationContext>();

            _.For<ISomeDependency>().Use<SomeDependency>();

            _.For<FancyLocalizationContext>().Use<FancyLocalizationContext>();

            _.For<ISomeDependency>().Use<FancyDependency>();

        });

        var localizationContext = incorrectContainer.GetInstance<LocalizationContext>();

        var fancyLocalizationContext = incorrectContainer.GetInstance<FancyLocalizationContext>();

        Console.WriteLine(localizationContext.Foo());

        Console.WriteLine(fancyLocalizationContext.Foo());

        Console.WriteLine("");      

        // This configuration uses the .Ctor<>() method to specify that for

        // when a FancyLocalizationContext is being resolved, the container

        // should provide a FancyDependency as the plugged type for ISomeDependency,

        // rather than the default plugged type of SomeDependency.

        //

        // It works!

        //

        // (idea stolen from: http://structuremap.github.io/registration/inline-dependencies/ )

        var correctContainer = new Container(_ => {

            _.For<LocalizationContext>().Use<LocalizationContext>();

            _.For<ISomeDependency>().Use<SomeDependency>();

            _.For<FancyLocalizationContext>().Use<FancyLocalizationContext>()

                .Ctor<ISomeDependency>().Is<FancyDependency>();

        });

        var localizationContext1 = correctContainer.GetInstance<LocalizationContext>();

        var fancyLocalizationContext1 = correctContainer.GetInstance<FancyLocalizationContext>();

        Console.WriteLine(localizationContext1.Foo());

        Console.WriteLine(fancyLocalizationContext1.Foo());

    }       

    public class LocalizationContext

    {

        private readonly ISomeDependency _someDependency;

        public LocalizationContext(ISomeDependency someDependency)

        {

            _someDependency = someDependency;

        }

        public string Foo(){ return "::[LocalizationContext:] I have a:\r\n\t" + _someDependency.Bar(); }

    }

    public class FancyLocalizationContext

    {

        private readonly ISomeDependency _someDependency;

        public FancyLocalizationContext(ISomeDependency someDependency)

        {

            _someDependency = someDependency;

        }

        public string Foo(){ return "::[LocalizationContext:] I have a:\r\n\t" + _someDependency.Bar();; }

    }

    public interface ISomeDependency

    {

        string Bar();

    }

    public class SomeDependency : ISomeDependency

    {

        public string Bar() { return "A Dependency"; }

    }

    public class FancyDependency : ISomeDependency

    {

        public string Bar() { return "A Struct"; }

    }

}