/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
* 
* Description:
*
*/
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Reflection;

namespace SymbianUtils.PluginManager
{
    public class PluginManager<T> : DisposableObject, IEnumerable<T>
    {
        #region Events
        public delegate void PluginLoadedHandler( T aPlugin );
        public event PluginLoadedHandler PluginLoaded;
        #endregion

        #region Constructors
        public PluginManager()
        {
        }

        public PluginManager( bool aDiagnostics )
        {
            iDiagnostics = aDiagnostics;
        }

        public PluginManager( int aMinimumNumberOfExpectedPlugins )
        {
            iMinimumNumberOfExpectedPlugins = aMinimumNumberOfExpectedPlugins;
        }

        public PluginManager( bool aDiagnostics, int aMinimumNumberOfExpectedPlugins )
            : this( aDiagnostics )
        {
            iMinimumNumberOfExpectedPlugins = aMinimumNumberOfExpectedPlugins;
        }
        #endregion

        #region API - loading
        public void Load( object[] aPluginConstructorParameters )
        {
            Trace( "Load() - invoked by: " + System.Environment.StackTrace );
            Assembly assembly = Assembly.GetCallingAssembly();
            string path = Path.GetDirectoryName( assembly.Location );
            FindPluginsWithinPath( path, KDefaultSearchSpecification, aPluginConstructorParameters, assembly );
        }

        public void LoadFromCallingAssembly()
        {
            Trace( "LoadFromCallingAssembly(1) - invoked by: " + System.Environment.StackTrace );
            Assembly assembly = Assembly.GetCallingAssembly();
            FindPluginsWithinAssembly( assembly, true, new object[] {} );
            Rationalise();
        }

        public void LoadFromCallingAssembly( object[] aPluginConstructorParameters )
        {
            Trace( "LoadFromCallingAssembly(2) - invoked by: " + System.Environment.StackTrace );
            Assembly assembly = Assembly.GetCallingAssembly();
            FindPluginsWithinAssembly( assembly, true, aPluginConstructorParameters );
            Rationalise();
        }

        public void LoadFromPath( string aPath, object[] aPluginConstructorParameters )
        {
            FindPluginsWithinPath( aPath, KDefaultSearchSpecification, aPluginConstructorParameters, null );
        }

        public void LoadFromPath( string aPath, string aMatchSpec, object[] aPluginConstructorParameters )
        {
            FindPluginsWithinPath( aPath, aMatchSpec, aPluginConstructorParameters, null );
        }
        #endregion

        #region API - misc
        public void Unload()
        {
            foreach ( T plugin in iPlugins )
            {
                IDisposable disposable = plugin as IDisposable;
                if ( disposable != null )
                {
                    disposable.Dispose();
                }
            }
            //
            iPlugins.Clear();
        }

        public void Sort( IComparer<T> aComparer )
        {
            iPlugins.Sort( aComparer );
        }

        public void Sort( Comparison<T> aComparer )
        {
            iPlugins.Sort( aComparer );
        }

        public bool Predicate( Predicate<T> aPredicate )
        {
            bool ret = iPlugins.Exists( aPredicate );
            return ret;
        }

        public void Rationalise()
        {
            List<T> plugins = iPlugins;
            iPlugins = new List<T>();
            //
            int count = plugins.Count;
            for ( int i = count - 1; i >= 0; i-- )
            {
                T pluginToCheck = plugins[ i ];
                plugins.RemoveAt( i );
                Trace( "Rationalise() - checking hierarchy for derivates of: " + pluginToCheck.GetType().ToString() );
                //
                bool isDerviedFromByOtherPlugin = IsClassDerivedFrom( plugins, pluginToCheck );
                Trace( "Rationalise() - is base class for other plugin: " + isDerviedFromByOtherPlugin );
                //
                if ( !isDerviedFromByOtherPlugin )
                {
                    iPlugins.Add( pluginToCheck );
                    Trace( "Rationalise() - found good plugin: " + pluginToCheck.GetType().ToString() );
                    OnPluginLoaded( pluginToCheck );
                }
            }

            // Check that we loaded the expected minimum amount
            count = iPlugins.Count;
            SymbianUtils.SymDebug.SymDebugger.Assert( iMinimumNumberOfExpectedPlugins < 0 || count >= iMinimumNumberOfExpectedPlugins );
        }
        #endregion

