from __future__ import absolute_import, print_function

import binascii

import getopt

import math

import os

import random

import sys

import time

from mercurial.node import nullrev

from mercurial import (

    ancestor,

    commands,

    hg,

    ui as uimod,

    util,

)

def buildgraph(rng, nodes=100, rootprob=0.05, mergeprob=0.2, prevprob=0.7):

    '''nodes: total number of nodes in the graph

    rootprob: probability that a new node (not 0) will be a root

    mergeprob: probability that, excluding a root a node will be a merge

    prevprob: probability that p1 will be the previous node

    return value is a graph represented as an adjacency list.

    '''

    graph = [None] * nodes

    for i in xrange(nodes):

        if i == 0 or rng.random() < rootprob:

            graph[i] = [nullrev]

        elif i == 1:

            graph[i] = [0]

        elif rng.random() < mergeprob:

            if i == 2 or rng.random() < prevprob:

                # p1 is prev

                p1 = i - 1

            else:

                p1 = rng.randrange(i - 1)

            p2 = rng.choice(range(0, p1) + range(p1 + 1, i))

            graph[i] = [p1, p2]

        elif rng.random() < prevprob:

            graph[i] = [i - 1]

        else:

            graph[i] = [rng.randrange(i - 1)]

    return graph

def buildancestorsets(graph):

    ancs = [None] * len(graph)

    for i in xrange(len(graph)):

        ancs[i] = set([i])

        if graph[i] == [nullrev]:

            continue

        for p in graph[i]:

            ancs[i].update(ancs[p])

    return ancs

class naiveincrementalmissingancestors(object):

    def __init__(self, ancs, bases):

        self.ancs = ancs

        self.bases = set(bases)

    def addbases(self, newbases):

        self.bases.update(newbases)

    def removeancestorsfrom(self, revs):

        for base in self.bases:

            if base != nullrev:

                revs.difference_update(self.ancs[base])

        revs.discard(nullrev)

    def missingancestors(self, revs):

        res = set()

        for rev in revs:

            if rev != nullrev:

                res.update(self.ancs[rev])

        for base in self.bases:

            if base != nullrev:

                res.difference_update(self.ancs[base])

        return sorted(res)

def test_missingancestors(seed, rng):

    # empirically observed to take around 1 second

    graphcount = 100

    testcount = 10

    inccount = 10

    nerrs = [0]

    # the default mu and sigma give us a nice distribution of mostly

    # single-digit counts (including 0) with some higher ones

    def lognormrandom(mu, sigma):

        return int(math.floor(rng.lognormvariate(mu, sigma)))

    def samplerevs(nodes, mu=1.1, sigma=0.8):

        count = min(lognormrandom(mu, sigma), len(nodes))

        return rng.sample(nodes, count)

    def err(seed, graph, bases, seq, output, expected):

        if nerrs[0] == 0:

            print('seed:', hex(seed)[:-1], file=sys.stderr)

        if gerrs[0] == 0:

            print('graph:', graph, file=sys.stderr)

        print('* bases:', bases, file=sys.stderr)

        print('* seq: ', seq, file=sys.stderr)

        print('*  output:  ', output, file=sys.stderr)

        print('*  expected:', expected, file=sys.stderr)

        nerrs[0] += 1

        gerrs[0] += 1

    for g in xrange(graphcount):

        graph = buildgraph(rng)

        ancs = buildancestorsets(graph)

        gerrs = [0]

        for _ in xrange(testcount):

            # start from nullrev to include it as a possibility

            graphnodes = range(nullrev, len(graph))

            bases = samplerevs(graphnodes)

            # fast algorithm

            inc = ancestor.incrementalmissingancestors(graph.__getitem__, bases)

            # reference slow algorithm

            naiveinc = naiveincrementalmissingancestors(ancs, bases)

            seq = []

            revs = []

            for _ in xrange(inccount):

                if rng.random() < 0.2:

                    newbases = samplerevs(graphnodes)

                    seq.append(('addbases', newbases))

                    inc.addbases(newbases)

                    naiveinc.addbases(newbases)

                if rng.random() < 0.4:

                    # larger set so that there are more revs to remove from

                    revs = samplerevs(graphnodes, mu=1.5)

                    seq.append(('removeancestorsfrom', revs))

                    hrevs = set(revs)

                    rrevs = set(revs)

                    inc.removeancestorsfrom(hrevs)

                    naiveinc.removeancestorsfrom(rrevs)

                    if hrevs != rrevs:

                        err(seed, graph, bases, seq, sorted(hrevs),

                            sorted(rrevs))

                else:

                    revs = samplerevs(graphnodes)

                    seq.append(('missingancestors', revs))

                    h = inc.missingancestors(revs)

                    r = naiveinc.missingancestors(revs)

                    if h != r:

                        err(seed, graph, bases, seq, h, r)

