using System;

using System.Collections.Generic;

using System.Text;

using System.IO;

using System.Reflection;



namespace Notepad_X.Plugin

{

    public class PluginServices : IPluginHost

    {

        Main main = Notepad_X.Static.MainInstance;

        public PluginServices()

        {

           

        }

        /// <summary>

        /// Available plugins collection

        /// </summary>

        public AvailablePlugins colAvailablePlugins = new AvailablePlugins();



        /// <summary>

        /// A Collection of all Plugins Found and Loaded by the FindPlugins() Method

        /// </summary>

        public AvailablePlugins AvailablePlugins

        {

            get { return colAvailablePlugins; }

            set { colAvailablePlugins = value; }

        }



        /// <summary>

        /// Searches the Application's Startup Directory for Plugins

        /// </summary>

        public void FindPlugins()

        {

            FindPlugins(AppDomain.CurrentDomain.BaseDirectory);

        }

        /// <summary>

        /// Searches the passed Path for Plugins

        /// </summary>

        /// <param name="Path">Directory to search for Plugins in</param>

        public void FindPlugins(string Path)

        {

            //First empty the collection, we're reloading them all

            colAvailablePlugins.Clear();



            //Go through all the files in the plugin directory

            foreach (string fileOn in Directory.GetFiles(Path))

            {

                FileInfo file = new FileInfo(fileOn);



                //Preliminary check, must be .dll

                if (file.Extension.Equals(".dll"))

                {

                    //Add the 'plugin'

                    this.AddPlugin(fileOn);

                }

            }

        }



        /// <summary>

        /// Unloads and Closes all AvailablePlugins

        /// </summary>

        /// 

        public void ClosePlugin(String pluginNameOrPath)

        {

            AvailablePlugin tmp = null; 

            foreach (AvailablePlugin pluginOn in colAvailablePlugins)

            {

                if((pluginOn.Instance.Name.Equals(pluginNameOrPath)) || pluginOn.AssemblyPath.Equals(pluginNameOrPath))

                {

                    pluginOn.Instance.Dispose();

                    pluginOn.Instance = null;

                    tmp = pluginOn;

                    break;

                }

               

             }

            if (tmp != null)

            {

                remove(tmp);

            }

     

        }

        private void remove(AvailablePlugin pl)

        {

            colAvailablePlugins.Remove(pl);

        }

        /// <summary>

        /// Close all the plugins

        /// </summary>

        public void ClosePlugins()

        {

            foreach (AvailablePlugin pluginOn in colAvailablePlugins)

            {

                try

                {

                    //Close all plugin instances

                    //We call the plugins Dispose sub first incase it has to do 

                    //Its own cleanup stuff

                    pluginOn.Instance.Dispose();



                    //After we give the plugin a chance to tidy up, get rid of it

                    pluginOn.Instance = null;

                }catch(Exception){

                }

               

            }



            //Finally, clear our collection of available plugins

            colAvailablePlugins.Clear();

        }

        /// <summary>

        /// Reads an toolbar file and returns the properties as array (Name,Author,Version,Description)

        /// </summary>

        /// <returns>String array (Name,Author,Version,Description)</returns>

        /// <param name="FileName">Filename of the plugin</param>

        public string[] hash(string FileName)

        {

            string[] ret = null;

            try

            {

                Assembly pluginAssembly = Assembly.LoadFrom(FileName);

                foreach (Type pluginType in pluginAssembly.GetTypes())

                {

                    if (pluginType.IsPublic)

                    {

                        if (!pluginType.IsAbstract)

                        {

                            Type typeInterface = pluginType.GetInterface("Notepad_X.Plugin.IPlugin", true);



                            if (typeInterface != null)

                            {

                                AvailablePlugin newPlugin = new AvailablePlugin();



                                newPlugin.AssemblyPath = FileName;

                                newPlugin.Instance = (IPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));



                                ret = new string[4];

                                ret[0] = newPlugin.Instance.Name;

                                ret[1] = newPlugin.Instance.Author;

                                ret[2] = newPlugin.Instance.Version;

                                ret[3] = newPlugin.Instance.Description;

                                newPlugin.Instance = null;

                                newPlugin = null;

                            }

                            typeInterface = null;

                        }



                    }

                }

                pluginAssembly = null;

            }

            catch

