import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

import java.util.List;

public class SimpleTest {

    private static Courier courier;
    private static final double INF = Double.MAX_VALUE;

    @BeforeAll
    public static void init() {
        courier = new PizzaCourier();
    }

    public static double totalProfit(List<Order> orders) {
        return orders.stream().mapToDouble(Order::price).sum();
    }

    @Test
    public void test1() {
        double[][] adjacency = new double[][] {
                {0, 8, INF, INF, INF, 6},
                {8, 0, 3, INF, INF, 5},
                {INF, 3, 0, 2, 15, INF},
                {INF, INF, 2, 0, 4, INF},
                {INF, INF, 15, 4, 0, 8},
                {6, 5, INF, INF, 8, 0},
        };
        List<Order> orders = List.of(new Order(2, 4, 20, 10), new Order(5, 4, 35, 15));
        double[][] paths = courier.findShortestPaths(adjacency);
        double[][] shortestPaths = new double[][] {
                {0, 8, 11, 13, 14, 6},
                {8, 0, 3, 5, 9, 5},
                {11, 3, 0, 2, 6, 8},
                {13, 5, 2, 0, 4, 10},
                {14, 9, 6, 4, 0, 8},
                {6, 5, 8, 10, 8, 0},
        };
        for (int i = 0; i < paths.length; i++) {
            for (int j = 0; j < paths[i].length; j++) {
                Assertions.assertEquals(shortestPaths[i][j], paths[i][j], 0.001, "Verkeerde kortste paden");
            }
        }
        List<Order> deliveries = courier.maximizeProfit(paths, orders, 0);
        Assertions.assertEquals(15, totalProfit(deliveries), "Geen maximale oplossing");
    }

    @Test
    public void test2() {
        double[][] adjacency = new double[][] {
                {0, 5},
                {5, 0},
        };
        List<Order> orders = List.of(new Order(0, 1, 10, 5), new Order(0, 1, 20, 5));
        double[][] paths = courier.findShortestPaths(adjacency);
        double[][] shortestPaths = new double[][] {
                {0, 5},
                {5, 0},
        };
        for (int i = 0; i < paths.length; i++) {
            for (int j = 0; j < paths[i].length; j++) {
                Assertions.assertEquals(shortestPaths[i][j], paths[i][j], 0.001, "Verkeerde kortste paden");
            }
        }
        List<Order> deliveries = courier.maximizeProfit(paths, orders, 0);
        Assertions.assertEquals(10, totalProfit(deliveries), 0.001, "Geen maximale oplossing");
    }

    @Test
    public void test3() {
        double[][] adjacency = new double[][] {
                {0, 1, 5},
                {1, 0, 1},
                {5, 1, 0},
        };
        List<Order> orders = List.of(new Order(2, 0, 2, 10));
        double[][] paths = courier.findShortestPaths(adjacency);
        double[][] shortestPaths = new double[][] {
                {0, 1, 2},
                {1, 0, 1},
                {2, 1, 0},
        };
        for (int i = 0; i < paths.length; i++) {
            for (int j = 0; j < paths[i].length; j++) {
                Assertions.assertEquals(shortestPaths[i][j], paths[i][j], 0.001, "Verkeerde kortste paden");
            }
        }
        List<Order> deliveries = courier.maximizeProfit(paths, orders, 0);
        Assertions.assertEquals(0, totalProfit(deliveries), 0.001, "Geen maximale oplossing");
    }

