package fr.im2ag.m2cci.geom;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import static org.junit.jupiter.api.Assertions.*;
import java.util.stream.Stream;

/**
 * Tests unitaires de la classe SegmentDeDroite
 * 
 * @author Philippe GENOUD - Université Grenoble Alpes (UGA) - Laboratoire Informatique de Grenoble
 *         (LIG) - équipe STeamer
 */
public class SegmentDeDroiteTest {

    
    static double X_ORIGINE = 10, Y_ORIGINE = 14;
    static double X_EXTREMITE = 20, Y_EXTREMITE = 24;
    static Point ORIGINE = new Point(X_ORIGINE, Y_ORIGINE);
    static Point EXTREMITE = new Point(X_EXTREMITE, Y_EXTREMITE);
    static Point EXTREMITE_VERTICAL = new Point(X_ORIGINE, Y_EXTREMITE);
    static Point EXTREMITE_HORIZONTAL = new Point(X_EXTREMITE, Y_ORIGINE);

    /**
     * vérifie que les constructeurs lèvent bien une exception si le segment est dégénéré (origne et
     * extrémité sont confondus).
     */
    @Test
    public void testDegenere() {
        System.out.println("cas de test 1");
        assertThrows(IllegalArgumentException.class,
                () -> new SegmentDeDroite(new Point(10, 10), new Point(10, 10)),
                "origine et extrémité confondues");
        assertThrows(IllegalArgumentException.class, 
                () -> new SegmentDeDroite(10, 10, 10, 10),
                "origine et extrémité confondues");
    }

    static Stream<Object[]> segmentsProvider() {
        return Stream.of(
            // Segments créés avec constructeur SegmentDeDroite(Point, Point)
            new Object[] { new SegmentDeDroite(ORIGINE, EXTREMITE), "p1,p2" }, // segment quelconque
            new Object[] { new SegmentDeDroite(EXTREMITE, ORIGINE), "p2,p1" },  // segment quelconque en inversant les points
            // Segments créés avec constructeur SegmentDeDroite(double, double, double, double)
            new Object[] { new SegmentDeDroite(X_ORIGINE,Y_ORIGINE,X_EXTREMITE,Y_EXTREMITE), "x1,y1,x2,y2", EXTREMITE },  // segment quelconque
            new Object[] { new SegmentDeDroite(X_EXTREMITE,Y_EXTREMITE,X_ORIGINE,Y_ORIGINE), "x2,y2,x1,y1", EXTREMITE }  // segment quelconque en inversant les coordonnées
        );
    }

    static Stream<Object[]> verticalSegmentsProvider() {
        return Stream.of(
            // Segments créés avec constructeur SegmentDeDroite(Point, Point)
            new Object[] { new SegmentDeDroite(ORIGINE, EXTREMITE_VERTICAL), "p1,p3" }, // segment vertical
            new Object[] { new SegmentDeDroite(EXTREMITE_VERTICAL, ORIGINE), "p3,p1" } ,  // segment vertical en inversant les points
            // Segments créés avec constructeur SegmentDeDroite(double, double, double, double)
            new Object[] { new SegmentDeDroite(X_ORIGINE,Y_ORIGINE,X_ORIGINE,Y_EXTREMITE), "x1,y1,x1,y2" },  // segment vertical
            new Object[] { new SegmentDeDroite(X_ORIGINE,Y_ORIGINE,X_ORIGINE,Y_EXTREMITE), "x1,y2,x1,y1" }  // segment vertical en inversant les coordonnées
        );
    }

    static Stream<Object[]> horizontalSegmentsProvider() {
        return Stream.of(
            // Segments créés avec constructeur SegmentDeDroite(Point, Point)
            new Object[] { new SegmentDeDroite(ORIGINE, EXTREMITE_HORIZONTAL), "p1,p4" }, // segment horizontal
            new Object[] { new SegmentDeDroite(EXTREMITE_HORIZONTAL, ORIGINE), "p4,p1" },  // segment horizontal en inversant les points
            // Segments créés avec constructeur SegmentDeDroite(double, double, double, double) 
            new Object[] { new SegmentDeDroite(X_ORIGINE,Y_ORIGINE,X_EXTREMITE,Y_ORIGINE), "x1,y1,x2,y1" },  // segment horizontal
            new Object[] { new SegmentDeDroite(X_EXTREMITE,Y_ORIGINE,X_ORIGINE,Y_ORIGINE), "x2,y1,x1,y1" }   // segment horizontal en inversant les coordonnées
        );
    }

    /**
     * Vérifie que la méthode getOrigne donne bien le point le bon Point quelle que soit la manière 
     * dont le point a été créé :
     * 
     * - quel que soit le constructeur utilisé (SegmentDeDroite(Point, Point) ou  SegmentDeDroite(double, double, double, double))
     * 
     * - quel que soit l'ordre dans lequel les points ou les coordonnées sont passés en paramètre
     * 
     * - quelle que soit la nature du segment (quelconque, vertical ou horizontal)
     */
    @DisplayName("getOrigine")
    @ParameterizedTest(name = "{displayName} avec segment construit avec SegmentDeDroite[{1}]") 
    @MethodSource("segmentsProvider")
    @MethodSource("verticalSegmentsProvider")
    @MethodSource("horizontalSegmentsProvider")
    public void testGetOrigine(SegmentDeDroite s, String paramsDuConstructeur) {
        System.out.println("testGetOrigine ");
        assertTrue(s.getOrigine().egale(ORIGINE));
        assertNotSame(ORIGINE, s.getOrigine());
    }

    /**
     * Vérifie pour un segment quelconque que la méthode getExtremite donne bien le point le bon Point quelle que soit la manière 
     * dont le point a été créé :
     * 
     * - quel que soit le constructeur utilisé (SegmentDeDroite(Point, Point) ou  SegmentDeDroite(double, double, double, double))
     * 
     * - quel que soit l'ordre dans lequel les points ou les coordonnées sont passés en paramètre
     * 
     */
    @DisplayName("getExtremite")
    @ParameterizedTest(name = "{displayName} avec segment construit avec SegmentDeDroite[{1}]") 
    @MethodSource("segmentsProvider")
    public void testGetExtremite(SegmentDeDroite s, String paramsDuConstructeur) {
        System.out.println("testGetExtremite");
        assertTrue(s.getExtremite().egale(EXTREMITE));
        assertNotSame(EXTREMITE, s.getOrigine());
    }

    /**
     * Vérifie pour un segment vertical que la méthode getExtremite donne bien le point le bon Point quelle que soit la manière 
     * dont le point a été créé :
     * 
     * - quel que soit le constructeur utilisé (SegmentDeDroite(Point, Point) ou  SegmentDeDroite(double, double, double, double))
     * 
     * - quel que soit l'ordre dans lequel les points ou les coordonnées sont passés en paramètre
     * 
     */
    @DisplayName("getExtremite Seg Vertical")
    @ParameterizedTest(name = "{displayName} avec segment construit avec SegmentDeDroite[{1}]") 
    @MethodSource("verticalSegmentsProvider")
    public void testGetExtremiteV(SegmentDeDroite s, String paramsDuConstructeur) {
        System.out.println("testGetExtremite");
        assertTrue(s.getExtremite().egale(EXTREMITE_VERTICAL));
        assertNotSame(EXTREMITE_VERTICAL, s.getOrigine());
    }

    /**
     * Vérifie pour un segment horizontal que la méthode getExtremite donne bien le point le bon Point quelle que soit la manière 
     * dont le point a été créé :
     * 
     * - quel que soit le constructeur utilisé (SegmentDeDroite(Point, Point) ou  SegmentDeDroite(double, double, double, double))
     * 
     * - quel que soit l'ordre dans lequel les points ou les coordonnées sont passés en paramètre
     * 
     */
    @DisplayName("getExtremite Seg Horizontal")
    @ParameterizedTest(name = "{displayName} avec segment construit avec SegmentDeDroite[{1}]") 
    @MethodSource("horizontalSegmentsProvider")
    public void testGetExtremiteH(SegmentDeDroite s, String paramsDuConstructeur) {
        System.out.println("testGetExtremite");
        assertTrue(s.getExtremite().egale(EXTREMITE_HORIZONTAL));
        assertNotSame(EXTREMITE_HORIZONTAL, s.getOrigine());
    }

    /**
     * Test de la méthode longueur.
     *
     * Le test vérifie l'exactitude de la méthode longueur pour les trois cas de figure que sont :
     *
     * - un segment quelconque
     *
     * - un segment vertical
     *
     * - segment horizontal
     *
     */
    @Test
    public void testLongueur() {
        System.out.println("test longueur");
        // test de la longueur d'un segment quelconque
        SegmentDeDroite s = new SegmentDeDroite(ORIGINE, EXTREMITE);
        assertEquals(ORIGINE.distance(EXTREMITE), s.longueur(),
                "longueur incorrecte pour un segment quelconque");
        // test de la longueur d'un segment vertical
        s = new SegmentDeDroite(ORIGINE, EXTREMITE_VERTICAL);
        assertEquals(EXTREMITE_VERTICAL.getY() - ORIGINE.getY(), s.longueur());
        // test de la longueur d'un segment horizontal
        s = new SegmentDeDroite(ORIGINE, EXTREMITE_HORIZONTAL);
        assertEquals(EXTREMITE_HORIZONTAL.getX() - ORIGINE.getX(), s.longueur(), 0.0);
    }

    /**
     * cas de test 11. Test de la méthode translater.
     *
     * Vérifie qu'après une translation l'origine et l'extrémité d'un segment ont bien été modifiées
     * selon le vecteur de translation
     */
    @Test
    public void translater() {
        System.out.println("test de translater");
        SegmentDeDroite s = new SegmentDeDroite(new Point(10, -50), new Point(20, -38));
        s.translater(-10, 30);
        assertEquals(0, s.getOrigine().getX(), "abscisse de l'origine incorrecte");
        assertEquals(-20, s.getOrigine().getY(),  "ordonnée origine incorrecte");
        assertEquals(10, s.getExtremite().getX(), "abscisse de l'extrémité incorrecte");
        assertEquals(-8, s.getExtremite().getY(), "ordonnée de l'extrémité incorrecte");
    }

    /**
     * Test de la méthode toString.
     *
     * vérifie que pour un segment d'origine (-20.5,10.45) et d'extrémité (14.33,-28.5) la méthode
     * to String renvoie bien la chaîne : "SegmentDeDroite[(-20.5,10.45);(14.33,-28.5)]"
     */
    @Test
    public void testToString() {
        System.out.println("test de toString");
        SegmentDeDroite s = new SegmentDeDroite(new Point(14.33, -28.5), new Point(-20.5, 10.45));
        assertEquals("SegmentDeDroite[(-20.5,10.45);(14.33,-28.5)]", s.toString());
    }

    /**
     * Test de la méthode estHorizontal
     */
    @Test
    public void testEstHorizontal() {
        System.out.println("test de estHorizontal");
        // un segment quelconque
        SegmentDeDroite s1 = new SegmentDeDroite(new Point(10, 10), new Point(20, 28));
        assertFalse(s1.estHorizontal());
        // un segment vertical
        s1 = new SegmentDeDroite(new Point(10, 10), new Point(10, 20));
        assertFalse(s1.estHorizontal());
        // un segment horizontal
        s1 = new SegmentDeDroite(new Point(10, 10), new Point(20, 10));
        assertTrue(s1.estHorizontal());
    }

    /**
     * Test de la méthode estVertical
     */
    @Test
    public void testEstVertical() {
        System.out.println("test de estVertical");
        // un segment quelconque
        SegmentDeDroite s1 = new SegmentDeDroite(new Point(10, 10), new Point(20, 28));
        assertFalse(s1.estVertical());
        // un segment horizontal
        s1 = new SegmentDeDroite(new Point(10, 10), new Point(20, 10));
        assertFalse(s1.estVertical());
        // un segment vertical
        s1 = new SegmentDeDroite(new Point(10, 10), new Point(10, 20));
        assertTrue(s1.estVertical());
    }

