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

"""

    vcs

    ~~~

    Various version Control System (vcs) management abstraction layer for

    Python.

    :created_on: Apr 8, 2010

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

"""

__version__ = '.'.join((str(each) for each in VERSION[:4]))

__all__ = [

    'get_version', 'get_repo', 'get_backend',

    'VCSError', 'RepositoryError', 'ChangesetError'

]

import sys

from rhodecode.lib.vcs.backends import get_repo, get_backend

from rhodecode.lib.vcs.exceptions import VCSError, RepositoryError, ChangesetError

class GitChangeset(BaseChangeset):

    """

    Represents state of the repository at single revision.

    """

    def __init__(self, repository, revision):

        self._stat_modes = {}

        self.repository = repository

        try:

            if isinstance(commit, objects.Tag):

                revision = commit.object[1]

                commit = self.repository._repo.get_object(commit.object[1])

        except KeyError:

            raise RepositoryError("Cannot get object with id %s" % revision)

        self.raw_id = revision

        self.id = self.raw_id

        self.short_id = self.raw_id[:12]

        self._commit = commit

        self._tree_id = commit.tree

        self._committer_property = 'committer'

        self._author_property = 'author'

        self._date_property = 'commit_time'

        self._date_tz_property = 'commit_timezone'

        self.revision = repository.revisions.index(revision)

        self.nodes = {}

        self._paths = {}

    @LazyProperty

    def committer(self):

        return safe_unicode(getattr(self._commit, self._committer_property))

    @LazyProperty

    def author(self):

        return safe_unicode(getattr(self._commit, self._author_property))

    @LazyProperty

    def date(self):

        return date_fromtimestamp(getattr(self._commit, self._date_property),

                                  getattr(self._commit, self._date_tz_property))

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

from rhodecode.lib.vcs.utils.paths import abspath, get_user_home

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

    hg_url, httpbasicauthhandler, httpdigestauthhandler

)

from .changeset import GitChangeset

from .config import ConfigFile

from .inmemory import GitInMemoryChangeset

from .workdir import GitWorkdir

log = logging.getLogger(__name__)

class GitRepository(BaseRepository):

    """

    Git repository backend.

    """

    DEFAULT_BRANCH_NAME = 'master'

    scm = 'git'

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

                 update_after_clone=False, bare=False):

        self.path = abspath(repo_path)

        repo = self._get_repo(create, src_url, update_after_clone, bare)

        self.bare = repo.bare

                     or abspath(self.path, '.git', 'config'),

            abspath(get_user_home(), '.gitconfig'),

        ]

    @property

    def _repo(self):

        return Repo(self.path)

    @property

    def head(self):

        try:

            return self._repo.head()

    def _get_all_revisions2(self):

        #alternate implementation using dulwich

        includes = [x[1][0] for x in self._parsed_refs.iteritems()

                    if x[1][1] != 'T']

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

        """

        For git backend we always return integer here. This way we ensure

        that changset's revision attribute would become integer.

        """

        is_null = lambda o: len(o) == revision.count('0')

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in (None, '', 'tip', 'HEAD', 'head', -1):

            or isinstance(revision, int) or is_null(revision)):

            try:

                revision = self.revisions[int(revision)]

            except Exception:

                raise ChangesetDoesNotExistError("Revision %s does not exist "

                    "for this repository" % (revision))

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

            if _ref_revision:  # and _ref_revision[1] in ['H', 'RH', 'T']:

                return _ref_revision[0]

            # maybe it's a tag ? we don't have them in self.revisions

                return _tags_shas[_tags_shas.index(revision)]

                raise ChangesetDoesNotExistError("Revision %s does not exist "

                    "for this repository" % (revision))

        # Ensure we return full id

            raise ChangesetDoesNotExistError("Given revision %s not recognized"

                % revision)

        return revision

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

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

                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

                                  "after end revision '%s'" % (start, end))

        if branch_name and branch_name not in self.allbranches.keys():

            raise BranchDoesNotExistError('Branch %s not found in'

                                  ' this repository' % branch_name)

        if end_pos is not None:

            end_pos += 1

        #filter branches

        filter_ = []

        if branch_name:

            filter_.append('branch("%s")' % (branch_name))

            filter_.append('date(">%s")' % start_date)

            filter_.append('date("<%s")' % end_date)

        if filter_:

            revisions = scmutil.revrange(self._repo, filter_)

        else:

            revisions = self.revisions

        revs = revisions[start_pos:end_pos]

        if reverse:

            revs = reversed(revs)

        return CollectionGenerator(self, revs)

    def pull(self, url):

    def test_get_changesets_includes_end_changeset(self):

        second_id = self.repo.revisions[1]

        changesets = list(self.repo.get_changesets(end=second_id))

        self.assertEqual(changesets[-1].raw_id, second_id)

    def test_get_changesets_respects_start_date(self):

        start_date = datetime.datetime(2010, 2, 1)

        for cs in self.repo.get_changesets(start_date=start_date):

            self.assertGreaterEqual(cs.date, start_date)

    def test_get_changesets_respects_end_date(self):

        end_date = datetime.datetime(2010, 2, 1)

        for cs in self.repo.get_changesets(end_date=end_date):

            self.assertLessEqual(cs.date, end_date)

    def test_get_changesets_respects_reverse(self):

        changesets_id_list = [cs.raw_id for cs in

            self.repo.get_changesets(reverse=True)]

        self.assertItemsEqual(changesets_id_list, reversed(self.repo.revisions))

    def test_get_filenodes_generator(self):

        tip = self.repo.get_changeset()

        filepaths = [node.path for node in tip.get_filenodes_generator()]

    def test_get_branch_for_default_branch(self):

        self.assertEqual(self.repo.workdir.get_branch(),

            self.repo.DEFAULT_BRANCH_NAME)

    def test_get_branch_after_adding_one(self):

        self.imc.add(FileNode('docs/index.txt',

            content='Documentation\n'))

        self.imc.commit(

            message=u'New branch: foobar',

            author=u'joe',

            branch='foobar',

        )

    def test_get_changeset(self):

        self.imc.add(FileNode('docs/index.txt',

            content='Documentation\n'))

        head = self.imc.commit(

            message=u'New branch: foobar',

            author=u'joe',

            branch='foobar',

        )

        self.assertEqual(self.repo.workdir.get_changeset(), head)

    def test_checkout_branch(self):

        from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError

        # first, 'foobranch' does not exist.

        self.assertRaises(BranchDoesNotExistError, self.repo.workdir.checkout_branch,

                          branch='foobranch')

        # create new branch 'foobranch'.

        self.imc.add(FileNode('file1', content='blah'))

        self.imc.commit(message=u'asd', author=u'john', branch='foobranch')

        # go back to the default branch

        self.repo.workdir.checkout_branch()

        self.assertEqual(self.repo.workdir.get_branch(), self.backend_class.DEFAULT_BRANCH_NAME)

        # checkout 'foobranch'