#include "catch.hpp"

// mapnik
#include <mapnik/image.hpp>
#include <mapnik/color.hpp>
#include <mapnik/image_view_any.hpp>
#include <mapnik/image_util.hpp>

TEST_CASE("image view")
{
    SECTION("test rgba8")
    {
        mapnik::image_rgba8 im(4, 4);
        mapnik::color c_red("red");
        mapnik::color c_blue("blue");
        mapnik::color c_green("green");
        mapnik::color c_yellow("yellow");
        mapnik::fill(im, c_red);
        // Upper Left 2x2 is blue
        mapnik::set_pixel(im, 0, 0, c_blue);
        mapnik::set_pixel(im, 0, 1, c_blue);
        mapnik::set_pixel(im, 1, 0, c_blue);
        mapnik::set_pixel(im, 1, 1, c_blue);
        // Upper Right 2x2 is green
        mapnik::set_pixel(im, 2, 0, c_green);
        mapnik::set_pixel(im, 2, 1, c_green);
        mapnik::set_pixel(im, 3, 0, c_green);
        mapnik::set_pixel(im, 3, 1, c_green);
        // Lower Left 2x2 is yellow
        mapnik::set_pixel(im, 0, 2, c_yellow);
        mapnik::set_pixel(im, 0, 3, c_yellow);
        mapnik::set_pixel(im, 1, 2, c_yellow);
        mapnik::set_pixel(im, 1, 3, c_yellow);

        mapnik::image_rgba8 im2(5, 5);
        mapnik::fill(im2, c_red);

        // Now that we have test data run tests
        mapnik::image_view_rgba8 view_all(0, 0, 4, 4, im);
        mapnik::image_view_rgba8 view_blue(0, 0, 2, 2, im);
        mapnik::image_view_rgba8 view_green(2, 0, 2, 2, im);
        mapnik::image_view_rgba8 view_yellow(0, 2, 2, 2, im);
        mapnik::image_view_rgba8 view_red(2, 2, 2, 2, im);
        mapnik::image_view_rgba8 view_bad(99, 99, 99, 99, im);
        const mapnik::image_view_rgba8 view_all_2(0, 0, 4, 4, im2);

        // Check that image_views all have the same underlying data
        CHECK(view_all == view_blue);
        CHECK(view_all == view_green);
        CHECK(view_all == view_yellow);
        CHECK(view_all == view_red);

        CHECK(view_all.data() == im);

        // Check that view_all and view_all_2 are not the same underlying data
        CHECK_FALSE(view_all == view_all_2);
        CHECK(view_all < view_all_2);

        // Check that copy constructor works
        mapnik::image_view_rgba8 view_all_3(view_all_2);
        CHECK(view_all_2 == view_all_3);

        // Check other constructor
        mapnik::image_view_rgba8 view_all_4(std::move(view_all_3));
        CHECK(view_all_2 == view_all_4);

        // Check that x offset is correct
        CHECK(view_all.x() == 0);
        CHECK(view_blue.x() == 0);
        CHECK(view_green.x() == 2);
        CHECK(view_yellow.x() == 0);
        CHECK(view_red.x() == 2);
        CHECK(view_bad.x() == 3);

        // Check that y offset is correct
        CHECK(view_all.y() == 0);
        CHECK(view_blue.y() == 0);
        CHECK(view_green.y() == 0);
        CHECK(view_yellow.y() == 2);
        CHECK(view_red.y() == 2);
        CHECK(view_bad.y() == 3);

        // Check that width is correct
        CHECK(view_all.width() == 4);
        CHECK(view_blue.width() == 2);
        CHECK(view_green.width() == 2);
        CHECK(view_yellow.width() == 2);
        CHECK(view_red.width() == 2);
        CHECK(view_bad.width() == 1);

        // Check that height is correct
        CHECK(view_all.height() == 4);
        CHECK(view_blue.height() == 2);
        CHECK(view_green.height() == 2);
        CHECK(view_yellow.height() == 2);
        CHECK(view_red.height() == 2);
        CHECK(view_bad.height() == 1);

        // Check that size is correct
        CHECK(view_all.size() == 64);
        CHECK(view_blue.size() == 16);
        CHECK(view_green.size() == 16);
        CHECK(view_yellow.size() == 16);
        CHECK(view_red.size() == 16);

        // Check that row_size is correct
        CHECK(view_all.row_size() == 16);
        CHECK(view_blue.row_size() == 8);
        CHECK(view_green.row_size() == 8);
        CHECK(view_yellow.row_size() == 8);
        CHECK(view_red.row_size() == 8);

        // Check that get_premultiplied is correct
        CHECK_FALSE(view_all.get_premultiplied());
        CHECK_FALSE(view_blue.get_premultiplied());
        CHECK_FALSE(view_green.get_premultiplied());
        CHECK_FALSE(view_yellow.get_premultiplied());
        CHECK_FALSE(view_red.get_premultiplied());

        // Check that operator to retrieve value works properly
        CHECK(view_all(0, 0) == c_blue.rgba());
        CHECK(view_blue(0, 0) == c_blue.rgba());
        CHECK(view_green(0, 0) == c_green.rgba());
        CHECK(view_yellow(0, 0) == c_yellow.rgba());
        CHECK(view_red.row_size() == 8);

        // Check that offset is correct
        CHECK(view_all.get_offset() == 0.0);
        CHECK(view_blue.get_offset() == 0.0);
        CHECK(view_green.get_offset() == 0.0);
        CHECK(view_yellow.get_offset() == 0.0);
        CHECK(view_red.get_offset() == 0.0);

        // Check that scaling is correct
        CHECK(view_all.get_scaling() == 1.0);
        CHECK(view_blue.get_scaling() == 1.0);
        CHECK(view_green.get_scaling() == 1.0);
        CHECK(view_yellow.get_scaling() == 1.0);
        CHECK(view_red.get_scaling() == 1.0);

        // CHECK that image dtype is correct
        CHECK(view_all.get_dtype() == mapnik::image_dtype_rgba8);
        CHECK(view_blue.get_dtype() == mapnik::image_dtype_rgba8);
        CHECK(view_green.get_dtype() == mapnik::image_dtype_rgba8);
        CHECK(view_yellow.get_dtype() == mapnik::image_dtype_rgba8);
        CHECK(view_red.get_dtype() == mapnik::image_dtype_rgba8);

        unsigned expected_val;
        using pixel_type = mapnik::image_view_rgba8::pixel_type;
        // Check that all data in the view is correct
        // Blue
        expected_val = c_blue.rgba();
        for (std::size_t y = 0; y < view_blue.height(); ++y)
        {
            std::size_t width = view_blue.width();
            pixel_type const* data_1 = view_blue.get_row(y);
            pixel_type const* data_2 = view_blue.get_row(y, 1);
            for (std::size_t x = 0; x < width; ++x)
            {
                CHECK(*data_1 == expected_val);
                ++data_1;
            }
            for (std::size_t x = 1; x < width; ++x)
            {
                CHECK(*data_2 == expected_val);
                ++data_2;
            }
        }
        // Green
        expected_val = c_green.rgba();
        for (std::size_t y = 0; y < view_green.height(); ++y)
        {
            std::size_t width = view_green.width();
            pixel_type const* data_1 = view_green.get_row(y);
            pixel_type const* data_2 = view_green.get_row(y, 1);
            for (std::size_t x = 0; x < width; ++x)
            {
                CHECK(*data_1 == expected_val);
                ++data_1;
            }
            for (std::size_t x = 1; x < width; ++x)
            {
                CHECK(*data_2 == expected_val);
                ++data_2;
            }
        }
        // Yellow
        expected_val = c_yellow.rgba();
        for (std::size_t y = 0; y < view_yellow.height(); ++y)
        {
            std::size_t width = view_yellow.width();
            pixel_type const* data_1 = view_yellow.get_row(y);
            pixel_type const* data_2 = view_yellow.get_row(y, 1);
            for (std::size_t x = 0; x < width; ++x)
            {
                CHECK(*data_1 == expected_val);
                ++data_1;
            }
            for (std::size_t x = 1; x < width; ++x)
            {
                CHECK(*data_2 == expected_val);
                ++data_2;
            }
        }
        // Red
        expected_val = c_red.rgba();
        for (std::size_t y = 0; y < view_red.height(); ++y)
        {
            std::size_t width = view_red.width();
            pixel_type const* data_1 = view_red.get_row(y);
            pixel_type const* data_2 = view_red.get_row(y, 1);
            for (std::size_t x = 0; x < width; ++x)
            {
                CHECK(*data_1 == expected_val);
                ++data_1;
            }
            for (std::size_t x = 1; x < width; ++x)
            {
                CHECK(*data_2 == expected_val);
                ++data_2;
            }
        }

    } // END SECTION

    SECTION("image_view_null")
    {
        mapnik::image_view_null view_null;
        const mapnik::image_view_null view_null2;
        mapnik::image_view_null view_null3(view_null2);
        mapnik::image_view_null& view_null4 = view_null3;

        // All nulls are equal
        CHECK(view_null == view_null4);
        CHECK(view_null == view_null2);

        // No null is greater
        CHECK_FALSE(view_null < view_null4);
        CHECK_FALSE(view_null < view_null2);

        // Check defaults
        CHECK(view_null.x() == 0);
        CHECK(view_null.y() == 0);
        CHECK(view_null.width() == 0);
        CHECK(view_null.height() == 0);
        CHECK(view_null.size() == 0);
        CHECK(view_null.row_size() == 0);
        CHECK(view_null.get_offset() == 0.0);
        CHECK(view_null.get_scaling() == 1.0);
        CHECK(view_null.get_dtype() == mapnik::image_dtype_null);
        CHECK_FALSE(view_null.get_premultiplied());

        // Should throw if we try to access data.
        REQUIRE_THROWS(view_null(0, 0));

        CHECK(view_null.get_row(0) == nullptr);
        CHECK(view_null.get_row(0, 0) == nullptr);

    } // END SECTION

    SECTION("image view any")
    {
        mapnik::image_view_any im_any_null;
        CHECK(im_any_null.get_dtype() == mapnik::image_dtype_null);

        mapnik::image_gray8 im(4, 4);
        mapnik::image_view_gray8 im_view(0, 0, 4, 4, im);
        mapnik::image_view_any im_view_any(im_view);

        CHECK(im_view_any.get_dtype() == mapnik::image_dtype_gray8);
        CHECK(im_view_any.width() == 4);
        CHECK(im_view_any.height() == 4);
        CHECK(im_view_any.size() == 16);
        CHECK(im_view_any.row_size() == 4);
        CHECK_FALSE(im_view_any.get_premultiplied());
        CHECK(im_view_any.get_offset() == 0.0);
        CHECK(im_view_any.get_scaling() == 1.0);

    } // END SECTION

} // END TEST CASE