/*
 * Util.AssemblyLocator.cs
 * Authors: Adam Nabinger
 * Copyright (c) 2007-2008 Cornell University

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Collections.Generic;
using System.Reflection;

namespace Util
{
	/// <summary>
	/// Collects and stores a list of referenced assemblies, for retrieving minigames dynamically.
	/// </summary>
	public static class AssemblyLocator
    {
        #region Fields

        // Should be Sets?

        // List of assemblies
		private static readonly ICollection<AssemblyInfo> assemblies = new List<AssemblyInfo>();
        
        // List of minigame infos
		private static readonly List<MiniGameInfo> minigameinfos = new List<MiniGameInfo>();

        // List of locations to search through
		private static readonly Queue<string> searchLocations = new Queue<string>();

        // Whether or not the list of assemblies has been resolved.
		private static bool resolved;

        #endregion

        #region Properties

        /// <summary>
		/// A collection of strings, each item of which is the name of a known assembly.
		/// </summary>
		public static ICollection<string> AllKnownAssemblies
		{
			get
			{
				if (!resolved)
				{
					Resolve();
				}
				ICollection<string> temp = new List<string>();
				foreach (AssemblyInfo info in assemblies)
				{
					temp.Add(info.path);
				}
				return temp;
			}
		}

		/// <summary>
		/// A collection of MiniGameInfos, each item of which representing a found minigame.
		/// </summary>
		public static List<MiniGameInfo> AllKnownMiniGames
		{
			get
			{
				if (!resolved)
				{
					Resolve();
				}
				return minigameinfos;
			}
        }

        #endregion

        #region Creation

        /// <summary>
        /// Constructor
        /// </summary>
        static AssemblyLocator()
        {
            searchLocations.Enqueue(ProjectInfo.HomeDirectory);
            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
        }

        #endregion

        #region Location

        /// <summary>
		/// Add a directory path to search for minigames in.
		/// Subdirectories under the main executable are searched by default.
		/// </summary>
		/// <param name="rootDirectory">The current root directory</param>
		public static void AddSearchLocation(string rootDirectory)
		{
			searchLocations.Enqueue(rootDirectory);
			resolved = false;
		}

        /// <summary>
        /// Get the location of an assembly by it's name.
        /// </summary>
        /// <param name="assemblyName">The name of the desired assembly.</param>
        /// <returns>The fully qualified path to the directory containing the assembly, or null if it is not known.</returns>
        public static string GetLocation(string assemblyName)
        {
            foreach (AssemblyInfo a in assemblies)
            {
                if (a.fullname == assemblyName)
                {
                    return a.path.Substring(0, a.path.LastIndexOf('\\'));
                }
            }
            return null;
        }

        #endregion

        #region Resolve

        /// <summary>
        /// An Event triggered when a dependant assembly cannot be found by the C# libraries.
        /// </summary>
        /// <param name="sender">Sender of the event</param>
        /// <param name="args">All arguments associtated with the resolved event</param>
        /// <returns></returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadFrom")]
		static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
		{
#if DEBUG
			Console.WriteLine("Debug: Trying to resolve " + args.Name);
#endif
			if (!resolved)
			{
				Resolve();
			}
			foreach (AssemblyInfo info in assemblies)
			{
				if (args.Name != info.fullname)
				{
					continue;
				}
				if (info.assembly == null)
				{
					info.assembly = Assembly.LoadFrom(info.path);
				}
				return info.assembly;
			}
			throw new InvalidOperationException("Error trying to load " + args.Name + ". Could not find assembly.");
		}

        /// <summary>
        /// Search through the given locations for any assemblies.
        /// </summary>
		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadFrom")]
		private static void Resolve()
		{
			AppDomain privateAppDomain = AppDomain.CreateDomain("Private Minigame Search AppDomain");
        	string fullname = Assembly.GetExecutingAssembly().FullName;
			if (string.IsNullOrEmpty(fullname))
			{
				return;
			}
			AssemblySearchWorker worker = (AssemblySearchWorker)privateAppDomain.CreateInstanceAndUnwrap(fullname, typeof(AssemblySearchWorker).FullName);
			worker.Resolve(searchLocations);
			foreach (AssemblyType pair in worker.Types)
			{
				if (!string.IsNullOrEmpty(pair.TypeName))
				{
					Assembly asm = Assembly.LoadFrom(pair.Assembly);
					Type t = asm.GetType(pair.TypeName);
					assemblies.Add(new AssemblyInfo(asm, pair.Assembly, pair.FullName));
					MiniGameInfo info = (MiniGameInfo)t.GetConstructor(Type.EmptyTypes).Invoke(null);
					info.RootDirectory = pair.Assembly.Substring(0, pair.Assembly.LastIndexOf('\\'));
					minigameinfos.Add(info);
				}
				else
				{
					assemblies.Add(new AssemblyInfo(null, pair.Assembly, pair.FullName));
				}
                minigameinfos.Sort();
			}
			AppDomain.Unload(privateAppDomain);
        }

        #endregion
    }

    /// <summary>
    /// Defines the info associated with any assembly
    /// </summary>
	internal sealed class AssemblyInfo
    {
        #region Fields

        /// <summary>
        ///  The assembly
        /// </summary>
		internal Assembly assembly;

        /// <summary>
        /// The path name
        /// </summary>
		internal readonly string path;

        /// <summary>
        /// The full name
        /// </summary>
		internal readonly string fullname;

        #endregion

        #region Creation

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="asm">The assembly</param>
        /// <param name="p">The path name</param>
        /// <param name="name">The full name</param>
		public AssemblyInfo(Assembly asm, string p, string name)
		{
			assembly = asm;
			path = p;
			fullname = name;
        }

        #endregion
    }
}