# coding=utf-8

# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2019 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT

from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
import logging
import os
import pwd
import json

from typing import AnyStr, Optional  # NOQA
from future.utils import iteritems

import secureio

from clselect.utils import get_abs_rel, run_process_in_cagefs
from clcommon.clpwd import drop_privileges
from clselect.baseclselect import (
    BaseSelectorError,
    MissingVirtualenvError,
    MissingAppRootError,
)

from clselect.clpassenger import WSGI_PATH
from clselect import ClSelectExcept, clpassenger, clselectctl
from clselect.baseclselect.apps_manager import BaseApplicationsManager
from clselect.clselectpython.python_manager import PythonManager


class PythonAppFormatVersion(object):
    """
    Class represents possible python application versions.
    """
    # application that was created in old selector
    # does not support version change and env variables
    LEGACY = 1
    # new application, supports all selector features
    STABLE = 2


class PythonVenvFormatVersion(object):
    """
    Class represents possible python application venv path versions.
    """
    # venv that was created in old selector
    # and was transformed like 'app/test_1' -> 'app_test__1'
    LEGACY = 1
    # any application (old & new) that does not contain
    # replacements in venv path
    STABLE = 2


class ApplicationsManager(BaseApplicationsManager):
    _USER_CONFIG = '.cl.selector/python-selector.json'
    _IMPORT_STATUS_ADMIN = '/var/lve/.py.migration.status'
    _IMPORT_STATUS_USER = '.cl.selector/.py.migration.status'
    _IMPORT_LOG_FILE = '/var/log/cloudlinux/py-selector/app_imports.log'
    _IMPORT_REQUIREMENTS_FILE = 'imported_pip_requirements.txt'
    INTERPRETER = 'python'
    VENV_DIR = 'virtualenv'
    BINARY_NAME = 'python'

    def __init__(self):
        super(ApplicationsManager, self).__init__(PythonManager())

    # TODO: replace with real implementation (LVEMAN-1324)
    def _find_config_files(self, user_name, app_directory, patterns=()):

        return super(ApplicationsManager, self)._find_config_files(user_name, app_directory, patterns=patterns)

    @staticmethod
    def get_interpreter_specific_passenger_lines(binary_path, app_config):
        """
        Return lines for htaccess that are specific to the python interpreter
        :param binary_path: path to the environment's python binary
        :param app_config: application's config dictionary
        """
        specific_lines = ['PassengerPython "{}"\n'.format(binary_path)]
        return specific_lines

    def _get_legacy_applications(self, user, logger):
        """
        Search server for old applications (created in old python selector)
        and add them to new config.
        :param user: user to search applications
        :param logger: logger to write messages to
        :return: tuple(list[applications], list[errors])
        """
        from clselect.clselectctlpython import WSGI_PATTERN
        applications = {}
        errors = {}

        user_config_data = self.get_user_config_data(user)
        for directory, data in iteritems(clpassenger.summary(user)):
            if data['interpreter'] != self.INTERPRETER:
                continue
            # noinspection PyBroadException
            try:
                app_wsgi = os.path.join(data['directory'], clpassenger.WSGI_PATH)
                # skip app if wsgi file was not found
                if not os.path.isfile(app_wsgi):
                    logger.warning('Application %s was skipped during import, because wsgi file was not found',
                                   directory)
                    continue
                with open(app_wsgi) as f:
                    wsgi_conf = f.read()
                match = WSGI_PATTERN.search(wsgi_conf)
                if match:
                    groupdict = match.groupdict()
                    wsgi_path = groupdict['script']
                    callable_object = groupdict['callable']
                else:
                    wsgi_path = callable_object = ''

                py_version = os.path.basename(os.path.dirname(
                    os.path.dirname(data['binary'])))
                domain = data['domains'][0]

                # LVEMAN-1502. if application already present in apps list use its app_version
                try:
                    app_ver = user_config_data[directory][u'app_version']
                except KeyError:
                    app_ver = PythonAppFormatVersion.LEGACY

                app_info = {
                    u'python_version': py_version,
                    u'app_version': app_ver,
                    u'domain': domain,
                    u'app_uri': data['alias'],
                    u'app_status': 'started',
                    u'startup_file': wsgi_path or WSGI_PATH,
                    u'config_files': [],
                    u'env_vars': {},
                    u'entry_point': callable_object or 'application'
                }

                applications[directory] = app_info
            except Exception:
                logger.exception('Unable to import application %s', directory)
                errors.setdefault(directory, []).append(
                    'Unexpected issue during application "%s" import. '
                    'Your python app will work as before, but you wo\'t be able '
                    'to control it from Python Selector UI. Please, ask your system '
                    'administrator to contact CloudLinux support '
                    'to resolve this issue.' % directory
                )
                continue

        return applications, errors

    def _setup_import_logger(self):
        """
        Setup logger for application import.
        """
        app_logger = logging.getLogger('import_apps')
        app_logger.setLevel(logging.DEBUG)
        fh = logging.FileHandler(self._IMPORT_LOG_FILE)
        fh.formatter = logging.Formatter(
            '[%(levelname)s | %(asctime)s]: %(message)s')
        cl = logging.StreamHandler()
        cl.setLevel(logging.INFO)
        app_logger.addHandler(fh)
        # app_logger.addHandler(cl)
        return app_logger

    def import_legacy_applications_to_config(self, user=None):
        """
        Scan users for legacy applications (created by old python selector)
        and import them into config file. Done automatically by spec file.
        """
        app_logger = self._setup_import_logger()

        users_info = self.get_users_dict(user)
        logging.debug('Start applications import for users %s', list(users_info.keys()))
        failed_users = []
        skipped_users_count = 0
        apps_errors = None

        for user, pw in iteritems(users_info):
            # Skip user if '.cl.selector' directory absent in his homedir
            cl_selector_dir = os.path.join(pw.pw_dir, '.cl.selector')
            if not os.path.isdir(cl_selector_dir):
                skipped_users_count += 1
                app_logger.warning('User %s is skipped due to %s directory absent' % (user, cl_selector_dir))
                continue
            app_logger.info('Importing user %s', user)

            try:
                # disable quota here, because clpassanger.summary creates htaccess_cache file
                # see clpassenger._summary for details. Will be fixed in LVEMAN-1524
                with drop_privileges(user), secureio.disable_quota():
                    try:
                        config = self.read_user_selector_config_json(
                            pw.pw_dir, pw.pw_uid, pw.pw_gid)
                    except BaseSelectorError:
                        config = {}

                    # take applications from clpassanger.summary and import them
                    apps, apps_errors = self._get_legacy_applications(user, app_logger)
                    if not apps:
                        continue

                for app_root, app_config in iteritems(apps):
                    if app_root in config:
                        # save fields that were probably set before
                        app_config['config_files'] = config[app_root]['config_files']
                        app_config['env_vars'] = config[app_root]['env_vars']

                    # generate pip requirements file for each legacy app
                    self.generate_pip_requirements(user, app_root, app_logger)
                    requirements_file = os.path.join(pw.pw_dir, app_root, self._IMPORT_REQUIREMENTS_FILE)
                    if os.path.isfile(requirements_file) and \
                            self._IMPORT_REQUIREMENTS_FILE not in app_config['config_files']:
                        # add this newly generated pip requirements file to config files
                        app_config['config_files'].append(self._IMPORT_REQUIREMENTS_FILE)

                    config[app_root] = app_config

                # case when hoster downgraded package for some time
                # and user destroyed some of applications
                # we should remove them from config file
                destroyed_apps = set(config.keys()) - set(apps.keys())
                for app_root in destroyed_apps:
                    config.pop(app_root)

                with drop_privileges(user), secureio.disable_quota():
                    self.write_full_user_config_data(user, config)
                    self._set_user_legacy_import_status(pw, is_import_failed=False, apps_errors=apps_errors)
            except Exception as e:
                import_error = 'Unable to import user `%s` to new python selector. ' + \
                               'Already created applications work as before, ' + \
                               'but user won\'t be able to manage them. Error is: `%s`'
                app_logger.exception(import_error, user, e)
                with drop_privileges(user), secureio.disable_quota():
                    self._set_user_legacy_import_status(pw, is_import_failed=True, apps_errors=apps_errors)
                failed_users.append(user)

        self._set_admin_legacy_import_status(failed_users)
        if skipped_users_count != 0:
            app_logger.warning('Some users skipped... see import log')

    def _get_legacy_import_status(self, user=None):
        """
        Read import log which contains information about
        failed users or apps depending on current user.
        """
        if user is None:
            if not os.path.exists(self._IMPORT_STATUS_ADMIN):
                return None

            with open(self._IMPORT_STATUS_ADMIN) as f:
                return json.load(f)
        else:
            user_pw = pwd.getpwnam(user)
            marker = os.path.join(user_pw.pw_dir, self._IMPORT_STATUS_USER)
            if not os.path.isfile(marker):
                return

            with open(marker) as f:
                return json.load(f)

    def _set_user_legacy_import_status(self, user_pw, is_import_failed, apps_errors):
        """
        Save information that some applications were not imported automatically
        to show warning for user in the future.
        """
        if not os.path.exists(os.path.join(user_pw.pw_dir, '.cl.selector')):
            return
        try:
            marker = os.path.join(user_pw.pw_dir, self._IMPORT_STATUS_USER)
            secureio.write_file_via_tempfile(json.dumps({
                'is_import_failed': is_import_failed,
                'apps_lookup_failed': apps_errors
            }), marker, 0o600)
        except (IOError, OSError):
            # sad, but not critical, go further
            logging.exception('Unable to save migration status file')

    def _set_admin_legacy_import_status(self, failed_users):
        """
        Save information that some users were not imported automatically
        to show warning for admin in the future.
        """
        packed = json.dumps({'failed_users': failed_users})
        secureio.write_file_via_tempfile(packed, self._IMPORT_STATUS_ADMIN, 0o600)

    def _get_admin_legacy_import_warning(self):
        config = self._get_legacy_import_status()

        if config is None or not config['failed_users']:
            return None
        warning_msg = 'Unexpected issue(s) happened during importing python ' \
                      'applications for the following users: "{users}". ' \
                      'Everything will work as before, but listed users wo\'t be able ' \
                      'to control applications from Python Selector UI. ' \
                      'Please, contact CloudLinux support and send them log file located at ' \
                      '`{log_file_path}` to investigate and ' \
                      'resolve this issue. Also you can hide this warning ' \
                      'by deleting `{import_warning_marker}` file' \
                      ''.format(users=','.join(config['failed_users']),
                                log_file_path=self._IMPORT_LOG_FILE,
                                import_warning_marker=self._IMPORT_STATUS_ADMIN)
        return warning_msg

    def _get_user_legacy_import_warning(self, username):
        config = self._get_legacy_import_status(user=username)
        if config is None:
            return None

        what_to_do_msg = \
            'Everything will work as before, but you won\'t be able to control ' \
            'listed applications from Python Selector UI. ' \
            'Please, ask you hoster to contact CloudLinux support ' \
            'to investigate and ' \
            'resolve this issue.\nAlso you can hide this warning ' \
            'by deleting `~/{import_warning_marker}` file.' \
            ''.format(import_warning_marker=self._IMPORT_STATUS_USER)

        if config['is_import_failed']:
            return 'Unexpected issue(s) happened during importing python ' \
                   'applications. ' \
                   '%s' % what_to_do_msg
        elif config['apps_lookup_failed']:
            return 'Unexpected issue(s) happened during importing following python ' \
                   'applications: "%s". ' \
                   '%s' % (','.join(config['apps_lookup_failed']), what_to_do_msg)
        return None

    def _get_legacy_import_warning_or_none(self, user=None):
        if user is None:
            return self._get_admin_legacy_import_warning()
        else:
            return self._get_user_legacy_import_warning(user)

    def migrate_application(self, user, app_root):
        """
        Update environment of specific application to support
        features of new python selector
        """
        from clselect.clselectctlpython import _get_environment
        application = self.get_app_config(user, app_root)
        if application is None:
            raise ClSelectExcept.WrongData("Application %s does not exist" % app_root)

        if application['app_version'] == PythonAppFormatVersion.STABLE:
            raise ClSelectExcept.WrongData(
                "Application %s is already new version "
                "and does not need any updates" % app_root)

        environment = _get_environment(user, app_root, apps_manager=self)
        try:
            environment.configure_environment(auto_restore=True)
        except Exception as e:
            raise ClSelectExcept.WrongData(
                "Unable to migrate application %s. "
                "Error is '%s', everything restored to work as before migration. "
                "Try again later or ask your hoster "
                "to contact CloudLinux support if the issue persists."
                "" % (app_root, e))

        application['app_version'] = PythonAppFormatVersion.STABLE
        self.add_app_to_config(user, app_root, application)

    def get_applications_users_info(self, user=None):
        result = super(ApplicationsManager, self). \
            get_applications_users_info(user)
        warning = self._get_legacy_import_warning_or_none(user)
        if warning is not None:
            result['warning'] = warning
        return result

    def generate_pip_requirements(self, user, app_root, app_logger):
        # type: (AnyStr, AnyStr, logging.Logger) -> Optional[AnyStr]
        """
        Generates requirements file from python apps
        :param user: username
        :param app_root: app root
        :param app_logger: app logger
        """
        app_path, _ = get_abs_rel(user, app_root)
        req_path = os.path.join(app_path, self._IMPORT_REQUIREMENTS_FILE)
        if os.path.exists(req_path):
            return

        from clselect.clselectctlpython import _get_environment
        with drop_privileges(user):
            environment = _get_environment(
                user, app_root, apps_manager=self)

            pip_path = environment.pip()
        user_home = pwd.getpwnam(user).pw_dir
        env_vars = {'HOME': user_home}

        modules = ''
        # need to pass users home as env var directly during running as user
        result = run_process_in_cagefs(user, pip_path, ['freeze', '-l'], env_vars=env_vars)
        if result['returncode'] != 0:
            app_logger.warning('Error during generation pip requirements file. ' + str(result['output']))
            # like in `check_output`
            raise ClSelectExcept.ExternalProgramFailed(result['output'])
        elif not result['failed']:
            modules = result['output']

        # write stdout to file with disabled quota
        with drop_privileges(user), secureio.disable_quota():
            f = open(req_path, 'w')
            f.write(modules)
            f.close()

    def get_app_folders(self, username, app_root, chk_env=True, chk_app_root=True):
        """
        Calculate, check exists and return application folders
        This method does not check that application exists in config.
        :raises: NoSuchUserException, MissingVirtualenvError, MissingAppRootError
        :return: tuple(app_root, app_venv) with absolute paths
        """
        user_home = self._pwd.get_pw_by_name(username).pw_dir
        _, rel_path = get_venv_rel_path(username, app_root)
        app_venv = os.path.join(user_home, rel_path)
        if chk_env and not os.path.exists(app_venv):
            raise MissingVirtualenvError(app_venv)

        app_root = os.path.join(user_home, app_root)
        if chk_app_root and not os.path.exists(app_root):
            raise MissingAppRootError(app_root)

        return app_root, app_venv

    def get_binary_path(self, user, app_root, user_dir, binary_name=None):
        """
        Return a path to the environment's interpreter binary
        Get interpreter path for application
        :param user: owner of the application
        :param app_root: app path relative to user home (app-root)
        :param user_dir: User's home directory
        :param binary_name: name of binary in virtual environemnt (python, npm, node)
        :return: path to interpreter binary in virtual environment
        """
        version = self.get_interpreter_version_for_app(user, app_root)
        if binary_name is None:
            binary_name = self.BINARY_NAME
        _, rel_path = get_venv_rel_path(user, app_root)
        return os.path.join(user_dir, rel_path, version, 'bin', binary_name)


# TODO: we definitely should refactor this one time
def get_venv_rel_path(user, directory, version=None):
    """
    Get path to users VENV relative to home dir.
    Old python selector transforms app_root using get_prefix() method
    before creating venv directory. We should handle both cases:
     - when app is from old selector
     - when app is from new selector
    and return right env directory.
    If both old and new vevns exist we use old one.
    Return tuple with two values:
    - detected version of venv path (LEGACY for
      path with replacements "/" -> "_" & "_" => "__"
      and STABLE in other case)
    - path to venv relative to user's home dir
    """
    _, new_rel_dir = get_abs_rel(user, os.path.join(ApplicationsManager.VENV_DIR, directory))
    old_abs_dir, old_rel_dir = get_abs_rel(
        user, os.path.join(ApplicationsManager.VENV_DIR, clselectctl.get_prefix(directory)))
    if version is None:
        if os.path.exists(old_abs_dir) and directory != clselectctl.get_prefix(directory):
            return PythonVenvFormatVersion.LEGACY, old_rel_dir
        return PythonVenvFormatVersion.STABLE, new_rel_dir
    elif version == PythonVenvFormatVersion.LEGACY:
        return PythonVenvFormatVersion.LEGACY, old_rel_dir
    elif version == PythonVenvFormatVersion.STABLE:
        return PythonVenvFormatVersion.STABLE, new_rel_dir
    else:
        raise ValueError("unknown version `%s`" % version)