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

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import static java.util.concurrent.TimeUnit.MILLISECONDS;

public class SimpleTest {

    private final MovePlanner planner = new BBMovePlanner();

    @Test
    public void test1() {
        List<MoveItem> items = List.of(
                new MoveItem(.7, .5),
                new MoveItem(.5, .3),
                new MoveItem(.5, .7),
                new MoveItem(.3, .5)
        );
        Collection<MovingBox> antw = planner.distribute(items);
        checkCapaciteit(antw);
        checkItems(antw, items);
        Assertions.assertEquals(2, antw.size());
    }

    @Test
    public void test2() {
        List<MoveItem> items = List.of(
                new MoveItem(.1, .2),
                new MoveItem(.4, .3),
                new MoveItem(.2, .4),
                new MoveItem(.4, .6),
                new MoveItem(.3, .3),
                new MoveItem(.5, .2),
                new MoveItem(.3, .5),
                new MoveItem(.5, .4)
        );
        Collection<MovingBox> antw = planner.distribute(items);
        checkCapaciteit(antw);
        checkItems(antw, items);
        Assertions.assertEquals(3, antw.size());
    }

    @Test
    public void test3() {
        List<MoveItem> items = List.of(
                new MoveItem(.6, .6),
                new MoveItem(.8, .6),
                new MoveItem(.1, .4),
                new MoveItem(.1, .6),
                new MoveItem(.1, .1),
                new MoveItem(.2, .0),
                new MoveItem(.9, .4),
                new MoveItem(.9, .8),
                new MoveItem(.6, .7),
                new MoveItem(.1, .2)
        );
        Collection<MovingBox> antw = planner.distribute(items);
        checkCapaciteit(antw);
        checkItems(antw, items);
        Assertions.assertEquals(5, antw.size());
    }

    @Test
    public void test4() {
        List<MoveItem> items = List.of(
                new MoveItem(.9, .0),
                new MoveItem(.0, .5),
                new MoveItem(.3, .9),
                new MoveItem(.5, .1),
                new MoveItem(.3, .5),
                new MoveItem(.1, .1),
                new MoveItem(.7, .6),
                new MoveItem(.9, .3),
                new MoveItem(.3, .3),
                new MoveItem(.0, .2)
        );
        Collection<MovingBox> antw = planner.distribute(items);
        checkCapaciteit(antw);
        checkItems(antw, items);
        Assertions.assertEquals(5, antw.size());
    }

    @Test
    @Timeout(value = 2000, unit = MILLISECONDS)
    public void test5() {
        List<MoveItem> items = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            items.add(new MoveItem(0.5625, i * .001));
            items.add(new MoveItem(0.3125, i * .001));
            items.add(new MoveItem(0.375, i * .001));
        }
        for (int i = 0; i < 8; i++) {
            items.add(new MoveItem(0.125, i * .001));
        }

        Collection<MovingBox> antw = planner.distribute(items);
        checkCapaciteit(antw);
        checkItems(antw, items);
        Assertions.assertEquals(6, antw.size());
    }

    public static void checkCapaciteit(Collection<MovingBox> antw) {
        for (MovingBox doos : antw) {
            double gewicht = doos.items().stream().mapToDouble(MoveItem::weight).sum();
            double volume = doos.items().stream().mapToDouble(MoveItem::volume).sum();
            Assertions.assertTrue(gewicht <= 1, "De doos " + doos + " is te zwaar: " + gewicht);
            Assertions.assertTrue(volume <= 1, "De doos " + doos + " is te vol: " + volume);
        }
    }

    public static void checkItems(Collection<MovingBox> antw, Collection<MoveItem> items) {
        Set<MoveItem> itemsInAntw = new HashSet<>();
        for (MovingBox doos : antw) {
            for (MoveItem item : doos.items()) {
                Assertions.assertTrue(items.contains(item), "Het item " + item + " zit niet in de lijst van items");
                Assertions.assertFalse(itemsInAntw.contains(item), "Het item " + item + " zit in meerdere dozen");
                itemsInAntw.add(item);
            }
        }
        Assertions.assertEquals(items.size(), itemsInAntw.size(), "Niet alle items zitten in een doos");
    }
}