# -----------------------------------------------------------------------------
# Copyright (c) 2014--, The Qiita Development Team.
#
# Distributed under the terms of the BSD 3-clause License.
#
# The full license is in the file LICENSE, distributed with this software.
# -----------------------------------------------------------------------------

from json import loads
from glob import glob
from os.path import join

from tornado.web import HTTPError

from .oauth2 import OauthBaseHandler, authenticate_oauth
from qiita_core.qiita_settings import qiita_config
import qiita_db as qdb


def _get_plugin(name, version):
    """Returns the plugin with the given name and version

    Parameters
    ----------
    name : str
        The name of the plugin
    version : str
        The version of the plugin

    Returns
    -------
    qiita_db.software.Software
        The requested plugin

    Raises
    ------
    HTTPError
        If the plugin does not exist, with error code 404
        If there is a problem instantiating the plugin, with error code 500
    """
    try:
        plugin = qdb.software.Software.from_name_and_version(name, version)
    except qdb.exceptions.QiitaDBUnknownIDError:
        raise HTTPError(404)
    except Exception as e:
        raise HTTPError(500, reason='Error instantiating plugin %s %s: %s'
                        % (name, version, str(e)))

    return plugin


class PluginHandler(OauthBaseHandler):
    @authenticate_oauth
    def get(self, name, version):
        """Retrieve the plugin information

        Parameters
        ----------
        name : str
            The plugin name
        version : str
            The plugin version

        Returns
        -------
        dict
            The plugin information:
            'name': the plugin name
            'version': the plugin version
            'description': the plugin description
            'commands': list of the plugin commands
            'publications': list of publications
            'default_workflows': list of the plugin default workflows
            'type': the plugin type
            'active': whether the plugin is active or not
        """
        with qdb.sql_connection.TRN:
            plugin = _get_plugin(name, version)
            response = {
                'name': plugin.name,
                'version': plugin.version,
                'description': plugin.description,
                'commands': [c.name for c in plugin.commands],
                'publications': [{'DOI': doi, 'PubMed': pubmed}
                                 for doi, pubmed in plugin.publications],
                'type': plugin.type,
                'active': plugin.active}
        self.write(response)


class CommandListHandler(OauthBaseHandler):
    @authenticate_oauth
    def post(self, name, version):
        """Create new command for a plugin

        Parameters
        ----------
        name : str
            The name of the plugin
        version : str
            The version of the plugin
        """
        with qdb.sql_connection.TRN:
            plugin = _get_plugin(name, version)

            cmd_name = self.get_argument('name')
            cmd_desc = self.get_argument('description')
            req_params = loads(self.get_argument('required_parameters'))
            opt_params = loads(self.get_argument('optional_parameters'))

            for p_name, vals in opt_params.items():
                if vals[0].startswith('mchoice'):
                    opt_params[p_name] = [vals[0], loads(vals[1])]
                    if len(vals) == 2:
                        opt_params[p_name] = [vals[0], loads(vals[1])]
                    elif len(vals) == 4:
                        opt_params[p_name] = [vals[0], loads(vals[1]), vals[2],
                                              vals[3]]
                    else:
                        raise qdb.exceptions.QiitaDBError(
                            "Malformed parameters dictionary, the format "
                            "should be either {param_name: [parameter_type, "
                            "default]} or {parameter_name: (parameter_type, "
                            "default, name_order, check_biom_merge)}. Found: "
                            "%s for parameter name %s"
                            % (vals, p_name))
                # adding an extra element to make sure the parser knows this is
                # an optional parameter
                opt_params[p_name].extend(['qiita_optional_parameter'])

            outputs = self.get_argument('outputs', None)
            if outputs:
                outputs = loads(outputs)
            dflt_param_set = loads(self.get_argument('default_parameter_sets'))
            analysis_only = self.get_argument('analysis_only', False)

            parameters = req_params
            parameters.update(opt_params)

            cmd = qdb.software.Command.create(
                plugin, cmd_name, cmd_desc, parameters, outputs,
                analysis_only=analysis_only)

            if dflt_param_set is not None:
                for name, vals in dflt_param_set.items():
                    qdb.software.DefaultParameters.create(name, cmd, **vals)

        self.finish()


def _get_command(plugin_name, plugin_version, cmd_name):
    """Returns the command with the given name within the given plugin

    Parameters
    ----------
    plugin_name : str
        The name of the plugin
    plugin_version : str
        The version of the plugin
    cmd_name : str
        The name of the command in the plugin

    Returns
    -------
    qiita_db.software.Command
        The requested command

    Raises
    ------
    HTTPError
        If the command does not exist, with error code 404
        If there is a problem instantiating the command, with error code 500
    """
    plugin = _get_plugin(plugin_name, plugin_version)
    try:
        cmd = plugin.get_command(cmd_name)
    except qdb.exceptions.QiitaDBUnknownIDError:
        raise HTTPError(404)
    except Exception as e:
        raise HTTPError(500, reason='Error instantiating cmd %s of plugin '
                        '%s %s: %s' % (cmd_name, plugin_name,
                                       plugin_version, str(e)))

    return cmd


class CommandHandler(OauthBaseHandler):
    @authenticate_oauth
    def get(self, plugin_name, plugin_version, cmd_name):
        """Retrieve the command information

        Parameters
        ----------
        plugin_name : str
            The plugin name
        plugin_version : str
            The plugin version
        cmd_name : str
            The command name

        Returns
        -------
        dict
            The command information
            'name': the command name
            'description': the command description
            'required_parameters': dict with the required parameters, in the
                format {parameter_name: [type, [subtypes]]}
            'optional_parameters': dict with the optional parameters, in the
                format {parameter_name: [type, default value]}
            'default_parameter_sets': dict with the default parameter sets, in
                the format {parameter set name: {parameter_name: value}}
        """
        with qdb.sql_connection.TRN:
            cmd = _get_command(plugin_name, plugin_version, cmd_name)
            response = {
                'name': cmd.name,
                'description': cmd.description,
                'required_parameters': cmd.required_parameters,
                'optional_parameters': cmd.optional_parameters,
                'default_parameter_sets': {
                    p.name: p.values for p in cmd.default_parameter_sets},
                'outputs': cmd.outputs}
        self.write(response)


class CommandActivateHandler(OauthBaseHandler):
    @authenticate_oauth
    def post(self, plugin_name, plugin_version, cmd_name):
        """Activates the command

        Parameters
        ----------
        plugin_name : str
            The plugin name
        plugin_version : str
            The plugin version
        cmd_name : str
            The command name
        """
        with qdb.sql_connection.TRN:
            cmd = _get_command(plugin_name, plugin_version, cmd_name)
            cmd.activate()

        self.finish()


class ReloadPluginAPItestHandler(OauthBaseHandler):
    @authenticate_oauth
    def post(self):
        """Reloads the plugins"""
        conf_files = sorted(glob(join(qiita_config.plugin_dir, "*.conf")))
        software = set([qdb.software.Software.from_file(fp, update=True)
                        for fp in conf_files])
        definition = set(
            [s for s in software if s.type == 'artifact definition'])
        transformation = software - definition
        for s in definition:
            s.activate()
            s.register_commands()
        for s in transformation:
            s.activate()
            s.register_commands()

        self.finish()