#!/usr/bin/env python

import os

import sys

try:

    import rhodecode

    from rhodecode.lib.hooks import handle_git_post_receive

except ImportError:

    rhodecode = None

def main():

    if rhodecode is None:

        # exit with success if we cannot import rhodecode !!

        # this allows simply push to this repo even without

        # rhodecode

        sys.exit(0)

    repo_path = os.path.abspath('.')    

    push_data = sys.stdin.read().strip().split(' ')

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # Environ get's some additional info from rhodecode system

    # like IP or username from basic-auth

    handle_git_post_receive(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    if isfunction(callback):

        kw = {'pushed_revs': revs}

        kw.update(extras)

        callback(**kw)

    return 0

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

    """

    Post create repository Hook. This is a dummy function for admins to re-use

    if needed. It's taken from rhodecode-extensions module and executed

    if present

    :param repository: dict dump of repository object

    :param created_by: username who created repository

    :param created_date: date of creation

    available keys of repository_dict:

     'repo_type',

     'description',

     'private',

     'created_on',

     'enable_downloads',

     'repo_id',

     'user_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

     'group_id',

     'repo_name'

    """

    from rhodecode import EXTENSIONS

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

    if isfunction(callback):

        kw = {}

        kw.update(repository_dict)

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

        kw.update(kwargs)

        return callback(**kw)

    return 0

def handle_git_post_receive(repo_path, revs, env):

    """

    A really hacky method that is runned by git post-receive hook and logs

    :param repo_path:

    :type repo_path:

    :param revs:

    :type revs:

    :param env:

    :type env:

    """

    from paste.deploy import appconfig

    from sqlalchemy import engine_from_config

    from rhodecode.config.environment import load_environment

    from rhodecode.model import init_model

    from rhodecode.model.db import RhodeCodeUi

    from rhodecode.lib.utils import make_ui

    from rhodecode.model.db import Repository

    path, ini_name = os.path.split(env['RHODECODE_CONFIG_FILE'])

    conf = appconfig('config:%s' % ini_name, relative_to=path)

    load_environment(conf.global_conf, conf.local_conf)

    engine = engine_from_config(conf, 'sqlalchemy.db1.')

    init_model(engine)

    baseui = make_ui('db')

    repo = Repository.get_by_full_path(repo_path)

    _hooks = dict(baseui.configitems('hooks')) or {}

    # if push hook is enabled via web interface

    if _hooks.get(RhodeCodeUi.HOOK_PUSH):

        extras = {

         'username': env['RHODECODE_USER'],

         'repository': repo.repo_name,

         'scm': 'git',

         'action': 'push',

         'ip': env['RHODECODE_CONFIG_IP'],

        }

        for k, v in extras.items():

            baseui.setconfig('rhodecode_extras', k, v)

        repo = repo.scm_instance

        repo.ui = baseui

        old_rev, new_rev, ref = revs

        if old_rev == EmptyChangeset().raw_id:

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

            heads = repo.run_git_command(cmd)[0]

            heads = heads.replace(ref, '')

            heads = ' '.join(map(lambda c: c.strip('\n').strip(),

                                 heads.splitlines()))