            {

                ret = null;

            }

            return ret;

        }

        public void AddPlugin(string FileName)

        {

            //Create a new assembly from the plugin file we're adding..

            Assembly pluginAssembly = Assembly.LoadFrom(FileName);

            //Next we'll loop through all the Types found in the assembly

            foreach (Type pluginType in pluginAssembly.GetTypes())

            {

                if (pluginType.IsPublic) //Only look at public types

                {

                    if (!pluginType.IsAbstract)  //Only look at non-abstract types

                    {

                        //Gets a type object of the interface we need the plugins to match

                        Type typeInterface = pluginType.GetInterface("Notepad_X.Plugin.IPlugin", true);



                        //Make sure the interface we want to use actually exists

                        if (typeInterface != null)

                        {

                            //Create a new available plugin since the type implements the IPlugin interface

                            AvailablePlugin newPlugin = new AvailablePlugin();



                            //Set the filename where we found it

                            newPlugin.AssemblyPath = FileName;



                            //Create a new instance and store the instance in the collection for later use

                            //We could change this later on to not load an instance.. we have 2 options

                            //1- Make one instance, and use it whenever we need it.. it's always there

                            //2- Don't make an instance, and instead make an instance whenever we use it, then close it

                            //For now we'll just make an instance of all the plugins

                            newPlugin.Instance = (IPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));



                            //Add the new plugin to our collection here

                            this.colAvailablePlugins.Add(newPlugin);



                            //Call the initialization sub of the plugin

                            newPlugin.Instance.Initialize();



                            //cleanup

                            newPlugin = null;

                        }

                        typeInterface = null; // Clean			

                    }

                }

            }



            pluginAssembly = null; //more cleanup

        }

    }



    public class AvailablePlugins : System.Collections.CollectionBase

	{

		//A Simple class to hold some info about our Available Plugins

		

		/// <summary>

		/// Add a Plugin to the collection of Available plugins

		/// </summary>

		/// <param name="pluginToAdd">The Plugin to Add</param>

		public void Add(AvailablePlugin pluginToAdd)

		{

			this.List.Add(pluginToAdd); 

		}

        public string get(int id)

        {

           return ((AvailablePlugin)this.List[id]).AssemblyPath;

        }

		/// <summary>

		/// Remove a Plugin to the collection of Available plugins

		/// </summary>

		/// <param name="pluginToRemove">The Plugin to Remove</param>

		public void Remove(AvailablePlugin pluginToRemove)

		{

			this.List.Remove(pluginToRemove);

            pluginToRemove = null;

		}

        public bool Exist(string pluginNameOrPath)

        {

            foreach (AvailablePlugin pluginOn in this.List)

            {

                try

                {

                    if ((pluginOn.Instance.Name.Equals(pluginNameOrPath)) || pluginOn.AssemblyPath.Equals(pluginNameOrPath))

                    {

                        return true;

                    }

                }

                catch { }

            }

            return false;

        }



		/// <summary>

		/// Finds a plugin in the available Plugins

		/// </summary>

		/// <param name="pluginNameOrPath">The name or File path of the plugin to find</param>

		/// <returns>Available Plugin, or null if the plugin is not found</returns>

		public AvailablePlugin Find(string pluginNameOrPath)

		{

			//Loop through all the plugins

			foreach (AvailablePlugin pluginOn in this.List)

			{

                try

                {

                    //Find the one with the matching name or filename

                    if ((pluginOn.Instance.Name.Equals(pluginNameOrPath)) || pluginOn.AssemblyPath.Equals(pluginNameOrPath))

                    {

                        return pluginOn;                        

                    }

                }

                catch { }

			}

			return null;

		}

	}

	

	/// <summary>

	/// Data Class for Available Plugin.  Holds and instance of the loaded Plugin, as well as the Plugin's Assembly Path

	/// </summary>

	public class AvailablePlugin

	{

		//This is the actual AvailablePlugin object.. 

		//Holds an instance of the plugin to access

		//Also holds assembly path

		private IPlugin myInstance = null;

		private string myAssemblyPath = "";

		

		public IPlugin Instance

		{

			get {return myInstance;}

			set	{myInstance = value;}

		}

		public string AssemblyPath

		{

			get {return myAssemblyPath;}

			set {myAssemblyPath = value;}

		}

	}

}