#!/usr/bin/env python

from os import environ

from os.path import join, dirname, abspath, splitext

from sys import platform, version as python_version, exit, executable, stdout

from unittest import TestLoader, TextTestRunner, TestCase

from smtplib import SMTP, SMTP_SSL

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

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

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

core_dependency_missing_msg = (

    '"%s" is missing and is a core requirement, for more information see the '

    'Qiita Installation Guide: '

    'https://github.com/biocore/qiita/blob/master/INSTALL.md')

extra_info = (core_dependency_missing_msg + '. It is also possible that you '

              'have an old version of this package, if so, please update to '

              'the latest.')

dependency_missing_msg = (

    '"%s" is missing but this is _not_ a core requirement, for more '

    'information see the Qiita Installation Guide: '

    'https://github.com/biocore/qiita/blob/master/INSTALL.md')

missing_deps_errors = []

missing_deps_warnings = []

try:

    from click import __version__ as click_lib_version

except ImportError as e:

    missing_deps_errors.append((e, extra_info % 'click'))

try:

    from numpy import __version__ as numpy_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'NumPy'))

try:

    from pandas import __version__ as pandas_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'pandas'))

try:

    from tornado import version as tornado_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'tornado'))

try:

    from redis import __version__ as redis_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'redis'))

try:

    from toredis import Client as toredis_client

    toredis_client()

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'toredis'))

try:

    from redbiom import __version__ as redbiom_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'redbiom'))

try:

    from bcrypt import __version__ as bcrypt_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'bcrypt'))

try:

    from pyparsing import __version__ as pyparsing_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'pyparsing'))

try:

    from networkx import __version__ as networkx_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'networkx'))

try:

    from wtforms import __version__ as wtforms_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'wtforms'))

try:

    from mock import __version__ as mock_lib_version

except ImportError as e:

    missing_deps_warnings.append((e, dependency_missing_msg % 'mock'))

    mock_lib_version = 'Not installed'

try:

    from psycopg2 import __version__ as psycopg2_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'psycopg2'))

try:

    from qiita_core import __version__ as qiita_core_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_core'))

try:

    from qiita_db import __version__ as qiita_db_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_db'))

try:

    from qiita_pet import __version__ as qiita_pet_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_pet'))

try:

    from qiita_ware import __version__ as qiita_ware_lib_version

except ImportError as e:

    missing_deps_errors.append((e, core_dependency_missing_msg % 'qiita_ware'))

try:

    from qiita_core.configuration_manager import ConfigurationManager

    ConfigurationManager()

except Exception as e:

    missing_deps_errors.append((e, 'You need to add to your enviroment '

                                'the Qiita configuration using '

                                'QIITA_CONFIG_FP'))

if missing_deps_errors:

    for e, t in missing_deps_errors:

        print('%s\n=============' % (t))

    exit('Missing core dependencies, can not continue.')

if missing_deps_warnings:

    for e, t in missing_deps_errors:

        print('%s\n=============' % (t))

# trick flake8 to not complain about module-level imports not being at the top

# of the file. These imports can only really happen if none of the core

# dependencies are missing

if True:

    from qiita_db.sql_connection import TRN

    from redis import StrictRedis