    @Test
    public void test4() {
        double[][] adjacency = new double[][] {
                {0, 10, 7, 3, 19, 11, 1, 19, 10, 0},
                {10, 0, 0, 15, 5, 17, 17, 11, 11, 14},
                {7, 0, 0, 7, 10, 1, 19, 13, 8, 8},
                {3, 15, 7, 0, 11, 10, 16, 12, 13, 6},
                {19, 5, 10, 11, 0, 15, 6, 16, 16, 16},
                {11, 17, 1, 10, 15, 0, 3, 6, 11, 12},
                {1, 17, 19, 16, 6, 3, 0, 0, 11, 8},
                {19, 11, 13, 12, 16, 6, 0, 0, 12, 4},
                {10, 11, 8, 13, 16, 11, 11, 12, 0, 12},
                {0, 14, 8, 6, 16, 12, 8, 4, 12, 0},
        };
        List<Order> orders = List.of(new Order(2, 8, 891, 0), new Order(0, 2, 570, 11), new Order(0, 3, 720, 57), new Order(2, 9, 533, 3), new Order(2, 8, 931, 87), new Order(5, 9, 791, 45), new Order(2, 7, 76, 48), new Order(9, 9, 463, 60), new Order(0, 5, 114, 71), new Order(0, 2, 626, 58), new Order(2, 3, 816, 16), new Order(1, 6, 712, 12), new Order(0, 9, 910, 98), new Order(6, 8, 45, 92), new Order(0, 2, 918, 57), new Order(3, 5, 496, 35), new Order(2, 4, 697, 95), new Order(0, 6, 674, 19), new Order(0, 3, 483, 82), new Order(1, 9, 389, 68), new Order(2, 8, 737, 40));
        double[][] paths = courier.findShortestPaths(adjacency);
        double[][] shortestPaths = new double[][] {
                {0, 5, 5, 3, 7, 4, 1, 1, 10, 0},
                {5, 0, 0, 7, 5, 1, 4, 4, 8, 5},
                {5, 0, 0, 7, 5, 1, 4, 4, 8, 5},
                {3, 7, 7, 0, 10, 7, 4, 4, 13, 3},
                {7, 5, 5, 10, 0, 6, 6, 6, 13, 7},
                {4, 1, 1, 7, 6, 0, 3, 3, 9, 4},
                {1, 4, 4, 4, 6, 3, 0, 0, 11, 1},
                {1, 4, 4, 4, 6, 3, 0 ,0 ,11 ,1},
                {10 ,8 ,8 ,13 ,13 ,9 ,11 ,11 ,0 ,10},
                {0 ,5 ,5 ,3 ,7 ,4 ,1 ,1 ,10 ,0},
        };
        for (int i = 0; i < paths.length; i++) {
            for (int j = 0; j < paths[i].length; j++) {
                Assertions.assertEquals(shortestPaths[i][j], paths[i][j], 0.001, "Verkeerde kortste paden");
            }
        }
        List<Order> deliveries = courier.maximizeProfit(paths, orders, 0);
        Assertions.assertEquals(1054, totalProfit(deliveries), 0.001, "Geen maximale oplossing");
    }

    @Test
    public void test5() {
        double[][] adjacency = new double[][] {
                {0, 15, 9, 1, 7, 18, 12, 0, 3, 14},
                {15, 0, 10, 15, 6, 6, 13, 5, 13, 8},
                {9, 10, 0, 4, 12, 6, 13, 13, 9, 1},
                {1, 15, 4, 0, 3, 1, 13, 0, 19, 1},
                {7, 6, 12, 3, 0, 0, 17, 8, 9, 14},
                {18, 6, 6, 1, 0, 0, 0, 0, 0, 1},
                {12, 13, 13, 13, 17, 0, 0, 5, 0, 19},
                {0, 5, 13, 0, 8, 0, 5, 0, 9, 9},
                {3, 13, 9, 19, 9, 0, 0, 9, 0, 5},
                {14, 8, 1, 1, 14, 1, 19, 9, 5, 0},
        };
        List<Order> orders = List.of(new Order(1, 7, 951, 75), new Order(1, 9, 135, 86), new Order(4, 5, 742, 14), new Order(3, 6, 521, 43), new Order(1, 1, 296, 38), new Order(2, 4, 604, 1), new Order(3, 5, 870, 93), new Order(1, 5, 52, 33), new Order(8, 8, 317, 78), new Order(4, 4, 302, 10), new Order(5, 8, 672, 55), new Order(3, 4, 124, 65), new Order(2, 8, 834, 70), new Order(3, 7, 491, 67), new Order(4, 7, 639, 1), new Order(3, 5, 443, 26), new Order(2, 4, 28, 79), new Order(0, 3, 40, 30), new Order(1, 9, 383, 16), new Order(2, 3, 558, 15), new Order(6, 9, 13, 66), new Order(0, 6, 458, 82), new Order(1, 4, 277, 6), new Order(1, 7, 850, 42), new Order(1, 7, 86, 5), new Order(1, 2, 260, 82));
        double[][] paths = courier.findShortestPaths(adjacency);
        double[][] shortestPaths = new double[][] {
            {0, 5, 2, 0, 0, 0, 0, 0, 0, 1},
            {5, 0, 7, 5, 5, 5, 5, 5, 5, 6},
            {2, 7, 0, 2, 2, 2, 2, 2, 2, 1},
            {0, 5, 2, 0, 0, 0, 0, 0, 0, 1},
            {0, 5, 2, 0, 0, 0, 0, 0, 0, 1},
            {0, 5, 2, 0, 0, 0, 0, 0, 0, 1},
            {0, 5, 2, 0, 0, 0, 0, 0, 0, 1},
            {0, 5, 2, 0, 0, 0, 0, 0, 0, 1},
            {0, 5, 2, 0, 0, 0, 0, 0, 0, 1},
            {1, 6, 1, 1, 1, 1, 1, 1, 1, 0},
        };
        for (int i = 0; i < paths.length; i++) {
            for (int j = 0; j < paths[i].length; j++) {
                Assertions.assertEquals(shortestPaths[i][j], paths[i][j], 0.001, "Verkeerde kortste paden");
            }
        }
        List<Order> deliveries = courier.maximizeProfit(paths, orders, 0);
        Assertions.assertEquals(1178, totalProfit(deliveries), 0.001, "Geen maximale oplossing");
    }

