/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.commons.numbers.complex.streams;

import org.apache.commons.numbers.complex.Complex;
import org.apache.commons.numbers.core.Precision;

import org.junit.jupiter.api.Assertions;

/**
 * Test utilities.
 */
@SuppressWarnings("WeakerAccess")
final class TestUtils {
    /**
     * Collection of static methods used in math unit tests.
     */
    private TestUtils() {
        super();
    }

    /**
     * Verifies that the two arguments are exactly the same, either
     * both NaN or infinities of same sign, or identical floating point values.
     */
    public static void assertSame(String msg, Complex[] expected, Complex[] actual) {
        assertEquals(msg, expected, actual, 0);
    }

    /**
     * Verifies that the two arguments are exactly the same, either
     * both NaN or infinities of same sign, or identical floating point values.
     */
    public static void assertSame(String msg, Complex[][] expected, Complex[][] actual) {
        assertEquals(msg, expected, actual, 0);
    }

    /**
     * Verifies that the two arguments are exactly the same, either
     * both NaN or infinities of same sign, or identical floating point values.
     */
    public static void assertSame(String msg, Complex[][][] expected, Complex[][][] actual) {
        assertEquals(msg, expected, actual, 0);
    }

    /**
     * Verifies that the two arguments are exactly the same, either
     * both NaN or infinities of same sign, or identical floating point values.
     */
    public static void assertSame(String msg, Complex[][][][] expected, Complex[][][][] actual) {
        assertEquals(msg, expected, actual, 0);
    }

    /**
     * Verifies that real and imaginary parts of the two complex arguments
     * are exactly the same.  Also ensures that NaN / infinite components match.
     */
    public static void assertSame(Complex expected, Complex actual) {
        Assertions.assertEquals(expected.getReal(), actual.getReal());
        Assertions.assertEquals(expected.getImaginary(), actual.getImaginary());
    }

    /**
     * Verifies that real and imaginary parts of the two complex arguments
     * differ by at most delta.  Also ensures that NaN / infinite components match.
     */
    public static void assertEquals(Complex expected, Complex actual, double delta) {
        Assertions.assertEquals(expected.getReal(), actual.getReal(), delta, "Real Values Differ");
        Assertions.assertEquals(expected.getImaginary(), actual.getImaginary(), delta, "Imaginary Values Differ");
    }

    /** verifies that two 2D arrays are close (sup norm) */
    public static void assertEquals(String msg, double[][] expected, double[][] observed, double tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            Assertions.assertArrayEquals(expected[i], observed[i], tolerance, msg + "[" + i + "]");
        }
    }

    /** verifies that two 3D arrays are close (sup norm) */
    public static void assertEquals(String msg, double[][][] expected, double[][][] observed, double tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance);
        }
    }

    /** verifies that two 4D arrays are close (sup norm) */
    public static void assertEquals(String msg, double[][][][] expected, double[][][][] observed, double tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance);
        }
    }

    /** verifies that two 4D arrays are close (sup norm) */
    public static void assertEquals(String msg, float[][][][] expected, float[][][][] observed, float tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance);
        }
    }

    /** verifies that two 2D arrays are close (sup norm) */
    public static void assertEquals(String msg, float[][] expected, float[][] observed, float tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            Assertions.assertArrayEquals(expected[i], observed[i], tolerance, msg + "[" + i + "]");
        }
    }

    /** verifies that two 3D arrays are close (sup norm) */
    public static void assertEquals(String msg, float[][][] expected, float[][][] observed, float tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance);
        }
    }

    /** verifies that two arrays are close (sup norm) */
    public static void assertEquals(String msg, Complex[] expected, Complex[] observed, double tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        StringBuilder out = new StringBuilder(msg);
        boolean failure = false;
        for (int i = 0; i < expected.length; i++) {
            if (!Precision.equalsIncludingNaN(expected[i].getReal(), observed[i].getReal(), tolerance)) {
                failure = true;
                out.append("\n[").append(i).append("] ");
                out.append("Real elements differ. ");
                out.append(" expected = ");
                out.append(expected[i].getReal());
                out.append(" observed = ");
                out.append(observed[i].getReal());
            }
            if (!Precision.equalsIncludingNaN(expected[i].getImaginary(), observed[i].getImaginary(), tolerance)) {
                failure = true;
                out.append("\n[").append(i).append("] ");
                out.append("Imaginary elements differ. ");
                out.append(" expected = ");
                out.append(expected[i].getImaginary());
                out.append(" observed = ");
                out.append(observed[i].getImaginary());
            }
        }
        if (failure) {
            Assertions.fail(out.toString());
        }
    }

    /** verifies that two 2D arrays are close (sup norm) */
    public static void assertEquals(String msg, Complex[][] expected, Complex[][] observed, double tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance);
        }
    }

    /** verifies that two 3D arrays are close (sup norm) */
    public static void assertEquals(String msg, Complex[][][] expected, Complex[][][] observed, double tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance);
        }
    }

    /** verifies that two 4D arrays are close (sup norm) */
    public static void assertEquals(String msg, Complex[][][][] expected, Complex[][][][] observed, double tolerance) {
        assertArrayLengthsEqual(msg, expected.length, observed.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance);
        }
    }

    /**
     * Assert that the given array lengths are the same
     * @param msg Initial message
     * @param expectedLength expected array length
     * @param observedLength observed array length
     */
    private static void assertArrayLengthsEqual(String msg, int expectedLength, int observedLength) {
        if (expectedLength != observedLength) {
            StringBuilder out = new StringBuilder(msg);
            if (msg != null && msg.length() > 0) {
                out.append("\n");
            }
            out.append("Arrays not same length. \n");
            out.append("expected has length ").append(expectedLength);
            out.append(" observed has length = ").append(observedLength);
            Assertions.fail(out.toString());
        }

    }
}