/*
 * 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.math4.legacy.core.jdkmath;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.numbers.core.Precision;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

// Unit test should be moved to module "commons-math-core".
// [Currently, it can't be because it depends on "legacy" classes.]
import org.apache.commons.math4.core.jdkmath.AccurateMath;

/**
 * Test to compare AccurateMath results against StrictMath results for boundary values.
 * <p>
 * Running all tests independently: <br>
 * {@code mvn test -Dtest=AccurateMathStrictComparisonTest}<br>
 * or just run tests against a single method (e.g. scalb):<br>
 * {@code mvn test -Dtest=AccurateMathStrictComparisonTest -DargLine="-DtestMethod=scalb"}
 */
@SuppressWarnings("boxing")
@RunWith(Parameterized.class)
public class AccurateMathStrictComparisonTest {

    // Values which often need special handling
    private static final Double[] DOUBLE_SPECIAL_VALUES = {
        -0.0, +0.0,                                         // 1,2
        Double.NaN,                                         // 3
        Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, // 4,5
        -Double.MAX_VALUE, Double.MAX_VALUE,                // 6,7
        // decreasing order of absolute value to help catch first failure
        -Precision.EPSILON, Precision.EPSILON,              // 8,9
        -Precision.SAFE_MIN, Precision.SAFE_MIN,            // 10,11
        -Double.MIN_VALUE, Double.MIN_VALUE,                // 12,13
    };

    private static final Float[] FLOAT_SPECIAL_VALUES = {
        -0.0f, +0.0f,                                       // 1,2
        Float.NaN,                                          // 3
        Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY,   // 4,5
        Float.MIN_VALUE, Float.MAX_VALUE,                   // 6,7
        -Float.MIN_VALUE, -Float.MAX_VALUE,                 // 8,9
    };

    private static final Object[] LONG_SPECIAL_VALUES = {
        -1, 0, 1,                                           // 1,2,3
        Long.MIN_VALUE, Long.MAX_VALUE,                     // 4,5
    };

    private static final Object[] INT_SPECIAL_VALUES = {
        -1, 0, 1,                                           // 1,2,3
        Integer.MIN_VALUE, Integer.MAX_VALUE,               // 4,5
    };

    private final Method mathMethod;
    private final Method fastMethod;
    private final Type[] types;
    private final Object[][] valueArrays;

    public AccurateMathStrictComparisonTest(Method m, Method f, Type[] types, Object[][] data) throws Exception {
        this.mathMethod = m;
        this.fastMethod = f;
        this.types = types;
        this.valueArrays = data;
    }

    @Test
    public void test1() throws Exception {
        setupMethodCall(mathMethod, fastMethod, types, valueArrays);
    }

    private static boolean isNumber(Double d) {
        return !(d.isInfinite() || d.isNaN());
    }

    private static boolean isNumber(Float f) {
        return !(f.isInfinite() || f.isNaN());
    }

    private static void reportFailedResults(Method mathMethod, Object[] params, Object expected, Object actual, int[] entries) {
        final String methodName = mathMethod.getName();
        String format = null;
        long actL = 0;
        long expL = 0;
        if (expected instanceof Double) {
            Double exp = (Double) expected;
            Double act = (Double) actual;
            if (isNumber(exp) && isNumber(act) && exp != 0) { // show difference as hex
                actL = Double.doubleToLongBits(act);
                expL = Double.doubleToLongBits(exp);
                if (Math.abs(actL - expL) == 1) {
                    // Not 100% sure off-by-one errors are allowed everywhere, so only allow for these methods
                    if (methodName.equals("toRadians") || methodName.equals("atan2")) {
                        return;
                    }
                }
                format = "%016x";
            }
        } else if (expected instanceof Float) {
            Float exp = (Float) expected;
            Float act = (Float) actual;
            if (isNumber(exp) && isNumber(act) && exp != 0) { // show difference as hex
                actL = Float.floatToIntBits(act);
                expL = Float.floatToIntBits(exp);
                format = "%08x";
            }
        }
        StringBuilder sb = new StringBuilder();
        sb.append(mathMethod.getReturnType().getSimpleName());
        sb.append(" ");
        sb.append(methodName);
        sb.append("(");
        String sep = "";
        for (Object o : params) {
            sb.append(sep);
            sb.append(o);
            sep = ", ";
        }
        sb.append(") expected ");
        if (format != null) {
            sb.append(String.format(format, expL));
        } else {
            sb.append(expected);
        }
        sb.append(" actual ");
        if (format != null) {
            sb.append(String.format(format, actL));
        } else {
            sb.append(actual);
        }
        sb.append(" entries ");
        sb.append(Arrays.toString(entries));
        String message = sb.toString();
        final boolean fatal = true;
        if (fatal) {
            Assert.fail(message);
        } else {
            // CHECKSTYLE: stop Regexp
            System.out.println(message);
            // CHECKSTYLE: resume Regexp
        }
    }

