:author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

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

import sys

import binascii

from inspect import isfunction

from mercurial.scmutil import revrange

from mercurial.node import nullrev

from rhodecode.lib import helpers as h

from rhodecode.lib.utils import action_logger

from rhodecode.lib.vcs.backends.base import EmptyChangeset

def _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

        alias += '.'

    size_scm, size_root = 0, 0

    for path, dirs, files in os.walk(root_path):

        if path.find(alias) != -1:

            for f in files:

                try:

                    size_scm += os.path.getsize(os.path.join(path, f))

                except OSError:

                    pass

        else:

            for f in files:

                try:

                    size_root += os.path.getsize(os.path.join(path, f))

                except OSError:

                    pass

    msg = ('Repository size .hg:%s repo:%s total:%s\n'

           'Last revision is now r%s:%s\n') % (

        size_hg_f, size_root_f, size_total_f, last_cs.rev(), last_cs.hex()[:12]

    )

    sys.stdout.write(msg)

def log_pull_action(ui, repo, **kwargs):

    """

    Logs user last pull action

    :param ui:

    :param repo:

    """

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    username = extras['username']

    repository = extras['repository']

    scm = extras['scm']

    action = 'pull'

    action_logger(username, action, repository, extras['ip'], commit=True)

    # extension hook call

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

    if isfunction(callback):

        kw = {}

        kw.update(extras)

        callback(**kw)

    return 0

def log_push_action(ui, repo, **kwargs):

    """

    Maps user last push action to new changeset id, from mercurial

    :param ui:

    :param repo: repo object containing the `ui` object

    """

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    username = extras['username']

    repository = extras['repository']

    action = extras['action'] + ':%s'

    scm = extras['scm']

    if scm == 'hg':

        def get_revs(repo, rev_opt):

            if rev_opt:

                revs = revrange(repo, rev_opt)

                if len(revs) == 0:

                    return (nullrev, nullrev)

                return (max(revs), min(revs))

            else:

                return (len(repo) - 1, 0)

        stop, start = get_revs(repo, [node + ':'])

        h = binascii.hexlify

        revs = (h(repo[r].node()) for r in xrange(start, stop + 1))

    elif scm == 'git':

        revs = kwargs.get('_git_revs', [])

        if '_git_revs' in kwargs:

            kwargs.pop('_git_revs')

    action = action % ','.join(revs)

    action_logger(username, action, repository, extras['ip'], commit=True)

    # extension hook call

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

    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'

    """

    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 pre-receive hook and logs

    an push action together with pushed revisions. It's runned by subprocess

    thus needs all info to be able to create a temp pylons enviroment, connect

    to database and run the logging code. Hacky as sh**t but works. ps.

    GIT SUCKS

    :param repo_path:

    :type repo_path:

    :param revs:

    :type revs:

    :param env:

        """

        git_command = self._get_fixedpath(request.path_info)

        if git_command not in self.commands:

            log.debug('command %s not allowed' % git_command)

            return exc.HTTPMethodNotAllowed()

        if 'CONTENT_LENGTH' in environ:

            inputstream = FileWrapper(environ['wsgi.input'],

                                      request.content_length)

        else:

            inputstream = environ['wsgi.input']

        try:

            gitenv = os.environ

            from rhodecode import CONFIG

            from rhodecode.lib.base import _get_ip_addr

            gitenv['RHODECODE_USER'] = self.username

            gitenv['RHODECODE_CONFIG_IP'] = _get_ip_addr(environ)

            # forget all configs

            gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

            # we need current .ini file used to later initialize rhodecode

            # env and connect to db

            gitenv['RHODECODE_CONFIG_FILE'] = CONFIG['__file__']

            opts = dict(

            )

            out = subprocessio.SubprocessIOChunker(

                r'git %s --stateless-rpc "%s"' % (git_command[4:],

                                                  self.content_path),

                inputstream=inputstream,

                **opts

            )

        except EnvironmentError, e:

            log.exception(e)

            raise exc.HTTPExpectationFailed()

        if git_command in [u'git-receive-pack']:

            # updating refs manually after each push.

            # Needed for pre-1.7.0.4 git clients using regular HTTP mode.

            subprocess.call(u'git --git-dir "%s" '

                            'update-server-info' % self.content_path,

                            shell=True)

        resp = Response()

        resp.content_type = 'application/x-%s-result' % git_command.encode('utf8')

        resp.app_iter = out

        return resp

    def __call__(self, environ, start_response):