import re

from itertools import chain

from dulwich import objects

from subprocess import Popen, PIPE

from kallithea.lib.vcs.conf import settings

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

from kallithea.lib.vcs.exceptions import (

    RepositoryError, ChangesetError, NodeDoesNotExistError, VCSError,

    ChangesetDoesNotExistError, ImproperArchiveTypeError

)

from kallithea.lib.vcs.nodes import (

    FileNode, DirNode, NodeKind, RootNode, RemovedFileNode, SubModuleNode,

    ChangedFileNodesGenerator, AddedFileNodesGenerator, RemovedFileNodesGenerator

)

from kallithea.lib.vcs.utils import (

    safe_unicode, safe_str, safe_int, date_fromtimestamp

)

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

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 message(self):

        return safe_unicode(self._commit.message)

    @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))

    @LazyProperty

    def _timestamp(self):

        return getattr(self._commit, self._date_property)

    @LazyProperty

    def status(self):

        """

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

        """

        return self.changed, self.added, self.removed

    @LazyProperty

    def tags(self):

        _tags = []

        for tname, tsha in self.repository.tags.iteritems():

            if tsha == self.raw_id:

                _tags.append(tname)

        return _tags

    @LazyProperty

    def branch(self):

        heads = self.repository._heads(reverse=False)

        ref = heads.get(self.raw_id)

        if ref:

            return safe_unicode(ref)

    def _fix_path(self, path):

        """

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

        needed.

        """

        if path.endswith('/'):

            path = path.rstrip('/')

        return path

    def _get_id_for_path(self, path):

        path = safe_str(path)

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

        if not path in self._paths:

            path = path.strip('/')

            # set root tree

            tree = self.repository._repo[self._tree_id]

            if path == '':

                self._paths[''] = tree.id

                return tree.id

            splitted = path.split('/')

            dirs, name = splitted[:-1], splitted[-1]

            curdir = ''

            # initially extract things from root dir

            for item, stat, id in tree.iteritems():

                if curdir:

                    name = '/'.join((curdir, item))

                else:

                    name = item

                self._paths[name] = id

                self._stat_modes[name] = stat

            for dir in dirs:

                if curdir:

                    curdir = '/'.join((curdir, dir))

                else:

                    curdir = dir

                dir_id = None

                for item, stat, id in tree.iteritems():

                    if dir == item:

                        dir_id = id

                if dir_id:

                    # Update tree

                    tree = self.repository._repo[dir_id]

                    if not isinstance(tree, objects.Tree):

                        raise ChangesetError('%s is not a directory' % curdir)

                else:

                    raise ChangesetError('%s have not been found' % curdir)

                # cache all items from the given traversed tree

                for item, stat, id in tree.iteritems():

                    if curdir:

                        name = '/'.join((curdir, item))

                    else:

                        name = item

                    self._paths[name] = id

                    self._stat_modes[name] = stat

            if not path in self._paths:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path '%s' at revision %s"

                    % (path, safe_str(self.short_id)))

        return self._paths[path]

    def _get_kind(self, path):

        obj = self.repository._repo[self._get_id_for_path(path)]

        if isinstance(obj, objects.Blob):

            return NodeKind.FILE

        elif isinstance(obj, objects.Tree):

            return NodeKind.DIR

    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 path

    def _get_file_nodes(self):

        return chain(*(t[2] for t in self.walk()))

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(parent)

                for parent in self._commit.parents]

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        rev_filter = _git_path = settings.GIT_REV_FILTER

        so, se = self.repository.run_git_command(

            "rev-list %s --children" % (rev_filter)

        )

        children = []

        pat = re.compile(r'^%s' % self.raw_id)

        for l in so.splitlines():

            if pat.match(l):

                childs = l.split(' ')[1:]

                children.extend(childs)

        return [self.repository.get_changeset(cs) for cs in children]

    def next(self, branch=None):

        if branch and self.branch != branch:

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

                           'to that branch')

        def _next(changeset, branch):

            try:

                next_ = changeset.revision + 1

                next_rev = changeset.repository.revisions[next_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = changeset.repository.get_changeset(next_rev)

            if branch and branch != cs.branch:

                return _next(cs, branch)

            return cs

        return _next(self, branch)

    def prev(self, branch=None):