using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.ComponentModel;
using Chernobyl.Creation;
using Chernobyl.Event;
using Chernobyl.Plugin.Exceptions;
using Microsoft.CSharp;

namespace Chernobyl.Plugin
{
    /// <summary>
    /// Creates plug-ins from a set of C# scripts.
    /// </summary>
    public class CSharpScriptPluginFactory : PluginBuilder, IFactory<IEnumerable<string>, Object[]>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that
        /// gives and takes services and is given to the created plug-ins
        /// if they have a constructor that takes an <see cref="IEventCollection{T}"/>
        /// instance.</param>
        public CSharpScriptPluginFactory(IEventCollection<object> services)
            : this(services, string.Empty)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that
        /// gives and takes services and is given to the created plug-ins
        /// if they have a constructor that takes an <see cref="IEventCollection{T}"/>
        /// instance.</param>
        /// <param name="sourceFileSearchPattern">If this script plug-in factory
        /// encounters a directory in the file paths passed to it in Create then
        /// it will use this string to search for the source files within that
        /// folder. Specify an empty <see cref="string"/> to use the default
        /// value which is "*.cs".</param>
        public CSharpScriptPluginFactory(IEventCollection<object> services, string sourceFileSearchPattern)
            : this(services, sourceFileSearchPattern, SearchOption.AllDirectories)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that
        /// gives and takes services and is given to the created plug-ins
        /// if they have a constructor that takes an <see cref="IEventCollection{T}"/>
        /// instance.</param>
        /// <param name="sourceFileSearchPattern">If this script plug-in factory
        /// encounters a directory in the file paths passed to it in Create then
        /// it will use this string to search for the source files within that
        /// folder. Specify an empty <see cref="string"/> to use the default
        /// value which is "*.cs".</param>
        /// <param name="sourceFileSearchOption">If this script plug-in factory
        /// encounters a directory in the file paths passed to it in Create then
        /// it will use this <see cref="SearchOption"/> to search for the source
        /// files within that directory/subdirectory. By default, this value is
        /// <see cref="SearchOption.AllDirectories"/>.</param>
        public CSharpScriptPluginFactory(IEventCollection<object> services, string sourceFileSearchPattern,
            SearchOption sourceFileSearchOption)
            : this(services, sourceFileSearchPattern, sourceFileSearchOption, null)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that
        /// gives and takes services and is given to the created plug-ins
        /// if they have a constructor that takes an <see cref="IEventCollection{T}"/>
        /// instance.</param>
        /// <param name="sourceFileSearchPattern">If this script plug-in factory
        /// encounters a directory in the file paths passed to it in Create then
        /// it will use this string to search for the source files within that
        /// folder. Specify an empty <see cref="string"/> to use the default
        /// value which is "*.cs".</param>
        /// <param name="sourceFileSearchOption">If this script plug-in factory
        /// encounters a directory in the file paths passed to it in Create then
        /// it will use this <see cref="SearchOption"/> to search for the source
        /// files within that directory/subdirectory. By default, this value is
        /// <see cref="SearchOption.AllDirectories"/>.</param>
        /// <param name="compilerParameters">The parameters for the compiler or
        /// null if the default <see cref="CompilerParameters"/> should be used.</param>
        public CSharpScriptPluginFactory(IEventCollection<object> services, string sourceFileSearchPattern,
            SearchOption sourceFileSearchOption, CompilerParameters compilerParameters)
            : this(services, sourceFileSearchPattern, sourceFileSearchOption, compilerParameters, null)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that
        /// gives and takes services and is given to the created plug-ins
        /// if they have a constructor that takes an <see cref="IEventCollection{T}"/>
        /// instance.</param>
        /// <param name="sourceFileSearchPattern">If this script plug-in factory
        /// encounters a directory in the file paths passed to it in Create then
        /// it will use this string to search for the source files within that
        /// folder. Specify an empty <see cref="string"/> to use the default
        /// value which is "*.cs".</param>
        /// <param name="sourceFileSearchOption">If this script plug-in factory
        /// encounters a directory in the file paths passed to it in Create then
        /// it will use this <see cref="SearchOption"/> to search for the source
        /// files within that directory/subdirectory. By default, this value is
        /// <see cref="SearchOption.AllDirectories"/>.</param>
        /// <param name="compilerParameters">The parameters for the compiler or
        /// null if the default <see cref="CompilerParameters"/> should be used.</param>
        /// <param name="codeProvider">The <see cref="CSharpCodeProvider"/> used
        /// to compile the C# scripts or null if the default
        /// <see cref="CSharpCodeProvider"/> should be used.</param>
        public CSharpScriptPluginFactory(IEventCollection<object> services, string sourceFileSearchPattern,
            SearchOption sourceFileSearchOption, CompilerParameters compilerParameters,
            CSharpCodeProvider codeProvider)
            : base(services)
        {
            if (sourceFileSearchPattern.Length == 0)
                sourceFileSearchPattern = "*.cs";
            SourceFileSearchPattern = sourceFileSearchPattern;

            SourceFileSearchOption = sourceFileSearchOption;

            if(compilerParameters == null)
            {
                compilerParameters = new CompilerParameters
                                         {
                                             GenerateExecutable = false,
                                             GenerateInMemory = true,
#if DEBUG
                                             IncludeDebugInformation = true,
#else
                                             IncludeDebugInformation = false,
#endif
                                             TreatWarningsAsErrors = false
                                         };

            }

            CompilerParameters = compilerParameters;

            if(codeProvider == null)
            {
                Dictionary<string, string> providerOptions = new Dictionary<string, string>();
                providerOptions.Add("CompilerVersion", "v3.5");
                codeProvider = new CSharpCodeProvider(providerOptions);
            }

            CodeProvider = codeProvider;
        }

