#include <mbgl/util/tile_cover.hpp>
#include <mbgl/util/geo.hpp>
#include <mbgl/map/transform.hpp>
#include <mbgl/math/angles.hpp>

#include <algorithm>
#include <cstdlib> /* srand, rand */
#include <ctime>   /* time */
#include <gtest/gtest.h>

using namespace mbgl;

TEST(TileCover, Empty) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(LatLngBounds::empty(), 0));
}

TEST(TileCover, Arctic) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(LatLngBounds::hull({86, -180}, {90, 180}), 0));
}

TEST(TileCover, Antarctic) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(LatLngBounds::hull({-86, -180}, {-90, 180}), 0));
}

TEST(TileCover, WorldZ0) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{
                  {0, 0, 0},
              }),
              util::tileCover(LatLngBounds::world(), 0));
}

TEST(TileCover, Pitch) {
    Transform transform;
    transform.resize({512, 512});
    // slightly offset center so that tile order is better defined

    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             0.1,
                             -0.1,
                         })
                         .withZoom(2.0)
                         .withBearing(5.0)
                         .withPitch(40.0));

    EXPECT_EQ((std::vector<OverscaledTileID>{{2, 1, 1}, {2, 2, 1}, {2, 1, 2}, {2, 2, 2}}),
              util::tileCover({transform.getState()}, 2));
}

TEST(TileCover, PitchIssue15442) {
    Transform transform;
    transform.resize({412, 691});

    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             59.116898740996106,
                             91.565660781803615,
                         })
                         .withZoom(2.0551126748417214)
                         .withBearing(util::rad2deg(0.74963938256567264))
                         .withPitch(util::rad2deg(1.0471975511965976)));

    EXPECT_EQ((std::vector<OverscaledTileID>{
                  {2, 3, 1}, {2, 2, 1}, {2, 3, 0}, {2, 2, 0}, {2, 1, {2, 0, 0}}, {2, 1, {2, 1, 0}}}),
              util::tileCover({transform.getState()}, 2));
}

TEST(TileCover, PitchOverAllowedByContentInsets) {
    Transform transform;
    transform.resize({512, 512});

    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{0.1, -0.1})
                         .withPadding(EdgeInsets{376, 0, 0, 0})
                         .withZoom(8.0)
                         .withBearing(45.0)
                         .withPitch(60.0));
    // Top padding of 376 leads to capped pitch. See Transform::getMaxPitchForEdgeInsets.
    EXPECT_LE(transform.getPitch() + 0.001, util::deg2rad(60));

    EXPECT_EQ((std::vector<OverscaledTileID>{{3, 4, 3}, {3, 3, 3}, {3, 4, 4}, {3, 3, 4}}),
              util::tileCover({transform.getState()}, 3));
}

TEST(TileCover, PitchWithLargerResultSet) {
    Transform transform;
    transform.resize({1024, 768});

    // The values used here triggered the regression with left and right edge
    // selection in tile_cover.cpp scanSpans.
    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{0.1, -0.1})
                         .withPadding(EdgeInsets{400, 0, 0, 0})
                         .withZoom(5)
                         .withBearing(-142.2630000003529176)
                         .withPitch(60.0));

    auto cover = util::tileCover({.transformState = transform.getState()}, 5);
    // Returned vector has above 100 elements, we check first 16 as there is a
    // plan to return lower LOD for distant tiles.
    EXPECT_EQ((std::vector<OverscaledTileID>{{5, 15, 16},
                                             {5, 15, 17},
                                             {5, 14, 16},
                                             {5, 16, 16},
                                             {5, 15, 15},
                                             {5, 14, 17},
                                             {5, 16, 17},
                                             {5, 14, 15},
                                             {5, 16, 15},
                                             {5, 15, 18},
                                             {5, 13, 16},
                                             {5, 14, 18},
                                             {5, 16, 18},
                                             {5, 13, 17},
                                             {5, 13, 18},
                                             {5, 15, 19}}),
              (std::vector<OverscaledTileID>{cover.begin(), cover.begin() + 16}));
}

