using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using Chernobyl.Attribution;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Creation;
using Chernobyl.Dependency;
using Chernobyl.Plugin;
using Chernobyl.Reflection;
using Chernobyl.Reflection.Resources;
using Chernobyl.Reflection.Template;
using Chernobyl.Resources;
using Chernobyl.StateMachine;
using Chernobyl.Update;
using Chernobyl.Extensions;

namespace Chernobyl.Config
{
    /// <summary>
    /// Represents the core of Chernobyl.
    /// </summary>
    public class Core : State, IPlugin
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Core"/> class that uses
        /// the default <see cref="SearchPaths"/> instance and the
        /// <see cref="Configuration"/> object returned by
        /// <see cref="ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel)"/>
        /// with a argument of <see cref="ConfigurationUserLevel.None"/>.
        /// </summary>
        public Core() : this(null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Core"/> class that uses
        /// the <see cref="Configuration"/> object returned by
        /// <see cref="ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel)"/>
        /// with a argument of <see cref="ConfigurationUserLevel.None"/>.
        /// </summary>
        /// <param name="searchPaths">The <see cref="SearchPaths"/> instance to
        /// use when locating files or null if the default
        /// <see cref="SearchPaths"/> should be used. The default search path
        /// instance contains the following paths: ".", "../../Chernobyl", and
        /// "../../Chernobyl/data"</param>
        public Core(SearchPaths searchPaths)
            : this(searchPaths, ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None))
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Core"/> class.
        /// </summary>
        /// <param name="searchPaths">The <see cref="SearchPaths"/> instance to
        /// use when locating files or null if the default
        /// <see cref="SearchPaths"/> should be used. The default search path
        /// instance contains the following paths: "." and "../../"</param>
        /// <param name="config">The <see cref="Configuration"/> instance that
        /// Chernobyl should pull settings from.</param>
        public Core(SearchPaths searchPaths, Configuration config)
        {
            Trace = new TraceSource("Chernobyl");

            // Setup the search paths.
            SearchPaths = searchPaths ?? new SearchPaths(".", "../../");
            string searchPath = ConfigurationManager.AppSettings["Chernobyl.SearchPath"];
            if (searchPath != null)
                SearchPaths.Add(searchPath);

            // Create the fallout processing chain. First we need to load in the
            // main IEventCollection<object> instance. We can't load anything else in for the
            // time being because those instances or the IResourceProcessors
            // processing them may need the IEventCollection<object> instance we are loading in.

            // First We'll need to have the ResourceRegistry and the
            // FileStreamResourceMapper process this IEventCollection<object> instance so
            // that they will store it.

            ResourceRegistry<IComponent> resourceRegistry = new ResourceRegistry<IComponent>();
            FalloutFileMapProcessor = new FileStreamResourceMapper<IComponent>();
            FileStreamProcessor<IComponent> contentFileStreamProcessor = new FileStreamProcessor<IComponent>(null);
            CodeDomContentResourceProcessor codeDomContentResourceProcessor = new CodeDomContentResourceProcessor(null);
            XmlContentResourceProcessor xmlContentProcessor = new XmlContentResourceProcessor(null);

            ComponentProcessor = resourceRegistry;
            resourceRegistry.NextResourceProcessor = FalloutFileMapProcessor;
            FalloutFileMapProcessor.NextResourceProcessor = codeDomContentResourceProcessor;
            codeDomContentResourceProcessor.NextResourceProcessor = contentFileStreamProcessor;
            contentFileStreamProcessor.AddProcessor("fall", xmlContentProcessor);

            using (_servicesStream = new FileStream(SearchPaths.FindFilePath("Chernobyl/services.fall"), FileMode.Open))
            {
                // The ServicesLoadedCallback method will finish the configuration
                // of the Chernobyl core when the IEventCollection<object> instance has been
                // loaded.
                ComponentProcessor.From(ServicesLoadedCallback, _servicesStream);
            }
        }

