"""

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 (

    ui, nullid, match, patch, diffopts, clone, get_contact,

    localrepository, RepoLookupError, Abort, RepoError, hex, scmutil, hg_url,

)

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

        """

        Creates and returns a tag for the given ``revision``.

        :param name: name for new tag

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param revision: changeset id for which new tag would be created

        :param message: message of the tag's commit

        :param date: date of tag's commit

        :raises TagAlreadyExistError: if tag with same name already exists

        """

        if name in self.tags:

            raise TagAlreadyExistError("Tag %s already exists" % name)

        changeset = self.get_changeset(revision)

        local = kwargs.setdefault('local', False)

        if message is None:

            message = "Added tag %s for changeset %s" % (name,

                changeset.short_id)

        if date is None:

            date = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S')

        try:

        except Abort as e:

            raise RepositoryError(e.message)

        # Reinitialize tags

        self.tags = self._get_tags()

        tag_id = self.tags[name]

        return self.get_changeset(revision=tag_id)

    def remove_tag(self, name, user, message=None, date=None):

        """

        Removes tag with the given ``name``.

        :param name: name of the tag to be removed

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param message: message of the tag's removal commit

        :param date: date of tag's removal commit

        :raises TagDoesNotExistError: if tag with given name does not exists

        """

        if name not in self.tags:

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        if message is None:

            message = "Removed tag %s" % name

        if date is None:

            date = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S')

        local = False

        try:

            self.tags = self._get_tags()

        except Abort as e:

            raise RepositoryError(e.message)

    @LazyProperty

    def bookmarks(self):

        """

        Gets bookmarks for this repository

        """

        return self._get_bookmarks()

    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()]

"""

Mercurial libs compatibility

"""

import mercurial

import mercurial.demandimport

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

mercurial.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.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.localrepo import localrepository

from mercurial.match import match

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.httppeer import httppeer

from mercurial.sshpeer import sshpeer

from mercurial.util import url as hg_url

from mercurial.scmutil import revrange

from mercurial.node import nullrev

# those authhandlers are patched for python 2.6.5 bug an

# infinite looping when given invalid resources

from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

import inspect

# Mercurial 3.1 503bb3af70fe

if inspect.getargspec(memfilectx.__init__).args[1] != 'repo':

    _org__init__ = memfilectx.__init__

    def _memfilectx__init__(self, repo, *a, **b):

        return _org__init__(self, *a, **b)

    memfilectx.__init__ = _memfilectx__init__

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

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

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

localrepository.lfstatus = False