TEST(TileCover, WorldZ1) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{
                  {1, 0, 0},
                  {1, 0, 1},
                  {1, 1, 0},
                  {1, 1, 1},
              }),
              util::tileCover(LatLngBounds::world(), 1));
}

TEST(TileCover, SingletonZ0) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(LatLngBounds::singleton({0, 0}), 0));
}

TEST(TileCover, SingletonZ1) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(LatLngBounds::singleton({0, 0}), 1));
}

TEST(TileCover, CoordinatesAreUnwrapped) {
    Transform transform;
    transform.resize({512, 512});
    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             0.1,
                             -180.1,
                         })
                         .withZoom(1.0));

    EXPECT_EQ(
        (std::vector<OverscaledTileID>{{1, 0, {1, 1, 0}}, {1, 1, {1, 0, 0}}, {1, 0, {1, 1, 1}}, {1, 1, {1, 0, 1}}}),
        util::tileCover({transform.getState()}, 1));
}

TEST(TileCover, DifferentOverscaledZ) {
    Transform transform;
    transform.resize({512, 512});
    // slightly offset center so that tile order is better defined

    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             0.1,
                             -0.1,
                         })
                         .withZoom(2.0));

    EXPECT_EQ(
        (std::vector<OverscaledTileID>{{3, 0, {2, 1, 1}}, {3, 0, {2, 2, 1}}, {3, 0, {2, 1, 2}}, {3, 0, {2, 2, 2}}}),
        util::tileCover({transform.getState()}, 2, 3));
}

TEST(TileCover, DifferentOverscaledZWithPitch) {
    Transform transform;
    transform.resize({512, 512});
    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             30.0,
                             -10.0,
                         })
                         .withZoom(3.5)
                         .withPitch(60));

    EXPECT_EQ((std::vector<OverscaledTileID>{{5, 0, {3, 3, 3}},
                                             {5, 0, {3, 4, 3}},
                                             {5, 0, {3, 3, 2}},
                                             {5, 0, {3, 4, 2}},
                                             {5, 0, {3, 3, 1}},
                                             {5, 0, {3, 4, 1}},
                                             {5, 0, {3, 2, 1}}}),
              util::tileCover({transform.getState()}, 3, 5));
}

TEST(TileCover, DifferentOverscaledZWrapped) {
    Transform transform;
    transform.resize({512, 512});
    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             0.1,
                             -180.1,
                         })
                         .withZoom(1.0));

    EXPECT_EQ(
        (std::vector<OverscaledTileID>{{2, 0, {1, 1, 0}}, {2, 1, {1, 0, 0}}, {2, 0, {1, 1, 1}}, {2, 1, {1, 0, 1}}}),
        util::tileCover({transform.getState()}, 1, 2));
}

TEST(TileCover, FlippedY) {
    Transform transform;
    transform.resize({512, 512});
    transform.setViewportMode(ViewportMode::FlippedY);
    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             0.2,
                             -0.1,
                         })
                         .withZoom(1.0));

    EXPECT_EQ((std::vector<OverscaledTileID>{{1, 0, 0}, {1, 1, 0}, {1, 0, 1}, {1, 1, 1}}),
              util::tileCover({transform.getState()}, 1));
}

TEST(TileCover, FlippedYPitch) {
    Transform transform;
    transform.resize({512, 512});
    transform.setViewportMode(ViewportMode::FlippedY);
    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             0.1,
                             -0.1,
                         })
                         .withZoom(2.0)
                         .withBearing(5.0)
                         .withPitch(40.0));

    EXPECT_EQ((std::vector<OverscaledTileID>{{2, 1, 1}, {2, 2, 1}, {2, 1, 2}, {2, 2, 2}}),
              util::tileCover({transform.getState()}, 2));
}

TEST(TileCover, FlippedYHelsinki) {
    Transform transform;
    transform.resize({512, 512});
    transform.setViewportMode(ViewportMode::FlippedY);
    transform.jumpTo(CameraOptions()
                         .withCenter(LatLng{
                             60.167231,
                             24.942063,
                         })
                         .withZoom(11.447425));

    EXPECT_EQ((std::vector<OverscaledTileID>{{11, 1165, 592}, {11, 1166, 592}, {11, 1165, 593}, {11, 1166, 593}}),
              util::tileCover({transform.getState()}, 11));
}

