# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import configparser

import functools

import logging.config

import os

import re

import sys

import click

import paste.deploy

import kallithea

import kallithea.config.application

# kallithea_cli is usually invoked through the 'kallithea-cli' wrapper script

# that is installed by setuptools, as specified in setup.py console_scripts

# entry_points. The script will be using the right virtualenv (if any), and for

# Unix, it will contain #! pointing at the right python executable. The script

# also makes sure sys.argv[0] points back at the script path, and that is what

# can be used to invoke 'kallithea-cli' later.

kallithea_cli_path = sys.argv[0]

def read_config(ini_file_name, strip_section_prefix):

    """Read ini_file_name content, and for all sections like '[X:Y]' where X is

    strip_section_prefix, replace the section name with '[Y]'."""

    def repl(m):

        if m.group(1) == strip_section_prefix:

            return '[%s]' % m.group(2)

        return m.group(0)

    with open(ini_file_name) as f:

        return re.sub(r'^\[([^:]+):(.*)]', repl, f.read(), flags=re.MULTILINE)

# This placeholder is the main entry point for the kallithea-cli command

@click.group(context_settings=dict(help_option_names=['-h', '--help']))

def cli():

    """Various commands to manage a Kallithea instance."""

def register_command(needs_config_file=False, config_file_initialize_app=False, hidden=False):

    """Register a kallithea-cli subcommand.

    If one of the needs_config_file flags are true, a config file must be specified

    with -c and it is read and logging is configured. The configuration is

    available in the kallithea.CONFIG dict.

    If config_file_initialize_app is true, Kallithea, TurboGears global state

    (including tg.config), and database access will also be fully initialized.

    """

    cli_command = cli.command(hidden=hidden)

    if needs_config_file or config_file_initialize_app:

        def annotator(annotated):

            @click.option('--config_file', '-c', help="Path to .ini file with app configuration.",

                type=click.Path(dir_okay=False, exists=True, readable=True), required=True)

            @functools.wraps(annotated) # reuse meta data from the wrapped function so click can see other options

            def runtime_wrapper(config_file, *args, **kwargs):

                path_to_ini_file = os.path.realpath(config_file)

                cp = configparser.ConfigParser(strict=False)

                cp.read_string(read_config(path_to_ini_file, strip_section_prefix=annotated.__name__))

                logging.config.fileConfig(cp,

                    {'__file__': path_to_ini_file, 'here': os.path.dirname(path_to_ini_file)})

                if config_file_initialize_app:

                    if needs_config_file:  # special case for db creation: also call annotated function (with config parameter) *before* app initialization

                return annotated(*args, **kwargs)

            return cli_command(runtime_wrapper)

        return annotator

    return cli_command

    Register that changes have been added to the repo - log the action *and* invalidate caches.

    Called from Mercurial changegroup.kallithea_log_push_action calling hook log_push_action,

    or from the Git post-receive hook calling handle_git_post_receive ...

    or from scm _handle_push.

    """

    ex = get_hook_environment()

    action = '%s:%s' % (ex.action, ','.join(revs))

    action_logger(ex.username, action, ex.repository, ex.ip, commit=True)

    from kallithea.model.scm import ScmModel

    ScmModel().mark_for_invalidation(ex.repository)

    # extension hook call

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PUSH_HOOK', None)

    if callable(callback):

        kw = {'pushed_revs': revs}

        kw.update(ex)

        callback(**kw)

def log_create_repository(repository_dict, created_by, **kwargs):

    """

    Post create repository Hook.

    :param repository: dict dump of repository object

    :param created_by: username who created repository

    available keys of repository_dict:

     'repo_type',

     'description',

     'private',

     'created_on',

     'enable_downloads',

     'repo_id',

     'owner_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

     'group_id',

     'repo_name'

    """

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'CREATE_REPO_HOOK', None)

    if callable(callback):

        kw = {}

        kw.update(repository_dict)

        kw.update({'created_by': created_by})

        kw.update(kwargs)

        return callback(**kw)

    return 0

def check_allowed_create_user(user_dict, created_by, **kwargs):

    # pre create hooks

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PRE_CREATE_USER_HOOK', None)

    if callable(callback):

        allowed, reason = callback(created_by=created_by, **user_dict)

        if not allowed:

            raise UserCreationError(reason)

def log_create_user(user_dict, created_by, **kwargs):

    """

    Post create user Hook.

    :param user_dict: dict dump of user object

    available keys for user_dict:

     'username',

     'full_name_or_username',

     'full_contact',

     'user_id',

     'name',

     'firstname',

     'short_contact',

     'admin',

     'lastname',

     'ip_addresses',

     'ldap_dn',

     'email',

     'api_key',

     'last_login',

     'full_name',

     'active',

     'password',

     'emails',

    """

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'CREATE_USER_HOOK', None)

    if callable(callback):

        return callback(created_by=created_by, **user_dict)

    return 0

def log_delete_repository(repository_dict, deleted_by, **kwargs):

    """

    Post delete repository Hook.

    :param repository: dict dump of repository object

    :param deleted_by: username who deleted the repository

    available keys of repository_dict:

     'repo_type',

     'description',

     'private',

     'created_on',

     'enable_downloads',

     'repo_id',

     'owner_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

     'group_id',

     'repo_name'

    """

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'DELETE_REPO_HOOK', None)

    if callable(callback):

        kw = {}

        kw.update(repository_dict)

        kw.update({'deleted_by': deleted_by,

                   'deleted_on': time.time()})

        kw.update(kwargs)

        return callback(**kw)

    return 0

def log_delete_user(user_dict, deleted_by, **kwargs):

    """

    Post delete user Hook.

    :param user_dict: dict dump of user object

    available keys for user_dict:

     'username',

     'full_name_or_username',

     'full_contact',

     'user_id',

     'name',

     'firstname',

     'short_contact',

     'admin',

     'lastname',

     'ip_addresses',

     'ldap_dn',

     'email',

     'api_key',

     'last_login',

     'full_name',

     'active',

     'password',

     'emails',

    """

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'DELETE_USER_HOOK', None)

    if callable(callback):

        return callback(deleted_by=deleted_by, **user_dict)

    return 0

def _hook_environment(repo_path):

    """

    Create a light-weight environment for stand-alone scripts and return an UI and the

    db repository.

    Git hooks are executed as subprocess of Git while Kallithea is waiting, and

    they thus need enough info to be able to create an app environment and

    connect to the database.

    """

    import paste.deploy

    import kallithea.config.application

    extras = get_hook_environment()

    path_to_ini_file = extras['config']

    #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging

    # fix if it's not a bare repo

    if repo_path.endswith(os.sep + '.git'):

        repo_path = repo_path[:-5]

    repo = Repository.get_by_full_path(repo_path)

    if not repo:

        raise OSError('Repository %s not found in database' % repo_path)

    baseui = make_ui()

    return baseui, repo

def handle_git_pre_receive(repo_path, git_stdin_lines):

    """Called from Git pre-receive hook"""

    # Currently unused. TODO: remove?

    return 0

def handle_git_post_receive(repo_path, git_stdin_lines):

    """Called from Git post-receive hook"""

    try:

        baseui, repo = _hook_environment(repo_path)

    except HookEnvironmentError as e:

        sys.stderr.write("Skipping Kallithea Git post-recieve hook %r.\nGit was apparently not invoked by Kallithea: %s\n" % (sys.argv[0], e))

        return 0

    # the post push hook should never use the cached instance

    scm_repo = repo.scm_instance_no_cache()

    rev_data = []

    for l in git_stdin_lines:

        old_rev, new_rev, ref = l.strip().split(' ')

        _ref_data = ref.split('/')

        if _ref_data[1] in ['tags', 'heads']:

            rev_data.append({'old_rev': old_rev,

                             'new_rev': new_rev,

                             'ref': ref,

                             'type': _ref_data[1],

                             'name': '/'.join(_ref_data[2:])})

    git_revs = []

    for push_ref in rev_data:

        _type = push_ref['type']

        if _type == 'heads':

            if push_ref['old_rev'] == EmptyChangeset().raw_id:

                # update the symbolic ref if we push new repo

                if scm_repo.is_empty():

                    scm_repo._repo.refs.set_symbolic_ref(

                        b'HEAD',

                        b'refs/heads/%s' % safe_bytes(push_ref['name']))

                # build exclude list without the ref

                cmd = ['for-each-ref', '--format=%(refname)', 'refs/heads/*']

                stdout = scm_repo.run_git_command(cmd)

                ref = push_ref['ref']

                heads = [head for head in stdout.splitlines() if head != ref]

                # now list the git revs while excluding from the list

                cmd = ['log', push_ref['new_rev'], '--reverse', '--pretty=format:%H']

                cmd.append('--not')

                cmd.extend(heads) # empty list is ok

                stdout = scm_repo.run_git_command(cmd)

                git_revs += stdout.splitlines()

            elif push_ref['new_rev'] == EmptyChangeset().raw_id:

                # delete branch case

                git_revs += ['delete_branch=>%s' % push_ref['name']]

            else:

                cmd = ['log', '%(old_rev)s..%(new_rev)s' % push_ref,

                       '--reverse', '--pretty=format:%H']

                stdout = scm_repo.run_git_command(cmd)

                git_revs += stdout.splitlines()

        elif _type == 'tags':

            git_revs += ['tag=>%s' % push_ref['name']]

    process_pushed_raw_ids(git_revs)

    return 0

# Almost exactly like Mercurial contrib/hg-ssh:

def rejectpush(ui, **kwargs):

    """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos"""

    ex = get_hook_environment()

    ui.warn(safe_bytes("Push access to %r denied\n" % ex.repository))

    return 1