# -*- coding: utf-8 -*-

import networkx as nx
from nose.tools import assert_equal, assert_raises
import os


class TestMinCostFlow:
    def test_simple_digraph(self):
        G = nx.DiGraph()
        G.add_node('a', demand=-5)
        G.add_node('d', demand=5)
        G.add_edge('a', 'b', weight=3, capacity=4)
        G.add_edge('a', 'c', weight=6, capacity=10)
        G.add_edge('b', 'd', weight=1, capacity=9)
        G.add_edge('c', 'd', weight=2, capacity=5)
        flowCost, H = nx.network_simplex(G)
        soln = {'a': {'b': 4, 'c': 1},
                'b': {'d': 4},
                'c': {'d': 1},
                'd': {}}
        assert_equal(flowCost, 24)
        assert_equal(nx.min_cost_flow_cost(G), 24)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 24)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 24)
        assert_equal(nx.cost_of_flow(G, H), 24)
        assert_equal(H, soln)

    def test_negcycle_infcap(self):
        G = nx.DiGraph()
        G.add_node('s', demand=-5)
        G.add_node('t', demand=5)
        G.add_edge('s', 'a', weight=1, capacity=3)
        G.add_edge('a', 'b', weight=3)
        G.add_edge('c', 'a', weight=-6)
        G.add_edge('b', 'd', weight=1)
        G.add_edge('d', 'c', weight=-2)
        G.add_edge('d', 't', weight=1, capacity=3)
        assert_raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)

    def test_sum_demands_not_zero(self):
        G = nx.DiGraph()
        G.add_node('s', demand=-5)
        G.add_node('t', demand=4)
        G.add_edge('s', 'a', weight=1, capacity=3)
        G.add_edge('a', 'b', weight=3)
        G.add_edge('a', 'c', weight=-6)
        G.add_edge('b', 'd', weight=1)
        G.add_edge('c', 'd', weight=-2)
        G.add_edge('d', 't', weight=1, capacity=3)
        assert_raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)

    def test_no_flow_satisfying_demands(self):
        G = nx.DiGraph()
        G.add_node('s', demand=-5)
        G.add_node('t', demand=5)
        G.add_edge('s', 'a', weight=1, capacity=3)
        G.add_edge('a', 'b', weight=3)
        G.add_edge('a', 'c', weight=-6)
        G.add_edge('b', 'd', weight=1)
        G.add_edge('c', 'd', weight=-2)
        G.add_edge('d', 't', weight=1, capacity=3)
        assert_raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)

    def test_transshipment(self):
        G = nx.DiGraph()
        G.add_node('a', demand=1)
        G.add_node('b', demand=-2)
        G.add_node('c', demand=-2)
        G.add_node('d', demand=3)
        G.add_node('e', demand=-4)
        G.add_node('f', demand=-4)
        G.add_node('g', demand=3)
        G.add_node('h', demand=2)
        G.add_node('r', demand=3)
        G.add_edge('a', 'c', weight=3)
        G.add_edge('r', 'a', weight=2)
        G.add_edge('b', 'a', weight=9)
        G.add_edge('r', 'c', weight=0)
        G.add_edge('b', 'r', weight=-6)
        G.add_edge('c', 'd', weight=5)
        G.add_edge('e', 'r', weight=4)
        G.add_edge('e', 'f', weight=3)
        G.add_edge('h', 'b', weight=4)
        G.add_edge('f', 'd', weight=7)
        G.add_edge('f', 'h', weight=12)
        G.add_edge('g', 'd', weight=12)
        G.add_edge('f', 'g', weight=-1)
        G.add_edge('h', 'g', weight=-10)
        flowCost, H = nx.network_simplex(G)
        soln = {'a': {'c': 0},
                'b': {'a': 0, 'r': 2},
                'c': {'d': 3},
                'd': {},
                'e': {'r': 3, 'f': 1},
                'f': {'d': 0, 'g': 3, 'h': 2},
                'g': {'d': 0},
                'h': {'b': 0, 'g': 0},
                'r': {'a': 1, 'c': 1}}
        assert_equal(flowCost, 41)
        assert_equal(nx.min_cost_flow_cost(G), 41)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 41)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 41)
        assert_equal(nx.cost_of_flow(G, H), 41)
        assert_equal(H, soln)

    def test_max_flow_min_cost(self):
        G = nx.DiGraph()
        G.add_edge('s', 'a', bandwidth=6)
        G.add_edge('s', 'c', bandwidth=10, cost=10)
        G.add_edge('a', 'b', cost=6)
        G.add_edge('b', 'd', bandwidth=8, cost=7)
        G.add_edge('c', 'd', cost=10)
        G.add_edge('d', 't', bandwidth=5, cost=5)
        soln = {'s': {'a': 5, 'c': 0},
                'a': {'b': 5},
                'b': {'d': 5},
                'c': {'d': 0},
                'd': {'t': 5},
                't': {}}
        flow = nx.max_flow_min_cost(G, 's', 't', capacity='bandwidth',
                                    weight='cost')
        assert_equal(flow, soln)
        assert_equal(nx.cost_of_flow(G, flow, weight='cost'), 90)

        G.add_edge('t', 's', cost=-100)
        flowCost, flow = nx.capacity_scaling(G, capacity='bandwidth',
                                             weight='cost')
        G.remove_edge('t', 's')
        assert_equal(flowCost, -410)
        assert_equal(flow['t']['s'], 5)
        del flow['t']['s']
        assert_equal(flow, soln)
        assert_equal(nx.cost_of_flow(G, flow, weight='cost'), 90)

    def test_digraph1(self):
        # From Bradley, S. P., Hax, A. C. and Magnanti, T. L. Applied
        # Mathematical Programming. Addison-Wesley, 1977.
        G = nx.DiGraph()
        G.add_node(1, demand=-20)
        G.add_node(4, demand=5)
        G.add_node(5, demand=15)
        G.add_edges_from([(1, 2, {'capacity': 15, 'weight': 4}),
                          (1, 3, {'capacity': 8, 'weight': 4}),
                          (2, 3, {'weight': 2}),
                          (2, 4, {'capacity': 4, 'weight': 2}),
                          (2, 5, {'capacity': 10, 'weight': 6}),
                          (3, 4, {'capacity': 15, 'weight': 1}),
                          (3, 5, {'capacity': 5, 'weight': 3}),
                          (4, 5, {'weight': 2}),
                          (5, 3, {'capacity': 4, 'weight': 1})])
        flowCost, H = nx.network_simplex(G)
        soln = {1: {2: 12, 3: 8},
                2: {3: 8, 4: 4, 5: 0},
                3: {4: 11, 5: 5},
                4: {5: 10},
                5: {3: 0}}
        assert_equal(flowCost, 150)
        assert_equal(nx.min_cost_flow_cost(G), 150)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 150)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 150)
        assert_equal(H, soln)
        assert_equal(nx.cost_of_flow(G, H), 150)

    def test_digraph2(self):
        # Example from ticket #430 from mfrasca. Original source:
        # http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
        G = nx.DiGraph()
        G.add_edge('s', 1, capacity=12)
        G.add_edge('s', 2, capacity=6)
        G.add_edge('s', 3, capacity=14)
        G.add_edge(1, 2, capacity=11, weight=4)
        G.add_edge(2, 3, capacity=9, weight=6)
        G.add_edge(1, 4, capacity=5, weight=5)
        G.add_edge(1, 5, capacity=2, weight=12)
        G.add_edge(2, 5, capacity=4, weight=4)
        G.add_edge(2, 6, capacity=2, weight=6)
        G.add_edge(3, 6, capacity=31, weight=3)
        G.add_edge(4, 5, capacity=18, weight=4)
        G.add_edge(5, 6, capacity=9, weight=5)
        G.add_edge(4, 't', capacity=3)
        G.add_edge(5, 't', capacity=7)
        G.add_edge(6, 't', capacity=22)
        flow = nx.max_flow_min_cost(G, 's', 't')
        soln = {1: {2: 6, 4: 5, 5: 1},
                2: {3: 6, 5: 4, 6: 2},
                3: {6: 20},
                4: {5: 2, 't': 3},
                5: {6: 0, 't': 7},
                6: {'t': 22},
                's': {1: 12, 2: 6, 3: 14},
                't': {}}
        assert_equal(flow, soln)

        G.add_edge('t', 's', weight=-100)
        flowCost, flow = nx.capacity_scaling(G)
        G.remove_edge('t', 's')
        assert_equal(flow['t']['s'], 32)
        assert_equal(flowCost, -3007)
        del flow['t']['s']
        assert_equal(flow, soln)
        assert_equal(nx.cost_of_flow(G, flow), 193)

    def test_digraph3(self):
        """Combinatorial Optimization: Algorithms and Complexity,
        Papadimitriou Steiglitz at page 140 has an example, 7.1, but that
        admits multiple solutions, so I alter it a bit. From ticket #430
        by mfrasca."""

        G = nx.DiGraph()
        G.add_edge('s', 'a')
        G['s']['a'].update({0: 2, 1: 4})
        G.add_edge('s', 'b')
        G['s']['b'].update({0: 2, 1: 1})
        G.add_edge('a', 'b')
        G['a']['b'].update({0: 5, 1: 2})
        G.add_edge('a', 't')
        G['a']['t'].update({0: 1, 1: 5})
        G.add_edge('b', 'a')
        G['b']['a'].update({0: 1, 1: 3})
        G.add_edge('b', 't')
        G['b']['t'].update({0: 3, 1: 2})

        "PS.ex.7.1: testing main function"
        sol = nx.max_flow_min_cost(G, 's', 't', capacity=0, weight=1)
        flow = sum(v for v in sol['s'].values())
        assert_equal(4, flow)
        assert_equal(23, nx.cost_of_flow(G, sol, weight=1))
        assert_equal(sol['s'], {'a': 2, 'b': 2})
        assert_equal(sol['a'], {'b': 1, 't': 1})
        assert_equal(sol['b'], {'a': 0, 't': 3})
        assert_equal(sol['t'], {})

        G.add_edge('t', 's')
        G['t']['s'].update({1: -100})
        flowCost, sol = nx.capacity_scaling(G, capacity=0, weight=1)
        G.remove_edge('t', 's')
        flow = sum(v for v in sol['s'].values())
        assert_equal(4, flow)
        assert_equal(sol['t']['s'], 4)
        assert_equal(flowCost, -377)
        del sol['t']['s']
        assert_equal(sol['s'], {'a': 2, 'b': 2})
        assert_equal(sol['a'], {'b': 1, 't': 1})
        assert_equal(sol['b'], {'a': 0, 't': 3})
        assert_equal(sol['t'], {})
        assert_equal(nx.cost_of_flow(G, sol, weight=1), 23)

    def test_zero_capacity_edges(self):
        """Address issue raised in ticket #617 by arv."""
        G = nx.DiGraph()
        G.add_edges_from([(1, 2, {'capacity': 1, 'weight': 1}),
                          (1, 5, {'capacity': 1, 'weight': 1}),
                          (2, 3, {'capacity': 0, 'weight': 1}),
                          (2, 5, {'capacity': 1, 'weight': 1}),
                          (5, 3, {'capacity': 2, 'weight': 1}),
                          (5, 4, {'capacity': 0, 'weight': 1}),
                          (3, 4, {'capacity': 2, 'weight': 1})])
        G.nodes[1]['demand'] = -1
        G.nodes[2]['demand'] = -1
        G.nodes[4]['demand'] = 2

        flowCost, H = nx.network_simplex(G)
        soln = {1: {2: 0, 5: 1},
                2: {3: 0, 5: 1},
                3: {4: 2},
                4: {},
                5: {3: 2, 4: 0}}
        assert_equal(flowCost, 6)
        assert_equal(nx.min_cost_flow_cost(G), 6)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 6)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 6)
        assert_equal(H, soln)
        assert_equal(nx.cost_of_flow(G, H), 6)

    def test_digon(self):
        """Check if digons are handled properly. Taken from ticket
        #618 by arv."""
        nodes = [(1, {}),
                 (2, {'demand': -4}),
                 (3, {'demand': 4}),
                 ]
        edges = [(1, 2, {'capacity': 3, 'weight': 600000}),
                 (2, 1, {'capacity': 2, 'weight': 0}),
                 (2, 3, {'capacity': 5, 'weight': 714285}),
                 (3, 2, {'capacity': 2, 'weight': 0}),
                 ]
        G = nx.DiGraph(edges)
        G.add_nodes_from(nodes)
        flowCost, H = nx.network_simplex(G)
        soln = {1: {2: 0},
                2: {1: 0, 3: 4},
                3: {2: 0}}
        assert_equal(flowCost, 2857140)
        assert_equal(nx.min_cost_flow_cost(G), 2857140)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 2857140)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 2857140)
        assert_equal(H, soln)
        assert_equal(nx.cost_of_flow(G, H), 2857140)

    def test_deadend(self):
        """Check if one-node cycles are handled properly. Taken from ticket
        #2906 from @sshraven."""
        G = nx.DiGraph()

        G.add_nodes_from(range(5), demand=0)
        G.node[4]['demand'] = -13
        G.node[3]['demand'] = 13

        G.add_edges_from([(0,2), (0, 3), (2, 1)], capacity=20, weight=0.1)
        assert_raises(nx.NetworkXUnfeasible, nx.min_cost_flow, G)

    def test_infinite_capacity_neg_digon(self):
        """An infinite capacity negative cost digon results in an unbounded
        instance."""
        nodes = [(1, {}),
                 (2, {'demand': -4}),
                 (3, {'demand': 4}),
                 ]
        edges = [(1, 2, {'weight': -600}),
                 (2, 1, {'weight': 0}),
                 (2, 3, {'capacity': 5, 'weight': 714285}),
                 (3, 2, {'capacity': 2, 'weight': 0}),
                 ]
        G = nx.DiGraph(edges)
        G.add_nodes_from(nodes)
        assert_raises(nx.NetworkXUnbounded, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)

    def test_finite_capacity_neg_digon(self):
        """The digon should receive the maximum amount of flow it can handle.
        Taken from ticket #749 by @chuongdo."""
        G = nx.DiGraph()
        G.add_edge('a', 'b', capacity=1, weight=-1)
        G.add_edge('b', 'a', capacity=1, weight=-1)
        min_cost = -2
        assert_equal(nx.min_cost_flow_cost(G), min_cost)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, -2)
        assert_equal(H, {'a': {'b': 1}, 'b': {'a': 1}})
        assert_equal(nx.cost_of_flow(G, H), -2)

    def test_multidigraph(self):
        """Multidigraphs are acceptable."""
        G = nx.MultiDiGraph()
        G.add_weighted_edges_from([(1, 2, 1), (2, 3, 2)], weight='capacity')
        flowCost, H = nx.network_simplex(G)
        assert_equal(flowCost, 0)
        assert_equal(H, {1: {2: {0: 0}}, 2: {3: {0: 0}}, 3: {}})

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 0)
        assert_equal(H, {1: {2: {0: 0}}, 2: {3: {0: 0}}, 3: {}})

    def test_negative_selfloops(self):
        """Negative selfloops should cause an exception if uncapacitated and
        always be saturated otherwise.
        """
        G = nx.DiGraph()
        G.add_edge(1, 1, weight=-1)
        assert_raises(nx.NetworkXUnbounded, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)
        G[1][1]['capacity'] = 2
        flowCost, H = nx.network_simplex(G)
        assert_equal(flowCost, -2)
        assert_equal(H, {1: {1: 2}})
        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, -2)
        assert_equal(H, {1: {1: 2}})

        G = nx.MultiDiGraph()
        G.add_edge(1, 1, 'x', weight=-1)
        G.add_edge(1, 1, 'y', weight=1)
        assert_raises(nx.NetworkXUnbounded, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnbounded, nx.capacity_scaling, G)
        G[1][1]['x']['capacity'] = 2
        flowCost, H = nx.network_simplex(G)
        assert_equal(flowCost, -2)
        assert_equal(H, {1: {1: {'x': 2, 'y': 0}}})
        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, -2)
        assert_equal(H, {1: {1: {'x': 2, 'y': 0}}})

    def test_bone_shaped(self):
        # From #1283
        G = nx.DiGraph()
        G.add_node(0, demand=-4)
        G.add_node(1, demand=2)
        G.add_node(2, demand=2)
        G.add_node(3, demand=4)
        G.add_node(4, demand=-2)
        G.add_node(5, demand=-2)
        G.add_edge(0, 1, capacity=4)
        G.add_edge(0, 2, capacity=4)
        G.add_edge(4, 3, capacity=4)
        G.add_edge(5, 3, capacity=4)
        G.add_edge(0, 3, capacity=0)
        flowCost, H = nx.network_simplex(G)
        assert_equal(flowCost, 0)
        assert_equal(
            H, {0: {1: 2, 2: 2, 3: 0}, 1: {}, 2: {}, 3: {}, 4: {3: 2}, 5: {3: 2}})
        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 0)
        assert_equal(
            H, {0: {1: 2, 2: 2, 3: 0}, 1: {}, 2: {}, 3: {}, 4: {3: 2}, 5: {3: 2}})

    def test_exceptions(self):
        G = nx.Graph()
        assert_raises(nx.NetworkXNotImplemented, nx.network_simplex, G)
        assert_raises(nx.NetworkXNotImplemented, nx.capacity_scaling, G)
        G = nx.MultiGraph()
        assert_raises(nx.NetworkXNotImplemented, nx.network_simplex, G)
        assert_raises(nx.NetworkXNotImplemented, nx.capacity_scaling, G)
        G = nx.DiGraph()
        assert_raises(nx.NetworkXError, nx.network_simplex, G)
        assert_raises(nx.NetworkXError, nx.capacity_scaling, G)
        G.add_node(0, demand=float('inf'))
        assert_raises(nx.NetworkXError, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
        G.nodes[0]['demand'] = 0
        G.add_node(1, demand=0)
        G.add_edge(0, 1, weight=-float('inf'))
        assert_raises(nx.NetworkXError, nx.network_simplex, G)
        assert_raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
        G[0][1]['weight'] = 0
        G.add_edge(0, 0, weight=float('inf'))
        assert_raises(nx.NetworkXError, nx.network_simplex, G)
        #assert_raises(nx.NetworkXError, nx.capacity_scaling, G)
        G[0][0]['weight'] = 0
        G[0][1]['capacity'] = -1
        assert_raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
        #assert_raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)
        G[0][1]['capacity'] = 0
        G[0][0]['capacity'] = -1
        assert_raises(nx.NetworkXUnfeasible, nx.network_simplex, G)
        #assert_raises(nx.NetworkXUnfeasible, nx.capacity_scaling, G)

    def test_large(self):
        fname = os.path.join(os.path.dirname(__file__), 'netgen-2.gpickle.bz2')
        G = nx.read_gpickle(fname)
        flowCost, flowDict = nx.network_simplex(G)
        assert_equal(6749969302, flowCost)
        assert_equal(6749969302, nx.cost_of_flow(G, flowDict))
        flowCost, flowDict = nx.capacity_scaling(G)
        assert_equal(6749969302, flowCost)
        assert_equal(6749969302, nx.cost_of_flow(G, flowDict))
