/// <summary>
 ///   Constructor
 /// </summary>
 public RelativePathSubDependencyResolver(IKernel kernel)
 {
     m_converter = (IConversionManager)kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey);
       SettingsSubSystem settingsSubSystem = kernel.GetSettingsSubSystem();
       settingsSubSystem.ResolveRelativePaths = true;
       VALUES = new Dictionary<string, object>();
 }

        protected virtual void SetUpComponents(IConfiguration[] configurations, IWindsorContainer container, IConversionManager converter)
        {
            foreach (var component in configurations)
            {
                var implementation = GetType(converter, component.Attributes["type"]);
                var firstService = GetType(converter, component.Attributes["service"]);
                var services = new HashSet<Type>();
                if (firstService != null)
                {
                    services.Add(firstService);
                }
                CollectAdditionalServices(component, converter, services);

                var name = default(string);
                if (implementation != null)
                {
                    AssertImplementsService(component, firstService, implementation);
                    var defaults = CastleComponentAttribute.GetDefaultsFor(implementation);
                    if (defaults.ServicesSpecifiedExplicitly && services.Count == 0)
                    {
                        defaults.Services.ForEach(s => services.Add(s));
                    }
                    name = GetName(defaults, component);
                }

                if (services.Count == 0 && implementation == null)
                {
                    continue;
                }

                container.Register(Component.For(services).ImplementedBy(implementation).Named(name));
            }
        }

		/// <summary>
		/// Adds the properties as optional dependencies of this component.
		/// </summary>
		/// <param name="kernel"></param>
		/// <param name="model"></param>
		public virtual void ProcessModel(IKernel kernel, ComponentModel model)
		{
			if (converter == null)
			{
				converter = (IConversionManager) 
					kernel.GetSubSystem( SubSystemConstants.ConversionManagerKey );
			}

			InspectProperties(model);
		}

		protected virtual void SetUpInstallers(IConfiguration[] installers, IWindsorContainer container, IConversionManager converter)
		{
			var instances = new Dictionary<Type, IWindsorInstaller>();
			foreach (var installer in installers)
			{
				AddInstaller(installer, instances, converter);
			}

			if (instances.Count != 0)
			{
				container.Install(instances.Values.ToArray());
			}
		}

		private void AddInstaller(IConfiguration installer, Dictionary<Type, IWindsorInstaller> cache,
		                          IConversionManager conversionManager, ICollection<Assembly> assemblies)
		{
			var typeName = installer.Attributes["type"];
			if (string.IsNullOrEmpty(typeName) == false)
			{
				var type = conversionManager.PerformConversion<Type>(typeName);
				AddInstaller(cache, type);
				return;
			}

			assemblyName = installer.Attributes["assembly"];
			if (string.IsNullOrEmpty(assemblyName) == false)
			{
				var assembly = ReflectionUtil.GetAssemblyNamed(assemblyName);
				if (assemblies.Contains(assembly))
				{
					return;
				}
				assemblies.Add(assembly);

				GetAssemblyInstallers(cache, assembly);
				return;
			}

#if !SILVERLIGHT
			var directory = installer.Attributes["directory"];
			var mask = installer.Attributes["fileMask"];
			var token = installer.Attributes["publicKeyToken"];
			Debug.Assert(directory != null, "directory != null");
			var assemblyFilter = new AssemblyFilter(directory, mask);
			if (token != null)
			{
				assemblyFilter.WithKeyToken(token);
			}

			foreach (var assembly in ReflectionUtil.GetAssemblies(assemblyFilter))
			{
				if (assemblies.Contains(assembly))
				{
					continue;
				}
				assemblies.Add(assembly);
				GetAssemblyInstallers(cache, assembly);
			}
#endif
		}

            public virtual void ProcessModel(IKernel kernel, ComponentModel model)
            {
                if (converter == null) {
                    converter = (IConversionManager) kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey);
                }

                var targetType = model.Implementation;

                var constructors = targetType.GetConstructors(BindingFlags.Public | BindingFlags.Instance);

                foreach (var constructor in constructors) {
                    // We register each public constructor
                    // and let the ComponentFactory select an
                    // eligible amongst the candidates later
                    model.Constructors.Add(CreateConstructorCandidate(model, constructor));
                }
            }

		private void AddInstaller(IConfiguration installer, Dictionary<Type, IWindsorInstaller> cache, IConversionManager conversionManager)
		{
			var typeName = installer.Attributes["type"];
			if (string.IsNullOrEmpty(typeName) == false)
			{
				var type = conversionManager.PerformConversion(typeName, typeof(Type)) as Type;
				AddInstaller(cache, type);
				return;
			}

			Debug.Assert(string.IsNullOrEmpty(installer.Attributes["assembly"]) == false);
			var types = Assembly.Load(installer.Attributes["assembly"]).GetExportedTypes();
			foreach (var type in InstallerTypes(types))
			{
				AddInstaller(cache, type);
			}
		}

		protected virtual void SetUpInstallers(IConfiguration[] installers, IWindsorContainer container,
		                                       IConversionManager converter)
		{
			var instances = new Dictionary<Type, IWindsorInstaller>();
			ICollection<Assembly> assemblies =
#if SL3
				new List<Assembly>();
#else
				new HashSet<Assembly>();
#endif
			foreach (var installer in installers)
			{
				AddInstaller(installer, instances, converter, assemblies);
			}

			if (instances.Count != 0)
			{
				container.Install(instances.Values.ToArray());
			}
		}

		private static void DeserializeComponents(XmlNodeList nodes, IConfigurationStore store, IConversionManager converter)
		{
			foreach(XmlNode node in nodes)
			{
				if (node.NodeType != XmlNodeType.Element) continue;

				AssertNodeName(node, ComponentNodeName);
				DeserializeComponent(node, store, converter);
			}
		}

		private Type GetType(IConversionManager converter, string typeName)
		{
			if (typeName == null)
			{
				return null;
			}
			return converter.PerformConversion<Type>(typeName);
		}

		private void CollectAdditionalServices(IConfiguration component, IConversionManager converter, ICollection<Type> services)
		{
			var forwardedTypes = component.Children["forwardedTypes"];
			if (forwardedTypes == null)
			{
				return;
			}

			foreach (var forwardedType in forwardedTypes.Children)
			{
				var forwardedServiceTypeName = forwardedType.Attributes["service"];
				try
				{
					services.Add(converter.PerformConversion<Type>(forwardedServiceTypeName));
				}
				catch (ConverterException e)
				{
					throw new ComponentRegistrationException(
						string.Format("Component {0} defines invalid forwarded type.", component.Attributes["id"]), e);
				}
			}
		}

		private static void DeserializeComponent(XmlNode node, IConfigurationStore store, IConversionManager converter)
		{
			var config = XmlConfigurationDeserializer.GetDeserializedNode(node);
			var id = config.Attributes["id"];
			if(string.IsNullOrEmpty(id))
			{
				var type = converter.PerformConversion<Type>(config.Attributes["type"]);
				id = type.FullName;
				config.Attributes["id"] = id;
				config.Attributes.Add("id-automatic", true.ToString());
			}
			AddComponentConfig(id, config, store);
		}

		/// <summary>
		///   Initializes a new instance of the <see cref = "SynchronizeMetaInfoStore" /> class.
		/// </summary>
		/// <param name = "conversionManager"></param>
		public SynchronizeMetaInfoStore(IConversionManager conversionManager)
		{
			converter = conversionManager;
		}

		protected virtual void SetUpComponents(IConfiguration[] configurations, IWindsorContainer container, IConversionManager converter)
		{
			foreach(IConfiguration component in configurations)
			{
				var id = component.Attributes["id"];
				
				var typeName = component.Attributes["type"];
				var serviceTypeName = component.Attributes["service"];
				
				if (string.IsNullOrEmpty(typeName)) continue;
				
				Type type = ObtainType(typeName,converter);
				Type service = type;

				if (!string.IsNullOrEmpty(serviceTypeName))
				{
					service = ObtainType(serviceTypeName,converter);
				}

				AssertImplementsService(id, service, type);


				Debug.Assert( id != null );
				Debug.Assert( type != null );
				Debug.Assert( service != null );
				container.AddComponent(id, service, type);
				SetUpComponentForwardedTypes(container, component, typeName, id,converter);

			}
		}

		/// <summary>
		///   Initializes a new instance of the <see cref = "CreateOnUIThreadInspector" /> class.
		/// </summary>
		/// <param name = "config">The config.</param>
		/// <param name = "converter"></param>
		public CreateOnUIThreadInspector(IConfiguration config, IConversionManager converter)
		{
			marshalingControl = new MarshalingControl();
			controlProxyHook = ObtainProxyHook(config, converter);
		}

		protected virtual void SetUpFacilities(IConfiguration[] configurations, IWindsorContainer container, IConversionManager converter)
		{
			foreach (var facility in configurations)
			{
				var type = converter.PerformConversion<Type>(facility.Attributes["type"]);
				var facilityInstance = type.CreateInstance<IFacility>();
				Debug.Assert(facilityInstance != null);

				container.AddFacility(facilityInstance);
			}
		}

		private void CollectForwardedTypes(IKernelInternal kernel, IConfiguration component, string typeName, string id,
		                                   IConversionManager converter, List<Type> services)
		{
			if (kernel == null)
			{
				return;
			}
			var forwardedTypes = component.Children["forwardedTypes"];
			if (forwardedTypes == null)
			{
				return;
			}

			foreach (var forwardedType in forwardedTypes.Children
				.Where(c => c.Name.Trim().Equals("add", StringComparison.InvariantCultureIgnoreCase)))
			{
				var forwardedServiceTypeName = forwardedType.Attributes["service"];
				try
				{
					services.Add(converter.PerformConversion<Type>(forwardedServiceTypeName));
				}
				catch (Exception e)
				{
					throw new Exception(
						string.Format("Component {0}-{1} defines invalid forwarded type.", id ?? string.Empty, typeName), e);
				}
			}
		}

		public ComponentProxyInspector(IConversionManager converter)
		{
			this.converter = converter;
		}

		public PropertiesDependenciesModelInspector(IConversionManager converter)
		{
			this.converter = converter;
		}

		private void SetUpComponentForwardedTypes(IWindsorContainer container, IConfiguration component, string typeName, string id, IConversionManager converter)
		{
			var forwardedTypes = component.Children["forwardedTypes"];
			if (forwardedTypes == null) return;

			var forwarded = new List<Type>();
			foreach (var forwardedType in forwardedTypes.Children
				.Where(c => c.Name.Equals("add", StringComparison.InvariantCultureIgnoreCase)))
			{
				var forwardedServiceTypeName = forwardedType.Attributes["service"];
				try
				{
					forwarded.Add(ObtainType(forwardedServiceTypeName,converter));
				}
				catch (Exception e)
				{
					throw new Exception(
						string.Format("Component {0}-{1} defines invalid forwarded type.", id ?? string.Empty, typeName), e);
				}
			}

			foreach (var forwadedType in forwarded)
			{
				container.Kernel.RegisterHandlerForwarding(forwadedType, id);
			}
		}