    /**
     * Teste que le constructeur SegmentDeDroite(Point, Point) définit bien une
     * relation de composition forte entre le segment et ses deux sommets.
     *
     * Ce test vérifie que si le segment est construit par deux points, une modification ultérieure
     * du segment (par translation) n'altère pas les points ayant servi à le construire et 
     * qu'inversement une modification des points ayant servi à construire le segment ne modifie
     * pas le segment.
     */
    @Test
    public void testCompositionForte() {
        System.out.println("testCompositionForte");
        Point p1 = new Point(10, -50);
        Point p2 = new Point(20, -38);
        SegmentDeDroite s1 = new SegmentDeDroite(p1, p2);
        s1.translater(-10, 30);
        // on vérifie que les points p1 et p2 ayant servi à créer le segment s1
        // n'ont pas été modifiés et ont toujours une valeur identique à celle
        // qui était la leur au moment de la création du segment
        assertEquals(10, p1.getX(), "abscisse de p1 a été modifiée");
        assertEquals(-50, p1.getY(),  "ordonnée de p1 a été modifiée");
        assertEquals(20, p2.getX(), "abscisse de p2 a été modifiée");
        assertEquals(-38, p2.getY(),  "ordonnée de p2 a été modifiée");

        SegmentDeDroite s2 = new SegmentDeDroite(p1, p2);
        p1.placerA(-100, 0);
        p2.placerA(-6, 30);
        // on vérifie que les modifications des points p1 et p2 ayant servi à créer le segment s2
        // n'ont pas modifié ni l'origine ni l'extrémté du segment s2
        assertEquals(10, s2.getOrigine().getX(), "abscisse de origine du segment a été modifiée");
        assertEquals(-50, s2.getOrigine().getY(),  "ordonnée de origine du segment a été modifiée");
        assertEquals(20, s2.getExtremite().getX(), "abscisse de extremité du segment a été modifiée");
        assertEquals(-38, s2.getExtremite().getY(),  "ordonnée de extremité du segment a été modifiée");
    }

    /**
     * Test de la méthode egale.
     *
     * 1. vérifie que egale est réflexive (un segment est égale à lui même)
     *
     * 2. teste que pour deux segments créés avec les mêmes points la méthode egale renvoie bien la
     * valeur true et qu'elle est symétrique.
     *
     * 3. teste que pour deux segments créés avec les mêmes points la méthode egale renvoie bien la
     * valeur true et qu'elle est symétrique.
     *
     */
    @Test
    public void testEgale() {
        System.out.println("test de egale");

        SegmentDeDroite s1 = new SegmentDeDroite(ORIGINE, EXTREMITE);
        // on vérifie que equals est réflexive
        assertTrue(s1.egale(s1));

        // test que l'égalité avec un autre segment identique est bien vérifiée
        SegmentDeDroite s2 = new SegmentDeDroite(EXTREMITE, ORIGINE);
        assertTrue(s1.egale(s2));
        // on verifie que equals est symétrique
        assertTrue(s2.egale(s1));

        // test que l'égalité avec un autre segment à l'extremité différente n'est pas vérifiée
        s2 = new SegmentDeDroite(ORIGINE, EXTREMITE_HORIZONTAL);
        assertFalse(s1.egale(s2));
        // on vérifie que equals est symétrique
        assertFalse(s2.egale(s1));

        // test que l'égalité avec un autre segment à l'origine différente n'est pas vérifiée
        s2 = new SegmentDeDroite(EXTREMITE_VERTICAL, EXTREMITE);
        assertFalse(s1.egale(s2));
        // on vérifie que equals est symétrique
        assertFalse(s2.egale(s1));

        // test que l'égalité avec un autre segment complètement différent n'est pas vérifiée
        s2 = new SegmentDeDroite(EXTREMITE_VERTICAL, EXTREMITE_HORIZONTAL);
        assertFalse(s1.egale(s2));
        // on vérifie que equals est symétrique
        assertFalse(s2.egale(s1));

        // test que l'égalité avec un Segment null renvoie bien false
        assertFalse(s1.egale(null));

    }

}