/**
 * \file
 * \copyright
 * Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org)
 *            Distributed under a Modified BSD License.
 *              See accompanying file LICENSE.txt or
 *              http://www.opengeosys.org/project/license
 */

#include <gtest/gtest.h>

#include <ctime>
#include <random>

#include "GeoLib/PointVec.h"

class PointVecTest : public testing::Test
{
public:
    using VectorOfPoints = std::vector<GeoLib::Point*>;

    PointVecTest() : gen(std::random_device()()), name("JustAName") {}

protected:
    // Generates n new points according to given random number distribution,
    // which is uniform distribution in [-1, 1]^3.
    void generateRandomPoints(VectorOfPoints& ps, std::size_t const n = 1000)
    {
        std::uniform_real_distribution<double> rnd(-1, 1);
        std::generate_n(std::back_inserter(ps), n, [&]() {
            return new GeoLib::Point(rnd(gen), rnd(gen), rnd(gen), ps.size());
        });
    }

protected:
    std::mt19937 gen;
    const std::string name;
};

// Testing nullptr input vector.
TEST_F(PointVecTest, TestPointVecCtorNullptr)
{
    ASSERT_THROW(GeoLib::PointVec(name, nullptr), std::runtime_error);
}

// Testing empty input vector.
TEST_F(PointVecTest, TestPointVecCtorEmpty)
{
    auto ps_ptr = std::make_unique<VectorOfPoints>();
    ASSERT_THROW(GeoLib::PointVec(name, std::move(ps_ptr)), std::runtime_error);
}

// Testing input vector with single point.
TEST_F(PointVecTest, TestPointVecCtorSinglePoint)
{
    auto ps_ptr = std::make_unique<VectorOfPoints>();
    ps_ptr->push_back(new GeoLib::Point(0, 0, 0, 0));
    auto point_vec =
        std::make_unique<GeoLib::PointVec>(name, std::move(ps_ptr));
    ASSERT_EQ(std::size_t(1), point_vec->size());
}

// Testing input vector with two different points.
TEST_F(PointVecTest, TestPointVecCtorTwoDiffPoints)
{
    auto ps_ptr = std::make_unique<VectorOfPoints>();
    ps_ptr->push_back(new GeoLib::Point(0, 0, 0, 0));
    ps_ptr->push_back(new GeoLib::Point(1, 0, 0, 1));

    auto point_vec =
        std::make_unique<GeoLib::PointVec>(name, std::move(ps_ptr));
    ASSERT_EQ(std::size_t(2), point_vec->size());
}

// Testing input vector with two equal points.
TEST_F(PointVecTest, TestPointVecCtorTwoEqualPoints)
{
    auto ps_ptr = std::make_unique<VectorOfPoints>();
    ps_ptr->push_back(new GeoLib::Point(0, 0, 0, 0));
    ps_ptr->push_back(new GeoLib::Point(0, 0, 0, 1));

    auto point_vec =
        std::make_unique<GeoLib::PointVec>(name, std::move(ps_ptr));
    ASSERT_EQ(std::size_t(1), point_vec->size());
}

