import os

import posixpath

from kallithea.lib.vcs.conf import settings

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

from kallithea.lib.vcs.exceptions import (

    ChangesetDoesNotExistError, ChangesetError, ImproperArchiveTypeError,

    NodeDoesNotExistError, VCSError

)

from kallithea.lib.vcs.nodes import (

    AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode,

    NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode

)

from kallithea.lib.vcs.utils import safe_str, safe_unicode, date_fromtimestamp

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

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

from kallithea.lib.vcs.utils.hgcompat import archival, hex

from mercurial import obsolete

class MercurialChangeset(BaseChangeset):

    """

    Represents state of the repository at the single revision.

    """

    def __init__(self, repository, revision):

        self.repository = repository

        assert isinstance(revision, basestring), repr(revision)

        self.raw_id = revision

        self._ctx = repository._repo[revision]

        self.revision = self._ctx._rev

        self.nodes = {}

    @LazyProperty

    def tags(self):

        return map(safe_unicode, self._ctx.tags())

    @LazyProperty

    def branch(self):

        return safe_unicode(self._ctx.branch())

    @LazyProperty

    def branches(self):

        return [safe_unicode(self._ctx.branch())]

    @LazyProperty

    def closesbranch(self):

        return self._ctx.closesbranch()

    @LazyProperty

    def obsolete(self):

        return self._ctx.obsolete()

    @LazyProperty

    def bumped(self):

        try:

            return self._ctx.phasedivergent()

        except AttributeError: # renamed in Mercurial 4.6 (9fa874fb34e1)

            return self._ctx.bumped()

    @LazyProperty

    def divergent(self):

        try:

            return self._ctx.contentdivergent()

        except AttributeError: # renamed in Mercurial 4.6 (8b2d7684407b)

            return self._ctx.divergent()

    @LazyProperty

    def extinct(self):

        return self._ctx.extinct()

    @LazyProperty

    def unstable(self):

        try:

            return self._ctx.orphan()

        except AttributeError: # renamed in Mercurial 4.6 (03039ff3082b)

            return self._ctx.unstable()

    @LazyProperty

    def phase(self):

        if(self._ctx.phase() == 1):

            return 'Draft'

        elif(self._ctx.phase() == 2):

            return 'Secret'

        else:

            return ''

    @LazyProperty

    def successors(self):

        try:

            from mercurial import obsutil

            successors = obsolete.successorssets(self._ctx._repo, self._ctx.node())

        if successors:

            # flatten the list here handles both divergent (len > 1)

            # and the usual case (len = 1)

            successors = [hex(n)[:12] for sub in successors for n in sub if n != self._ctx.node()]

        return successors

    @LazyProperty

    def predecessors(self):

        predecessors = set()

        nm = self._ctx._repo.changelog.nodemap

            pr = nm.get(p[0])

            if pr is not None:

                predecessors.add(hex(p[0])[:12])

        return predecessors

    @LazyProperty

    def bookmarks(self):

        return map(safe_unicode, self._ctx.bookmarks())

    @LazyProperty

    def message(self):

        return safe_unicode(self._ctx.description())

    @LazyProperty

    def committer(self):

        return safe_unicode(self.author)

    @LazyProperty

    def author(self):

        return safe_unicode(self._ctx.user())

    @LazyProperty

    def date(self):

        return date_fromtimestamp(*self._ctx.date())

    @LazyProperty

    def _timestamp(self):

        return self._ctx.date()[0]

    @LazyProperty

    def status(self):

        """

        Returns modified, added, removed, deleted files for current changeset

        """

        return self.repository._repo.status(self._ctx.p1().node(),

                                            self._ctx.node())

    @LazyProperty

    def _file_paths(self):

        return list(self._ctx)

    @LazyProperty

    def _dir_paths(self):

        p = list(set(get_dirs_for_path(*self._file_paths)))

        p.insert(0, '')

        return p

    @LazyProperty

    def _paths(self):

        return self._dir_paths + self._file_paths

    @LazyProperty

    def id(self):

        if self.last:

            return u'tip'

        return self.short_id

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(parent.rev())

                for parent in self._ctx.parents() if parent.rev() >= 0]

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        return [self.repository.get_changeset(child.rev())

                for child in self._ctx.children() if child.rev() >= 0]

    def next(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        cs = self

        while True:

            try:

                next_ = cs.repository.revisions.index(cs.raw_id) + 1

                next_rev = cs.repository.revisions[next_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = cs.repository.get_changeset(next_rev)

            if not branch or branch == cs.branch:

                return cs

    def prev(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        cs = self

        while True:

            try:

                prev_ = cs.repository.revisions.index(cs.raw_id) - 1

                if prev_ < 0:

                    raise IndexError

                prev_rev = cs.repository.revisions[prev_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = cs.repository.get_changeset(prev_rev)

            if not branch or branch == cs.branch:

                return cs

    def diff(self):

        # Only used for feed diffstat

        return ''.join(self._ctx.diff())

    def _fix_path(self, path):

        """

        Paths are stored without trailing slash so we need to get rid off it if

        needed. Also mercurial keeps filenodes as str so we need to decode

        from unicode to str

        """

        if path.endswith('/'):

            path = path.rstrip('/')

        return safe_str(path)

    def _get_kind(self, path):

        path = self._fix_path(path)

        if path in self._file_paths:

            return NodeKind.FILE

        elif path in self._dir_paths:

            return NodeKind.DIR

        else:

            raise ChangesetError("Node does not exist at the given path '%s'"

                % (path))

    def _get_filectx(self, path):

        path = self._fix_path(path)

        if self._get_kind(path) != NodeKind.FILE:

            raise ChangesetError("File does not exist for revision %s at "

                " '%s'" % (self.raw_id, path))

        return self._ctx.filectx(path)

    def _extract_submodules(self):

        """

        returns a dictionary with submodule information from substate file

        of hg repository

        """

        return self._ctx.substate

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        fctx = self._get_filectx(path)

        if 'x' in fctx.flags():

            return 0100755

        else:

            return 0100644

    def get_file_content(self, path):

        """

        Returns content of the file at given ``path``.

        """

        fctx = self._get_filectx(path)

        return fctx.data()

    def get_file_size(self, path):

        """

        Returns size of the file at given ``path``.

        """

        fctx = self._get_filectx(path)

        return fctx.size()

    def get_file_changeset(self, path):

        """

        Returns last commit of the file at the given ``path``.

        """

        return self.get_file_history(path, limit=1)[0]

    def get_file_history(self, path, limit=None):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        fctx = self._get_filectx(path)

        hist = []

        cnt = 0

        for cs in reversed([x for x in fctx.filelog()]):

            cnt += 1

                   20: {'lines_no': 1,

                        'changesets': [4]},

                   55: {'lines_no': 31,

                        'changesets': [32, 32, 45, 32, 32, 37, 32, 32, 32, 44,

                                       37, 37, 37, 37, 45, 37, 44, 37, 37, 37,

                                       32, 32, 32, 32, 37, 32, 37, 37, 32,

                                       32, 32]}},

                 'vcs/exceptions.py':

                 {89: {'lines_no': 18,

                       'changesets': [16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

                                      16, 16, 17, 16, 16, 18, 18, 18]},

                  20: {'lines_no': 18,

                       'changesets': [16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

                                      16, 16, 17, 16, 16, 18, 18, 18]},

                  55: {'lines_no': 18, 'changesets': [16, 16, 16, 16, 16, 16,

                                                      16, 16, 16, 16, 16, 16,

                                                      17, 16, 16, 18, 18, 18]}},

                 'MANIFEST.in': {89: {'lines_no': 5,

                                      'changesets': [7, 7, 7, 71, 71]},

                                 20: {'lines_no': 3,

                                      'changesets': [7, 7, 7]},

                                 55: {'lines_no': 3,

                                     'changesets': [7, 7, 7]}}}

        for fname, revision_dict in files.items():

            for rev, data in revision_dict.items():

                cs = self.repo.get_changeset(rev)

                l1_1 = [x[1] for x in cs.get_file_annotate(fname)]

                l1_2 = [x[2]().raw_id for x in cs.get_file_annotate(fname)]

                assert l1_1 == l1_2

                l1 = l1_2 = [x[2]().revision for x in cs.get_file_annotate(fname)]

                l2 = files[fname][rev]['changesets']

                assert l1 == l2, "The lists of revision for %s@rev%s" \

                    "from annotation list should match each other," \

                    "got \n%s \nvs \n%s " % (fname, rev, l1, l2)

    def test_changeset_state(self):

        """

        Tests which files have been added/changed/removed at particular revision

        """

        # rev 46ad32a4f974:

        # hg st --rev 46ad32a4f974

        #    changed: 13

        #    added:   20

        #    removed: 1

        changed = set(['.hgignore'

            , 'README.rst' , 'docs/conf.py' , 'docs/index.rst' , 'setup.py'

            , 'tests/test_hg.py' , 'tests/test_nodes.py' , 'vcs/__init__.py'

            , 'vcs/backends/__init__.py' , 'vcs/backends/base.py'

            , 'vcs/backends/hg.py' , 'vcs/nodes.py' , 'vcs/utils/__init__.py'])

        added = set(['docs/api/backends/hg.rst'

            , 'docs/api/backends/index.rst' , 'docs/api/index.rst'

            , 'docs/api/nodes.rst' , 'docs/api/web/index.rst'

            , 'docs/api/web/simplevcs.rst' , 'docs/installation.rst'

            , 'docs/quickstart.rst' , 'setup.cfg' , 'vcs/utils/baseui_config.py'

            , 'vcs/utils/web.py' , 'vcs/web/__init__.py' , 'vcs/web/exceptions.py'

            , 'vcs/web/simplevcs/__init__.py' , 'vcs/web/simplevcs/exceptions.py'

            , 'vcs/web/simplevcs/middleware.py' , 'vcs/web/simplevcs/models.py'

            , 'vcs/web/simplevcs/settings.py' , 'vcs/web/simplevcs/utils.py'

            , 'vcs/web/simplevcs/views.py'])

        removed = set(['docs/api.rst'])

        chset64 = self.repo.get_changeset('46ad32a4f974')

        assert set((node.path for node in chset64.added)) == added

        assert set((node.path for node in chset64.changed)) == changed

        assert set((node.path for node in chset64.removed)) == removed

        # rev b090f22d27d6:

        # hg st --rev b090f22d27d6

        #    changed: 13

        #    added:   20

        #    removed: 1

        chset88 = self.repo.get_changeset('b090f22d27d6')

        assert set((node.path for node in chset88.added)) == set()

        assert set((node.path for node in chset88.changed)) == set(['.hgignore'])

        assert set((node.path for node in chset88.removed)) == set()

        # 85:

        #    added:   2 ['vcs/utils/diffs.py', 'vcs/web/simplevcs/views/diffs.py']

        #    changed: 4 ['vcs/web/simplevcs/models.py', ...]

        #    removed: 1 ['vcs/utils/web.py']

        chset85 = self.repo.get_changeset(85)

        assert set((node.path for node in chset85.added)) == set([

            'vcs/utils/diffs.py',

            'vcs/web/simplevcs/views/diffs.py'

        ])

        assert set((node.path for node in chset85.changed)) == set([

            'vcs/web/simplevcs/models.py',

            'vcs/web/simplevcs/utils.py',

            'vcs/web/simplevcs/views/__init__.py',

            'vcs/web/simplevcs/views/repository.py',

        ])

        assert set((node.path for node in chset85.removed)) == set([

            'vcs/utils/web.py'

        ])

    def test_files_state(self):

        """

        Tests state of FileNodes.

        """

        chset = self.repo.get_changeset(85)

        node = chset.get_node('vcs/utils/diffs.py')

        assert node.state, NodeState.ADDED

        assert node.added

        assert not node.changed

        assert not node.not_changed

        assert not node.removed

        chset = self.repo.get_changeset(88)

        node = chset.get_node('.hgignore')

        assert node.state, NodeState.CHANGED

        assert not node.added

        assert node.changed

        assert not node.not_changed

        assert not node.removed

        chset = self.repo.get_changeset(85)

        node = chset.get_node('setup.py')

        assert node.state, NodeState.NOT_CHANGED

        assert not node.added

        assert not node.changed

        assert node.not_changed

        assert not node.removed

        # If node has REMOVED state then trying to fetch it would raise

        # ChangesetError exception

        chset = self.repo.get_changeset(2)

        path = 'vcs/backends/BaseRepository.py'

        with pytest.raises(NodeDoesNotExistError):

            chset.get_node(path)

        # but it would be one of ``removed`` (changeset's attribute)

        assert path in [rf.path for rf in chset.removed]

    def test_commit_message_is_unicode(self):

        for cm in self.repo:

            assert type(cm.message) == unicode

    def test_changeset_author_is_unicode(self):

        for cm in self.repo:

            assert type(cm.author) == unicode

    def test_repo_files_content_is_unicode(self):

        test_changeset = self.repo.get_changeset(100)

        for node in test_changeset.get_node('/'):

            if node.is_file():

                assert type(node.content) == unicode

    def test_wrong_path(self):

        # There is 'setup.py' in the root dir but not there:

        path = 'foo/bar/setup.py'

        with pytest.raises(VCSError):

            self.repo.get_changeset().get_node(path)

    def test_archival_file(self):

        # TODO:

        pass

    def test_archival_as_generator(self):

        # TODO:

        pass

    def test_archival_wrong_kind(self):

        tip = self.repo.get_changeset()

        with pytest.raises(VCSError):

            tip.fill_archive(kind='error')

    def test_archival_empty_prefix(self):

        # TODO:

        pass

    def test_author_email(self):

        assert 'marcin@python-blog.com' == self.repo.get_changeset('b986218ba1c9').author_email

        assert 'lukasz.balcerzak@python-center.pl' == self.repo.get_changeset('3803844fdbd3').author_email

        assert '' == self.repo.get_changeset('84478366594b').author_email

    def test_author_username(self):

        assert 'Marcin Kuzminski' == self.repo.get_changeset('b986218ba1c9').author_name

        assert 'Lukasz Balcerzak' == self.repo.get_changeset('3803844fdbd3').author_name

        assert 'marcink' == self.repo.get_changeset('84478366594b').author_name

    def test_successors(self):

        init_chset = self.repo.get_changeset(0)

        assert init_chset.successors == []

    def test_predecessors(self):

        init_chset = self.repo.get_changeset(0)