TEST(TileCoverStream, Arctic) {
    auto bounds = LatLngBounds::hull({84, -180}, {70, 180});
    auto zoom = 3;
    util::TileCover tc(bounds, zoom);
    auto results = util::tileCover(bounds, zoom);
    std::vector<UnwrappedTileID> t;
    while (tc.hasNext()) {
        t.push_back(*tc.next());
    };
    EXPECT_EQ(t.size(), results.size());
}

TEST(TileCoverStream, WorldZ1) {
    auto zoom = 1;
    util::TileCover tc(LatLngBounds::world(), zoom);
    std::vector<UnwrappedTileID> t;
    while (tc.hasNext()) {
        t.push_back(*tc.next());
    };
    EXPECT_EQ((std::vector<UnwrappedTileID>{
                  {1, 0, 0},
                  {1, 1, 0},
                  {1, 0, 1},
                  {1, 1, 1},
              }),
              t);
}

static const LatLngBounds sanFrancisco = LatLngBounds::hull({37.6609, -122.5744}, {37.8271, -122.3204});

TEST(TileCover, SanFranciscoZ0) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{
                  {0, 0, 0},
              }),
              util::tileCover(sanFrancisco, 0));
}

TEST(TileCover, SanFranciscoZ10) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{
                  {10, 163, 395},
                  {10, 163, 396},
                  {10, 164, 395},
                  {10, 164, 396},
              }),
              util::tileCover(sanFrancisco, 10));
}

static const LatLngBounds sanFranciscoWrapped = LatLngBounds::hull({37.6609, 238.5744}, {37.8271, 238.3204});

TEST(TileCover, SanFranciscoZ0Wrapped) {
    EXPECT_EQ((std::vector<UnwrappedTileID>{{0, 1, 0}}), util::tileCover(sanFranciscoWrapped, 0));
}

TEST(TileCover, GeomPoint) {
    auto point = Point<double>{-122.5744, 37.6609};

    EXPECT_EQ((std::vector<UnwrappedTileID>{{2, 0, 1}}), util::tileCover(point, 2));
}

TEST(TileCover, GeomMultiPoint) {
    auto points = MultiPoint<double>{{-122.5, 37.76}, {-122.4, 37.76}};

    EXPECT_EQ((std::vector<UnwrappedTileID>{{20, 167480, 405351}, {20, 167772, 405351}}), util::tileCover(points, 20));
}

TEST(TileCover, GeomLineZ10) {
    auto lineCover = util::tileCover(
        LineString<double>{{-121.49368286132812, 38.57903714667459}, {-122.4422836303711, 37.773157169570695}}, 10);
    EXPECT_EQ((std::vector<UnwrappedTileID>{{10, 166, 392},
                                            {10, 165, 393},
                                            {10, 166, 393},
                                            {10, 164, 394},
                                            {10, 165, 394},
                                            {10, 163, 395},
                                            {10, 164, 395}}),
              lineCover);
}

TEST(TileCover, GeomLineRegression11870) {
    auto lineCover = util::tileCover(
        LineString<double>{
            {-121.5063900000001, 40.470099999999945},
            {-121.5065300000001, 40.470369999999946},
            {-121.5065900000001, 40.470519999999944},
        },
        14);
    EXPECT_EQ((std::vector<UnwrappedTileID>{{14, 2662, 6174}}), lineCover);
}

TEST(TileCover, WrappedGeomLineZ10) {
    auto lineCover = util::tileCover(
        LineString<double>{{-179.93342914581299, 38.892101707724315}, {-180.02394485473633, 38.89203490311832}}, 10);
    EXPECT_EQ((std::vector<UnwrappedTileID>{{10, -1, 391}, {10, 0, 391}}), lineCover);

    lineCover = util::tileCover(
        LineString<double>{{179.93342914581299, 38.892101707724315}, {180.02394485473633, 38.89203490311832}}, 10);
    EXPECT_EQ((std::vector<UnwrappedTileID>{{10, 1023, 391}, {10, 1024, 391}}), lineCover);
}

