#define CATCH_CONFIG_MAIN
#include "catch.hpp"

#include <mapnik/mapnik.hpp>
#include <mapnik/map.hpp>
#include <mapnik/load_map.hpp>
#include <mapnik/save_map.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/datasource_cache.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/filesystem.hpp>
#include <boost/format.hpp>
#include <boost/range/iterator_range_core.hpp>

#include <iostream>
#include <random>

namespace {

static std::random_device entropy;

std::string unique_mapnik_name()
{
    std::mt19937 gen(entropy());
    std::uniform_int_distribution<> distrib(0, 65535);
    auto fmt = boost::format("mapnik-test-%1$04x-%2$04x-%3$04x-%4$04x") % distrib(gen) % distrib(gen) % distrib(gen) %
               distrib(gen);
    return fmt.str();
}

class tmp_dir
{
  private:
    mapnik::fs::path m_path;

  public:
    tmp_dir()
        : m_path(mapnik::fs::temp_directory_path() / unique_mapnik_name())
    {
        mapnik::fs::create_directories(m_path);
    }

    ~tmp_dir()
    {
        // files might be deleted by other things while the test is
        // running, which isn't necessarily an error as far as this
        // code is concerned - it just wants to delete everything
        // underneath the temporary directory.
        mapnik::error_code err;

        // catch all errors - we don't want to throw in the destructor
        try
        {
            // but loop while the path exists and the errors are
            // ignorable.
            while (mapnik::fs::exists(m_path))
            {
                mapnik::fs::remove_all(m_path, err);

                // for any non-ignorable error, there's not much we can
                // do from the destructor. it's in /tmp anyway, so it'll
                // get reclaimed next boot.
                if (err && (err != std::errc::no_such_file_or_directory))
                {
                    break;
                }
            }
        }
        catch (std::exception const& e)
        {
            std::cerr << "Exception caught while trying to remove " << "temporary directory " << m_path << ": "
                      << e.what() << "\n";
        }
        catch (...)
        {
            std::cerr << "Unknown exception caught while trying to " << "remove temporary directory " << m_path << "\n";
        }
    }

    mapnik::fs::path path() const { return m_path; }
};

void compare_map(mapnik::fs::path xml)
{
    tmp_dir dir;
    mapnik::Map m(256, 256);
    REQUIRE(m.register_fonts("fonts", true));
    mapnik::fs::path abs_base = xml.parent_path();

    // first, load the XML into a map object and save it. this
    // is a normalisation step to ensure that the file is in
    // whatever the current version of mapnik uses as the
    // standard indentation, quote style, etc...
    REQUIRE_NOTHROW(mapnik::load_map(m, xml.generic_string(), false, abs_base.generic_string()));
    mapnik::fs::path test_map1 = dir.path() / "mapnik-temp-map1.xml";
    REQUIRE_NOTHROW(mapnik::save_map(m, test_map1.generic_string()));

    // create a new map, load the one saved in the previous
    // step, and write it out again.
    mapnik::Map new_map(256, 256);
    REQUIRE(new_map.register_fonts("fonts", true));
    REQUIRE_NOTHROW(mapnik::load_map(new_map, test_map1.generic_string(), false, abs_base.generic_string()));
    mapnik::fs::path test_map2 = dir.path() / "mapnik-temp-map2.xml";
    REQUIRE_NOTHROW(mapnik::save_map(new_map, test_map2.generic_string()));

    // if all the information survived the load/save round-trip
    // then the two files ought to be identical.
    REQUIRE(mapnik::fs::is_regular_file(test_map1));
    REQUIRE(mapnik::fs::is_regular_file(test_map2));
    REQUIRE(mapnik::fs::file_size(test_map1) == mapnik::fs::file_size(test_map2));
    std::ifstream in_map1(test_map1.native()), in_map2(test_map2.native());
    REQUIRE(std::equal(std::istream_iterator<char>(in_map1),
                       std::istream_iterator<char>(),
                       std::istream_iterator<char>(in_map2)));
}

void add_xml_files(mapnik::fs::path dir, std::vector<mapnik::fs::path>& xml_files)
{
    for (auto const& entry :
         boost::make_iterator_range(mapnik::fs::directory_iterator(dir), mapnik::fs::directory_iterator()))
    {
        auto path = entry.path();
        if (path.extension().generic_string() == ".xml")
        {
            xml_files.emplace_back(path);
        }
    }
}

void load_map(mapnik::Map& m, mapnik::fs::path const& path)
{
    try
    {
        mapnik::load_map(m, path.generic_string());
    }
    catch (std::exception const& ex)
    {
        // errors which come from the datasource not being loaded or
        // database not being set up aren't really useful - they're
        // more likely to be spurious than meaningful, so ignore them.
        std::string what = ex.what();
        if ((what.find("Could not create datasource") == std::string::npos) &&
            (what.find("Postgis Plugin: could not connect to server") == std::string::npos))
        {
            throw;
        }
    }
}

} // anonymous namespace
#ifndef MAPNIK_STATIC_PLUGINS
bool const registered =
  mapnik::datasource_cache::instance().register_datasources((mapnik::fs::path("plugins") / "input").generic_string());
#endif
TEST_CASE("map xml I/O")
{
    mapnik::setup();
#ifndef MAPNIK_STATIC_PLUGINS
    // make sure plugins are loaded
    REQUIRE(registered);
#endif

    // make the tests silent since we intentially test error conditions that are noisy
    auto const severity = mapnik::logger::instance().get_severity();
    mapnik::logger::instance().set_severity(mapnik::logger::none);

    SECTION("good maps")
    {
        std::vector<mapnik::fs::path> good_maps;
        add_xml_files(mapnik::fs::path("test") / "data" / "good_maps", good_maps);

        for (auto const& path : good_maps)
        {
            CAPTURE(path.generic_string());

            // check that it can load
            mapnik::Map m(256, 256);
            REQUIRE(m.register_fonts("fonts", true));
            REQUIRE_NOTHROW(load_map(m, path));

            // and, if it can, that it saves the same way
            compare_map(path);
        }
    } // END SECTION

    SECTION("duplicate styles only throw in strict mode")
    {
        std::string duplicate_stylename(
          (mapnik::fs::path("test") / "data" / "broken_maps" / "duplicate_stylename.xml").generic_string());
        CAPTURE(duplicate_stylename);
        mapnik::Map m(256, 256);
        REQUIRE(m.register_fonts("fonts", true));
        REQUIRE_NOTHROW(mapnik::load_map(m, duplicate_stylename, false));
        mapnik::Map m2(256, 256);
        REQUIRE(m2.register_fonts("fonts", true));
        REQUIRE_THROWS(mapnik::load_map(m2, duplicate_stylename, true));
    } // END SECTION

    SECTION("broken maps")
    {
        std::vector<mapnik::fs::path> broken_maps;
        add_xml_files(mapnik::fs::path("test") / "data" / "broken_maps", broken_maps);
        broken_maps.emplace_back(mapnik::fs::path("test") / "data" / "broken_maps" / "does_not_exist.xml");

        for (auto const& path : broken_maps)
        {
            CAPTURE(path.generic_string());

            mapnik::Map m(256, 256);
            REQUIRE(m.register_fonts("fonts", true));
            REQUIRE_THROWS(mapnik::load_map(m, path.generic_string(), true));
        }
    } // END SECTION

    mapnik::logger::instance().set_severity(severity);
} // END TEST CASE
