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

"""

    vcs.backends.hg.repository

    ~~~~~~~~~~~~~~~~~~~~~~~~~~

    Mercurial repository implementation.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import os

import time

import urllib

import urllib2

import logging

import datetime

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError,

    RepositoryError, VCSError, TagAlreadyExistError, TagDoesNotExistError

)

from kallithea.lib.vcs.utils import (

    author_email, author_name, date_fromtimestamp, makedate, safe_unicode, safe_str,

)

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.ordered_dict import OrderedDict

from kallithea.lib.vcs.utils.paths import abspath

from kallithea.lib.vcs.utils.hgcompat import (

    localrepo, RepoLookupError, Abort, RepoError, hex, scmutil, hg_url,

    httpbasicauthhandler, httpdigestauthhandler, peer, httppeer, sshpeer, tag

)

from .changeset import MercurialChangeset

from .inmemory import MercurialInMemoryChangeset

from .workdir import MercurialWorkdir

log = logging.getLogger(__name__)

class MercurialRepository(BaseRepository):

    """

    Mercurial repository backend

    """

    DEFAULT_BRANCH_NAME = 'default'

    scm = 'hg'

    def __init__(self, repo_path, create=False, baseui=None, src_url=None,

                 update_after_clone=False):

        """

        Raises RepositoryError if repository could not be find at the given

        ``repo_path``.

        :param repo_path: local path of the repository

        :param create=False: if set to True, would try to create repository if

           it does not exist rather than raising exception

        :param baseui=None: user data

        :param src_url=None: would try to clone repository from given location

        :param update_after_clone=False: sets update of working copy after

          making a clone

        """

        if not isinstance(repo_path, str):

            raise VCSError('Mercurial backend requires repository path to '

                           'be instance of <str> got %s instead' %

                           type(repo_path))

        self.path = abspath(repo_path)

        self.baseui = baseui or ui.ui()

        # We've set path and ui, now we can set _repo itself

        self._repo = self._get_repo(create, src_url, update_after_clone)

    @property

    def _empty(self):

        """

        Checks if repository is empty ie. without any changesets

        """

    def _get_bookmarks(self):

        if self._empty:

            return {}

        sortkey = lambda ctx: ctx[0]  # sort by name

        _bookmarks = [(safe_unicode(n), hex(h),) for n, h in

                 self._repo._bookmarks.items()]

        return OrderedDict(sorted(_bookmarks, key=sortkey, reverse=True))

    def _get_all_revisions(self):

        return [self._repo[x].hex() for x in self._repo.filtered('visible').changelog.revs()]

    def get_diff(self, rev1, rev2, path='', ignore_whitespace=False,

                  context=3):

        """

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

        :param context: How many lines before/after changed lines should be

          shown. Defaults to ``3``. If negative value is passed-in, it will be

          set to ``0`` instead.

        """

        # Negative context values make no sense, and will result in

        # errors. Ensure this does not happen.

        if context < 0:

            context = 0

        if hasattr(rev1, 'raw_id'):

            rev1 = getattr(rev1, 'raw_id')

        if hasattr(rev2, 'raw_id'):

            rev2 = getattr(rev2, 'raw_id')

        # Check if given revisions are present at repository (may raise

        # ChangesetDoesNotExistError)

        if rev1 != self.EMPTY_CHANGESET:

            self.get_changeset(rev1)

        self.get_changeset(rev2)

        if path:

        else:

            file_filter = None

        return ''.join(patch.diff(self._repo, rev1, rev2, match=file_filter,

                          opts=diffopts(git=True,

                                        showfunc=True,

                                        ignorews=ignore_whitespace,

                                        context=context)))

    @classmethod

    def _check_url(cls, url, repoui=None):

        """

        Function will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError, exception is also thrown

        when the return code is non 200

        """

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if url.startswith('ssh:'):

            # in case of invalid uri or authentication issues, sshpeer will

            # throw an exception.

            sshpeer.instance(repoui or ui.ui(), url, False).lookup('tip')

            return True

        url_prefix = None

        if '+' in url[:url.find('://')]:

            url_prefix, url = url.split('+', 1)

        handlers = []

        url_obj = hg_url(url)

        test_uri, authinfo = url_obj.authinfo()

        url_obj.passwd = '*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((httpbasicauthhandler(passmgr),

                             httpdigestauthhandler(passmgr)))

"""

Mercurial libs compatibility

"""

import mercurial

from mercurial import demandimport

# patch demandimport, due to bug in mercurial when it always triggers demandimport.enable()

demandimport.enable = lambda *args, **kwargs: 1

from mercurial import archival, merge as hg_merge, patch, ui

from mercurial import discovery

from mercurial import localrepo

from mercurial import unionrepo

from mercurial import scmutil

from mercurial import config

from mercurial.tags import tag

from mercurial import httppeer

from mercurial import sshpeer

from mercurial import obsutil

from mercurial.commands import clone, nullid, pull

from mercurial.context import memctx, memfilectx

from mercurial.error import RepoError, RepoLookupError, Abort

from mercurial.hgweb import hgweb_mod

from mercurial.hgweb.common import get_contact

from mercurial.mdiff import diffopts

from mercurial.node import hex

from mercurial.encoding import tolocal

from mercurial.discovery import findcommonoutgoing

from mercurial.hg import peer

from mercurial.util import url as hg_url

from mercurial.scmutil import revrange

from mercurial.node import nullrev

from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

# workaround for 3.3 94ac64bcf6fe and not calling largefiles reposetup correctly

localrepo.localrepository._lfstatuswriters = [lambda *msg, **opts: None]

# 3.5 7699d3212994 added the invariant that repo.lfstatus must exist before hitting overridearchive

localrepo.localrepository.lfstatus = False

# Mercurial 5.0 550a172a603b renamed memfilectx argument `copied` to `copysource`

import inspect

if inspect.getargspec(memfilectx.__init__).args[7] != 'copysource':

    assert inspect.getargspec(memfilectx.__init__).args[7] == 'copied', inspect.getargspec(memfilectx.__init__).args

    __org_memfilectx_ = memfilectx

    memfilectx = lambda repo, changectx, path, data, islink=False, isexec=False, copysource=None: \

        __org_memfilectx_(repo, changectx, path, data, islink=islink, isexec=isexec, copied=copysource)