'rev': 'id',

                }

            rev_spec = "max(%s(%%s))" % _revset_predicates[ref[0]]

            revs = repo.scm_instance._repo.revs(rev_spec, safe_str(ref[1]))

            if revs:

                rev = revs[-1]

            # else: TODO: just report 'not found'

        try:

            return repo.scm_instance.get_changeset(rev).raw_id

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=repo.repo_name))

        except RepositoryError, e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            if not partial:

                redirect(h.url('summary_home', repo_name=repo.repo_name))

            raise HTTPBadRequest()

        """

        """

        ancestor = None

        if org_rev == other_rev:

            changesets = []

            if merge:

                ancestor = org_rev

        elif alias == 'hg':

            #case two independent repos

            if org_repo != other_repo:

                hgrepo = unionrepo.unionrepository(other_repo.baseui,

                                                   other_repo.path,

                                                   org_repo.path)

                # all the changesets we are looking for will be in other_repo,

                # so rev numbers from hgrepo can be used in other_repo

            #no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            if merge:

                revs = hgrepo.revs("ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                                   other_rev, org_rev, org_rev)

                ancestors = hgrepo.revs("ancestor(id(%s), id(%s))", org_rev, other_rev)

                if ancestors:

                    # pick arbitrary ancestor - but there is usually only one

                    ancestor = hgrepo[ancestors[0]].hex()

            else:

                # TODO: have both + and - changesets

                revs = hgrepo.revs("id(%s) :: id(%s) - id(%s)",

                                   org_rev, other_rev, org_rev)

            changesets = [other_repo.get_changeset(rev) for rev in revs]

        elif alias == 'git':

            if org_repo != other_repo:

                raise Exception('Comparing of different GIT repositories is not'

                                'allowed. Got %s != %s' % (org_repo, other_repo))

            so, se = org_repo.run_git_command(

                'log --reverse --pretty="format: %%H" -s -p %s..%s'

            )

            changesets = [org_repo.get_changeset(cs)

                          for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

        return changesets, ancestor

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, org_ref_type, org_ref, other_ref_type, other_ref):

        # org_ref will be evaluated in org_repo

        org_repo = c.rhodecode_db_repo.repo_name

        org_ref = (org_ref_type, org_ref)

        # other_ref will be evaluated in other_repo

        other_ref = (other_ref_type, other_ref)

        other_repo = request.GET.get('other_repo', org_repo)

        # If merge is True:

        #   Show what org would get if merged with other:

        #   List changesets that are ancestors of other but not of org.

        #   New changesets in org is thus ignored.

        #   Diff will be from common ancestor, and merges of org to other will thus be ignored.

        # If merge is False:

        #   Make a raw diff from org to other, no matter if related or not.

        #   Changesets in one and not in the other will be ignored

            raise HTTPNotFound

        if other_repo is None:

            log.error('Could not find other repo %s' % other_repo)

            raise HTTPNotFound

        if org_repo != other_repo and h.is_git(org_repo):

            log.error('compare of two remote repos not available for GIT REPOS')

            raise HTTPNotFound

        if org_repo.scm_instance.alias != other_repo.scm_instance.alias:

            log.error('compare of two different kind of remote repos not available')

            raise HTTPNotFound

        org_rev = self.__get_rev_or_redirect(ref=org_ref, repo=org_repo, partial=partial)

        other_rev = self.__get_rev_or_redirect(ref=other_ref, repo=other_repo, partial=partial)

        c.org_repo = org_repo

        c.other_repo = other_repo

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        c.org_ref_type = org_ref[0]

        c.other_ref_type = other_ref[0]

        c.cs_ranges, c.ancestor = self._get_changesets(org_repo.scm_instance.alias,

                                                       merge)

        c.statuses = c.rhodecode_db_repo.statuses([x.raw_id for x in

                                                   c.cs_ranges])

        if merge and not c.ancestor:

            log.error('Unable to find ancestor revision')

        if partial:

            return render('compare/compare_cs.html')

        if c.ancestor:

            assert merge

            # case we want a simple diff without incoming changesets,

            # previewing what will be merged.

            # Make the diff on the other repo (which is known to have other_ref)

            log.debug('Using ancestor %s as org_ref instead of %s'

                      % (c.ancestor, org_ref))

            org_rev = c.ancestor

            org_repo = other_repo

        diff_limit = self.cut_off_limit if not c.fulldiff else None

        log.debug('running diff between %s and %s in %s'

                  % (org_rev, other_rev, org_repo.scm_instance.path))