// Testing input vector with single point.
TEST_F(PointVecTest, TestPointVecPushBack)
{
    auto ps_ptr = std::make_unique<VectorOfPoints>();
    ps_ptr->push_back(new GeoLib::Point(0, 0, 0, 0));
    ps_ptr->push_back(new GeoLib::Point(1, 0, 0, 1));
    ps_ptr->push_back(new GeoLib::Point(0, 1, 0, 2));
    ps_ptr->push_back(new GeoLib::Point(0, 0, 1, 3));
    GeoLib::PointVec point_vec(name, std::move(ps_ptr));

    ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[0]);
    ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[1]);
    ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[2]);
    ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[3]);

    // Adding some points that are already existing.
    ASSERT_EQ(std::size_t(0),
              point_vec.push_back(new GeoLib::Point(0, 0, 0, 4)));
    ASSERT_EQ(std::size_t(1),
              point_vec.push_back(new GeoLib::Point(1, 0, 0, 5)));
    ASSERT_EQ(std::size_t(2),
              point_vec.push_back(new GeoLib::Point(0, 1, 0, 6)));
    ASSERT_EQ(std::size_t(3),
              point_vec.push_back(new GeoLib::Point(0, 0, 1, 7)));

    ASSERT_EQ(std::size_t(4), point_vec.size());
    ASSERT_EQ(std::size_t(8), point_vec.getIDMap().size());

    ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[4]);
    ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[5]);
    ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[6]);
    ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[7]);

    // Adding again some already existing points.
    ASSERT_EQ(std::size_t(0),
              point_vec.push_back(new GeoLib::Point(0, 0, 0, 8)));
    ASSERT_EQ(std::size_t(1),
              point_vec.push_back(new GeoLib::Point(1, 0, 0, 9)));
    ASSERT_EQ(std::size_t(2),
              point_vec.push_back(new GeoLib::Point(0, 1, 0, 10)));
    ASSERT_EQ(std::size_t(3),
              point_vec.push_back(new GeoLib::Point(0, 0, 1, 11)));

    ASSERT_EQ(std::size_t(4), point_vec.size());
    ASSERT_EQ(std::size_t(12), point_vec.getIDMap().size());

    ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[8]);
    ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[9]);
    ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[10]);
    ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[11]);

    // Adding some new points.
    ASSERT_EQ(std::size_t(4),
              point_vec.push_back(new GeoLib::Point(0.1, 0.1, 0.1, 12)));
    ASSERT_EQ(std::size_t(5),
              point_vec.push_back(new GeoLib::Point(1.1, 0.1, 0.1, 13)));
    ASSERT_EQ(std::size_t(6),
              point_vec.push_back(new GeoLib::Point(0.1, 1.1, 0.1, 14)));
    ASSERT_EQ(std::size_t(7),
              point_vec.push_back(new GeoLib::Point(0.1, 0.1, 1.1, 15)));

    ASSERT_EQ(std::size_t(8), point_vec.size());
    ASSERT_EQ(std::size_t(16), point_vec.getIDMap().size());

    ASSERT_EQ(std::size_t(4), point_vec.getIDMap()[12]);
    ASSERT_EQ(std::size_t(5), point_vec.getIDMap()[13]);
    ASSERT_EQ(std::size_t(6), point_vec.getIDMap()[14]);
    ASSERT_EQ(std::size_t(7), point_vec.getIDMap()[15]);

    // Adding again some already existing points.
    ASSERT_EQ(std::size_t(0),
              point_vec.push_back(new GeoLib::Point(0, 0, 0, 16)));
    ASSERT_EQ(std::size_t(1),
              point_vec.push_back(new GeoLib::Point(1, 0, 0, 17)));
    ASSERT_EQ(std::size_t(2),
              point_vec.push_back(new GeoLib::Point(0, 1, 0, 18)));
    ASSERT_EQ(std::size_t(3),
              point_vec.push_back(new GeoLib::Point(0, 0, 1, 19)));

    ASSERT_EQ(std::size_t(8), point_vec.size());
    ASSERT_EQ(std::size_t(20), point_vec.getIDMap().size());

    ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[16]);
    ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[17]);
    ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[18]);
    ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[19]);

    ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[0]);
    ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[1]);
    ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[2]);
    ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[3]);
    ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[4]);
    ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[5]);
    ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[6]);
    ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[7]);
    ASSERT_EQ(std::size_t(0), point_vec.getIDMap()[8]);
    ASSERT_EQ(std::size_t(1), point_vec.getIDMap()[9]);
    ASSERT_EQ(std::size_t(2), point_vec.getIDMap()[10]);
    ASSERT_EQ(std::size_t(3), point_vec.getIDMap()[11]);
    ASSERT_EQ(std::size_t(4), point_vec.getIDMap()[12]);
    ASSERT_EQ(std::size_t(5), point_vec.getIDMap()[13]);
    ASSERT_EQ(std::size_t(6), point_vec.getIDMap()[14]);
    ASSERT_EQ(std::size_t(7), point_vec.getIDMap()[15]);
}

// Testing random input points.
TEST_F(PointVecTest, TestPointVecCtorRandomPoints)
{
    auto ps_ptr = std::make_unique<VectorOfPoints>();
    generateRandomPoints(*ps_ptr, 10000);

    auto point_vec =
        std::make_unique<GeoLib::PointVec>(name, std::move(ps_ptr));
}
TEST_F(PointVecTest, TestPointVecCtorRandomPointsLargeEps)
{
    auto ps_ptr = std::make_unique<VectorOfPoints>();
    generateRandomPoints(*ps_ptr, 10000);

    auto point_vec = std::make_unique<GeoLib::PointVec>(
        name, std::move(ps_ptr), nullptr, GeoLib::PointVec::PointType::POINT,
        1e-2);
}