import graphlib.edges.UndirectedEdge;

import graphlib.graphs.UndirectedGraph;
import graphlib.nodes.Node;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class SimpleTest {

    private static final List<Indiening> voorbeelden = List.of(
            new Indiening("Anna", "00112233"),
            new Indiening("Bert", "00000030"),
            new Indiening("Ciel", "00112233"),
            new Indiening("Dora", "99999999"),
            new Indiening("Erik", "99990000"),
            new Indiening("Fien", "55555555"),
            new Indiening("Gert", "98765432"),
            new Indiening("Hans", "90705030")
    );

    /**
     * Deze plagiaatdetector kijkt naar het aantal gelijke karakters in de code.
     * De kans op plagiaat is het aantal gelijke karakters op dezelfde positie,
     * gedeeld door de lengte van de langste code.
     */
    public static class GedeeldeKaraktersPlagiaatDetector implements PlagiaatDetector {
        @Override
        public double probabiliteit(Indiening indiening1, Indiening indiening2) {
            int overlap = 0;
            for (int i = 0; i < Math.min(indiening1.code().length(), indiening2.code().length()); i++) {
                if (indiening1.code().charAt(i) == indiening2.code().charAt(i)) {
                    overlap++;
                }
            }
            return overlap / (double) Math.max(indiening1.code().length(), indiening2.code().length());
        }
    }
    public static void checkGroepen(Collection<? extends Collection<Indiening>> expected, Collection<? extends Collection<Indiening>> actual) {
        Assertions.assertEquals(expected.size(), actual.size(), "Aantal groepen komt niet overeen.");
        for (Collection<Indiening> groep : actual) {
            Assertions.assertTrue(
                    expected.stream().anyMatch(expectedGroep -> groep.containsAll(expectedGroep) && expectedGroep.containsAll(groep)),
                    String.format("Groep %s komt niet overeen met een verwachte groep (%s).", groep, expected)
            );
        }
    }

    public static void checkBoog(UndirectedGraph<Indiening> graph, Indiening indiening1, Indiening indiening2, double expectedWeight) {
        Node<Indiening> node1 = graph.getNode(indiening1);
        Node<Indiening> node2 = graph.getNode(indiening2);
        UndirectedEdge<Indiening> edge = graph.getEdge(node1, node2);
        Assertions.assertNotNull(edge, String.format("Boog tussen %s en %s ontbreekt.", indiening1, indiening2));
        Assertions.assertEquals(expectedWeight, edge.getWeight(), 0.0001, String.format("Boog tussen %s en %s heeft verkeerd gewicht.", indiening1, indiening2));
    }

    private GraafMaker pgm;

    @BeforeEach
    public void init() {
        pgm = new PlagiaatGraafMaker();
    }

    @Test
    public void geenBoogBijProbabiliteit0() {
        List<Indiening> indieningen = List.of(
                voorbeelden.get(1),
                voorbeelden.get(3)
        );
        UndirectedGraph<Indiening> graph = pgm.maakPlagiaatgraaf(indieningen, new GedeeldeKaraktersPlagiaatDetector());
        Assertions.assertFalse(graph.containsEdge(graph.getNode(indieningen.get(0)), graph.getNode(indieningen.get(1))), "Wanneer twee indieningen een probabiliteit op plagiaat van 0 hebben, mag er geen boog tussen de toppen bestaan.");
    }

    @Test
    public void testGroepen1() {
        UndirectedGraph<Indiening> graph = new UndirectedGraph<>();
        Node<Indiening> a = graph.addNode(voorbeelden.get(0));
        Node<Indiening> b = graph.addNode(voorbeelden.get(1));
        graph.addEdge(new UndirectedEdge<>(a, b, .8));
        checkGroepen(Collections.singleton(List.of(voorbeelden.get(0), voorbeelden.get(1))), pgm.maximaleGroepen(graph));
    }

    @Test
    public void testGroepen2() {
        UndirectedGraph<Indiening> graph = new UndirectedGraph<>();
        Node<Indiening> a = graph.addNode(voorbeelden.get(0));
        Node<Indiening> b = graph.addNode(voorbeelden.get(1));
        Node<Indiening> c = graph.addNode(voorbeelden.get(2));
        Node<Indiening> d = graph.addNode(voorbeelden.get(3));
        graph.addEdge(new UndirectedEdge<>(a, b, .8));
        graph.addEdge(new UndirectedEdge<>(b, c, .5));
        graph.addEdge(new UndirectedEdge<>(c, d, .7));
        graph.addEdge(new UndirectedEdge<>(d, a, .4));

        checkGroepen(
                List.of(
                        List.of(voorbeelden.get(0), voorbeelden.get(1)),
                        List.of(voorbeelden.get(2), voorbeelden.get(3))
                ),
                pgm.maximaleGroepen(graph)
        );
    }

    @Test
    public void testGraaf1() {
        Collection<Indiening> indieningen = List.of(
                voorbeelden.get(6),
                voorbeelden.get(7)
        );
        UndirectedGraph<Indiening> graph = pgm.maakPlagiaatgraaf(indieningen, new GedeeldeKaraktersPlagiaatDetector());
        Assertions.assertEquals(indieningen.size(), graph.getAllNodes().size(), "Aantal toppen komt niet overeen.");

        Assertions.assertEquals(1, graph.getAllEdges().size(), "Aantal bogen is niet correct.");
        checkBoog(graph, voorbeelden.get(6), voorbeelden.get(7), .5);
    }

    @Test
    public void testGraaf2() {
        Collection<Indiening> indieningen = List.of(
                voorbeelden.get(0),
                voorbeelden.get(1),
                voorbeelden.get(2),
                voorbeelden.get(3)
        );
        UndirectedGraph<Indiening> graph = pgm.maakPlagiaatgraaf(indieningen, new GedeeldeKaraktersPlagiaatDetector());
        Assertions.assertEquals(indieningen.size(), graph.getAllNodes().size(), "Aantal toppen komt niet overeen.");

        Assertions.assertEquals(3, graph.getAllEdges().size(), "Aantal bogen is niet correct.");
        checkBoog(graph, voorbeelden.get(0), voorbeelden.get(1), .375);
        checkBoog(graph, voorbeelden.get(0), voorbeelden.get(2), 1);
        checkBoog(graph, voorbeelden.get(1), voorbeelden.get(2), .375);
    }

    @Test
    public void testMaximaleGroepjes() {
        checkGroepen(
                List.of(
                        List.of(voorbeelden.get(0), voorbeelden.get(2)),
                        List.of(voorbeelden.get(1), voorbeelden.get(6), voorbeelden.get(7)),
                        List.of(voorbeelden.get(3), voorbeelden.get(4))
                ),
                pgm.plagiaatGroepen(voorbeelden, new GedeeldeKaraktersPlagiaatDetector())
        );
    }
}