        /// <summary>
        /// Creates a set of objects, from a set of files, using the
        /// <see cref="IPluginBuilder.Predicate"/> method to choose which objects to create and
        /// the <see cref="IPluginBuilder.Creator"/> method to do the actually creation.
        /// </summary>
        /// <param name="pathsOrSource">This can be a list of one of the following
        /// things:
        /// <list type="">
        ///     <item>File paths to source files.</item>
        ///     <item>Directory paths that contain source files.</item>
        ///     <item>File paths to source files and directory paths that contain source files.</item>
        ///     <item>Pure C# source code.</item>
        /// </list></param>
        /// <returns>The objects that were created.</returns>
        /// <exception cref="CompileErrorException">Thrown if the compilation of
        /// the scripts fails.</exception>
        public object[] Create(IEnumerable<string> pathsOrSource)
        {
            try
            {
                CompilerResults compileResults;
                object[] objects = Create(out compileResults, pathsOrSource.ToArray());

                // Throw an exception for any errors received.
                if (compileResults.Errors.Count > 0)
                    throw new CompileErrorException("Compilation of some C# " +
                                                    "scripts has failed.",
                                                    compileResults);

                ReportCreation(objects);
                return objects;
            }
            catch (Exception e)
            {
                ReportCreation(new CreationEventArgs<object[]>(e));
                throw;
            }
        }

        /// <summary>
        /// If this script plug-in factory encounters a directory in the
        /// file paths passed to it in Create then it will use this string
        /// to search for the source files within that folder. By default,
        /// this value is "*.cs".
        /// </summary>
        public string SourceFileSearchPattern { get; set; }

        /// <summary>
        /// If this script plug-in factory encounters a directory in the
        /// file paths passed to it in Create then it will use this
        /// <see cref="SearchOption"/> to search for the source files within
        /// that directory/subdirectory. By default, this value is
        /// <see cref="SearchOption.AllDirectories"/>.
        /// </summary>
        public SearchOption SourceFileSearchOption { get; set; }

        /// <summary>
        /// The parameters for the compiler.
        /// </summary>
        public CompilerParameters CompilerParameters { get; set; }

        /// <summary>
        /// The C# code provider used to compile the C# scripts.
        /// </summary>
        public CSharpCodeProvider CodeProvider { get; set; }

        /// <summary>
        /// Creates a set of objects, from a set of files, using the
        /// <see cref="IPluginBuilder.Predicate"/> method to choose which objects to create and
        /// the <see cref="IPluginBuilder.Creator"/> method to do the actually creation.
        /// </summary>
        /// <param name="compileResults">The results from the compilation of the
        /// C# scripts.</param>
        /// <param name="pathsOrSource">This can be a list of one of the following
        /// things:
        /// <list type="">
        ///     <item>File paths to source files.</item>
        ///     <item>Directory paths that contain source files.</item>
        ///     <item>File paths to source files and directory paths that contain source files.</item>
        ///     <item>Pure C# source code.</item>
        /// </list></param>
        /// <returns>The objects that were created.</returns>
        object[] Create(out CompilerResults compileResults, string[] pathsOrSource)
        {
            List<object> interfaces = new List<object>();
            if (pathsOrSource.Length == 0)
            {
                compileResults = null;
                return interfaces.ToArray();
            }

            // add in our assemblies
            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
            foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
                CompilerParameters.ReferencedAssemblies.Add(asm.Location);

            if (File.Exists(pathsOrSource[0]) || Directory.Exists(pathsOrSource[0]))
            {
                // this is a set of files or directories

                // make sure all of the files exist and we get the source files from directories.
                List<string> sourceFiles = new List<string>();
                foreach (string path in pathsOrSource)
                {
                    // make sure the path is absolute or the compilation will
                    // fail
                    string finalPath = path;
                    if (Path.IsPathRooted(path) == false)
                        finalPath = Path.GetFullPath(path);

                    if (File.Exists(finalPath))
                        sourceFiles.Add(finalPath);
                    else if (Directory.Exists(finalPath))
                        sourceFiles.AddRange(Directory.GetFiles(finalPath, SourceFileSearchPattern, SourceFileSearchOption));
                }

                compileResults = CodeProvider.CompileAssemblyFromFile(CompilerParameters, sourceFiles.ToArray());
            }
            else // this is pure source code; compile it.
                compileResults = CodeProvider.CompileAssemblyFromSource(CompilerParameters, pathsOrSource);

            // get the interfaces we need from the compile.
            if (compileResults.Errors.Count == 0)
            {
                // get the interfaces from the assembly of compiled scripts
                foreach (Type type in compileResults.CompiledAssembly.GetTypes())
                {
                    if (Predicate(type))
                        interfaces.Add(Creator(type));
                }
            }

            return interfaces.ToArray();
        }
    }
}