import re

from itertools import chain

from dulwich import objects

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import ChangesetError

from rhodecode.lib.vcs.exceptions import NodeDoesNotExistError

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import ImproperArchiveTypeError

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

from rhodecode.lib.vcs.nodes import FileNode, DirNode, NodeKind, RootNode, \

    RemovedFileNode, SubModuleNode

from rhodecode.lib.vcs.utils import safe_unicode

from rhodecode.lib.vcs.utils import date_fromtimestamp

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

from dulwich.objects import Commit, Tag

class GitChangeset(BaseChangeset):

    """

    Represents state of the repository at single revision.

    """

    def __init__(self, repository, revision):

        self._stat_modes = {}

        self.repository = repository

        try:

        except KeyError:

        self._commit = commit

            self._tree_id = commit.tree

            self._commiter_property = 'committer'

            self._date_property = 'commit_time'

            self._date_tz_property = 'commit_timezone'

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

        self.message = safe_unicode(commit.message)

        #self.branch = None

        self.tags = []

        self.nodes = {}

        self._paths = {}

    @LazyProperty

    def author(self):

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

    @LazyProperty

    def date(self):

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

                                  getattr(self._commit, self._date_tz_property))

    @LazyProperty

    def status(self):

        """

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

        """

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

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

        # 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]

        dirnodes = []

        filenodes = []

        als = self.repository.alias

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

            if objects.S_ISGITLINK(stat):

                dirnodes.append(SubModuleNode(name, url=None, changeset=id,

                                              alias=als))

                continue

            obj = self.repository._repo.get_object(id)

            if path != '':

                obj_path = '/'.join((path, name))

            else:

                obj_path = name

            if obj_path not in self._stat_modes:

                self._stat_modes[obj_path] = stat

            if isinstance(obj, objects.Tree):

                dirnodes.append(DirNode(obj_path, changeset=self))

            elif isinstance(obj, objects.Blob):

                filenodes.append(FileNode(obj_path, changeset=self, mode=stat))

            else:

                raise ChangesetError("Requested object should be Tree "

                                     "or Blob, is %r" % type(obj))

        nodes = dirnodes + filenodes

        for node in nodes:

            if not node.path in self.nodes:

                self.nodes[node.path] = node

        nodes.sort()

        return nodes

    def get_node(self, path):

        if isinstance(path, unicode):

            path = path.encode('utf-8')

        path = self._fix_path(path)

        if not path in self.nodes:

            try:

                id_ = self._get_id_for_path(path)

            except ChangesetError:

                raise NodeDoesNotExistError("Cannot find one of parents' "

                    "directories for a given path: %s" % path)

            _GL = lambda m: m and objects.S_ISGITLINK(m)

            if _GL(self._stat_modes.get(path)):

                node = SubModuleNode(path, url=None, changeset=id_,

                                     alias=self.repository.alias)

            else:

                obj = self.repository._repo.get_object(id_)

                    if path == '':

                        node = RootNode(changeset=self)

                    else:

                        node = DirNode(path, changeset=self)

                    node._tree = obj

                elif isinstance(obj, objects.Blob):

                    node = FileNode(path, changeset=self)

                    node._blob = obj

                else:

                    raise NodeDoesNotExistError("There is no file nor directory "

                        "at the given path %r at revision %r"

                        % (path, self.short_id))

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        Get's a fast accessible file changes for given changeset

        """

        return self.added + self.changed

    @LazyProperty

    def _diff_name_status(self):

        output = []

        for parent in self.parents:

            cmd = 'diff --name-status %s %s --encoding=utf8' % (parent.raw_id, self.raw_id)

            so, se = self.repository.run_git_command(cmd)

            output.append(so.strip())

        return '\n'.join(output)

    def _get_paths_for_status(self, status):

        """

        Returns sorted list of paths for given ``status``.

        :param status: one of: *added*, *modified* or *deleted*

        """

        paths = set()

        char = status[0].upper()

        for line in self._diff_name_status.splitlines():

            if not line:

                continue

            if line.startswith(char):

                splitted = line.split(char, 1)

                if not len(splitted) == 2: