public HomeController(IDependency dependency, ITenantIdentificationStrategy tenantIdStrategy, IMultitenantService standardService, IMetadataConsumer metadataService)
 {
     this.Dependency = dependency;
     this.TenantIdentificationStrategy = tenantIdStrategy;
     this.StandardServiceProxy = standardService;
     this.MetadataServiceProxy = metadataService;
 }

		private void OnDependencyReady(IDependency dependency)
		{
			dependency.Ready -= OnDependencyReady;
			DependencyReadyStatus[dependency] = true;
			if (DependencyReadyStatus.Values.All(status => status))
				DoStart();
		}

        /// <summary>
        /// Emits the instructions that will instantiate the current implementation using the given factory functor.
        /// </summary>
        /// <param name="dependency">The dependency that describes the service to be instantiated.</param>
        /// <param name="serviceMap">The service map that contains the list of dependencies in the application.</param>
        /// <param name="targetMethod">The target method.</param>
        public void Emit(IDependency dependency,
            IDictionary<IDependency, IImplementation> serviceMap,
            MethodDefinition targetMethod)
        {
            var declaringType = targetMethod.DeclaringType;
            var module = declaringType.Module;

            var serviceType = module.Import(_serviceType);
            var createInstanceMethod = typeof(FunctorRegistry).GetMethod("CreateInstance");
            var createInstance = module.Import(createInstanceMethod);

            // Register the functor
            RegisterFunctor();

            var body = targetMethod.Body;
            var IL = body.GetILProcessor();

            // Instantiate the instance at runtime using the
            // given functor associated with the functor id
            IL.Emit(OpCodes.Ldstr, _functorId);
            IL.Emit(OpCodes.Ldarg_0);
            IL.Emit(OpCodes.Call, createInstance);

            if (serviceType.IsValueType)
                return;

            IL.Emit(OpCodes.Castclass, serviceType);
        }

 private static IEnumerable<INode> GetDependencyNodes(this TreeContext context, IDependency dep1)
 {
     return dep1.Type == DependencyType.Single
         ? new[] { context.Tree.Nodes[dep1.Token] }
         : context.Tree.GetNode(dep1.Token)
                  .Provider.Dependencies
                  .SelectMany(context.GetDependencyNodes);
 }

        /// <inheritdoc />
        public override void ContainerInitialized(Container container)
        {
            base.ContainerInitialized(container);

            Log.Info("ExtensionWhichNeedsDependency is using the initialized container.");

            this.Dependency = this.Container.Resolve<IDependency>();
        }

        /// <summary>
        /// Associates the given <paramref name="implementation"/> with the target <paramref name="dependency"/>.
        /// </summary>
        /// <param name="dependency">The dependency that will be associated with the implementation.</param>
        /// <param name="implementation">The implementation itself.</param>
        public void AddService(IDependency dependency, IImplementation implementation)
        {
            var currentImplementation = implementation;

            if (Injector != null)
                currentImplementation = Injector.Inject(dependency, currentImplementation);

            _entries.Add(dependency, currentImplementation);
        }

 // can be used after the tree is built
 public static INode GetDependencyNode(this TreeContext context, IDependency dependency)
 {
     var node = context.Tree.GetNode(dependency.Token);
     return dependency.Type == DependencyType.CollectionValidity
                ? node.Parent
                : dependency.Type == DependencyType.Collection
                      ? node.SourceParent
                      : node;
 }

        public Constructor(IDependency dependency, ConstructorInfo constructor)
            : base(dependency)
        {
            ConstructorInfo = constructor;

            _requiredDependencies = constructor.GetParameters()
                .Select(p => new Dependency(p.ParameterType))
                .ToArray();
        }

        private static void SetNodeWeights(TreeContext context, IDependency dependency, IDependency dep2)
        {
            if (context.IsParent(dependency.Token, dep2.Token) || context.IsParent(dep2.Token, dependency.Token))
            {
                return;
            }

            SetNodeWeights(context, dependency);
            SetNodeWeights(context, dep2);
        }

 public TflRoot(
         string cfg, 
         Dictionary<string, string> parameters = null,
         IDependency logger = null)
     : base(
           new DefaultReader(new SourceDetector(), new FileReader(), new ReTryingReader(new WebReader(), 3)), 
           logger
     ) {
     Load(cfg, parameters);
 }

        public GenericTypeInstantiation(IDependency dependency, Constructor constructor, IEnumerable<Type> typeArguments) : base(dependency)
        {
            if (dependency == null)
                throw new ArgumentNullException(nameof(dependency));

            if (constructor == null)
                throw new ArgumentNullException(nameof(constructor));

            Constructor = constructor;
            TypeArguments = typeArguments;
        }

        /// <summary>
        /// Emits the instructions that will instantiate the current implementation.
        /// </summary>
        /// <param name="dependency">The dependency that describes the service to be instantiated.</param>
        /// <param name="serviceMap">The service map that contains the list of dependencies in the application.</param>
        /// <param name="targetMethod">The target method.</param>
        public void Emit(IDependency dependency, IDictionary<IDependency, IImplementation> serviceMap, MethodDefinition targetMethod)
        {
            var declaringType = targetMethod.DeclaringType;
            var module = declaringType.Module;

            var microContainerType = module.ImportType<IMicroContainer>();

            var il = targetMethod.GetILGenerator();

            // if (this is IMicroContainer && this.NextContainer != null) {
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Isinst, microContainerType);

            var skipCreate = il.Create(OpCodes.Nop);
            il.Emit(OpCodes.Brfalse, skipCreate);

            EmitGetContainerInstance(module, microContainerType, il, skipCreate);

            var getInstance = module.ImportMethod<IMicroContainer>("GetInstance");
            var getTypeFromHandleMethod = typeof(System.Type).GetMethod("GetTypeFromHandle", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
            var getTypeFromHandle = module.Import(getTypeFromHandleMethod);

            // Push the service type onto the stack
            var serviceType = module.Import(_serviceType);
            il.Emit(OpCodes.Ldtoken, serviceType);
            il.Emit(OpCodes.Call, getTypeFromHandle);

            var loadString = string.IsNullOrEmpty(_serviceName)
                                 ? il.Create(OpCodes.Ldnull)
                                 : il.Create(OpCodes.Ldstr, _serviceName);

            il.Append(loadString);
            il.Emit(OpCodes.Callvirt, getInstance);

            var endLabel = il.Create(OpCodes.Nop);
            il.Emit(OpCodes.Br, endLabel);

            il.Append(skipCreate);

            var serviceNotFoundExceptionCtor = module.ImportConstructor<ServiceNotFoundException>(typeof(string),
                                                                                                  typeof(System.Type));
            var serviceName = dependency.ServiceName ?? string.Empty;
            il.Emit(OpCodes.Ldstr, serviceName);
            il.Emit(OpCodes.Ldtoken, serviceType);
            il.Emit(OpCodes.Call, getTypeFromHandle);

            il.Emit(OpCodes.Newobj, serviceNotFoundExceptionCtor);
            il.Emit(OpCodes.Throw);

            il.Append(endLabel);

            // }
        }

        public int CompareTo(IDependency other)
        {
            var areEqual = (other.Name == this.Name && other.DependencyType == this.DependencyType);
            if (areEqual)
                return 0;

            var otherHash = other.GetHashCode();
            var thisHash = this.GetHashCode();

            var isGreater = otherHash > thisHash;

            return isGreater ? 1 : -1;
        }

        public static void ReorderNodes(this TreeContext context,
            IDepend depend,
            IDependency dependency1,
            IDependency dependency2)
        {
            var node1 = context.GetDependencyNode(dependency1);
            var node2 = context.GetDependencyNode(dependency2);
            if (node1 == node2)
            {
                return;
            }

            ReorderNodes(node1, node2, depend.DiagInfo);
            context.CreateNonEqualFilter(node1, node2, context.GetParentGroup(depend), depend.DiagInfo);
        }

        /// <summary>
        /// Injects the target <paramref name="IImplementation"/> instance.
        /// </summary>
        /// <param name="dependency">The target dependency.</param>
        /// <param name="originalImplementation">The target implementation that will be intercepted by this method.</param>
        /// <returns>The <see cref="IImplementation"/> instance that will be injected in place of the original implementation.</returns>
        public IImplementation Inject(IDependency dependency, IImplementation originalImplementation)
        {
            var staticImplementation = originalImplementation as IStaticImplementation;

            // HACK: Ignore primitive types by default
            var serviceType = dependency.ServiceType;
            if (serviceType.IsValueType || serviceType==typeof(string))
                return originalImplementation;

            // Property injection can only be performend on early-bound instantiations
            if (staticImplementation == null)
                return originalImplementation;

            return new PropertyInjectionCall(staticImplementation);
        }

        /// <summary>
        /// Emits the instructions that will instantiate the current implementation.
        /// </summary>
        /// <param name="dependency">The dependency that describes the service to be instantiated.</param>
        /// <param name="serviceMap">The service map that contains the list of dependencies in the application.</param>
        /// <param name="targetMethod">The target method.</param>
        public void Emit(IDependency dependency, IDictionary<IDependency, IImplementation> serviceMap, MethodDefinition targetMethod)
        {
            var declaringType = targetMethod.DeclaringType;
            var module = declaringType.Module;

            var listType = typeof(List<>).MakeGenericType(_serviceType);
            var listCtor = module.ImportConstructor(listType, new Type[0]);

            var listVariable = targetMethod.AddLocal(listType);
            var IL = targetMethod.GetILGenerator();
            IL.Emit(OpCodes.Newobj, listCtor);
            IL.Emit(OpCodes.Stloc, listVariable);

            var targetDependencies = (from d in serviceMap.Keys
                                     where d.ServiceType == _serviceType
                                     select d).ToArray();

            var addItem = module.ImportMethod("Add", listType);

            var serviceType = module.Import(_serviceType);
            var currentService = targetMethod.AddLocal(_serviceType);
            foreach(var currentDependency in targetDependencies)
            {
                IL.Emit(OpCodes.Ldloc, listVariable);

                // Instantiate the current service type
                var implementation = new ContainerCall(currentDependency.ServiceType, currentDependency.ServiceName);
                implementation.Emit(currentDependency, serviceMap, targetMethod);

                IL.Emit(OpCodes.Isinst, serviceType);
                IL.Emit(OpCodes.Stloc, currentService);

                // Call IInitialize.Initialize(container) on the current service type
                _initializer.Initialize(IL, module, currentService);

                IL.Emit(OpCodes.Ldloc, currentService);
                IL.Emit(OpCodes.Callvirt, addItem);
            }

            var enumerableType = typeof(IEnumerable<>).MakeGenericType(_serviceType);
            var importedEnumerableType = module.Import(enumerableType);

            IL.Emit(OpCodes.Ldloc, listVariable);
            IL.Emit(OpCodes.Isinst, importedEnumerableType);
        }

        /// <summary>
        /// Builds a service info response.
        /// </summary>
        /// <param name="serviceImplementation">
        /// The service implementation that will be returning the response.
        /// </param>
        /// <param name="dependency">
        /// The dependency that was provided to the service implementation on construction.
        /// </param>
        /// <param name="tenantIdStrategy">
        /// The tenant ID strategy.
        /// </param>
        /// <returns>
        /// A populated service info response.
        /// </returns>
        public static GetServiceInfoResponse Build(IMultitenantService serviceImplementation, IDependency dependency, ITenantIdentificationStrategy tenantIdStrategy)
        {
            object tenantId = null;
            bool success = tenantIdStrategy.TryIdentifyTenant(out tenantId);
            if (!success || tenantId == null)
            {
                tenantId = "[Default Tenant]";
            }

            var response = new GetServiceInfoResponse()
            {
                ServiceImplementationTypeName = serviceImplementation.GetType().Name,
                DependencyInstanceId = dependency.InstanceId,
                DependencyTypeName = dependency.GetType().Name,
                TenantId = tenantId.ToString()
            };
            return response;
        }

        /// <summary>
        /// Emits the <see cref="IFactory{T}.Create"/> method call that will instantiate the current service instance.
        /// </summary>
        /// <param name="dependency">The dependency that describes the service to be instantiated.</param>
        /// <param name="serviceMap">The service map that contains the list of dependencies in the application.</param>
        /// <param name="targetMethod">The target method.</param>
        public void Emit(IDependency dependency, IDictionary<IDependency, IImplementation> serviceMap, MethodDefinition targetMethod)
        {
            var factoryType = typeof (IFactory<>).MakeGenericType(_serviceType);
            var getFactoryInstanceCall = new ContainerCall(factoryType, _serviceName);

            var factoryName = _serviceName;
            getFactoryInstanceCall.Emit(new Dependency(factoryType, factoryName), serviceMap, targetMethod);

            var declaringType = targetMethod.DeclaringType;
            var module = declaringType.Module;
            var factoryTypeReference = module.Import(factoryType);

            var createMethod = module.Import(factoryType.GetMethod("Create"));

            var IL = targetMethod.GetILGenerator();
            IL.Emit(OpCodes.Isinst, factoryTypeReference);
            IL.Emit(OpCodes.Callvirt, createMethod);
        }

        /// <summary>
        /// Emits a service as a singleton type.
        /// </summary>
        /// <param name="targetMethod">The <see cref="IMicroContainer.GetInstance"/> method implementation.</param>
        /// <param name="dependency">The dependency that will be instantiated by the container.</param>
        /// <param name="implementation">The implementation that will be used to instantiate the dependency.</param>
        /// <param name="serviceMap">The service map the contains the current application dependencies.</param>
        public void EmitService(MethodDefinition targetMethod, IDependency dependency, 
                                IImplementation implementation, IDictionary<IDependency, IImplementation> serviceMap)
        {
            MethodDefinition getInstanceMethod = null;

            var worker = targetMethod.GetILGenerator();

            // Emit only one singleton per dependency and call
            // the singleton GetInstance() method on every subsequent emit call
            if (_entries.ContainsKey(dependency))
            {
                getInstanceMethod = _entries[dependency];
                worker.Emit(OpCodes.Call, getInstanceMethod);
                return;
            }

            var declaringType = targetMethod.DeclaringType;
            var module = declaringType.Module;

            var serviceType = dependency.ServiceType;

            var typeName = serviceType.Name;
            var singletonName = string.Format("{0}ServiceSingleton-{1}", typeName, dependency.GetHashCode());
            const TypeAttributes typeAttributes = TypeAttributes.NotPublic | TypeAttributes.AutoClass | TypeAttributes.Sealed |
                                                  TypeAttributes.BeforeFieldInit;
            var objectType = module.Import(typeof(object));

            var singletonType = AddDefaultSingletonConstructor(module, singletonName, typeAttributes, objectType);

            var instanceField = new FieldDefinition("__instance", FieldAttributes.Assembly | FieldAttributes.InitOnly | FieldAttributes.Static, objectType);

            DefineNestedType(module, singletonType, instanceField, serviceMap, implementation, dependency,
                             targetMethod);

            getInstanceMethod = DefineGetInstance(singletonType, worker, instanceField);

            worker.Emit(OpCodes.Call, getInstanceMethod);

            var serviceTypeRef = module.Import(serviceType);
            worker.Emit(OpCodes.Unbox_Any, serviceTypeRef);

            // Cache the singleton method
            _entries[dependency] = getInstanceMethod;
        }

        public static void Register(IDependency container)
        {
            #region Settings
            container.Register<IHttpControllerActivator, WindsorCompositionRoot>();
            container.Register<IConnection, ConnectionConfig>();
            #endregion

            #region Services
            container.Register<IUserService, UserService>();
            container.Register<BabySitterMessageService, BabySitterMessageService>();
            container.Register<CarPullMessageService, CarPullMessageService>();
            container.Register<IMessageService<BulletinBoardTable, BulletinBoardDto>, MessageService<BulletinBoardTable, BulletinBoardDto>>();
            container.Register<IMessageService<GiveAndTakeTable, GiveAndTakeDto>, MessageService<GiveAndTakeTable, GiveAndTakeDto>>();
            container.Register<ISurveyService, SurveyService>();
            #endregion

            #region Repositories
            container.Register<IDataBase<UserTable>, DataBase<UserTable>>();
            container.Register<IDataBase<BabySitterTable>, DataBase<BabySitterTable>>();
            container.Register<IDataBase<CarPullTable>, DataBase<CarPullTable>>();
            container.Register<IDataBase<BulletinBoardTable>, DataBase<BulletinBoardTable>>();
            container.Register<IDataBase<SurveyTable>, DataBase<SurveyTable>>();
            container.Register<IDataBase<GiveAndTakeTable>, DataBase<GiveAndTakeTable>>();
            #endregion

            #region Controllers
            container.Register<LoginController, LoginController>();
            container.Register<RegisterController, RegisterController>();
            container.Register<UserController, UserController>();
            container.Register<BabySitterController, BabySitterController>();
            container.Register<CarpullController, CarpullController>();
            container.Register<BulletinBoardController, BulletinBoardController>();
            container.Register<SurveyController, SurveyController>();
            container.Register<VoteController, VoteController>();
            container.Register<GiveAndTakeController, GiveAndTakeController>();
            container.Register<ForgotPasswordController, ForgotPasswordController>();

            container.Register<SettingsController, SettingsController>();
            #endregion
        }