# -----------------------------------------------------------------------------

# 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.

# -----------------------------------------------------------------------------

import qiita_db as qdb

class Archive(qdb.base.QiitaObject):

    r"""Extra information for any features stored in a BIOM Artifact

    Methods

    -------

    insert_from_artifact

    get_merging_scheme_from_job

    retrieve_feature_values

    insert_features

    See Also

    --------

    qiita_db.QiitaObject

    """

    @classmethod

    def merging_schemes(cls):

        r"""Returns the available merging schemes

        Returns

        -------

        Iterator

            Iterator over the sample ids

        See Also

        --------

        keys

        """

        with qdb.sql_connection.TRN:

            sql = """SELECT archive_merging_scheme_id, archive_merging_scheme

                     FROM qiita.archive_merging_scheme"""

            qdb.sql_connection.TRN.add(sql)

            return dict(qdb.sql_connection.TRN.execute_fetchindex())

    @classmethod

    def _inserting_main_steps(cls, ms, features):

        with qdb.sql_connection.TRN:

            sql = """INSERT INTO qiita.archive_merging_scheme

                        (archive_merging_scheme)

                     SELECT %s WHERE NOT EXISTS (

                        SELECT 1 FROM qiita.archive_merging_scheme

                        WHERE archive_merging_scheme = %s)"""

            qdb.sql_connection.TRN.add(sql, [ms, ms])

            sql = """SELECT archive_merging_scheme_id

                     FROM qiita.archive_merging_scheme

                     WHERE archive_merging_scheme = %s"""

            qdb.sql_connection.TRN.add(sql, [ms])

            amsi = qdb.sql_connection.TRN.execute_fetchlast()

            vals = [[amsi, _id, val] for _id, val in features.items()]

            qdb.sql_connection.TRN.add(

                "SELECT archive_upsert(%s, %s, %s)", vals, many=True)

            qdb.sql_connection.TRN.execute()

    @classmethod

    def insert_from_artifact(cls, artifact, features):

        r"""Inserts new features to the database based on a given artifact

        Parameters

        ----------

        artifact : qiita_db.artifact.Artifact

            The artifact from which the features were generated

        features : dict {str: str}

            A dictionary of the features and the values to be stored

        Raises

        ------

        ValueError

            If the Artifact type is not BIOM

            If the artifact doesn't have a biom filepath

        """

        with qdb.sql_connection.TRN:

            atype = artifact.artifact_type

            if atype != 'BIOM':

                raise ValueError(

                    "To archive artifact must be BIOM but %s" % atype)

            bfps = [x['fp'] for x in artifact.filepaths

                    if x['fp_type'] == 'biom']

            if not bfps:

                raise ValueError("The artifact has no biom files")

            # [0] as it returns a list

            ms = qdb.util.get_artifacts_information(

                [artifact.id])[0]['algorithm']

            cls._inserting_main_steps(ms, features)

    @classmethod

    def get_merging_scheme_from_job(cls, job):

        r"""Inserts new features to the database based on a given job

        Parameters

        ----------

        job : qiita_db.processing_job.ProcessingJob

            The Qiita process job_id generating the artifact holding the

            features to be retrieved or stored.

        Raises

        ------

            ValueError

                If the Artifact type is not BIOM

                If the artifact doesn't have a biom filepath

        """

        with qdb.sql_connection.TRN:

            acmd = job.command

            parent = job.input_artifacts[0]

            parent_pparameters = parent.processing_parameters

            phms = None

            if parent_pparameters is None:

                parent_cmd_name = None

                parent_parameters = None

                parent_merging_scheme = None

            else:

                pcmd = parent_pparameters.command

                parent_cmd_name = pcmd.name

                parent_parameters = parent_pparameters.values

                parent_merging_scheme = pcmd.merging_scheme

                if not parent_merging_scheme['ignore_parent_command']:

                    gp = parent.parents[0]

                    gp_params = gp.processing_parameters

                    if gp_params is not None:

                        gp_cmd = gp_params.command

                        phms = qdb.util.human_merging_scheme(

                            parent_cmd_name, parent_merging_scheme,

                            gp_cmd.name, gp_cmd.merging_scheme,

                            parent_parameters, [], gp_params.values)

            hms = qdb.util.human_merging_scheme(

                acmd.name, acmd.merging_scheme,

                parent_cmd_name, parent_merging_scheme,

                job.parameters.values, [], parent_parameters)

            if phms is not None:

                hms = qdb.util.merge_overlapping_strings(hms, phms)

            return hms

    @classmethod

    def retrieve_feature_values(cls, archive_merging_scheme=None,

                                features=None):

        r"""Retrieves all features/values from the archive

        Parameters

        ----------

        archive_merging_scheme : optional, str

            The name of the archive_merging_scheme to retrieve

        features : list of str, optional

            List of features to retrieve information from the archive

        Notes

        -----

        If archive_merging_scheme is None it will return all

        feature values

        """

        with qdb.sql_connection.TRN:

            extras = []

            vals = []

            if archive_merging_scheme is not None:

                extras.append("""archive_merging_scheme = %s""")

                vals.append(archive_merging_scheme)

            if features is not None:

                extras.append("""archive_feature IN %s""")

                # depending on the method calling test retrieve_feature_values

                # the features elements can be string or bytes; making sure

                # everything is string for SQL

                vals.append(

                    tuple([f.decode('ascii') if isinstance(f, bytes) else f

                           for f in features]))

            sql = """SELECT archive_feature, archive_feature_value

                     FROM qiita.archive_feature_value

                     LEFT JOIN qiita.archive_merging_scheme

                        USING (archive_merging_scheme_id) {0}

                     ORDER BY archive_merging_scheme, archive_feature"""

            if extras:

                sql = sql.format('WHERE ' + ' AND '.join(extras))

                qdb.sql_connection.TRN.add(sql, vals)

            else:

                qdb.sql_connection.TRN.add(sql.format(''))

            return dict(qdb.sql_connection.TRN.execute_fetchindex())

    @classmethod

    def insert_features(cls, merging_scheme, features):

        r"""Inserts new features to the database based on a given artifact

        Parameters

        ----------

        merging_scheme : str

            The merging scheme to store these features

        features : dict {str: str}

            A dictionary of the features and the values to be stored

        Returns

        -------

        dict, feature: value

            The inserted new values

        """

        cls._inserting_main_steps(merging_scheme, features)

        inserted = cls.retrieve_feature_values(

            archive_merging_scheme=merging_scheme, features=features.keys())

        return inserted