#############################
### Tree Hash computation ###
#############################

# Status: dropable
#
# This module don't need to be upstreamed and can be dropped if its maintenance
# become a burden

import hashlib

from mercurial import (
    error,
    node,
    obsolete,
)

from mercurial.i18n import _

from . import (
    compat,
    exthelper,
)

eh = exthelper.exthelper()

# Dash computed from a given changesets using all markers relevant to it and
# the obshash of its parents.  This is similar to what happend for changeset
# node where the parent is used in the computation
@eh.command(
    b'debugobsrelsethashtree',
    [(b'', b'v0', None, b'hash on marker format "0"'),
     (b'', b'v1', None, b'hash on marker format "1" (default)')], _(b''))
def debugobsrelsethashtree(ui, repo, v0=False, v1=False):
    """display Obsolete markers, Relevant Set, Hash Tree
    changeset-node obsrelsethashtree-node

    It computed form the "obs-hash-tree" value of its parent and markers
    relevant to the changeset itself.

    The obs-hash-tree is no longer used for any user facing logic. However the
    debug command stayed as an inspection tool. It does not seem supseful to
    upstream the command with the rest of evolve. We can safely drop it."""
    if v0 and v1:
        raise error.Abort(b'cannot only specify one format')
    elif v0:
        treefunc = _obsrelsethashtreefm0
    else:
        treefunc = _obsrelsethashtreefm1

    for chg, obs in treefunc(repo):
        ui.status(b'%s %s\n' % (node.hex(chg), node.hex(obs)))

def _obsrelsethashtreefm0(repo):
    return _obsrelsethashtree(repo, obsolete._fm0encodeonemarker)

def _obsrelsethashtreefm1(repo):
    return _obsrelsethashtree(repo, obsolete._fm1encodeonemarker)

def _obsrelsethashtree(repo, encodeonemarker):
    cache = []
    unfi = repo.unfiltered()
    markercache = {}
    compat.progress(repo.ui, _(b"preparing locally"), 0, total=len(unfi),
                    unit=_(b"changesets"))
    for i in unfi:
        ctx = unfi[i]
        entry = 0
        sha = hashlib.sha1()
        # add data from p1
        for p in ctx.parents():
            p = p.rev()
            if p < 0:
                p = node.nullid
            else:
                p = cache[p][1]
            if p != node.nullid:
                entry += 1
                sha.update(p)
        tmarkers = repo.obsstore.relevantmarkers([ctx.node()])
        if tmarkers:
            bmarkers = []
            for m in tmarkers:
                if m not in markercache:
                    markercache[m] = encodeonemarker(m)
                bmarkers.append(markercache[m])
            bmarkers.sort()
            for m in bmarkers:
                entry += 1
                sha.update(m)
        if entry:
            cache.append((ctx.node(), sha.digest()))
        else:
            cache.append((ctx.node(), node.nullid))
        compat.progress(repo.ui, _(b"preparing locally"), i, total=len(unfi),
                        unit=_(b"changesets"))
    compat.progress(repo.ui, _(b"preparing locally"), None)
    return cache