        #region Properties
        public int Count
        {
            get { return iPlugins.Count; }
        }

        public T this[ int aIndex ]
        {
            get { return iPlugins[ aIndex ]; }
        }

        public Type PluginType
        {
            get { return typeof( T ); }
        }
        #endregion
        
        #region Internal constants
        private const string KDefaultSearchSpecification = "*.plugin.dll";
        #endregion

        #region Event propgation
        private void OnPluginLoaded( T aPlugin )
        {
            if ( PluginLoaded != null )
            {
                PluginLoaded( aPlugin );
            }
        }
        #endregion

        #region Internal methods
        private void Trace( string aMessage )
        {
            System.Diagnostics.Debug.WriteLineIf( iDiagnostics, "PluginLoader<" + typeof(T).Name + "> " + aMessage );
        }

        private void Trace( Exception aException, string aFunction )
        {
            Trace( string.Format( "PluginLoader.{0}() - exception: {1}", aFunction, aException.Message ) );
            Trace( string.Format( "PluginLoader.{0}() - stack:     {1}", aFunction, aException.StackTrace ) );
            //
            if ( aException is ReflectionTypeLoadException )
            {
                ReflectionTypeLoadException refEx = (ReflectionTypeLoadException) aException;
                foreach ( Exception l in refEx.LoaderExceptions )
                {
                    Trace( string.Format( "     loader exception: {0}", l.Message ) );
                    Trace( string.Format( "     loader stack:     {0}", l.StackTrace ) );
                }
            }
            else if ( aException is FileNotFoundException )
            {
                FileNotFoundException fnf = (FileNotFoundException) aException;
                Trace( string.Format( "     file name:  {0}", fnf.FileName ) );
                Trace( string.Format( "     fusion log: {0}", fnf.FusionLog ) );
            }
        }

        private static bool IsClassDerivedFrom( List<T> aPluginList, T aPlugin )
        {
            bool ret = false;
            Type checkType = aPlugin.GetType();
            //
            foreach ( T plugin in aPluginList )
            {
                Type type = plugin.GetType();
                if ( type.IsSubclassOf( checkType ) )
                {
                    ret = true;
                    break;
                }
            }
            //
            return ret;
        }

        private void CreateFromTypes( Type[] aTypes, object[] aPluginConstructorParameters )
        {
            Type pluginType = PluginType;
            Trace( "CreateFromTypes() - got " + aTypes.Length + " types. Searching for instances of: " + pluginType.Name );
            // 
            foreach ( Type type in aTypes )
            {
                if ( pluginType.IsAssignableFrom( type ) )
                {
                    Trace( "CreateFromTypes() - found type: " + type.Name );
                    if ( !type.IsAbstract )
                    {
                        Trace( "CreateFromTypes() - type \'" + type.Name + "\' is concrete implementation" );
                        CreateFromType( type, aPluginConstructorParameters );
                    }
                }
            }
        }

        private void CreateFromType( Type aType, object[] aPluginConstructorParameters )
        {
            try
            {
                Trace( "CreateFromType() - calling constructor: " + aType.Name );
                //
                object ret = CallConstructor( aType, aPluginConstructorParameters );
                if ( ret != null )
                {
                    T plugin = (T) ret;
                    Trace( "CreateFromType() - saving instance: " + plugin.GetType().ToString() );
                    iPlugins.Add( plugin );
                }
            }
            catch ( FileNotFoundException )
            {
            }
            catch ( Exception e )
            {
                Trace( e, "CreateFromType" );
            }
        }

        private object CallConstructor( Type aType, object[] aParameters )
        {
            object ret = null;
            //
            try
            {
                ret = Activator.CreateInstance( aType, aParameters );
            }
            catch ( Exception e )
            {
                Trace( e, "CallConstructor" );
            }
            //
            return ret;
        }

