#!/usr/bin/python

import ri_data

from xml.dom import minidom
import os.path

dep_xml = os.path.join(os.path.dirname(__file__), '../xml/dependency.xml')

class Depending:
    ''' Class recording depending relation '''
    dict={}
    def __init__(self, n):
        self.name = n
        self.depending = set()
        # flag for resolve recursive
        self.resolved  = False
        Depending.dict[n] = self

    def resolve_recursive(self):
        if self.resolved: return
        for d in self.depending:
            Depending.dict[d].resolve_recursive()
        tmp=set(self.depending)
        for d in self.depending:
            tmp.update(Depending.dict[d].depending)
        self.depending = tmp
        self.resolved = True

class Depended:
    ''' Class recording depended by relation '''
    dict={}
    def __init__(self, n):
        self.name = n
        self.depended_by = set()
        Depended.dict[n] = self

def construct_depending():
    xml_doc  = minidom.parse(dep_xml)
    xml_root = xml_doc.firstChild
    xml_dict = {}
    for n in xml_root.childNodes:
        if n.nodeType == n.ELEMENT_NODE and n.nodeName == 'package':
            xml_dict[n.attributes['name'].value] = n
            Depending(n.attributes['name'].value)

    for d in Depending.dict.values():
        n = xml_dict[d.name]
        for r in n.getElementsByTagName('runtime'):
            for dep in r.getElementsByTagName('depending'):
                d.depending.add(dep.attributes['package'].value)

def resolve_recursive_depending():
    for d in Depending.dict.values():
        d.resolve_recursive()

def construct_depended():
    for d in Depending.dict.values():
        for dep in d.depending:
            if not Depended.dict.has_key(dep):
                Depended(dep)
            Depended.dict[dep].depended_by.add(d.name)

def get_extra_depending():
    l = []
    for g in ri_data.Group.dict.values():
        if g.install != 'no':
            l.extend([ p for p in g.mandatory ])
            l.extend([ p[0] for p in g.optional if p[1] == 'yes' ])

    set1 = set(l)
    set2 = set(set1)

    for d in set1:
        set2.update(Depending.dict[d].depending)

    res = {}
    for d in set2.difference(set1):
        res[d] = Depended.dict[d].depended_by.intersection(set1)

    return res