TEST(TileCover, GeomMultiLineString) {
    auto geom = MultiLineString<double>{{{-122.5, 37.76}, {-122.4, 37.76}}, {{-122.5, 37.72}, {-122.4, 37.72}}};

    EXPECT_EQ((std::vector<UnwrappedTileID>{{14, 2616, 6333},
                                            {14, 2617, 6333},
                                            {14, 2618, 6333},
                                            {14, 2619, 6333},
                                            {14, 2620, 6333},
                                            {14, 2621, 6333},
                                            {14, 2616, 6335},
                                            {14, 2617, 6335},
                                            {14, 2618, 6335},
                                            {14, 2619, 6335},
                                            {14, 2620, 6335},
                                            {14, 2621, 6335}}),
              util::tileCover(geom, 14));
}

TEST(TileCover, GeomPolygon) {
    auto polygon = Polygon<double>{{
                                       {5.09765625, 53.067626642387374},
                                       {2.373046875, 43.389081939117496},
                                       {-4.74609375, 48.45835188280866},
                                       {-1.494140625, 37.09023980307208},
                                       {22.587890625, 36.24427318493909},
                                       {31.640625, 46.13417004624326},
                                       {17.841796875, 54.7246201949245},
                                       {5.09765625, 53.067626642387374},
                                   },
                                   {{19.6875, 49.66762782262194},
                                    {22.8515625, 43.51668853502906},
                                    {13.623046875, 45.089035564831036},
                                    {16.34765625, 39.095962936305476},
                                    {5.185546875, 41.244772343082076},
                                    {8.701171874999998, 50.233151832472245},
                                    {19.6875, 49.66762782262194}}};

    auto results = util::tileCover(polygon, 8);

    EXPECT_NE(std::ranges::find(results, UnwrappedTileID{8, 134, 87}), results.end());
    EXPECT_NE(std::ranges::find(results, UnwrappedTileID{8, 139, 87}), results.end());
    // Should have a hole
    EXPECT_EQ(std::ranges::find(results, UnwrappedTileID{8, 136, 87}), results.end());
}

TEST(TileCover, GeomMultiPolygon) {
    auto multiPolygon = MultiPolygon<double>{{{
                                                 {5.09765625, 53.067626642387374},
                                                 {2.373046875, 43.389081939117496},
                                                 {-4.74609375, 48.45835188280866},
                                                 {-1.494140625, 37.09023980307208},
                                                 {22.587890625, 36.24427318493909},
                                                 {31.640625, 46.13417004624326},
                                                 {17.841796875, 54.7246201949245},
                                                 {5.09765625, 53.067626642387374},
                                             }},
                                             {{{59.150390625, 45.460130637921004},
                                               {65.126953125, 41.11246878918088},
                                               {69.169921875, 47.45780853075031},
                                               {63.896484375, 50.064191736659104},
                                               {59.150390625, 45.460130637921004}}}};
    auto results = util::tileCover(multiPolygon, 8);

    EXPECT_EQ(424u, results.size());
    EXPECT_NE(std::ranges::find(results, UnwrappedTileID{8, 139, 87}), results.end());
    EXPECT_NE(std::ranges::find(results, UnwrappedTileID{8, 136, 87}), results.end());
    EXPECT_NE(std::ranges::find(results, UnwrappedTileID{8, 174, 94}), results.end());
}

TEST(TileCover, GeomSanFranciscoPoly) {
    auto sanFranciscoGeom = Polygon<double>{
        {{-122.5143814086914, 37.779127216982424},  {-122.50811576843262, 37.72721239056709},
         {-122.50313758850099, 37.70820178063929},  {-122.3938751220703, 37.707454835665274},
         {-122.37567901611328, 37.70663997801684},  {-122.36297607421874, 37.71343018466285},
         {-122.354736328125, 37.727280276860036},   {-122.36469268798828, 37.73868429065797},
         {-122.38014221191408, 37.75442980295571},  {-122.38391876220702, 37.78753873820529},
         {-122.35919952392578, 37.8065289741725},   {-122.35679626464844, 37.820632846207864},
         {-122.3712158203125, 37.835276322922695},  {-122.3818588256836, 37.82958198283902},
         {-122.37190246582031, 37.80788523279169},  {-122.38735198974608, 37.791337175930686},
         {-122.40966796874999, 37.812767557570204}, {-122.46425628662108, 37.807071480609274},
         {-122.46803283691405, 37.810326435534755}, {-122.47901916503906, 37.81168262440736},
         {-122.48966217041016, 37.78916666399649},  {-122.50579833984375, 37.78781006166096},
         {-122.5143814086914, 37.779127216982424}}};

    EXPECT_EQ(
        (std::vector<UnwrappedTileID>{
            {12, 654, 1582}, {12, 655, 1582}, {12, 654, 1583}, {12, 655, 1583}, {12, 654, 1584}, {12, 655, 1584}}),
        util::tileCover(sanFranciscoGeom, 12));
}