        private void LoadAssemblyAndCreatePlugins( string aFileName, object[] aPluginConstructorParameters, bool aExplicit )
        {
            try
            {
                Trace( "LoadAssemblyAndCreatePlugins() - Trying to load plugins from dll: " + aFileName );
                if ( SymbianUtils.Assemblies.AssemblyHelper.IsCLRAssembly( aFileName ) )
                {
                    Assembly pluginAssembly = Assembly.LoadFrom( aFileName );
                    if ( pluginAssembly != null )
                    {
                        FindPluginsWithinAssembly( pluginAssembly, aExplicit, aPluginConstructorParameters );
                    }
                }
            }
            catch ( BadImageFormatException )
            {
                // Not a managed dll - ignore error
            }
            catch ( Exception assemblyLoadException )
            {
                Trace( assemblyLoadException, "LoadAssemblyAndCreatePlugins" );
            }
        }

        private void FindPluginsWithinAssembly( Assembly aAssembly, bool aExplit, object[] aPluginConstructorParameters )
        {
            bool okayToGetTypes = aExplit;

#if BETTER_PERFORMANCE
            // If explit load requested, then don't check for plugin attribute. Otherwise, to avoid
            // enumerating all types we can check for our special "plugin" attribute
            object[] attributes = aAssembly.GetCustomAttributes( typeof( PluginAssemblyAttribute ), false) ;
            if ( attributes != null && attributes.Length > 0 ) 
            {
                okayToGetTypes = true;
            }
#else
            okayToGetTypes = true;
#endif

            // Now get types
            if ( okayToGetTypes )
            {
                Trace( "DoLoad() - getting types from assembly: " + aAssembly.Location );
                Type[] types = aAssembly.GetTypes();
                CreateFromTypes( types, aPluginConstructorParameters );
            }
        }

        private void FindPluginsWithinPath( string aPath, string aMatchSpec, object[] aPluginConstructorParameters, Assembly aAdditionalSearchAssembly )
        {
            Trace( string.Format( "FindPluginsWithinPath() - path: {0}, matchSpec: {1}, invoked by: {2}", aPath, aMatchSpec, System.Environment.StackTrace ) );
            Unload();
            
            // Find from path
            string[] dllNames = Directory.GetFiles( aPath, aMatchSpec );
            foreach ( string dll in dllNames )
            {
                string justFileName = Path.GetFileName( dll );
                LoadAssemblyAndCreatePlugins( dll, aPluginConstructorParameters, false );
            }

            // Check additional assembly
            if ( aAdditionalSearchAssembly != null )
            {
                FindPluginsWithinAssembly( aAdditionalSearchAssembly, true, aPluginConstructorParameters );
            }
   
            // Check hierarchy for derived plugins
            Rationalise();
        }
        #endregion

        #region From IEnumerable<T>
        public IEnumerator<T> GetEnumerator()
        {
            foreach ( T p in iPlugins )
            {
                yield return p;
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            foreach ( T p in iPlugins )
            {
                yield return p;
            }
        }
        #endregion

        #region From System.Object
        public override string ToString()
        {
            StringBuilder ret = new StringBuilder();
            ret.AppendFormat( "Found: {0} of type: {1}", iPlugins.Count, typeof(T).Name );
            if ( iMinimumNumberOfExpectedPlugins > 0 )
            {
                ret.AppendFormat( ", expected: {2}", iMinimumNumberOfExpectedPlugins );
            }
            return ret.ToString();
        }
        #endregion

        #region From DisposableObject
        protected override void CleanupManagedResources()
        {
            try
            {
                base.CleanupManagedResources();
            }
            finally
            {
                foreach ( T obj in iPlugins )
                {
                    IDisposable disp = obj as IDisposable;
                    if ( disp != null )
                    {
                        disp.Dispose();
                    }
                }
                //
                iPlugins.Clear();
                iPlugins = null;
            }
        }
        #endregion

        #region Data members
        private bool iDiagnostics = false;
        private int iMinimumNumberOfExpectedPlugins = -1;
        private List<T> iPlugins = new List<T>();
        #endregion
    }
}