from __future__ import annotations

from typing import (

    Iterable,

    Iterator,

)

from mercurial.i18n import _

from mercurial.node import (

    bin,

    hex,

    nullrev,

    sha1nodeconstants,

)

from mercurial import (

    ancestor,

    changelog as hgchangelog,

    dagop,

    encoding,

    error,

    manifest,

    pycompat,

)

from mercurial.interfaces import (

    repository,

)

from mercurial.utils import stringutil

from . import (

    gitutil,

    index,

    manifest as gitmanifest,

)

pygit2 = gitutil.get_pygit2()

class baselog:  # revlog.revlog):

    """Common implementations between changelog and manifestlog."""

    def __init__(self, gr, db):

        self.gitrepo = gr

        self._db = db

    def __len__(self) -> int:

    def files(self):

        raise NotImplementedError

    def storageinfo(

        self,

        exclusivefiles=False,

        sharedfiles=False,

        revisionscount=False,

        trackedsize=False,

        storedsize=False,

    ):

        raise NotImplementedError

    def verifyintegrity(self, state) -> Iterable[repository.iverifyproblem]:

        raise NotImplementedError

    def revs(self, start=0, stop=None):

        raise NotImplementedError

    def addgroup(

        self,

        deltas,

        linkmapper,

        transaction,

        addrevisioncb=None,

        duplicaterevisioncb=None,

    ):

        raise NotImplementedError

    def commonancestorsheads(self, node1, node2):

        raise NotImplementedError

    def descendants(self, revs):

        raise NotImplementedError

    def heads(self, start=None, stop=None):

        raise NotImplementedError

    def children(self, node):

        raise NotImplementedError

    def emitrevisions(

        self,

        nodes,

        nodesorder=None,

        revisiondata=False,

        assumehaveparentrevisions=False,

    ):

        raise NotImplementedError

    def getstrippoint(self, minlink):

        raise NotImplementedError

    def iscensored(self, rev):

        raise NotImplementedError

    def parentrevs(self, rev):

        raise NotImplementedError

    def rawdata(self, node):

        raise NotImplementedError

    def revision(self, node):

        raise NotImplementedError

    def size(self, rev):

        raise NotImplementedError

    def strip(self, minlink, transaction):

        raise NotImplementedError

    def addrevision(

        self,

        revisiondata,

        transaction,

        linkrev,

        p1,

        p2,

        node=None,

        flags=0,

        cachedelta=None,

    ):

        raise NotImplementedError

    def censorrevision(self, tr, node, tombstone=b''):

        raise NotImplementedError

    def rev(self, n):

        if n == sha1nodeconstants.nullid:

            return -1

        t = self._db.execute(

            'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),)

        ).fetchone()

        if t is None:

            raise error.LookupError(n, b'00changelog.i', _(b'no node %d'))

        return t[0]

    def node(self, r):

        if r == nullrev:

            return sha1nodeconstants.nullid

        t = self._db.execute(

            'SELECT node FROM changelog WHERE rev = ?', (r,)

        ).fetchone()

        if t is None:

            raise error.LookupError(r, b'00changelog.i', _(b'no node'))

        return bin(t[0])

    def synthetic(self, n):

        """Map any node to a non-synthetic node.

        Indexing may have created synthetic nodes to handle octopus merges.

        Certain operations on these made up nodes need to actually happen on

        the real octopus merge commit.  Given any node, this function

        returns the real commit hash.  One can think of this as hg-to-git

        commit hash translation that always works."""

        t = self._db.execute(

            'SELECT synthetic FROM changelog WHERE node = ?',

            (gitutil.togitnode(n),),

        ).fetchone()

        if t is None or t[0] is None:

            return n

        return bin(t[0])

    def hasnode(self, n):

        t = self._db.execute(

            'SELECT node FROM changelog WHERE node = ?',

            (pycompat.sysstr(n),),

        ).fetchone()

        return t is not None

class baselogindex:

    def __init__(self, log):

        self._log = log

    def has_node(self, n):

        return self._log.rev(n) != -1

    def __len__(self):

        return len(self._log)

    def __getitem__(self, idx):

        p1rev, p2rev = self._log.parentrevs(idx)

        # TODO: it's messy that the index leaks so far out of the

        # storage layer that we have to implement things like reading

        # this raw tuple, which exposes revlog internals.

        return (

            # Pretend offset is just the index, since we don't really care.

            idx,

            # Same with lengths

            idx,  # length

            idx,  # rawsize

            -1,  # delta base

            idx,  # linkrev TODO is this right?

            p1rev,

            p2rev,

            self._log.node(idx),

        )

    def rev(self, node):

        return self._log.rev(node)

    def get_rev(self, node):

        return self._log.get_rev(node)

