import sys

class bayes(object):
    def __init__(self, inputfile = None, verbose = False) :
        self.parent = {}
        self.evidence = {}
        self.lambdam = {}  # can't just use "self.lambda", lambda is a reserved word
        self.pi = {}
        self.linkmatrix = {}
        self.lambda_C = {}
        self.pi_P = {}
        self.numValues = {}
        self.topoOrder = [ ]
        self.topoNumber = { }
        if inputfile != None:
            self.readfile(inputfile)
        self.verbose = verbose

### Read in a single link matrix, set up the appropriate
### parent pointers, as well as all of the values in the
### link matrix
    def readMatrix(self, infile):
        header = infile.readline()
        childParentList  = header[header.find("(") + 1:header.find(")")].split("|")
        if len(childParentList) == 1:
            child = childParentList[0]
            parent = None
        else:
            [child,parent] = childParentList
        self.parent[child] = parent
        if parent == None:
            self.linkmatrix[child] = infile.readline().split()
        else:
            self.linkmatrix[child] = []
            for i in range(self.numValues[parent]):
                self.linkmatrix[child].append([float(x) for x in infile.readline().split()])

### Do a topological sort on the graph defined by the parent pointers
###  self.parent[], puting the result in self.topologicalOrder.  If
###  node 'a' appears 5th in a topological sort of the graph, then
###  self.topoloNumber['a'] == 5, and self.topoOrder[5] = 'a'.  Note that
###  topological ordering starts at 0                
    def topoSort(self):
        outDegree = {}
        stack = []
        for x in self.parent:
            outDegree[x] = 0
        for x in self.parent:
            par = self.parent[x]
            if par != None:
                outDegree[par] = outDegree[par] + 1
        zeroOutdegree = [x for x in self.parent if outDegree[x] == 0]
        topoNum = len(self.parent) - 1
        self.topoOrder = [-1] * len(self.parent)
        while (zeroOutdegree != []):
            next = zeroOutdegree.pop()
            self.topoNumber[next] = topoNum
            self.topoOrder[topoNum] = next
            topoNum= topoNum - 1
            par = self.parent[next]
            if par != None:
                outDegree[par] = outDegree[par] - 1
                if outDegree[par] == 0:
                    zeroOutdegree.append(par)

### Read in the graph & link matrices from a file
    def readfile(self, filename):
        infile = file(filename)
        numvars = int(infile.readline())
        for i in range(numvars):
            [var, numVals] = infile.readline().split()
            self.numValues[var] = int(numVals)
        for i in range(numvars):
            self.readMatrix(infile)
        infile.readline()
        evidenceLine = infile.readline()
        for x in self.numValues:
            self.evidence[x] = [1] * self.numValues[x]
        while evidenceLine[0] != '-':
            evidence = evidenceLine.split()
            self.evidence[evidence[0]] = [int(x) for x in evidence[1:]]
            evidenceLine = infile.readline()
        self.topoSort()
        

    ## FILL ME IN
    def doMessagePassing(self):
        pass

    ## FILL ME IN
    def printResults(self):
        pass
    
if __name__ == '__main__':
    verbose = (len(sys.argv) == 3 and sys.argv[1] == '-v')
    network = bayes(sys.argv[-1], verbose)
    network.doMessagePassing()
    network.printResults()