# -*- 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.conf import settings

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError,

    RepositoryError, VCSError, TagAlreadyExistError, TagDoesNotExistError

)

from kallithea.lib.vcs.utils import (

)

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, pull,

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

    httpbasicauthhandler, httpdigestauthhandler, peer, httppeer

)

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)

                    % (self.path, err)

            raise RepositoryError(msg)

    @LazyProperty

    def in_memory_changeset(self):

        return MercurialInMemoryChangeset(self)

    @LazyProperty

    def description(self):

        undefined_description = u'unknown'

        _desc = self._repo.ui.config('web', 'description', None, untrusted=True)

        return safe_unicode(_desc or undefined_description)

    @LazyProperty

    def contact(self):

        undefined_contact = u'Unknown'

        return safe_unicode(get_contact(self._repo.ui.config)

                            or undefined_contact)

    @LazyProperty

    def last_change(self):

        """

        Returns last change made on this repository as datetime object

        """

        return date_fromtimestamp(self._get_mtime(), makedate()[1])

    def _get_mtime(self):

        try:

            return time.mktime(self.get_changeset().date.timetuple())

        except RepositoryError:

            #fallback to filesystem

            cl_path = os.path.join(self.path, '.hg', "00changelog.i")

            st_path = os.path.join(self.path, '.hg', "store")

            if os.path.exists(cl_path):

                return os.stat(cl_path).st_mtime

            else:

                return os.stat(st_path).st_mtime

    def _get_hidden(self):

        return self._repo.ui.configbool("web", "hidden", untrusted=True)

    def _get_revision(self, revision):

        """

        Gets an ID revision given as str. This will always return a fill

        40 char revision number

        :param revision: str or int or None

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, 'tip', None]:

            revision = 'tip'

        try:

            revision = hex(self._repo.lookup(revision))

        except (LookupError, ):

            msg = ("Ambiguous identifier `%s` for %s" % (revision, self))

            raise ChangesetDoesNotExistError(msg)

        except (IndexError, ValueError, RepoLookupError, TypeError):

            msg = ("Revision %s does not exist for %s" % (revision, self))

            raise ChangesetDoesNotExistError(msg)

        return revision

    def _get_archives(self, archive_name='tip'):

        allowed = self.baseui.configlist("web", "allow_archive",

                                         untrusted=True)

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

            if i[0] in allowed or self._repo.ui.configbool("web",

                                                           "allow" + i[0],

                                                           untrusted=True):

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

        """

        url = str(url)

        if url != 'default' and not '://' in url:

            url = "file:" + urllib.pathname2url(url)

        return url

    def get_hook_location(self):

        """

        returns absolute path to location where hooks are stored

        """

        return os.path.join(self.path, '.hg', '.hgrc')

    def get_changeset(self, revision=None):

        """

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.