#/*##########################################################################
#
# The PyMca X-Ray Fluorescence Toolkit
#
# Copyright (c) 2004-2019 European Synchrotron Radiation Facility
#
# This file is part of the PyMca X-ray Fluorescence Toolkit developed at
# the ESRF by the Software group.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
#############################################################################*/
__author__ = "V.A. Sole - ESRF Data Analysis"
__contact__ = "sole@esrf.fr"
__license__ = "MIT"
__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
__doc__ = """

Class to handle loading of plugins according to target method.

On instantiation, this clase imports all the plugins found in the PLUGINS_DIR
directory and stores them into the attributes pluginList and pluginInstanceDict

"""
import os
import sys
import glob
import logging

PLUGINS_DIR = None

_logger = logging.getLogger(__name__)


class PluginLoader(object):
    def __init__(self, method=None, directoryList=None):
        self._pluginDirList = []
        self.pluginList = []
        self.pluginInstanceDict = {}
        self.getPlugins(method=method, directoryList=directoryList)

    def setPluginDirectoryList(self, dirlist):
        """
        :param dirlist: Set directories to search for plugins
        :type dirlist: list
        """
        for directory in dirlist:
            if not os.path.exists(directory):
                raise IOError("Directory:\n%s\ndoes not exist." % directory)
        self._pluginDirList = dirlist

    def getPluginDirectoryList(self):
        """
        :return dirlist: List of directories for searching plugins
        """
        return self._pluginDirList

    def getPlugins(self, method=None, directoryList=None, exceptions=False):
        """
        Import or reloads all the available plugins with the target method

        :param method: The method to be searched for.
        :type method: string, default "getPlugin1DInstance"
        :param directoryList: The list of directories for the search.
        :type directoryList: list or None (default).
        :param exceptions: If True, return the list of error messages
        :type exceptions: boolean (default False)
        :return: The number of plugins loaded. If exceptions is True, also the
                 text with the error encountered.
        """
        if method is None:
            method = 'getPlugin1DInstance'
        targetMethod = method
        if directoryList in [None, [] ]:
            directoryList = self._pluginDirList
            if directoryList in [None, []]:
                directoryList = [PLUGINS_DIR]
        _logger.debug("method: %s", targetMethod)
        _logger.debug("directoryList: %s", directoryList)
        exceptionMessage = ""
        self._pluginDirList = directoryList
        self.pluginList = []
        for directory in self._pluginDirList:
            if directory is None:
                continue
            if not os.path.exists(directory):
                raise IOError("Directory:\n%s\ndoes not exist." % directory)

            fileList = glob.glob(os.path.join(directory, "*.py"))
            # prevent unnecessary imports
            moduleList = []
            for fname in fileList:
                # in Python 3, rb implies bytes and not strings
                f = open(fname, 'r')
                lines = f.readlines()
                f.close()
                f = None
                for line in lines:
                    if line.startswith("def"):
                        if line.split(" ")[1].startswith(targetMethod):
                            moduleList.append(fname)
                            break
            for module in moduleList:
                try:
                    pluginName = os.path.basename(module)[:-3]
                    _logger.debug("pluginName %s", pluginName)
                    plugin = pluginName
                    if directory not in sys.path:
                        sys.path.insert(0, directory)
                    if pluginName in self.pluginList:
                        idx = self.pluginList.index(pluginName)
                        del self.pluginList[idx]
                    if plugin in self.pluginInstanceDict.keys():
                        del self.pluginInstanceDict[plugin]
                    if plugin in sys.modules:
                        if hasattr(sys.modules[plugin], targetMethod):
                            if sys.version.startswith('3'):
                                import importlib
                                importlib.reload(sys.modules[plugin])
                            else:
                                reload(sys.modules[plugin])
                    else:
                        __import__(plugin)
                    if hasattr(sys.modules[plugin], targetMethod):
                        theCall = getattr(sys.modules[plugin], targetMethod)
                        self.pluginInstanceDict[plugin] = theCall(self)
                        self.pluginList.append(plugin)
                except:
                    exceptionMessage += \
                        "Problem importing module %s\n" % plugin
                    exceptionMessage += "%s\n" % sys.exc_info()[0]
                    exceptionMessage += "%s\n" % sys.exc_info()[1]
                    exceptionMessage += "%s\n" % sys.exc_info()[2]

        if len(exceptionMessage) and _logger.getEffectiveLevel() == logging.DEBUG:
            raise IOError(exceptionMessage)
        if exceptions:
            return len(self.pluginList), exceptionMessage
        else:
            return len(self.pluginList)

def main(targetMethod, directoryList):
    loader = PluginLoader()
    n = loader.getPlugins(targetMethod, directoryList)
    print("Loaded %d plugins" % n)
    for m in loader.pluginList:
        print("Module %s" % m)
        module = sys.modules[m]
        if hasattr(module, 'MENU_TEXT'):
            text = module.MENU_TEXT
        else:
            text = os.path.basename(module.__file__)
            if text.endswith('.pyc'):
                text = text[:-4]
            elif text.endswith('.py'):
                text = text[:-3]
        print("\tMENU TEXT: %s" % text)
        methods = loader.pluginInstanceDict[m].getMethods()
        if not len(methods):
            continue
        for method in methods:
            print("\t\t %s" % method)

if __name__ == "__main__":
    if len(sys.argv) > 2:
        targetMethod  = sys.argv[1]
        directoryList = sys.argv[2:len(sys.argv)]
    elif len(sys.argv) > 1:
        targetMethod = None
        directoryList = sys.argv[1:len(sys.argv)]
    else:
        print("Usage: python PluginLoader.py [targetMethod] directory")
    main(targetMethod, directoryList)