TEST(TileCover, GeomInvalid) {
    auto point = Point<double>{-122.5744, 97.6609};
    EXPECT_THROW(util::tileCover(point, 2), std::domain_error);

    auto badLine = LineString<double>{{1.0, 35.0}};
    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(badLine, 16));

    auto badPoly = Polygon<double>{{{1.0, 35.0}}};
    EXPECT_EQ((std::vector<UnwrappedTileID>{}), util::tileCover(badPoly, 16));

    // Should handle open polygons.
    badPoly = Polygon<double>{{{1.0, 34.2}, {1.0, 34.4}, {0.5, 34.3}}};
    EXPECT_EQ((std::vector<UnwrappedTileID>{{10, 513, 407}, {10, 514, 407}, {10, 513, 408}, {10, 514, 408}}),
              util::tileCover(badPoly, 10));
}

TEST(TileCount, World) {
    EXPECT_EQ(1u, util::tileCount(LatLngBounds::world(), 0));
    EXPECT_EQ(4u, util::tileCount(LatLngBounds::world(), 1));
}

TEST(TileCount, SanFranciscoZ10) {
    EXPECT_EQ(4u, util::tileCount(sanFrancisco, 10));
}

TEST(TileCount, SanFranciscoWrappedZ10) {
    EXPECT_EQ(4u, util::tileCount(sanFranciscoWrapped, 10));
}

TEST(TileCount, SanFranciscoZ22) {
    EXPECT_EQ(7254450u, util::tileCount(sanFrancisco, 22));
}

TEST(TileCount, BoundsCrossingAntimeridian) {
    auto crossingBounds = LatLngBounds::hull({-20.9615, -214.309}, {19.477, -155.830});

    EXPECT_EQ(1u, util::tileCount(crossingBounds, 0));
    EXPECT_EQ(4u, util::tileCount(crossingBounds, 3));
    EXPECT_EQ(8u, util::tileCount(crossingBounds, 4));
}

TEST(TileCover, DISABLED_FuzzPoly) {
    while (true) {
        std::srand(static_cast<uint32_t>(time(nullptr)));
        std::size_t len = std::rand() % 10000 + 3;
        Polygon<double> polygon;

        std::size_t num_rings = 1;
        num_rings += std::rand() % 5;
        while (num_rings > 0) {
            LinearRing<double> ring;
            for (std::size_t i = 0; i < len; ++i) {
                double x = std::rand() % 180;
                double y = std::rand() % 90;

                ring.push_back({x, y});
            }
            polygon.emplace_back(ring);
            --num_rings;
        }

        std::clog << ".";
        util::TileCover tc(polygon, 5);
        while (tc.next()) {
        };
    }
}

TEST(TileCover, DISABLED_FuzzLine) {
    while (true) {
        std::srand(static_cast<uint32_t>(time(nullptr)));
        std::size_t len = std::rand() % 10000 + 3;
        MultiLineString<double> mls;

        std::size_t num_lines = 1;
        num_lines += std::rand() % 5;
        while (num_lines > 0) {
            LineString<double> line;
            for (std::size_t i = 0; i < len; ++i) {
                double x = std::rand() % 180;
                double y = std::rand() % 90;

                line.push_back({x, y});
            }
            mls.emplace_back(line);
            --num_lines;
        }

        std::clog << ".";
        util::TileCover tc(mls, 5);
        while (tc.next()) {
        };
    }
}