# graph is a dict of child->parent adjacency lists for this graph:

# o  13

# |

# | o  12

# | |

# | | o    11

# | | |\

# | | | | o  10

# | | | | |

# | o---+ |  9

# | | | | |

# o | | | |  8

#  / / / /

# | | o |  7

# | | | |

# o---+ |  6

#  / / /

# | | o  5

# | |/

# | o  4

# | |

# o |  3

# | |

# | o  2

# |/

# o  1

# |

# o  0

graph = {0: [-1], 1: [0], 2: [1], 3: [1], 4: [2], 5: [4], 6: [4],

         7: [4], 8: [-1], 9: [6, 7], 10: [5], 11: [3, 7], 12: [9],

         13: [8]}

def genlazyancestors(revs, stoprev=0, inclusive=False):

    print(("%% lazy ancestor set for %s, stoprev = %s, inclusive = %s" %

           (revs, stoprev, inclusive)))

    return ancestor.lazyancestors(graph.get, revs, stoprev=stoprev,

                                  inclusive=inclusive)

def printlazyancestors(s, l):

    print('membership: %r' % [n for n in l if n in s])

    print('iteration:  %r' % list(s))

def test_lazyancestors():

    # Empty revs

    s = genlazyancestors([])

    printlazyancestors(s, [3, 0, -1])

    # Standard example

    s = genlazyancestors([11, 13])

    printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])

    # Standard with ancestry in the initial set (1 is ancestor of 3)

    s = genlazyancestors([1, 3])

    printlazyancestors(s, [1, -1, 0])

    # Including revs

    s = genlazyancestors([11, 13], inclusive=True)

    printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])

    # Test with stoprev

    s = genlazyancestors([11, 13], stoprev=6)

    printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])

    s = genlazyancestors([11, 13], stoprev=6, inclusive=True)

    printlazyancestors(s, [11, 13, 7, 9, 8, 3, 6, 4, 1, -1, 0])

# The C gca algorithm requires a real repo. These are textual descriptions of

# DAGs that have been known to be problematic.

dagtests = [

    '+2*2*2/*3/2',

    '+3*3/*2*2/*4*4/*4/2*4/2*2',

]

def test_gca():

    u = uimod.ui()

    for i, dag in enumerate(dagtests):

        repo = hg.repository(u, 'gca%d' % i, create=1)

        cl = repo.changelog

        if not util.safehasattr(cl.index, 'ancestors'):

            # C version not available

            return

        commands.debugbuilddag(u, repo, dag)

        # Compare the results of the Python and C versions. This does not

        # include choosing a winner when more than one gca exists -- we make

        # sure both return exactly the same set of gcas.

        for a in cl:

            for b in cl:

                cgcas = sorted(cl.index.ancestors(a, b))

                pygcas = sorted(ancestor.ancestors(cl.parentrevs, a, b))

                if cgcas != pygcas:

                    print("test_gca: for dag %s, gcas for %d, %d:"

                          % (dag, a, b))

                    print("  C returned:      %s" % cgcas)

                    print("  Python returned: %s" % pygcas)

def main():

    seed = None

    opts, args = getopt.getopt(sys.argv[1:], 's:', ['seed='])

    for o, a in opts:

        if o in ('-s', '--seed'):

            seed = long(a, base=0) # accepts base 10 or 16 strings

    if seed is None:

        try:

            seed = long(binascii.hexlify(os.urandom(16)), 16)

        except AttributeError:

            seed = long(time.time() * 1000)

    rng = random.Random(seed)

    test_missingancestors(seed, rng)

    test_lazyancestors()

    test_gca()

if __name__ == '__main__':

    main()