    @Test
    public void test6() {
        double[][] adjacency = new double[][] {
                {0, 5, 16, 14, 14, 7, 16, 11, 13, 14},
                {5, 0, 11, 19, 0, 19, 0, 5, 18, 13},
                {16, 11, 0, 14, 16, 7, 3, 13, 14, 12},
                {14, 19, 14, 0, 19, 14, 19, 0, 17, 10},
                {14, 0, 16, 19, 0, 9, 3, 3, 7, 10},
                {7, 19, 7, 14, 9, 0, 16, 12, 10, 0},
                {16, 0, 3, 19, 3, 16, 0, 10, 19, 13},
                {11, 5, 13, 0, 3, 12, 10, 0, 7, 7},
                {13, 18, 14, 17, 7, 10, 19, 7, 0, 6},
                {14, 13, 12, 10, 10, 0, 13, 7, 6, 0},
        };
        List<Order> orders = List.of(new Order(4, 7, 505, 49), new Order(4, 5, 76, 41), new Order(0, 1, 853, 73), new Order(2, 8, 611, 62), new Order(4, 6, 401, 35), new Order(1, 3, 512, 0), new Order(5, 9, 519, 95), new Order(5, 5, 22, 91), new Order(4, 9, 19, 14), new Order(0, 9, 474, 85), new Order(4, 5, 186, 91), new Order(3, 8, 819, 41), new Order(4, 7, 759, 46), new Order(1, 6, 691, 81), new Order(0, 7, 699, 20), new Order(5, 9, 681, 17), new Order(1, 7, 858, 18), new Order(0, 7, 14, 68), new Order(4, 5, 918, 22), new Order(3, 4, 43, 36), new Order(0, 6, 917, 67), new Order(6, 7, 393, 85), new Order(3, 8, 142, 37), new Order(0, 3, 657, 53), new Order(9, 9, 285, 16), new Order(4, 7, 256, 17));
        double[][] paths = courier.findShortestPaths(adjacency);
        double[][] shortestPaths = new double[][] {
            {0, 5, 8, 8, 5, 7, 5, 8, 12, 7},
            {5, 0, 3, 3, 0, 9, 0, 3, 7, 9},
            {8, 3, 0, 6, 3, 7, 3, 6, 10, 7},
            {8, 3, 6, 0, 3, 7, 3, 0, 7, 7},
            {5, 0, 3, 3, 0, 9, 0, 3, 7, 9},
            {7, 9, 7, 7, 9, 0, 9, 7, 6, 0},
            {5, 0, 3, 3, 0, 9, 0, 3, 7, 9},
            {8, 3, 6, 0, 3, 7, 3, 0, 7, 7},
            {12, 7, 10, 7, 7, 6, 7, 7, 0, 6},
            {7, 9, 7, 7, 9, 0, 9, 7, 6, 0},
        };
        for (int i = 0; i < paths.length; i++) {
            for (int j = 0; j < paths[i].length; j++) {
                Assertions.assertEquals(shortestPaths[i][j], paths[i][j], 0.001, "Verkeerde kortste paden");
            }
        }
        List<Order> deliveries = courier.maximizeProfit(paths, orders, 0);
        Assertions.assertEquals(1204, totalProfit(deliveries), 0.001, "Geen maximale oplossing");
    }

}