class Route(object):
    """docstring for Route."""
    def __init__(self, route_id, contract_id, load,src,dst):
        super(Route, self).__init__()
        self.route_id = route_id
        self.contract_id = contract_id
        self.load = load
        self.src = src
        self.dst = dst

    def __repr__(self):
        return str(self.route_id)+":"+self.src+" - "+self.dst+" "+self.load


class Contract(object):
    """docstring for Contract."""
    def __init__(self, contract_id, routes):
        super(Contract, self).__init__()
        self.contract_id = contract_id
        self.routes = routes

    def __repr__(self):
        return "\tContract : "+str(self.contract_id)+"\n\tRoutes\n\t\t"+"\n\t\t".join(map(repr,self.routes))

class Transporter(object):
    """docstring for Transporter."""
    def __init__(self, contracts):
        super(Transporter, self).__init__()
        self.contracts = contracts

    @classmethod
    def from_file(cls,c_file):
        return cls(cls.read_contracts(c_file))

    @staticmethod
    def read_contracts(c_file):
        c_lines = open(c_file,'r').readlines()
        c_dict = {}
        for l in c_lines:
            (c_id,src,dst,load) = l.split(' ')
            if c_dict.has_key(c_id):
                route_id = len(c_dict[c_id])
                c_dict[c_id].append(Route(route_id,int(c_id),load,src,dst))
            else:
                c_dict[c_id] = [Route(0,int(c_id),load,src,dst)]
        contrants = []
        for c_id in c_dict:
            contrants.append(Contract(int(c_id),c_dict[c_id]))
        return contrants

    def routes(self):
        all_routes = []
        routes_map = {}
        for c in self.contracts:
            for r in c.routes:
                all_routes.append(r)
                if routes_map.has_key(r.src):
                    routes_map[r.src].append(r.dst)
                else:
                    routes_map[r.src]= [r.dst]
        return all_routes,routes_map

    def is_cyclic(self):
        return circular_dep(self.routes()[1])

def find_loop(elem,dep_elem,deps,checked=set()):
    if dep_elem in checked or not deps.has_key(dep_elem):
        return (False,len(checked))
    else:
        checked.add(dep_elem)
    for c in deps[dep_elem]:
        if elem == c:
            return (True,len(checked))
    for c in deps[dep_elem]:
        c_loop = find_loop(elem,c,deps,checked)
        if c_loop[0]:
            return c_loop
    return (False,len(checked))
    
def circular_dep(deps):
    dep_state = []
    for k in deps.keys():
        circ_dep_k = find_loop(k,k,deps,set())
        dep_state.append((k,circ_dep_k))
    return dep_state

print Transporter.from_file('./contracts_test.txt').is_cyclic()