using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Windows.Forms;
using TradeIdeas.TIProData;
using TradeIdeas.TIProData.Interfaces;
using TradeIdeas.TIProGUI;

namespace TradeIdeas.Extensions
{
    /// <summary>
    /// This is the called on each extension which supports it.  This is called after loading the
    /// config files, but before loading the default layout.
    /// </summary>
    public interface IMainInit
    {
        void MainInit();
    }

    /// <summary>
    /// This is the preferred way to talk with the main program.
    /// </summary>
    public interface IMainProgram
    {
        /// <summary>
        /// This is the preferred way to expose a window to the user.  This creates a new menu
        /// item on the tools menu.  This is only aimed at extensions.  Presumably when this
        /// becomes real, it will be added to the menu in a more appropriate place.
        /// </summary>
        /// <param name="name">The user visible name.  (Currently there is no attempt at using translations.)</param>
        /// <param name="callback">The Click event for the menu item.</param>
        /// <returns>This is a pointer to the newly created menu item.  This allows for further customization, if required.</returns>
        System.Windows.Forms.ToolStripMenuItem AddToToolsMenu(string name, Action callback);

        /// <summary>
        /// This is to add to the REAL Tools menu. AddToToolsMenu() is actually being used to add
        /// to the New menu on the main form.
        /// </summary>
        /// <param name="name">The user visible name.  (Currently there is no attempt at using translations.)</param>
        /// <param name="callback">The Click event for the menu item.</param>
        /// <returns>This is a pointer to the newly created menu item.  This allows for further customization, if required.</returns>
        System.Windows.Forms.ToolStripMenuItem AddToRealToolsMenu(string name, Action callback);

        /// <summary>
        /// This will allow us to add a panel to the toolbar.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="callback"></param>
        /// <returns></returns>
        System.Windows.Forms.ToolStripControlHost AddPanelToToolBar(Action liveCallback, Action simCallback);

        /// <summary>
        /// How to access the server.
        /// 
        /// Typically the main program hands this to each new window.  Currently there is exactly one of these,
        /// but a main program certainly could create more and give different ones to different windows.
        /// Typically a window will take this as an argument to the constructor.
        /// </summary>
        IConnectionMaster ConnectionMaster { get; }
        string AppNameInternal { get; }
        // new properties to get dock panel settings and layout manager from main program - RVH20210506
        bool DockPanelMode { get; }
        string MainDockPanelName { get; }
        string MainDockPanelTitle { get; }

        /// <summary>
        /// LayoutManager defined in the main program.
        /// </summary>
        LayoutManager LayoutManager { get; }

        /// <summary>
        /// This will allow us to add a monitor control to right of the tick panel.
        /// </summary>
        /// <param name="control">The control to add.</param>
        /// <returns></returns>
        void AddMonitorControl(Control control);
    }


    /// <summary>
    /// This is primarily aimed at the main program.  This finds all extensions.
    /// 
    /// If you want to provide an extension, create a DLL named *Extension.DLL and put it in the same
    /// directory as the main program.  Within that, create one or more class with a mathod with the
    /// following name and signature:
    /// public static IList< Object > GetExtensions(Object mainProgram)
    /// 
    /// Note that the input and outputs are all of type Object.  For maximum flexibility these are
    /// cast to different interfaces as needed.  Some extensions and some main programs may not
    /// implement all interfaces.
    /// </summary>
    public class ExtensionHelper
    {
        private string _fileFilter = "*Extension.DLL";
        public string FileFilter
        {
            get { return _fileFilter; }
            set { _fileFilter = value; }
        }

        private string _extensionMethodName = "GetExtensions";
        public string ExtensionMethodName
        {
            get { return _extensionMethodName; }
            set { _extensionMethodName = value; }
        }

        private List<object> _extensions = new List<object>();
        public IList<object> Extensions
        {
            get
            {
                return _extensions;
            }
        }
        public IList<T> GetExtensions<T>() where T : class
        {
            IList<T> result = new List<T>();
            foreach (object possible in _extensions)
            {
                T found = possible as T;
                if (null != found)
                    result.Add(found);
            }
            return result;
        }

        /// <summary>
        /// This helps when you are in the debugger.  Otherwise is it not used.
        /// </summary>
        private Exception _unexpectedFailure;

        private void LoadFromDirectory(String directoryName)
        {
            try
            {
                string[] filenames = Directory.GetFiles(directoryName, _fileFilter);
                foreach (string extensionFileName in filenames)
                {
                    LoadFromFile(extensionFileName);
                }
            }
            catch (Exception ex)
            {
                _unexpectedFailure = ex;
            }
        }

        private HashSet<string> _extensionFileNamesLoaded = new HashSet<string>();

        /// <summary>
        /// Try to load all extensions from a specific file.  This is all wrapped in a big try block.
        /// Most errors will be ignored and will all look the same.  It is safe, for example, always
        /// to try to load a file, rather than looking to see if the file exists, first.
        /// </summary>
        /// <param name="extensionFileName">
        /// The file to load.  This must be an absolute path name.  See Path.GetFullPath.
        /// </param>
        private void LoadFromFile(String extensionFileName)
        {
            try
            {
                string fileName = Path.GetFileName(extensionFileName);
                if (_extensionFileNamesLoaded.Contains(fileName))
                    return;
                Assembly assembly = Assembly.LoadFile(extensionFileName);
                foreach (Type type in assembly.GetTypes())
                {
                    MethodInfo methodInfo = type.GetMethod(_extensionMethodName);
                    if (null != methodInfo)
                    {
                        try
                        {
                            Object result = methodInfo.Invoke(null, _args);
                            _extensions.AddRange(result as IList<Object>);
                            _extensionFileNamesLoaded.Add(fileName);
                        }
                        catch (Exception ex)
                        {
                            _unexpectedFailure = ex;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _unexpectedFailure = ex;
            }
        }
        private readonly Object[] _args;
        private bool _devMode = false;

        /// <summary>
        /// Find all extensions.
        /// </summary>
        /// <param name="mainProgram">This will be sent to each extension in the initialization process.</param>
        public ExtensionHelper(IMainProgram mainProgram, bool devMode = false)
        {
            _devMode = devMode;
            _args = new Object[1];
            HelperStartup(mainProgram);
        }

        /// <summary>
        /// Find all extensions.
        /// </summary>
        /// <param name="mainProgram">This will be sent to each extension in the initialization process.</param>
        /// <param name="fileFilter">This is the file filter to use for extension DLLs.  Default is *Extension.DLL</param>
        /// <param name="extensionMethodName">This is the method name to look for in each DLL.  Default is GetExtensions</param>
        public ExtensionHelper(IMainProgram mainProgram, string fileFilter, string extensionMethodName)
        {
            _args = new Object[1];
            _fileFilter = fileFilter;
            _extensionMethodName = extensionMethodName;
            HelperStartup(mainProgram);
        }

        private void HelperStartup(IMainProgram mainProgram)
        {
            _args[0] = mainProgram;
            LoadFromDirectory(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
            if (_devMode)
            {
                //LoadFromFile(Path.GetFullPath(@"..\..\..\TIProDevExtension\bin\Release\TIProDevExtension.dll"));
                //LoadFromFile(Path.GetFullPath(@"..\..\..\TIProDevExtension\bin\Debug\TIProDevExtension.dll"));
                string extensionsDirectory = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\devextensions";
                LoadFromDirectory(extensionsDirectory);
            }
        }
    }
}