import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;
import java.util.Collections;


public class SimpleTest {

    private static Turnpike turnpike;

    @BeforeClass
    public static void init() {
        turnpike = new RecursiveTurnpike();
    }

    @Test
    public void testTwoPoints() {
        Set<Integer> points = new HashSet<>(Arrays.asList(0, 3));

        Map<Integer, Long> distances = turnpike.pointsToDistances(
                Collections.unmodifiableSet(points));
        Assert.assertNotNull(distances);
        Assert.assertEquals(1, distances.size());
        Assert.assertEquals(1L, distances.get(3).longValue());

        Set<Integer> npoints = turnpike.distancesToPoints(
                Collections.unmodifiableMap(distances));
        Assert.assertEquals(points, npoints);
    }

    @Test
    public void testEmpty() {
        Set<Integer> points = Collections.singleton(0);

        Map<Integer, Long> distances = turnpike.pointsToDistances(points);
        Assert.assertNotNull(distances);
        Assert.assertTrue(distances.isEmpty());

        Set<Integer> npoints = turnpike.distancesToPoints(distances);
        Assert.assertEquals(points, npoints);
    }


    @Test
    public void testThreePoints() {
        Set<Integer> points = new HashSet<>(Arrays.asList(0, 2, 4));

        Map<Integer, Long> distances = turnpike.pointsToDistances(points);
        Assert.assertNotNull(distances);
        Assert.assertEquals(2, distances.size());
        Assert.assertEquals(2L, distances.get(2).longValue());
        Assert.assertEquals(1L, distances.get(4).longValue());

        Set<Integer> npoints = turnpike.distancesToPoints(distances);
        Assert.assertEquals(points, npoints);
    }

    @Test
    public void testFourPoints() {
        Set<Integer> points = new HashSet<>(Arrays.asList(0, 3, 6, 8));
        //Set<Integer> points = new HashSet<>(Arrays.asList(0, 2, 5, 8));

        Map<Integer, Long> distances = turnpike.pointsToDistances(points);
        Assert.assertNotNull(distances);
        Assert.assertEquals(5, distances.size());
        Assert.assertEquals(1L, distances.get(2).longValue());
        Assert.assertEquals(2L, distances.get(3).longValue());
        Assert.assertEquals(1L, distances.get(5).longValue());
        Assert.assertEquals(1L, distances.get(6).longValue());
        Assert.assertEquals(1L, distances.get(8).longValue());

        Map<Integer, Long> distancesCopy = new HashMap<>(distances);

        Set<Integer> npoints = turnpike.distancesToPoints(distancesCopy);
        Map<Integer, Long> ndistances = turnpike.pointsToDistances(npoints);

        Assert.assertEquals(distances, ndistances);
    }

    @Test
    public void testNoSolution() {
        Map<Integer, Long> distances = new HashMap<>();
        distances.put(5, 2L);
        distances.put(10, 2L);

        Assert.assertNull(turnpike.distancesToPoints(distances));
    }

}