# TODO: an interface for the changelog type?

class changelog(baselog):

    # TODO: this appears to be an enumerated type, and should probably

    # be part of the public changelog interface

    _copiesstorage = b'extra'

    def __contains__(self, rev):

        try:

            self.node(rev)

            return True

        except error.LookupError:

            return False

    def __iter__(self):

        return iter(range(len(self)))

    @property

    def filteredrevs(self):

        # TODO: we should probably add a refs/hg/ namespace for hidden

        # heads etc, but that's an idea for later.

        return set()

    @property

    def index(self):

        return baselogindex(self)

    @property

    def nodemap(self):

        r = {

            bin(v[0]): v[1]

            for v in self._db.execute('SELECT node, rev FROM changelog')

        }

        r[sha1nodeconstants.nullid] = nullrev

        return r

    def tip(self):

        t = self._db.execute(

            'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1'

        ).fetchone()

        if t:

            return bin(t[0])

        return sha1nodeconstants.nullid

    def revs(self, start=0, stop=None):

        if stop is None:

            stop = self.tiprev()

        t = self._db.execute(

            'SELECT rev FROM changelog '

            'WHERE rev >= ? AND rev <= ? '

            'ORDER BY REV ASC',

            (start, stop),

        )

        return (int(r[0]) for r in t)

    def tiprev(self):

        t = self._db.execute(

            'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1'

        ).fetchone()

        if t is not None:

            return t[0]

        return -1

    def _partialmatch(self, id):

        if sha1nodeconstants.wdirhex.startswith(id):

            raise error.WdirUnsupported

        candidates = [

            bin(x[0])

            for x in self._db.execute(

                'SELECT node FROM changelog WHERE node LIKE ?',

                (pycompat.sysstr(id + b'%'),),

            )

        ]

        if sha1nodeconstants.nullhex.startswith(id):

            candidates.append(sha1nodeconstants.nullid)

        if len(candidates) > 1:

            raise error.AmbiguousPrefixLookupError(

                id, b'00changelog.i', _(b'ambiguous identifier')

            )

        if candidates:

            return candidates[0]

        return None

    def flags(self, rev):

        return 0

    def shortest(self, node, minlength=1):

        nodehex = hex(node)

        for attempt in range(minlength, len(nodehex) + 1):

            candidate = nodehex[:attempt]

            matches = int(

                self._db.execute(

                    'SELECT COUNT(*) FROM changelog WHERE node LIKE ?',

                    (pycompat.sysstr(candidate + b'%'),),

                ).fetchone()[0]

            )

            if matches == 1:

                return candidate

        return nodehex

    def headrevs(self, revs=None):

        realheads = [

            int(x[0])

            for x in self._db.execute(

                'SELECT rev FROM changelog '

                'INNER JOIN heads ON changelog.node = heads.node'

            )

        ]

        if revs:

            return sorted([r for r in revs if r in realheads])

        return sorted(realheads)

    def changelogrevision(self, nodeorrev):

        # Ensure we have a node id

        if isinstance(nodeorrev, int):

            n = self.node(nodeorrev)

        else:

            n = nodeorrev

        extra = {b'branch': b'default'}

        # handle looking up nullid

        if n == sha1nodeconstants.nullid:

            return hgchangelog._changelogrevision(

                extra=extra, manifest=sha1nodeconstants.nullid

            )

        n = self.synthetic(n)

        hn = gitutil.togitnode(n)

        # We've got a real commit!

        index._index_repo_commit(self.gitrepo, self._db, hn, commit=True)

        files = [

            r[0]

            for r in self._db.execute(

                'SELECT filename FROM changedfiles '

                'WHERE node = ? and filenode != ?',

                (hn, gitutil.nullgit),

            )

        ]

        filesremoved = [

            r[0]

            for r in self._db.execute(

                'SELECT filename FROM changedfiles '

                'WHERE node = ? and filenode = ?',

                (hn, gitutil.nullgit),

            )

        ]

        c = self.gitrepo[hn]

        return hgchangelog._changelogrevision(

            manifest=n,  # pretend manifest the same as the commit node

            user=b'%s <%s>'

            % (c.author.name.encode('utf8'), c.author.email.encode('utf8')),

            date=(c.author.time, -c.author.offset * 60),

            files=files,

            # TODO filesadded in the index

            filesremoved=filesremoved,

            description=c.message.encode('utf8'),

            # TODO do we want to handle extra? how?

            extra=extra,

        )

    def ancestors(self, revs, stoprev=0, inclusive=False):

        revs = list(revs)

        tip = self.rev(self.tip())

        for r in revs:

            if r > tip:

                raise IndexError(b'Invalid rev %r' % r)

        return ancestor.lazyancestors(

            self.parentrevs, revs, stoprev=stoprev, inclusive=inclusive

        )

    # Cleanup opportunity: this is *identical* to the revlog.py version

    def descendants(self, revs):

        return dagop.descendantrevs(revs, self.revs, self.parentrevs)

    def incrementalmissingrevs(self, common=None):

        """Return an object that can be used to incrementally compute the

        revision numbers of the ancestors of arbitrary sets that are not

        ancestors of common. This is an ancestor.incrementalmissingancestors

        object.

        'common' is a list of revision numbers. If common is not supplied, uses

        nullrev.

        """

        if common is None:

            common = [nullrev]

        return ancestor.incrementalmissingancestors(self.parentrevs, common)

    def findmissingrevs(self, common=None, heads=None):

        """Return the revision numbers of the ancestors of heads that

        are not ancestors of common.

        More specifically, return a list of revision numbers corresponding to

        nodes N such that every N satisfies the following constraints:

          1. N is an ancestor of some node in 'heads'

          2. N is not an ancestor of any node in 'common'

        The list is sorted by revision number, meaning it is

        topologically sorted.

        'heads' and 'common' are both lists of revision numbers.  If heads is

        not supplied, uses all of the revlog's heads.  If common is not

        supplied, uses nullid."""

        if common is None:

            common = [nullrev]

        if heads is None:

            heads = self.headrevs()

        inc = self.incrementalmissingrevs(common=common)

        return inc.missingancestors(heads)

    def findmissing(self, common=None, heads=None):

        """Return the ancestors of heads that are not ancestors of common.

        More specifically, return a list of nodes N such that every N

        satisfies the following constraints:

          1. N is an ancestor of some node in 'heads'

          2. N is not an ancestor of any node in 'common'

        The list is sorted by revision number, meaning it is

        topologically sorted.

        'heads' and 'common' are both lists of node IDs.  If heads is

        not supplied, uses all of the revlog's heads.  If common is not

        supplied, uses nullid."""

        if common is None:

            common = [sha1nodeconstants.nullid]

        if heads is None:

            heads = [self.node(r) for r in self.headrevs()]

        common = [self.rev(n) for n in common]

        heads = [self.rev(n) for n in heads]

        inc = self.incrementalmissingrevs(common=common)

        return [self.node(r) for r in inc.missingancestors(heads)]

    def children(self, node):

        """find the children of a given node"""

        c = []

        p = self.rev(node)

        for r in self.revs(start=p + 1):

            prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]

            if prevs:

                for pr in prevs:

                    if pr == p:

                        c.append(self.node(r))

            elif p == nullrev:

                c.append(self.node(r))

        return c

    def reachableroots(self, minroot, heads, roots, includepath=False):

        return dagop._reachablerootspure(

            self.parentrevs, minroot, roots, heads, includepath

        )

    # Cleanup opportunity: this is *identical* to the revlog.py version

    def isancestor(self, a, b):

        a, b = self.rev(a), self.rev(b)

        return self.isancestorrev(a, b)

    # Cleanup opportunity: this is *identical* to the revlog.py version

    def isancestorrev(self, a, b):

        if a == nullrev:

            return True

        elif a == b:

            return True

        elif a > b:

            return False

        return bool(self.reachableroots(a, [b], [a], includepath=False))

    def parentrevs(self, rev):

        assert rev >= 0, rev

        t = self._db.execute(

            'SELECT p1, p2 FROM changelog WHERE rev = ?', (rev,)

        ).fetchone()

        if t is None:

            raise error.LookupError(rev, b'00changelog.i', _(b'no rev'))

        return self.rev(bin(t[0])), self.rev(bin(t[1]))

    # Private method is used at least by the tags code.

    _uncheckedparentrevs = parentrevs

    def commonancestorsheads(self, a, b):

        # TODO the revlog verson of this has a C path, so we probably

        # need to optimize this...

        a, b = self.rev(a), self.rev(b)

        return [

            self.node(n)

            for n in ancestor.commonancestorsheads(self.parentrevs, a, b)

        ]