from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .config import ConfigFile

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)

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

        try:

            self.head = self._repo.head()

        except KeyError:

            self.head = None

        self._config_files = [

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

                'config'),

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

        ]

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

    def run_git_command(self, cmd):

        """

        Runs given ``cmd`` as git command and returns tuple

        (returncode, stdout, stderr).

        .. note::

           This method exists only until log/blame functionality is implemented

           at Dulwich (see https://bugs.launchpad.net/bugs/645142). Parsing

           os command's output is road to hell...

        :param cmd: git command to be executed

        """

        #cmd = '(cd %s && git %s)' % (self.path, cmd)

        if isinstance(cmd, basestring):

        else:

        try:

            opts = dict(

                shell=isinstance(cmd, basestring),

                stdout=PIPE,

                stderr=PIPE)

            if os.path.isdir(self.path):

                opts['cwd'] = self.path

            p = Popen(cmd, **opts)

        except OSError, err:

            raise RepositoryError("Couldn't run git command (%s).\n"

                "Original error was:%s" % (cmd, err))

        so, se = p.communicate()

        if not se.startswith("fatal: bad default revision 'HEAD'") and \

            p.returncode != 0:

            raise RepositoryError("Couldn't run git command (%s).\n"

                "stderr:\n%s" % (cmd, se))

        return so, se

    def _check_url(self, url):

        """

        Functon 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

        """

        #TODO: implement this

        pass

    def _get_repo(self, create, src_url=None, update_after_clone=False,

            bare=False):

        if create and os.path.exists(self.path):

            raise RepositoryError("Location already exist")

        if src_url and not create:

            raise RepositoryError("Create should be set to True if src_url is "

                                  "given (clone operation creates repository)")

        try:

            if create and src_url:

                self._check_url(src_url)

                self.clone(src_url, update_after_clone, bare)

                return Repo(self.path)

            elif create:

                os.mkdir(self.path)

                if bare:

                    return Repo.init_bare(self.path)

                else: