import org.junit.jupiter.api.Test;

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

public class VectorTest {

    @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);
        int[] v4 = {};
        Vector.scalarMultiplication(v4, 2);
        assertArrayEquals(new int[] {  0,0,0}, v4);
        int[] v5 = null;
        Vector.scalarMultiplication(v5, 5);
        assertArrayEquals(null, v5);
    }

    @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[][] non3DSquare = {
                { 1, 2 },
                { 3, 4 }
        };
        assertNull(Vector.matrixMultiplication(non3DSquare, 3));

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