    private static void callMethods(Method mathMethod, Method fastMethod,
            Object[] params, int[] entries) throws IllegalAccessException {
        try {
            Object expected;
            try {
                expected = mathMethod.invoke(mathMethod, params);
            } catch (InvocationTargetException ite) {
                expected = ite.getCause();
            }
            Object actual;
            try {
                actual = fastMethod.invoke(mathMethod, params);
            } catch (InvocationTargetException ite) {
                actual = ite.getCause();
            }
            if (expected instanceof ArithmeticException) {
                Assert.assertTrue(actual instanceof ArithmeticException);
            } else if (!expected.equals(actual)) {
                reportFailedResults(mathMethod, params, expected, actual, entries);
            }
        } catch (IllegalArgumentException e) {
            Assert.fail(mathMethod + " " + e);
        }
    }

    private static void setupMethodCall(Method mathMethod, Method fastMethod,
            Type[] types, Object[][] valueArrays) throws Exception {
        Object[] params = new Object[types.length];
        int entry1 = 0;
        int[] entries = new int[types.length];
        for (Object d : valueArrays[0]) {
            entry1++;
            params[0] = d;
            entries[0] = entry1;
            if (params.length > 1) {
                int entry2 = 0;
                for (Object d1 : valueArrays[1]) {
                    entry2++;
                    params[1] = d1;
                    entries[1] = entry2;
                    callMethods(mathMethod, fastMethod, params, entries);
                }
            } else {
                callMethods(mathMethod, fastMethod, params, entries);
            }
        }
    }

    @Parameters
    public static List<Object[]> data() throws Exception {
        // CHECKSTYLE: stop Regexp
        String singleMethod = System.getProperty("testMethod");
        List<Object[]> list = new ArrayList<>();
        for (Method mathMethod : StrictMath.class.getDeclaredMethods()) {
            method:
            if (Modifier.isPublic(mathMethod.getModifiers())) { // Only test public methods
                Type[] types = mathMethod.getGenericParameterTypes();
                if (types.length >= 1) { // Only check methods with at least one parameter
                    try {
                        // Get the corresponding AccurateMath method
                        Method fastMethod = AccurateMath.class.getDeclaredMethod(mathMethod.getName(), (Class[]) types);
                        if (Modifier.isPublic(fastMethod.getModifiers())) { // It must be public too
                            if (singleMethod != null && !fastMethod.getName().equals(singleMethod)) {
                                break method;
                            }
                            Object[][] values = new Object[types.length][];
                            int index = 0;
                            for (Type t : types) {
                                if (t.equals(double.class)) {
                                    values[index] = DOUBLE_SPECIAL_VALUES;
                                } else if (t.equals(float.class)) {
                                    values[index] = FLOAT_SPECIAL_VALUES;
                                } else if (t.equals(long.class)) {
                                    values[index] = LONG_SPECIAL_VALUES;
                                } else if (t.equals(int.class)) {
                                    values[index] = INT_SPECIAL_VALUES;
                                } else {
                                    System.out.println("Cannot handle class " + t + " for " + mathMethod);
                                    break method;
                                }
                                index++;
                            }
//                          System.out.println(fastMethod);
                            /*
                             * The current implementation runs each method as a separate test.
                             * Could be amended to run each value as a separate test
                             */
                            list.add(new Object[]{mathMethod, fastMethod, types, values});
//                            setupMethodCall(mathMethod, fastMethod, params, data);
                        } else {
                            System.out
                                .println("Cannot find public AccurateMath method corresponding to: " + mathMethod);
                        }
                    } catch (NoSuchMethodException e) {
                        System.out.println("Cannot find AccurateMath method corresponding to: " + mathMethod);
                    }
                }
            }
        }
        return list;
        // CHECKSTYLE: resume Regexp
    }
}