        /// <summary>
        /// A method that is given to the
        /// <see cref="IResourceProcessor{T}.From(ResourceProcessCallback{T}, Stream, IOption[])"/>
        /// method of the <see cref="ComponentProcessor"/> during construction.
        /// This method is invoked when the <see cref="IEventCollection{T}"/> instance has
        /// been loaded.
        /// </summary>
        /// <param name="result">The result.</param>
        void ServicesLoadedCallback(IResourceProcessResult<IComponent> result)
        {
            Services = (IEventCollection<object>) ((IInstance) result.Resource).TheInstance;

            // Now that we've loaded in the IEventCollection<object> instance we can get rid of
            // that Stream that points to it so that other code can get access to
            // the same file.
            _servicesStream.Dispose();

            // Now we'll need to replace some of the fallout processors with
            // new fallout processors that reference the newly loaded
            // IEventCollection<object> instance. We'll then hook those new processors up
            // to the ResourceRegistry and FileStreamResourceMapper we
            // previously created and that now hold the IEventCollection<object> instance

            FileStreamProcessor<IComponent> contentFileStreamProcessor = new FileStreamProcessor<IComponent>(Services);
            CodeDomContentResourceProcessor codeDomContentResourceProcessor = new CodeDomContentResourceProcessor(Services);
            XmlContentResourceProcessor xmlContentProcessor = new XmlContentResourceProcessor(Services);

            FalloutFileMapProcessor.NextResourceProcessor = codeDomContentResourceProcessor;
            codeDomContentResourceProcessor.NextResourceProcessor = contentFileStreamProcessor;
            contentFileStreamProcessor.AddProcessor("fall", xmlContentProcessor);

            // Now that we have loaded the IEventCollection<object> instance, we can finish
            // the configuration of the Chernobyl core.

            // configuration and set the current state
            ConfigurationState = new ConfigState();
            LoadingState = new LoadState();
            RunningState = new RunState();
            ChildState = ConfigurationState;

            RootUpdateable = new RootUpdateable(true);

            ObjectProcessor = new ObjectContentResourceProcessor(Services);

            Services.Inject(this);
            Services.Add(this);

            // load plug-ins
            IFactory<IEnumerable<AssemblyName>, object[]> dllPluginFactory =
                new AssemblyFilePluginFactory(Services, ProcessAssemblyPlugin);
            string plugins = ConfigurationManager.AppSettings["Chernobyl.Plugins"];
            if (plugins != null)
            {
                IEnumerable<AssemblyName> pluginList = from plugin in plugins.Split(new[] {';'})
                                                       where plugin.Length != 0
                                                       select new AssemblyName(plugin);
                Plugins = dllPluginFactory.Create(pluginList).Cast<IPlugin>().ToList();
            }
            else
            {
                Trace.TraceEvent(TraceEventType.Information, 0, "The application  " +
                    "setting \"Chernobyl.Plugins\" (from \"appSettings\" in the  " +
                    "application configuration file) could not be found. Therefore, " +
                    "no plug-ins will be loaded.");
            }

            ConfigurationState.Left += ConfigurationStateLeft;
        }

        /// <summary>
        /// Starts Chernobyl so that a plug-in that handles the rendering and
        /// updating of the application (like Chernobyl.Xna) can begin working.
        /// Note, you only need to call <see cref="Run()"/> if you are using
        /// Chernobyl to update or render your application. Otherwise, don't call
        /// this method.
        /// </summary>
        public void Run()
        {
            if (Runner == null)
                throw  new Exception("Unable to run Chernobyl as the Runner method " +
                "has not been set. This could be caused by not having a plug-in installed " +
                "that handles application rendering and updates. Note, if you do not need " +
                "to update or render, then you don't need to call Chernobyl.Run().");

            Runner();
        }

        Stream _servicesStream;

        /// <summary>
        /// A <see cref="TraceSource"/> used to output errors, warnings, information,
        /// etc., that are specific to Chernobyl. This <see cref="TraceSource"/>
        /// will have the name "Chernobyl".
        /// </summary>
        public static TraceSource Trace { get; private set; }

        /// <summary>
        /// The method that starts the rendering and updating of the application.
        /// This must be provided by a plug-in as Chernobyl does not provide this
        /// method. The <see cref="Runner"/> method is responsible for setting the
        /// <see cref="IRunningState"/> (located in the <see cref="IEventCollection{T}"/>
        /// instance) onto the <see cref="IState.ChildState"/> of this
        /// <see cref="IState"/> (also located in the <see cref="IEventCollection{T}"/>
        /// instance).
        /// </summary>
        public Action Runner { get; set; }

