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

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

import qiita_db as qdb

class Portal(qdb.base.QiitaObject):

    r"""Portal object to create and maintain portals in the system

    Attributes

    ----------

    portal

    Methods

    -------

    get_studies

    add_studies

    remove_studies

    get_analyses

    add_analyses

    remove_analyses

    """

    _table = 'portal_type'

    def __init__(self, portal):

        with qdb.sql_connection.TRN:

            self.portal = portal

            portal_id = qdb.util.convert_to_id(portal, 'portal_type', 'portal')

            super(Portal, self).__init__(portal_id)

    @staticmethod

    def list_portals():

        """Returns list of non-default portals available in system

        Returns

        -------

        list of str

            List of portal names for the system

        Notes

        -----

        This does not return the QIITA portal in the list, as it is a required

        portal that can not be edited.

        """

        with qdb.sql_connection.TRN:

            sql = """SELECT portal

                     FROM qiita.portal_type

                     WHERE portal != 'QIITA'

                     ORDER BY portal"""

            qdb.sql_connection.TRN.add(sql)

            return qdb.sql_connection.TRN.execute_fetchflatten()

    @classmethod

    def create(cls, portal, desc):

        """Creates a new portal and its default analyses on the system

        Parameters

        ----------

        portal : str

            The name of the portal to add

        desc : str

            Description of the portal

        Raises

        ------

        QiitaDBDuplicateError

            Portal name already exists

        """

        if cls.exists(portal):

            raise qdb.exceptions.QiitaDBDuplicateError("Portal", portal)

        # Add portal and default analyses for all users

        sql = """DO $do$

            DECLARE

                pid bigint;

                eml varchar;

                aid bigint;

            BEGIN

                INSERT INTO qiita.portal_type (portal, portal_description)

                VALUES (%s, %s)

                RETURNING portal_type_id INTO pid;

                FOR eml IN

                    SELECT email FROM qiita.qiita_user

                LOOP

                    INSERT INTO qiita.analysis

                        (email, name, description, dflt)

                    VALUES (eml, eml || '-dflt', 'dflt', true)

                    RETURNING analysis_id INTO aid;

                    INSERT INTO qiita.analysis_portal

                        (analysis_id, portal_type_id)

                    VALUES (aid, pid);

                END LOOP;

            END $do$;"""

        qdb.sql_connection.perform_as_transaction(sql, [portal, desc])

        return cls(portal)

    @staticmethod

    def delete(portal):

        """Removes a portal and its default analyses from the system

        Parameters

        ----------

        portal : str

            The name of the portal to add

        Raises

        ------

        QiitaDBError

            Portal has analyses or studies attached to it

        """

        with qdb.sql_connection.TRN:

            # Check if attached to any studies

            portal_id = qdb.util.convert_to_id(portal, 'portal_type', 'portal')

            sql = """SELECT study_id

                     FROM qiita.study_portal

                     WHERE portal_type_id = %s"""

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

            studies = qdb.sql_connection.TRN.execute_fetchflatten()

            if studies:

                raise qdb.exceptions.QiitaDBError(

                    " Cannot delete portal '%s', studies still attached: %s" %

                    (portal, ', '.join(map(str, studies))))

            # Check if attached to any analyses

            sql = """SELECT analysis_id

                     FROM qiita.analysis_portal

                        JOIN qiita.analysis USING (analysis_id)

                     WHERE portal_type_id = %s AND dflt = FALSE"""

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

            analyses = qdb.sql_connection.TRN.execute_fetchflatten()

            if analyses:

                raise qdb.exceptions.QiitaDBError(

                    " Cannot delete portal '%s', analyses still attached: %s" %

                    (portal, ', '.join(map(str, analyses))))

            # Remove portal and default analyses for all users

            sql = """DO $do$

                DECLARE

                    aid bigint;

                BEGIN

                    FOR aid IN

                        SELECT analysis_id

                        FROM qiita.analysis_portal

                            JOIN qiita.analysis USING (analysis_id)

                        WHERE portal_type_id = %s AND dflt = True

                    LOOP

                        DELETE FROM qiita.analysis_portal

                        WHERE analysis_id = aid;

                        DELETE FROM qiita.analysis_sample

                        WHERE analysis_id = aid;

                        DELETE FROM qiita.analysis

                        WHERE analysis_id = aid;

                    END LOOP;

                    DELETE FROM qiita.portal_type WHERE portal_type_id = %s;

                END $do$;"""

            qdb.sql_connection.TRN.add(sql, [portal_id] * 2)

            qdb.sql_connection.TRN.execute()

    @staticmethod

    def exists(portal):

        """Returns whether the portal name already exists on the system

        Parameters

        ----------

        portal : str

            Name of portal to check

        Returns

        -------

        bool

            Whether the portal exists or not

        """

        try:

            qdb.util.convert_to_id(portal, 'portal_type', 'portal')

        except qdb.exceptions.QiitaDBLookupError:

            return False

        else:

            return True

    def get_studies(self):

        """Returns all studies belonging to the portal

        Returns

        -------

        set of qiita_db.study.Study

            All studies attached to the portal

        """

        with qdb.sql_connection.TRN:

            sql = """SELECT study_id

                     FROM qiita.study_portal

                     WHERE portal_type_id = %s"""

            qdb.sql_connection.TRN.add(sql, [self._id])

            return set(

                qdb.study.Study(sid)

                for sid in qdb.sql_connection.TRN.execute_fetchflatten())

    def _check_studies(self, studies):

        with qdb.sql_connection.TRN:

            # Check if any study IDs given do not exist.

            sql = "SELECT study_id FROM qiita.study WHERE study_id IN %s"

            qdb.sql_connection.TRN.add(sql, [tuple(studies)])

            existing = qdb.sql_connection.TRN.execute_fetchflatten()

            if len(existing) != len(list(studies)):

                bad = map(str, set(studies).difference(existing))

                raise qdb.exceptions.QiitaDBError(

                    "The following studies do not exist: %s" % ", ".join(bad))

    def add_studies(self, studies):

        """Adds studies to given portal

        Parameters

        ----------

        studies : iterable of int

            Study ids to attach to portal

        Raises

        ------

        QiitaDBError

            Some studies given do not exist in the system

        QiitaDBWarning

            Some studies already exist in the given portal

        """

        with qdb.sql_connection.TRN:

            self._check_studies(studies)

            # Clean list of studies down to ones not associated

            # with portal already

            sql = """SELECT study_id

                     FROM qiita.study_portal

                     WHERE portal_type_id = %s AND study_id IN %s"""

            qdb.sql_connection.TRN.add(sql, [self._id, tuple(studies)])

            duplicates = qdb.sql_connection.TRN.execute_fetchflatten()

            if len(duplicates) > 0:

                warnings.warn(

                    "The following studies are already part of %s: %s"

                    % (self.portal, ', '.join(map(str, duplicates))),

                    qdb.exceptions.QiitaDBWarning)

            # Add cleaned list to the portal

            clean_studies = set(studies).difference(duplicates)

            sql = """INSERT INTO qiita.study_portal (study_id, portal_type_id)

                     VALUES (%s, %s)"""

            if len(clean_studies) != 0:

                qdb.sql_connection.TRN.add(

                    sql, [[s, self._id] for s in clean_studies], many=True)

            qdb.sql_connection.TRN.execute()

    def remove_studies(self, studies):

        """Removes studies from given portal

        Parameters

        ----------

        studies : iterable of int

            Study ids to remove from portal

        Raises

        ------

        ValueError

            Trying to delete from QIITA portal

        QiitaDBError

            Some studies given do not exist in the system

            Some studies are already used in an analysis on the portal

        QiitaDBWarning

            Some studies already do not exist in the given portal

        """

        if self.portal == "QIITA":

            raise ValueError('Can not remove from main QIITA portal!')

        with qdb.sql_connection.TRN:

            self._check_studies(studies)

            # Make sure study not used in analysis in portal

            sql = """SELECT DISTINCT study_id

                     FROM qiita.study_artifact

                        JOIN qiita.analysis_sample USING (artifact_id)

                        JOIN qiita.analysis_portal USING (analysis_id)

                     WHERE portal_type_id = %s AND study_id IN %s"""

            qdb.sql_connection.TRN.add(sql, [self.id, tuple(studies)])

            analysed = qdb.sql_connection.TRN.execute_fetchflatten()

            if analysed:

                raise qdb.exceptions.QiitaDBError(

                    "The following studies are used in an analysis on portal "

                    "%s and can't be removed: %s"

                    % (self.portal, ", ".join(map(str, analysed))))

            # Clean list of studies down to ones associated with portal already

            sql = """SELECT study_id

                     FROM qiita.study_portal

                     WHERE portal_type_id = %s AND study_id IN %s"""

            qdb.sql_connection.TRN.add(sql, [self._id, tuple(studies)])

            clean_studies = qdb.sql_connection.TRN.execute_fetchflatten()

            if len(clean_studies) != len(studies):

                rem = map(str, set(studies).difference(clean_studies))

                warnings.warn(

                    "The following studies are not part of %s: %s"

                    % (self.portal, ', '.join(rem)),

                    qdb.exceptions.QiitaDBWarning)

            sql = """DELETE FROM qiita.study_portal

                     WHERE study_id IN %s AND portal_type_id = %s"""

            if len(clean_studies) != 0:

                qdb.sql_connection.TRN.add(sql, [tuple(studies), self._id])

            qdb.sql_connection.TRN.execute()

    def get_analyses(self):

        """Returns all analyses belonging to a portal

        Returns

        -------

        set of qiita_db.analysis.Analysis

            All analyses belonging to the portal

        """

        with qdb.sql_connection.TRN:

            sql = """SELECT analysis_id

                     FROM qiita.analysis_portal

                     WHERE portal_type_id = %s"""

            qdb.sql_connection.TRN.add(sql, [self._id])

            return set(

                qdb.analysis.Analysis(aid)

                for aid in qdb.sql_connection.TRN.execute_fetchflatten())

    def _check_analyses(self, analyses):

        with qdb.sql_connection.TRN:

            # Check if any analysis IDs given do not exist.

            sql = """SELECT analysis_id

                     FROM qiita.analysis

                     WHERE analysis_id IN %s"""

            qdb.sql_connection.TRN.add(sql, [tuple(analyses)])

            existing = qdb.sql_connection.TRN.execute_fetchflatten()

            if len(existing) != len(analyses):

                bad = map(str, set(analyses).difference(existing))

                raise qdb.exceptions.QiitaDBError(

                    "The following analyses do not exist: %s" % ", ".join(bad))

            # Check if any analyses given are default

            sql = """SELECT analysis_id

                     FROM qiita.analysis

                     WHERE analysis_id IN %s AND dflt = True"""

            qdb.sql_connection.TRN.add(sql, [tuple(analyses)])

            default = qdb.sql_connection.TRN.execute_fetchflatten()

            if len(default) > 0:

                bad = map(str, set(analyses).difference(default))

                raise qdb.exceptions.QiitaDBError(

                    "The following analyses are default and can't be deleted "

                    "or assigned to another portal: %s" % ", ".join(bad))

    def add_analyses(self, analyses):

        """Adds analyses to given portal

        Parameters

        ----------

        analyses : iterable of int

            Analysis ids to attach to portal

        Raises

        ------

        QiitaDBError

            Some given analyses do not exist in the system,

            or are default analyses

            Portal does not contain all studies used in analyses

        QiitaDBWarning

            Some analyses already exist in the given portal

        """

        with qdb.sql_connection.TRN:

            self._check_analyses(analyses)

            if self.portal != "QIITA":

                # Make sure new portal has access to all studies in analysis

                sql = """SELECT DISTINCT analysis_id

                         FROM qiita.analysis_sample

                            JOIN qiita.study_artifact

                                USING (artifact_id)

                         WHERE study_id NOT IN (

                            SELECT study_id

                            FROM qiita.study_portal

                            WHERE portal_type_id = %s)

                         AND analysis_id IN %s

                         ORDER BY analysis_id"""

                qdb.sql_connection.TRN.add(sql, [self._id, tuple(analyses)])

                missing_info = qdb.sql_connection.TRN.execute_fetchflatten()

                if missing_info:

                    raise qdb.exceptions.QiitaDBError(

                        "Portal %s is mising studies used in the following "

                        "analyses: %s"

                        % (self.portal, ", ".join(map(str, missing_info))))

            # Clean list of analyses to ones not already associated with portal

            sql = """SELECT analysis_id

                     FROM qiita.analysis_portal

                        JOIN qiita.analysis USING (analysis_id)

                     WHERE portal_type_id = %s AND analysis_id IN %s

                        AND dflt != TRUE"""

            qdb.sql_connection.TRN.add(sql, [self._id, tuple(analyses)])

            duplicates = qdb.sql_connection.TRN.execute_fetchflatten()

            if len(duplicates) > 0:

                warnings.warn(

                    "The following analyses are already part of %s: %s"

                    % (self.portal, ', '.join(map(str, duplicates))),

                    qdb.exceptions.QiitaDBWarning)

            sql = """INSERT INTO qiita.analysis_portal

                        (analysis_id, portal_type_id)

                     VALUES (%s, %s)"""

            clean_analyses = set(analyses).difference(duplicates)

            if len(clean_analyses) != 0:

                qdb.sql_connection.TRN.add(

                    sql, [[a, self._id] for a in clean_analyses], many=True)

            qdb.sql_connection.TRN.execute()

    def remove_analyses(self, analyses):

        """Removes analyses from given portal

        Parameters

        ----------

        analyses : iterable of int

            Analysis ids to remove from portal

        Raises

        ------

        ValueError

            Trying to delete from QIITA portal

        QiitaDBWarning

            Some analyses already do not exist in the given portal

        """

        with qdb.sql_connection.TRN:

            self._check_analyses(analyses)

            if self.portal == "QIITA":

                raise ValueError('Can not remove from main QIITA portal!')

            # Clean list of analyses to ones already associated with portal

            sql = """SELECT analysis_id

                     FROM qiita.analysis_portal

                        JOIN qiita.analysis USING (analysis_id)

                     WHERE portal_type_id = %s AND analysis_id IN %s

                        AND dflt != TRUE"""

            qdb.sql_connection.TRN.add(sql, [self._id, tuple(analyses)])

            clean_analyses = qdb.sql_connection.TRN.execute_fetchflatten()

            if len(clean_analyses) != len(analyses):

                rem = map(str, set(analyses).difference(clean_analyses))

                warnings.warn(

                    "The following analyses are not part of %s: %s"

                    % (self.portal, ', '.join(rem)),

                    qdb.exceptions.QiitaDBWarning)

            sql = """DELETE FROM qiita.analysis_portal

                     WHERE analysis_id IN %s AND portal_type_id = %s"""

            if len(clean_analyses) != 0:

                qdb.sql_connection.TRN.add(

                    sql, [tuple(clean_analyses), self._id])

            qdb.sql_connection.TRN.execute()