#

# 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

from rhodecode.lib.compat import json

from rhodecode.model.db import Repository, User

from rhodecode.lib.utils2 import safe_str

from rhodecode.lib.exceptions import HTTPLockedRC

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

    size_scm_f = h.format_byte_size(size_scm)

    size_root_f = h.format_byte_size(size_root)

    size_total_f = h.format_byte_size(size_root + size_scm)

    return size_scm_f, size_root_f, size_total_f

def repo_size(ui, repo, hooktype=None, **kwargs):

    """

    Presents size of repository after push

    :param ui:

    :param repo:

    :param hooktype:

    """

    size_hg_f, size_root_f, size_total_f = _get_scm_size('.hg', repo.root)

    last_cs = repo[len(repo) - 1]

    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 pre_push(ui, repo, **kwargs):

    # pre push function, currently used to ban pushing when

    # repository is locked

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

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

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        locked_by = extras['locked_by']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        locked_by = rc_extras['locked_by']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    usr = User.get_by_username(username)

    if locked_by[0] and usr.user_id != int(locked_by[0]):

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

    # pre push function, currently used to ban pushing when

    # repository is locked

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

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

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        locked_by = extras['locked_by']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        locked_by = rc_extras['locked_by']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    if locked_by[0]:

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

    """

    Logs user last pull action

    :param ui:

    :param repo:

    """

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

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

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        make_lock = extras['make_lock']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        make_lock = rc_extras['make_lock']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    user = User.get_by_username(username)

    action = 'pull'

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

    # extension hook call

    from rhodecode import EXTENSIONS

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

    if isfunction(callback):

        kw = {}

        kw.update(extras)

        callback(**kw)

    if make_lock is True:

        Repository.lock(Repository.get_by_repo_name(repository), user.user_id)

        #msg = 'Made lock on repo `%s`' % repository

        #sys.stdout.write(msg)

    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

    """

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

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

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        make_lock = extras['make_lock']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        make_lock = rc_extras['make_lock']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    action = 'push' + ':%s'

    if scm == 'hg':

        node = kwargs['node']

        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')