/*
 * 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.geometry.enclosing.euclidean.twod;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.geometry.core.GeometryTestUtils;
import org.apache.commons.geometry.enclosing.EnclosingBall;
import org.apache.commons.geometry.euclidean.EuclideanTestUtils;
import org.apache.commons.geometry.euclidean.twod.Vector2D;
import org.apache.commons.numbers.core.Precision;
import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.simple.RandomSource;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

class WelzlEncloser2DTest {

    private static final double TEST_EPS = 1e-10;

    private static final Precision.DoubleEquivalence TEST_PRECISION =
            Precision.doubleEquivalenceOfEpsilon(TEST_EPS);

    private final WelzlEncloser2D encloser = new WelzlEncloser2D(TEST_PRECISION);

    @Test
    void testNoPoints() {
        // arrange
        final String msg = "Unable to generate enclosing ball: no points given";

        // act/assert
        GeometryTestUtils.assertThrowsWithMessage(() -> {
            encloser.enclose(null);
        }, IllegalArgumentException.class, msg);

        GeometryTestUtils.assertThrowsWithMessage(() -> {
            encloser.enclose(new ArrayList<Vector2D>());
        }, IllegalArgumentException.class, msg);
    }

    @Test
    void testRegularPoints() {
        // arrange
        final List<Vector2D> list = buildList(22, 26, 30, 38, 64, 28,  8, 54, 11, 15);

        // act/assert
        checkDisk(list, Arrays.asList(list.get(2), list.get(3), list.get(4)));
    }

    @Test
    void testSolutionOnDiameter() {
        // arrange
        final List<Vector2D> list = buildList(22, 26, 30, 38, 64, 28,  8, 54);

        // act/assert
        checkDisk(list, Arrays.asList(list.get(2), list.get(3)));
    }

    @Test
    void testReducingBall1() {
        // arrange
        final List<Vector2D> list = buildList(0.05380958511396061, 0.57332359658700000,
                                        0.99348810731127870, 0.02056421361521466,
                                        0.01203950647796437, 0.99779675042261860,
                                        0.00810189987706078, 0.00589246003827815,
                                        0.00465180821202149, 0.99219972923046940);

        // act/assert
        checkDisk(list, Arrays.asList(list.get(1), list.get(3), list.get(4)));
    }

    @Test
    void testReducingBall2() {
        // arrange
        final List<Vector2D> list = buildList(0.016930586154703, 0.333955448537779,
                                        0.987189104892331, 0.969778855274507,
                                        0.983696889599935, 0.012904580013266,
                                        0.013114499572905, 0.034740156356895);

        // act/assert
        checkDisk(list, Arrays.asList(list.get(1), list.get(2), list.get(3)));
    }

    @Test
    void testLargeSamples() {
        // arrange
        final UniformRandomProvider random = RandomSource.create(RandomSource.WELL_1024_A, 0xa2a63cad12c01fb2L);
        for (int k = 0; k < 100; ++k) {
            final int nbPoints = random.nextInt(10000);
            final List<Vector2D> points = new ArrayList<>();
            for (int i = 0; i < nbPoints; ++i) {
                final double x = random.nextDouble();
                final double y = random.nextDouble();
                points.add(Vector2D.of(x, y));
            }

            // act/assert
            checkDisk(points);
        }
    }

    @Test
    void testEnclosingWithPrecision() {
        // arrange
        final List<Vector2D> points = Arrays.asList(
                Vector2D.of(271.59, 57.282),
                Vector2D.of(269.145, 57.063),
                Vector2D.of(309.117, 77.187),
                Vector2D.of(316.989, 34.835),
                Vector2D.of(323.101, 53.972)
        );
        final double precision = 1;
        final Precision.DoubleEquivalence precisionContext = Precision.doubleEquivalenceOfEpsilon(precision);
        final WelzlEncloser2D customPrecisionEncloser = new WelzlEncloser2D(precisionContext);

        // act
        final EnclosingBall<Vector2D> result = customPrecisionEncloser.enclose(points);

        // assert
        Assertions.assertEquals(27.099954200964234, result.getRadius(), TEST_EPS);
        EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(296.0056977503686, 53.469890753441945),
                result.getCenter(), TEST_EPS);
    }

    private List<Vector2D> buildList(final double... coordinates) {
        final List<Vector2D> list = new ArrayList<>(coordinates.length / 2);
        for (int i = 0; i < coordinates.length; i += 2) {
            list.add(Vector2D.of(coordinates[i], coordinates[i + 1]));
        }
        return list;
    }

    private void checkDisk(final List<Vector2D> points, final List<Vector2D> refSupport) {

        final EnclosingBall<Vector2D> disk = checkDisk(points);

        // compare computed disk with expected disk
        final EnclosingBall<Vector2D> expected = new DiskGenerator().ballOnSupport(refSupport);
        Assertions.assertEquals(refSupport.size(), disk.getSupportSize());
        Assertions.assertEquals(expected.getRadius(),        disk.getRadius(),        1.0e-10);
        Assertions.assertEquals(expected.getCenter().getX(), disk.getCenter().getX(), 1.0e-10);
        Assertions.assertEquals(expected.getCenter().getY(), disk.getCenter().getY(), 1.0e-10);

        for (final Vector2D s : disk.getSupport()) {
            boolean found = false;
            for (final Vector2D rs : refSupport) {
                if (s == rs) {
                    found = true;
                    break;
                }
            }
            Assertions.assertTrue(found);
        }

        // check removing any point of the support disk fails to enclose the point
        for (int i = 0; i < disk.getSupportSize(); ++i) {
            final List<Vector2D> reducedSupport = new ArrayList<>();
            int count = 0;
            for (final Vector2D s : disk.getSupport()) {
                if (count++ != i) {
                    reducedSupport.add(s);
                }
            }
            final EnclosingBall<Vector2D> reducedDisk = new DiskGenerator().ballOnSupport(reducedSupport);
            boolean foundOutside = false;
            for (int j = 0; j < points.size() && !foundOutside; ++j) {
                if (!reducedDisk.contains(points.get(j), TEST_PRECISION)) {
                    foundOutside = true;
                }
            }
            Assertions.assertTrue(foundOutside);
        }
    }

    private EnclosingBall<Vector2D> checkDisk(final List<Vector2D> points) {

        final EnclosingBall<Vector2D> disk = encloser.enclose(points);

        // all points are enclosed
        for (final Vector2D v : points) {
            Assertions.assertTrue(disk.contains(v, TEST_PRECISION));
        }

        // all support points are on the boundary
        final Vector2D center = disk.getCenter();
        final double radius = disk.getRadius();

        for (final Vector2D s : disk.getSupport()) {
            Assertions.assertTrue(TEST_PRECISION.eqZero(center.distance(s) - radius));
        }

        return disk;
    }
}