class QiitaConfig(TestCase):

    def setUp(self):

        self.config = ConfigurationManager()

        try:

            with TRN:

                TRN.add("SELECT version()")

                self.psql_version = TRN.execute_fetchflatten()[0]

        except Exception:

            self.psql_version = None

        try:

            r = StrictRedis(

                host=self.config.redis_host,

                password=self.config.redis_password,

                port=self.config.redis_port,

                db=self.config.redis_db)

            self.redis_version = r.info()['redis_version']

        except Exception:

            self.redis_version = None

    def test_pandas_library_version(self):

        acceptable_version = (0, 15)

        string_acceptable_version = '.'.join(map(str, acceptable_version))

        version = tuple(map(int, pandas_lib_version.split('.')))

        self.assertTrue(acceptable_version <= version,

                        'Unsupported pandas version. You have %s but the '

                        'minimum required version is %s'

                        % (pandas_lib_version, string_acceptable_version))

    def test_torando_library_version(self):

        acceptable_version = (3, 1, 1)

        string_acceptable_version = '.'.join(map(str, acceptable_version))

        version = tuple(map(int, tornado_lib_version.split('.')))

        self.assertTrue(acceptable_version <= version,

                        'Unsupported tornado version. You have %s but the '

                        'minimum required version is %s'

                        % (tornado_lib_version, string_acceptable_version))

    def test_pyparsing_library_version(self):

        acceptable_version = (2, 0, 2)

        string_acceptable_version = '.'.join(map(str, acceptable_version))

        version = tuple(map(int, pyparsing_lib_version.split('.')))

        self.assertTrue(acceptable_version <= version,

                        'Unsupported pyparsing version. You have %s but the '

                        'minimum required version is %s'

                        % (pyparsing_lib_version, string_acceptable_version))

    def test_wtforms_library_version(self):

        acceptable_version = (2, 0, 1)

        string_acceptable_version = '.'.join(map(str, acceptable_version))

        version = tuple(map(int, wtforms_lib_version.split('.')))

        self.assertTrue(acceptable_version <= version,

                        'Unsupported WTForms version. You have %s but the '

                        'minimum required version is %s'

                        % (wtforms_lib_version, string_acceptable_version))

    def test_postgresql_version(self):

        if not self.psql_version:

            self.assertTrue(False, 'PostgreSQL not running or configured')

        acceptable_version = (9, 3, 0)

        string_acceptable_version = '.'.join(map(str, acceptable_version))

        version = tuple(map(int, self.psql_version.split(' ')[1].split('.')))

        self.assertTrue(acceptable_version <= version,

                        'Unsupported PostgreSQL version. You have %s but the '

                        'minimum required version is %s'

                        % ('.'.join(map(str, version)),

                           string_acceptable_version))

    def test_redis_version(self):

        if not self.redis_version:

            self.assertTrue(False, 'redis not running or configured')

        acceptable_version = (2, 8, 17)

        string_acceptable_version = '.'.join(map(str, acceptable_version))

        version = tuple(map(int, self.redis_version.split('.')))

        self.assertTrue(acceptable_version <= version,

                        'Unsupported redis version. You have %s but the '

                        'minimum required version is %s'

                        % ('.'.join(map(str, version)),

                           string_acceptable_version))

    def test_redbiom_version(self):

        acceptable_version = (0, 3, 8)

        string_acceptable_version = '.'.join(map(str, acceptable_version))

        version = tuple(map(int, redbiom_lib_version.split('.')))

        self.assertTrue(acceptable_version <= version,

                        'Unsupported redbiom version. You have %s but the '

                        'minimum required version is %s'

                        % ('.'.join(map(str, version)),

                           string_acceptable_version))

system_info_header = """

System information

==================

"""

dependency_info_header = """

Dependency versions

===================

"""

qiita_config_header = """

Qiita config

============

For definitions of these settings and to learn how to configure Qiita, visit:

 https://github.com/biocore/qiita/blob/master/INSTALL.md#install

"""

qiita_config_tests_header = """

Qiita version and configuration tests

=====================================

"""

qiita_plugins_header = """

Qiita plugins

=============

"""

