/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed 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 com.android.settingslib.inputmethod;

import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;

import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.function.ToIntBiFunction;

/**
 * Utility class to assert {@link Comparable} objects.
 */
final class ComparableUtils {

    private ComparableUtils() {
    }

    /**
     * Checks whether specified items have ascending ordering.
     *
     * @param items     objects to be checked Comparable contracts.
     * @param compareTo function to compare two objects as {@link Comparable#compareTo(Object)}.
     * @param name      function to extract name of an object.
     * @param <T>       type that implements {@link Comparable}.
     */
    static <T> void assertAscendingOrdering(final List<T> items,
            final ToIntBiFunction<T, T> compareTo, final Function<T, String> name) {
        for (int i = 1; i < items.size(); i++) {
            final T x = items.get(i - 1);
            final T y = items.get(i);
            assertTrue(name.apply(x) + " is less than " + name.apply(y),
                    compareTo.applyAsInt(x, y) < 0);
        }
    }

    /**
     * Checks whether specified items have the same ordering.
     *
     * @param items     objects to be checked equality.
     * @param compareTo function to compare two objects as {@link Comparable#compareTo(Object)}.
     * @param name      function to extract name of an object.
     * @param <T>       type that implements {@link Comparable}.
     */
    static <T> void assertSameOrdering(final Collection<T> items,
            final ToIntBiFunction<T, T> compareTo, final Function<T, String> name) {
        for (final T x : items) {
            for (final T y : items) {
                assertTrue(name.apply(x) + " is equal to " + name.apply(y),
                        compareTo.applyAsInt(x, y) == 0);
            }
        }
    }

    /**
     * Checks whether a {@link Comparable} type complies with Comparable contracts.
     * <ul>
     * <li>Ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y.</li>
     * <li>Ensure that the relation is transitive:
     *     (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.</li>
     * <li>Ensure that x.compareTo(y)==0 implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)),
     *     for all z.</li>
     * </ul>
     *
     * @param items     objects to be checked Comparable contracts.
     * @param compareTo function to compare two objects as {@link Comparable#compareTo(Object)}.
     * @param name      function to extract name of an object.
     * @param <T>       type that implements {@link Comparable}.
     */
    static <T> void assertComparableContracts(final Collection<T> items,
            final ToIntBiFunction<T, T> compareTo, final Function<T, String> name) {
        for (final T x : items) {
            final String nameX = name.apply(x);
            assertTrue("Reflective: " + nameX + " is equal to itself",
                    compareTo.applyAsInt(x, x) == 0);
            for (final T y : items) {
                final String nameY = name.apply(y);
                assertEquals("Asymmetric: " + nameX + " and " + nameY,
                        Integer.signum(compareTo.applyAsInt(x, y)),
                        -Integer.signum(compareTo.applyAsInt(y, x)));
                for (final T z : items) {
                    final String nameZ = name.apply(z);
                    if (compareTo.applyAsInt(x, y) > 0 && compareTo.applyAsInt(y, z) > 0) {
                        assertTrue("Transitive: " + nameX + " is greater than " + nameY
                                        + " and " + nameY + " is greater than " + nameZ
                                        + " then " + nameX + " is greater than " + nameZ,
                                compareTo.applyAsInt(x, z) > 0);
                    }
                    if (compareTo.applyAsInt(x, y) == 0) {
                        assertEquals("Transitive: " + nameX + " and " + nameY + " is same "
                                        + " then both return the same result for " + nameZ,
                                Integer.signum(compareTo.applyAsInt(x, z)),
                                Integer.signum(compareTo.applyAsInt(y, z)));
                    }
                }
            }
        }
    }
}