from cyclic_utils import rem_routes


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 __eq__(self, rt):
        eq = self.route_id == rt.route_id and self.contract_id == rt.contract_id
        return eq

    def __repr__(self):
        return str(self.contract_id) + "-" + 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)]
        contracts = [Contract(int(i), c_dict[i])
                     for i in sorted(c_dict.keys())]

        return contracts

    def contract_routes(self):
        all_routes = []
        for c in self.contracts:
            for r in c.routes:
                all_routes.append(r)
        return all_routes

    def contracts_required(self):
        routes = self.contract_routes()
        unfulfilled = rem_routes(routes)
        print "No of contracts required : ", len(unfulfilled)
        if len(unfulfilled) > 0:
            print "Contracts from ", repr(unfulfilled)

    def contract_corridors(self):
        return rem_routes(self.contract_routes())

if __name__ == '__main__':
    Transporter.from_file('./contracts_test.txt').contracts_required()