        /// <summary>
        /// The plug-ins that have been loaded.
        /// </summary>
        public List<IPlugin> Plugins { get; set; }

        /// <summary>
        /// The services provided by this plug-in or null if no services are
        /// provided.
        /// </summary>
        public IEventCollection<object> Services { get; private set; }

        /// <summary>
        /// The default root updateable.
        /// </summary>
        [Provide]
        public IRootUpdateable RootUpdateable { get; set; }

        /// <summary>
        /// The root component processor for Chernobyl.
        /// </summary>
        [Provide]
        public IResourceProcessor<IComponent> ComponentProcessor { get; set; }

        /// <summary>
        /// The root object processor for Chernobyl.
        /// </summary>
        [Provide]
        public IResourceProcessor<object> ObjectProcessor { get; set; }

        /// <summary>
        /// The default ISearchPaths implementation used by other systems.
        /// </summary>
        [Provide]
        public ISearchPaths SearchPaths { get; set; }

        /// <summary>
        /// The <see cref="IState"/> that represents the configuration or
        /// initialization state of the application.
        /// </summary>
        [Provide]
        public IConfigurationState ConfigurationState { get; set; }

        /// <summary>
        /// The <see cref="IState"/> that represents the loading state of the
        /// application after the configuration state (<see cref="IConfigurationState"/>)
        /// </summary>
        [Provide]
        public ILoadingState LoadingState { get; set; }

        /// <summary>
        /// The <see cref="IState"/> that represents the started running state
        /// after the loading state (<see cref="ILoadingState"/>).
        /// </summary>
        [Provide]
        public IRunningState RunningState { get; set; }

        /// <summary>
        /// The main <see cref="FileStreamResourceMapper{T}"/> for fallout files.
        /// </summary>
        FileStreamResourceMapper<IComponent> FalloutFileMapProcessor { get; set; }

        /// <summary>
        /// The main object that was loaded from the main Chernobyl
        /// configuration file. This file is specified by the application
        /// configuration file (specified as *.config) under "AppSettings" with
        /// the key "Chernobyl.Configuration". This fall file contains an
        /// instance named "main" which is the instance represented by this
        /// property.
        /// </summary>
        public object MainInstance { get; private set; }

        /// <summary>
        /// Loads the <see cref="IProcessAttribute{TCustomAttributeProvider}"/>
        /// instances that process <see cref="Assembly"/> instances on the plugin
        /// and invokes them.
        /// </summary>
        /// <param name="assembly">The plugin whose
        /// <see cref="IProcessAttribute{TCustomAttributeProvider}"/> that process
        /// <see cref="Assembly"/> instances are to be invoked.</param>
        void ProcessAssemblyPlugin(Assembly assembly)
        {
            foreach (IProcessAttribute<Assembly> assemblyAttribute in
                     assembly.GetCustomAttributes<IProcessAttribute<Assembly>>(true))
                assemblyAttribute.Process(assembly);
        }

        /// <summary>
        /// An event handler that is invoked when Chernobyl has left the
        /// configuration state. At this point it is safe to configure
        /// instances in the main configuration file.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance
        /// containing the event data.</param>
        void ConfigurationStateLeft(object sender, EventArgs e)
        {
            // Get the main instance from the main configuration file.
            Resource.From<object>(Services, mainResult => MainInstance = mainResult.Resource,
                                  ConfigurationManager.AppSettings["Chernobyl.Configuration"],
                                  new ResourceName("main"));
        }

        /// <summary>
        /// An <see cref="IConfigurationState"/> used as the default value for
        /// the <see cref="ConfigurationState"/>.
        /// </summary>
        class ConfigState : State, IConfigurationState
        { }

        /// <summary>
        /// An <see cref="ILoadingState"/> used as the default value for
        /// the <see cref="LoadingState"/>.
        /// </summary>
        class LoadState : State, ILoadingState
        { }

        /// <summary>
        /// An <see cref="IRunningState"/> used as the default value for
        /// the <see cref="RunningState"/>.
        /// </summary>
        class RunState : State, IRunningState
        { }
    }
}