def main():

    system_info = [

        ("Platform", platform),

        ("Python version", python_version.replace('\n', ' ')),

        ("Python executable", executable)]

    max_len = max([len(e[0]) for e in system_info])

    print(system_info_header)

    for v in system_info:

        print("%*s:\t%s" % (max_len, v[0], v[1]))

    with TRN:

        TRN.add("SELECT current_patch FROM settings")

        current_patch = TRN.execute_fetchflatten()[0]

    qiita_db_patch_number = splitext(current_patch)[0]

    # Getting required environment variables

    if 'REDBIOM_HOST' in environ:

        redbiom_host = environ['REDBIOM_HOST']

    else:

        redbiom_host = None

    version_info = [

        ('click library version', click_lib_version),

        ('numpy library version', numpy_lib_version),

        ('pandas library version', pandas_lib_version),

        ('tornado library version', tornado_lib_version),

        ('redis library version', redis_lib_version),

        ('redbiom library version', '%s - host: %s' % (

            redbiom_lib_version, redbiom_host)),

        ('bcrypt library version', bcrypt_lib_version),

        ('pyparsing library version', pyparsing_lib_version),

        ('networkX library version', networkx_lib_version),

        ('WTForms library version', wtforms_lib_version),

        ('mock library version', mock_lib_version),

        ('psycopg2 library version', psycopg2_lib_version),

        ('Qiita core library version', qiita_core_lib_version),

        ('Qiita db library version', qiita_db_lib_version),

        ('Qiita db patch number', qiita_db_patch_number),

        ('Qiita pet library version', qiita_pet_lib_version),

        ('Qiita ware library version', qiita_ware_lib_version)

    ]

    max_len = max([len(e[0]) for e in version_info])

    print(dependency_info_header)

    for v in version_info:

        print("%*s:\t%s" % (max_len, v[0], v[1]))

    extra_info = None

    qiita_config = ConfigurationManager()

    try:

        qiita_conf_fp = environ['QIITA_CONFIG_FP']

    except KeyError:

        qiita_conf_fp = join(dirname(abspath(__file__)),

                             'support_files/config_test.cfg')

    smtp = SMTP_SSL() if qiita_config.smtp_ssl else SMTP()

    smtp.set_debuglevel(False)

    try:

        smtp.connect(qiita_config.smtp_host, qiita_config.smtp_port)

        smtp.verify

        send_email = True

    except Exception:

        send_email = False

    ebi_credentials = (qiita_config.ebi_center_name != '' and

                       qiita_config.ebi_dropbox_url != '' and

                       qiita_config.ebi_organization_prefix != '' and

                       qiita_config.ebi_seq_xfer_pass != '' and

                       qiita_config.ebi_seq_xfer_url != '' and

                       qiita_config.ebi_seq_xfer_user != '')

    vamps_credentials = (qiita_config.vamps_pass != '' and

                         qiita_config.vamps_url != '' and

                         qiita_config.vamps_user != '')

    try:

        with TRN:

            psql_running = True

    except Exception:

        psql_running = False

    try:

        StrictRedis(

            host=qiita_config.redis_host,

            password=qiita_config.redis_password,

            port=qiita_config.redis_port,

            db=qiita_config.redis_db)

        redis_running = True

    except Exception:

        redis_running = False

    try:

        StrictRedis(

             host=qiita_config.redbiom_redis_host,

             password=qiita_config.redbiom_redis_password,

             port=qiita_config.redbiom_redis_port,

             db=qiita_config.redbiom_redis_db)

        redbiom_redis_running = True

    except Exception:

        redbiom_redis_running = False

    print(qiita_config_header)

    qiita_config_info = [

        ('QIITA_CONFIG_FP filepath', qiita_conf_fp),

        ('Test environment', str(qiita_config.test_environment)),

        ('Base URL', qiita_config.base_url),

        ('EBI credentials exist', ebi_credentials),

        ('VAMPS credentials exist', vamps_credentials),

        ('Can the system send emails?', str(send_email) + '. When true, '

         'emails could still not be going out due to your network '

         'configuration.'),

        ('Valid file extensions for upload', ', '.join(

         qiita_config.valid_upload_extension)),

        ('PostgreSQL is up and configuration can connect?', psql_running),

        ('Redis is up and configuracion can connect?',

            redis_running if not redis_running else '%s --port %d' % (

                redis_running, qiita_config.redis_port)),

        ('Redbiom redis is up and configuracion can connect?',

            redbiom_redis_running if not redbiom_redis_running else

            '%s --port %d' % (redbiom_redis_running,

                              qiita_config.redbiom_redis_port)),

        ('Extra info', extra_info)

    ]

    max_len = max([len(e[0]) for e in qiita_config_info])

    for v in qiita_config_info:

        if v != ('Extra info', None):

            print("%*s:\t%s" % (max_len, v[0], v[1]))

    print(qiita_plugins_header)

    if not psql_running:

        print("PostgreSQL not running, can't retrieve plugin information")

    else:

        try:

            import qiita_db as qdb

            with qdb.sql_connection.TRN:

                sql = """SELECT name, version, client_id, client_secret

                         FROM qiita.software

                            JOIN qiita.oauth_software USING (software_id)

                            JOIN qiita.oauth_identifiers USING (client_id)"""

                qdb.sql_connection.TRN.add(sql)

                res = qdb.sql_connection.TRN.execute_fetchindex()

                for name, version, client_id, client_secret in res:

                    print("Plugin name: %s" % name)

                    print("\tVersion: %s" % version)

                    print("\tClient id: %s" % client_id)

                    print("\tClient secret: %s" % client_secret)

        except Exception as e:

            print("An error occurred while retrieving plugin information: %s"

                  % str(e))

    print(qiita_config_tests_header)

    suite = TestLoader().loadTestsFromTestCase(QiitaConfig)

    TextTestRunner(stream=stdout, verbosity=1).run(suite)

if __name__ == "__main__":

    main()