import org.junit.jupiter.api.Test;

import static org.junit.Assert.assertNull;
import static org.junit.jupiter.api.Assertions.*;

public class VectorTest {

    @Test
    void testScalarMultiplication() {
        int[] vector = {1, 2, 3};
        int scalar = 2;
        Vector.scalarMultiplication(vector, scalar);
        assertArrayEquals(new int[]{2, 4, 6}, vector);
        int[] vector1 = {7, 8, 15};

        Vector.scalarMultiplication(vector1, -1);
        assertArrayEquals(new int[]{-7, -8, -15}, vector1);
    }

    @Test
    void testVectorProduct2D() {
        int[] vector1 = {3, 4};
        int[] vector2 = {5, 6};
        // Für 2D Kreuzprodukt wird der Skalarwert (Z-Komponente des 3D-Kreuzprodukts) verwendet
        // 3*6 - 4*5 = 18 - 20 = -2
        // Erwartete Ausgabe: -2
        System.out.print("Erwartete Ausgabe: -2\nTatsächliche Ausgabe: ");
        Vector.vectorProduct(vector1, vector2);
    }

    @Test
    void testVectorProduct3D() {
        int[] vector1 = {1, 2, 3};
        int[] vector2 = {4, 5, 6};
        // Kreuzprodukt:
        // x = 2*6 - 3*5 = 12 - 15 = -3
        // y = 3*4 - 1*6 = 12 - 6 = 6
        // z = 1*5 - 2*4 = 5 - 8 = -3
        System.out.print("Erwartete Ausgabe: [-3, 6, -3]\nTatsächliche Ausgabe: ");
        Vector.vectorProduct(vector1, vector2);
    }

    @Test
    void testVectorLength() {
        int[] vector = {3, 4};
        double length = Vector.vectorLength(vector);
        assertEquals(5.0, length, 0.001);

        int[] vector3D = {1, 2, 2};
        assertEquals(3.0, Vector.vectorLength(vector3D), 0.001);
    }

    @Test
    void testMatrixMultiplicationValidMatrix() {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        int scalar = 2;
        int[][] expected = {
            {2, 4, 6},
            {8, 10, 12},
            {14, 16, 18}
        };
        assertArrayEquals(expected, Vector.matrixMultiplication(matrix, scalar));
    }

    @Test
    void testMatrixMultiplicationInvalidMatrix() {
        int[][] invalidMatrix = {
            {1, 2},
            {3, 4}
        };
        assertNull(Vector.matrixMultiplication(invalidMatrix, 3));
    }



    @Test
    void testScalarMultiplicationVariants() {
        int[] v1 = {1, 2, 3};
        Vector.scalarMultiplication(v1, 2);
        assertArrayEquals(new int[]{2, 4, 6}, v1);

        int[] v2 = {7, 8, 15};
        Vector.scalarMultiplication(v2, -1);
        assertArrayEquals(new int[]{-7, -8, -15}, v2);

        int[] v3 = {0, 0, 0};
        Vector.scalarMultiplication(v3, 5);
        assertArrayEquals(new int[]{0, 0, 0}, v3);
    }

    @Test
    void testVectorProduct2DVariants() {
        int ergebnis1 = -2;
        System.out.println("Erwartet: " + ergebnis1 );
        Vector.vectorProduct(new int[]{3, 4}, new int[]{5, 6});
        int ergebnis2 = -1;
        System.out.println("Erwartet: " + ergebnis2 );
        Vector.vectorProduct(new int[]{0, 1}, new int[]{1, 0});

    }

    @Test
    void testVectorProduct3DVariants() {
        int[] ergebnis1 = {-3, 6, -3};
        System.out.println("Erwartet: [" + ergebnis1[0]+", " + ergebnis1[1] +", " + ergebnis1[2]+"]");
        Vector.vectorProduct(new int[]{1, 2, 3}, new int[]{4, 5, 6});
        int[] ergebnis2 = {-1, 0, 0};
        System.out.println("Erwartet: [" + ergebnis2[0]+", " + ergebnis2[1] +", " + ergebnis2[2]+"]");
        Vector.vectorProduct(new int[]{0, 0, 1}, new int[]{0, 1, 0});

    }

    @Test
    void testVectorProductInvalidDimensions() {
        System.out.println("Erwartet: illegale Dimension" );
        Vector.vectorProduct(new int[]{1, 0}, new int[]{0, 1, 0});
    }

    @Test
    void testVectorLengthVariants() {
        assertEquals(5.0, Vector.vectorLength(new int[]{3, 4}), 0.001);
        assertEquals(3.0, Vector.vectorLength(new int[]{1, 2, 2}), 0.001);
        assertEquals(0.0, Vector.vectorLength(new int[]{0, 0, 0}), 0.001);
    }

    @Test
    void testMatrixMultiplicationVariants() {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        int[][] expected = {
            {2, 4, 6},
            {8, 10, 12},
            {14, 16, 18}
        };
        assertArrayEquals(expected, Vector.matrixMultiplication(matrix, 2));

        int[][] zeroMatrix = {
            {1, -2, -6},
            {-3, 4, 5},
            {-70, 12, -8}
        };
        int[][] expectedZero = {
            {0, 0, 0},
            {0, 0, 0},
            {0, 0, 0}
        };
        assertArrayEquals(expectedZero, Vector.matrixMultiplication(zeroMatrix, 0));
    }

    @Test
    void testMatrixMultiplicationInvalidCases() {
        int[][] nonSquare = {
            {1, 2},
            {3, 4}
        };
        assertNull(Vector.matrixMultiplication(nonSquare, 3));

        int[][] empty = new int[0][0];
        assertNull(Vector.matrixMultiplication(empty, 2));
    }
}