# 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 = ["ancestors(id('%s')) and not ancestors(id('%s')) and not id('%s')" %

                        (other_rev, org_rev, org_rev)]

                ancestors = scmutil.revrange(hgrepo,

                     ["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 = ["id('%s') :: id('%s') - id('%s')" %

                        (org_rev, other_rev, org_rev)]

            changesets = [other_repo.get_changeset(cs)

                          for cs in scmutil.revrange(hgrepo, revs)]

        elif alias == 'git':

            so, se = org_repo.run_git_command(

            )

            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

            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

        self.__get_cs_or_redirect(rev=org_ref, repo=org_repo, partial=partial)

        self.__get_cs_or_redirect(rev=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,

                                                       org_repo.scm_instance, org_ref,

                                                       other_repo.scm_instance, other_ref,

                                                       merge)

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

                                                   c.cs_ranges])

        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_ref = ('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@%s and %s@%s'

                  % (org_repo.scm_instance.path, org_ref,

                     other_repo.scm_instance.path, other_ref))

        diff_processor = diffs.DiffProcessor(_diff or '', format='gitdiff',

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.files = []

        c.changes = {}

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            if st[0] != 'b':

                c.lines_added += st[0]

                c.lines_deleted += st[1]

            fid = h.FID('', f['filename'])

            c.files.append([fid, f['operation'], f['filename'], f['stats']])

            diff = diff_processor.as_html(enable_comments=False, parsed_lines=[f])

            c.changes[fid] = [f['operation'], f['filename'], diff]

        return render('compare/compare_diff.html')