import datetime

import errno

from kallithea.lib.vcs.backends.base import BaseInMemoryChangeset

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils.hgcompat import memfilectx, memctx, hex, tolocal

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

    def commit(self, message, author, parents=None, branch=None, date=None,

            **kwargs):

        """

        Performs in-memory commit (doesn't check workdir in any way) and

        returns newly created ``Changeset``. Updates repository's

        ``revisions``.

        :param message: message of the commit

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

        :param parents: single parent or sequence of parents from which commit

          would be derived

        :param date: ``datetime.datetime`` instance. Defaults to

          ``datetime.datetime.now()``.

        :param branch: branch name, as string. If none given, default backend's

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        self.check_integrity(parents)

        from .repository import MercurialRepository

        if not isinstance(message, unicode) or not isinstance(author, unicode):

            raise RepositoryError('Given message and author needs to be '

                                  'an <unicode> instance got %r & %r instead'

                                  % (type(message), type(author)))

        if branch is None:

            branch = MercurialRepository.DEFAULT_BRANCH_NAME

        kwargs['branch'] = branch

        def filectxfn(_repo, memctx, path):

            """

            Marks given path as added/changed/removed in a given _repo. This is

            for internal mercurial commit function.

            """

            # check if this path is removed

            if path in (node.path for node in self.removed):

                if getattr(memctx, '_returnnoneformissingfiles', False):

                    return None

                else:

                    # (hg < 3.2) Raising exception is the way to mark node for

                    # removal

                    raise IOError(errno.ENOENT, '%s is deleted' % path)

            # check if this path is added

            for node in self.added:

                if node.path == path:

                    return memfilectx(_repo, path=node.path,

                        data=(node.content.encode('utf8')

                              if not node.is_binary else node.content),

                        islink=False,

                        isexec=node.is_executable,

                        copied=False)

            # or changed

            for node in self.changed:

                if node.path == path:

                    return memfilectx(_repo, path=node.path,

                        data=(node.content.encode('utf8')

                              if not node.is_binary else node.content),

                        islink=False,

                        isexec=node.is_executable,

                        copied=False)

            raise RepositoryError("Given path haven't been marked as added,"

                                  "changed or removed (%s)" % path)

        parents = [None, None]

        for i, parent in enumerate(self.parents):

            if parent is not None:

                parents[i] = parent._ctx.node()

        if date and isinstance(date, datetime.datetime):

        commit_ctx = memctx(repo=self.repository._repo,

            parents=parents,

            text='',

            files=self.get_paths(),

            filectxfn=filectxfn,

            user=author,

            date=date,

            extra=kwargs)

        loc = lambda u: tolocal(u.encode('utf-8'))

        # injecting given _repo params

        commit_ctx._text = loc(message)

        commit_ctx._user = loc(author)

        commit_ctx._date = date

        # TODO: Catch exceptions!

        n = self.repository._repo.commitctx(commit_ctx)

        # Returns mercurial node

        self._commit_ctx = commit_ctx  # For reference

        # Update vcs repository object & recreate mercurial _repo

        # new_ctx = self.repository._repo[node]

        # new_tip = self.repository.get_changeset(new_ctx.hex())

        new_id = hex(n)

        self.repository.revisions.append(new_id)

        self._repo = self.repository._get_repo(create=False)

        self.repository.branches = self.repository._get_branches()

        tip = self.repository.get_changeset()

        self.reset()

        return tip

        Checks if repository is empty ie. without any changesets

        """

        # TODO: Following raises errors when using InMemoryChangeset...

        # return len(self._repo.changelog) == 0

        return len(self.revisions) == 0

    @LazyProperty

    def revisions(self):

        """

        Returns list of revisions' ids, in ascending order.  Being lazy

        attribute allows external tools to inject shas from cache.

        """

        return self._get_all_revisions()

    @LazyProperty

    def name(self):

        return os.path.basename(self.path)

    @LazyProperty

    def branches(self):

        return self._get_branches()

    @LazyProperty

    def closed_branches(self):

        return self._get_branches(normal=False, closed=True)

    @LazyProperty

    def allbranches(self):

        """

        List all branches, including closed branches.

        """

        return self._get_branches(closed=True)

    def _get_branches(self, normal=True, closed=False):

        """

        Gets branches for this repository

        Returns only not closed branches by default

        :param closed: return also closed branches for mercurial

        :param normal: return also normal branches

        """

        if self._empty:

            return {}

        bt = OrderedDict()

        for bn, _heads, tip, isclosed in sorted(self._repo.branchmap().iterbranches()):

            if isclosed:

                if closed:

                    bt[safe_unicode(bn)] = hex(tip)

            else:

                if normal:

                    bt[safe_unicode(bn)] = hex(tip)

        return bt

    @LazyProperty

    def tags(self):

        """

        Gets tags for this repository

        """

        return self._get_tags()

    def _get_tags(self):

        if self._empty:

            return {}

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

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

                 self._repo.tags().items()]

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

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

        """

        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:

        try:

            self._repo.tag(name, changeset._ctx.node(), message, local, user,

                date)

        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:

        local = False

        try:

            self._repo.tag(name, nullid, message, local, user, date)

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

    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 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:

            file_filter = match(self.path, '', [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(repoui or ui.ui(), url).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)