/// <summary>
		/// 	generates manifest for all libraries in given directory, if no given - environment.currentdir used
		/// </summary>
		/// <param name="options"> </param>
		/// <returns> </returns>
		/// <exception cref="ArgumentNullException"></exception>
		/// <exception cref="ArgumentException"></exception>
		public string GenerateManifest(ManifestBxlGeneratorOptions options = null) {
			options = options ?? new ManifestBxlGeneratorOptions();
			if (options.LibraryDirectory.IsEmpty()) {
				options.LibraryDirectory = Environment.CurrentDirectory;
			}

			IList<string> assemblyfiles = null;
			if (options.LibraryName.IsEmpty()) {
				assemblyfiles = Directory.GetFiles(options.LibraryDirectory, "*.dll");
				if (options.ExcludeLibRegex.IsNotEmpty()) {
					assemblyfiles =
						assemblyfiles.Where(x => !Regex.IsMatch(Path.GetFileNameWithoutExtension(x), options.ExcludeLibRegex)).ToArray();
				}
			}
			else {
				assemblyfiles = new List<string>(new[] {options.LibraryName});
				NeedExportAttribute = false;
			}
			IList<Assembly> assembliestoconfigure = new List<Assembly>();
			foreach (var assemblyfile in assemblyfiles) {
				if (Path.GetFileNameWithoutExtension(assemblyfile) == "Qorpent.Core") {
					continue;
				}
				assembliestoconfigure.Add(Assembly.Load(File.ReadAllBytes(assemblyfile),File.ReadAllBytes(assemblyfile.Replace(".dll",".pdb"))));
			}
			return GenerateManifest(assembliestoconfigure.ToArray(), options);
		}
		/// <summary>
		/// 	When overridden in a derived class, executes the task.
		/// </summary>
		/// <returns> true if the task successfully executed; otherwise, false. </returns>
		public override bool Execute() {
			var assemblypath = Path.GetFullPath(AssemblyPath);
			var manifestpath = Path.GetFullPath(ManifestPath);
			Log.LogMessage("Start generate Short:{0} manifest for {1}", Short, assemblypath);
			var generator = new ManifestBxlGenerator();
		    generator.NeedExportAttribute = false;
			var assembly = Assembly.Load(File.ReadAllBytes(assemblypath),File.ReadAllBytes(FileNameResolverExtensions.GetSymbolFileName(assemblypath)));
			var options = new ManifestBxlGeneratorOptions {UseShortNames = Short};
			var result = generator.GenerateManifest(new[] {assembly}, options);
			Directory.CreateDirectory(Path.GetDirectoryName(manifestpath));
			File.WriteAllText(ManifestPath, result, Encoding.UTF8);
			Log.LogMessage("Manifest {0} generated", manifestpath);
			return true;
		}
        /// <summary>
        ///     generates manifest for all libraries in given directory, if no given - environment.currentdir used
        /// </summary>
        /// <param name="options"> </param>
        /// <returns> </returns>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="ArgumentException"></exception>
        public string GenerateManifest(ManifestBxlGeneratorOptions options = null)
        {
            options = options ?? new ManifestBxlGeneratorOptions();
            if (options.LibraryDirectory.IsEmpty())
            {
                options.LibraryDirectory = Environment.CurrentDirectory;
            }

            IList <string> assemblyfiles = null;

            if (options.LibraryName.IsEmpty())
            {
                assemblyfiles = Directory.GetFiles(options.LibraryDirectory, "*.dll");
                if (options.ExcludeLibRegex.IsNotEmpty())
                {
                    assemblyfiles =
                        assemblyfiles.Where(x => !Regex.IsMatch(Path.GetFileNameWithoutExtension(x), options.ExcludeLibRegex)).ToArray();
                }
            }
            else
            {
                assemblyfiles       = new List <string>(new[] { options.LibraryName });
                NeedExportAttribute = false;
            }
            IList <Assembly> assembliestoconfigure = new List <Assembly>();

            foreach (var assemblyfile in assemblyfiles)
            {
                if (Path.GetFileNameWithoutExtension(assemblyfile) == "Qorpent.Core")
                {
                    continue;
                }
                assembliestoconfigure.Add(Assembly.Load(File.ReadAllBytes(assemblyfile), File.ReadAllBytes(assemblyfile.Replace(".dll", ".pdb"))));
            }
            return(GenerateManifest(assembliestoconfigure.ToArray(), options));
        }
		/// <summary>
		/// 	generates single bxl string from assembly manifests
		/// </summary>
		/// <param name="assemblies"> </param>
		/// <param name="options"> </param>
		/// <returns> </returns>
		public string GenerateManifest(Assembly[] assemblies, ManifestBxlGeneratorOptions options = null) {
			if (assemblies == null) {
				throw new ArgumentNullException("assemblies");
			}
			if (0 == assemblies.Length) {
				throw new ArgumentException("no assemblies given");
			}
			var gen = new BxlGenerator();
			var genopts = new BxlGeneratorOptions
				{
					NoRootElement = true,
					UseTrippleQuotOnValues = false,
					InlineAlwaysAttributes = new[] {"code", "name", "priority"}
				};
			options = options ?? new ManifestBxlGeneratorOptions();
			var xml = new XElement("root");
			IList<IComponentDefinition> componentsToGenerate = new List<IComponentDefinition>();
			foreach (var assembly in assemblies.Distinct()) {
				Console.WriteLine("Enter: " + assembly.GetName().Name);
				var def = new AssemblyManifestDefinition(assembly, NeedExportAttribute);

				if (def.Descriptor != null) {
					Console.WriteLine("IsConfigurable: " + assembly.GetName().Name);
					foreach (var classDefinition in def.ComponentDefinitions) {
						componentsToGenerate.Add(classDefinition.GetComponent());
					}
				}
			}
			var useshortnames = false;
			if (options.UseShortNames) {
				useshortnames = CanUseShortNames(componentsToGenerate);
			}
			if (useshortnames) {
				foreach (var assembly in assemblies) {
					var def = new AssemblyManifestDefinition(assembly, NeedExportAttribute);
					if (def.Descriptor != null) {
						xml.Add(new XElement("ref", new XAttribute("code", assembly.GetName().Name)));
					}
				}
				var namespaces =
					componentsToGenerate.Select(x => x.ServiceType).Union(componentsToGenerate.Select(x => x.ImplementationType))
						.Distinct().Select(x => x.Namespace).Distinct();
				foreach (var ns in namespaces) {
					xml.Add(new XElement("using", new XAttribute("code", ns)));
				}
			}
			foreach (var definition in componentsToGenerate) {
				var elementname = definition.Lifestyle.ToString().ToLowerInvariant();
				var value = GetTypeName(definition.ServiceType, useshortnames);
				var e = new XElement(elementname, value);
				if (definition.Name.IsEmpty()) {
					e.Add(new XAttribute("code", GetTypeName(definition.ImplementationType, useshortnames)));
				}
				else {
					e.Add(new XAttribute("code", definition.Name));
					e.Add(new XAttribute("name", GetTypeName(definition.ImplementationType, useshortnames)));
				}
				e.Add(new XAttribute("priority", definition.Priority));
				if (definition.Role.IsNotEmpty()) {
					e.Add(new XAttribute("role", definition.Role));
				}
				if (definition.Help.IsNotEmpty()) {
					e.Add(new XAttribute("help", definition.Help));
				}
				xml.Add(e);
			}

			var result = gen.Convert(xml, genopts);
			return result;
		}
        /// <summary>
        ///     generates single bxl string from assembly manifests
        /// </summary>
        /// <param name="assemblies"> </param>
        /// <param name="options"> </param>
        /// <returns> </returns>
        public string GenerateManifest(Assembly[] assemblies, ManifestBxlGeneratorOptions options = null)
        {
            if (assemblies == null)
            {
                throw new ArgumentNullException("assemblies");
            }
            if (0 == assemblies.Length)
            {
                throw new ArgumentException("no assemblies given");
            }
            var gen     = new BxlGenerator();
            var genopts = new BxlGeneratorOptions
            {
                NoRootElement          = true,
                UseTrippleQuotOnValues = false,
                InlineAlwaysAttributes = new[] { "code", "name", "priority" }
            };

            options = options ?? new ManifestBxlGeneratorOptions();
            var xml = new XElement("root");
            IList <IComponentDefinition> componentsToGenerate = new List <IComponentDefinition>();

            foreach (var assembly in assemblies.Distinct())
            {
                Console.WriteLine("Enter: " + assembly.GetName().Name);
                var def = new AssemblyManifestDefinition(assembly, NeedExportAttribute);

                if (def.Descriptor != null)
                {
                    Console.WriteLine("IsConfigurable: " + assembly.GetName().Name);
                    foreach (var classDefinition in def.ComponentDefinitions)
                    {
                        componentsToGenerate.Add(classDefinition.GetComponent());
                    }
                }
            }
            var useshortnames = false;

            if (options.UseShortNames)
            {
                useshortnames = CanUseShortNames(componentsToGenerate);
            }
            if (useshortnames)
            {
                foreach (var assembly in assemblies)
                {
                    var def = new AssemblyManifestDefinition(assembly, NeedExportAttribute);
                    if (def.Descriptor != null)
                    {
                        xml.Add(new XElement("ref", new XAttribute("code", assembly.GetName().Name)));
                    }
                }
                var namespaces =
                    componentsToGenerate.Select(x => x.ServiceType).Union(componentsToGenerate.Select(x => x.ImplementationType))
                    .Distinct().Select(x => x.Namespace).Distinct();
                foreach (var ns in namespaces)
                {
                    xml.Add(new XElement("using", new XAttribute("code", ns)));
                }
            }
            foreach (var definition in componentsToGenerate)
            {
                var elementname = definition.Lifestyle.ToString().ToLowerInvariant();
                var value       = GetTypeName(definition.ServiceType, useshortnames);
                var e           = new XElement(elementname, value);
                if (definition.Name.IsEmpty())
                {
                    e.Add(new XAttribute("code", GetTypeName(definition.ImplementationType, useshortnames)));
                }
                else
                {
                    e.Add(new XAttribute("code", definition.Name));
                    e.Add(new XAttribute("name", GetTypeName(definition.ImplementationType, useshortnames)));
                }
                e.Add(new XAttribute("priority", definition.Priority));
                if (definition.Role.IsNotEmpty())
                {
                    e.Add(new XAttribute("role", definition.Role));
                }
                if (definition.Help.IsNotEmpty())
                {
                    e.Add(new XAttribute("help", definition.Help));
                }
                xml.Add(e);
            }

            var result = gen.Convert(xml, genopts);

            return(result);
        }