#if defined(GRID_RENDERER)

// mapnik
#include <mapnik/version.hpp>

#include "mapnik_grid.hpp"
#include "mapnik_grid_view.hpp"
#include "js_grid_utils.hpp"
#include "utils.hpp"

// std
#include <exception>

namespace detail {

// AsyncWorker

struct AsyncGridClear : Napi::AsyncWorker
{
    using Base = Napi::AsyncWorker;
    AsyncGridClear(grid_ptr const& grid, Napi::Function const& callback)
        : Base(callback),
          grid_(grid)
    {
    }

    void Execute() override
    {
        grid_->clear();
    }

    std::vector<napi_value> GetResult(Napi::Env env) override
    {
        if (grid_)
        {
            Napi::Value arg = Napi::External<grid_ptr>::New(env, &grid_);
            Napi::Object obj = Grid::constructor.New({arg});
            return {env.Null(), napi_value(obj)};
        }
        return Base::GetResult(env);
    }
    grid_ptr grid_;
};

struct AsyncGridEncode : Napi::AsyncWorker
{
    using Base = Napi::AsyncWorker;
    // ctor
    AsyncGridEncode(grid_ptr grid, unsigned resolution, bool add_features, Napi::Function const& callback)
        : Base(callback),
          grid_(grid),
          resolution_(resolution),
          add_features_(add_features)
    {
    }
    void Execute() override
    {
        try
        {
            node_mapnik::grid2utf<mapnik::grid>(*grid_,
                                                lines_,
                                                key_order_,
                                                resolution_);
        }
        catch (std::exception const& ex)
        {
            SetError(ex.what());
        }
    }
    std::vector<napi_value> GetResult(Napi::Env env) override
    {
        // convert key order to proper javascript array
        Napi::Array keys_a = Napi::Array::New(env, key_order_.size());
        std::vector<std::string>::iterator it;
        std::size_t i;
        for (it = key_order_.begin(), i = 0; it < key_order_.end(); ++it, ++i)
        {
            keys_a.Set(i, *it);
        }

        mapnik::grid const& grid_type = *grid_;
        // gather feature data
        Napi::Object feature_data = Napi::Object::New(env);
        if (add_features_)
        {
            node_mapnik::write_features<mapnik::grid>(env, grid_type,
                                                      feature_data,
                                                      key_order_);
        }

        // Create the return hash.
        Napi::Object json = Napi::Object::New(env);
        Napi::Array grid_array = Napi::Array::New(env, lines_.size());
        for (std::size_t j = 0; j < lines_.size(); ++j)
        {
            node_mapnik::grid_line_type const& line = lines_[j];
            grid_array.Set(j, Napi::String::New(env, (char*)line.get()));
        }
        json.Set("grid", grid_array);
        json.Set("keys", keys_a);
        json.Set("data", feature_data);
        return {env.Null(), json};
    }

  private:
    grid_ptr grid_;
    std::vector<node_mapnik::grid_line_type> lines_;
    unsigned int resolution_;
    bool add_features_;
    std::vector<mapnik::grid::lookup_type> key_order_;
};

} // namespace detail

Napi::FunctionReference Grid::constructor;

Napi::Object Grid::Initialize(Napi::Env env, Napi::Object exports, napi_property_attributes prop_attr)
{
    // clang-format off
    Napi::Function func = DefineClass(env, "Grid", {
            InstanceAccessor<&Grid::key, &Grid::key>("key", prop_attr),
            InstanceMethod<&Grid::encodeSync>("encodeSync", prop_attr),
            InstanceMethod<&Grid::encode>("encode", prop_attr),
            InstanceMethod<&Grid::clearSync>("clearSync", prop_attr),
            InstanceMethod<&Grid::clear>("clear", prop_attr),
            InstanceMethod<&Grid::painted>("painted", prop_attr),
            InstanceMethod<&Grid::fields>("fields", prop_attr),
            InstanceMethod<&Grid::addField>("addField", prop_attr),
            InstanceMethod<&Grid::view>("view", prop_attr),
            InstanceMethod<&Grid::width>("width", prop_attr),
            InstanceMethod<&Grid::height>("height", prop_attr),
            StaticValue("base_mask", Napi::Number::New(env, mapnik::grid::base_mask))
        });
    // clang-format on
    constructor = Napi::Persistent(func);
    constructor.SuppressDestruct();
    exports.Set("Grid", func);
    return exports;
}

/**
 * **`mapnik.Grid`**
 *
 * Generator for [UTFGrid](https://www.mapbox.com/guides/an-open-platform)
 * representations of data.
 *
 * @class Grid
 * @param {number} width
 * @param {number} height
 * @param {Object} [options={}] optional argument, which can have a 'key' property
 * @property {string} key
 */

Grid::Grid(Napi::CallbackInfo const& info)
    : Napi::ObjectWrap<Grid>(info)
{
    Napi::Env env = info.Env();
    if (info.Length() == 1 && info[0].IsExternal())
    {
        auto ext = info[0].As<Napi::External<grid_ptr>>();
        if (ext) grid_ = *ext.Data();
        return;
    }
    if (info.Length() >= 2)
    {
        if (!info[0].IsNumber() || !info[1].IsNumber())
        {
            Napi::TypeError::New(env, "Grid 'width' and 'height' must be integers").ThrowAsJavaScriptException();
            return;
        }

        // defaults
        std::string key("__id__");

        if (info.Length() >= 3)
        {

            if (!info[2].IsObject())
            {
                Napi::TypeError::New(env, "optional third arg must be an options object").ThrowAsJavaScriptException();
                return;
            }
            Napi::Object options = info[2].As<Napi::Object>();

            if (options.Has("key"))
            {
                Napi::Value bind_opt = options.Get("key");
                if (!bind_opt.IsString())
                {
                    Napi::TypeError::New(env, "optional arg 'key' must be an string").ThrowAsJavaScriptException();
                    return;
                }

                key = bind_opt.As<Napi::String>();
            }
        }
        grid_ = std::make_shared<mapnik::grid>(info[0].As<Napi::Number>().Int32Value(),
                                               info[1].As<Napi::Number>().Int32Value(),
                                               key);
    }
    else
    {
        Napi::Error::New(env, "please provide Grid width and height").ThrowAsJavaScriptException();
    }
}

Napi::Value Grid::clearSync(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    grid_->clear();
    return env.Undefined();
}

Napi::Value Grid::clear(Napi::CallbackInfo const& info)
{
    if (info.Length() == 0)
    {
        return clearSync(info);
    }
    Napi::Env env = info.Env();
    // ensure callback is a function

    Napi::Value callback_val = info[info.Length() - 1];
    if (!callback_val.IsFunction())
    {
        Napi::TypeError::New(env, "last argument must be a callback function").ThrowAsJavaScriptException();
        return env.Undefined();
    }
    auto* worker = new detail::AsyncGridClear{grid_, callback_val.As<Napi::Function>()};
    worker->Queue();
    return env.Undefined();
}

Napi::Value Grid::painted(Napi::CallbackInfo const& info)
{
    return Napi::Boolean::New(info.Env(), grid_->painted());
}

/**
 * Get this grid's width
 * @memberof Grid
 * @instance
 * @name width
 * @returns {number} width
 */
Napi::Value Grid::width(Napi::CallbackInfo const& info)
{
    return Napi::Number::New(info.Env(), grid_->width());
}

/**
 * Get this grid's height
 * @memberof Grid
 * @instance
 * @name height
 * @returns {number} height
 */
Napi::Value Grid::height(Napi::CallbackInfo const& info)
{
    return Napi::Number::New(info.Env(), grid_->height());
}

Napi::Value Grid::key(Napi::CallbackInfo const& info)
{
    return Napi::String::New(info.Env(), grid_->get_key());
}

void Grid::key(Napi::CallbackInfo const& info, const Napi::Value& value)
{
    Napi::Env env = info.Env();
    if (!value.IsString())
    {
        Napi::TypeError::New(env, "key must be an string").ThrowAsJavaScriptException();
        return;
    }
    grid_->set_key(value.As<Napi::String>());
}

/**
 * Add a field to this grid's output
 * @memberof Grid
 * @instance
 * @name addField
 * @param {string} field
 */
Napi::Value Grid::addField(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    if (info.Length() == 1)
    {
        if (!info[0].IsString())
        {
            Napi::TypeError::New(env, "argument must be a string").ThrowAsJavaScriptException();
            return env.Undefined();
        }
        grid_->add_field(info[0].As<Napi::String>());
    }
    else
    {
        Napi::TypeError::New(env, "one parameter, a string is required").ThrowAsJavaScriptException();
    }
    return env.Undefined();
}

/**
 * Get all of this grid's fields
 * @memberof Grid
 * @instance
 * @name addField
 * @returns {v8::Array<string>} fields
 */
Napi::Value Grid::fields(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);
    std::set<std::string> const& a = grid_->get_fields();
    std::set<std::string>::const_iterator itr = a.begin();
    std::set<std::string>::const_iterator end = a.end();
    Napi::Array l = Napi::Array::New(env, a.size());
    std::size_t idx = 0;
    for (; itr != end; ++itr)
    {
        l.Set(idx++, *itr);
    }
    return scope.Escape(l);
}

/**
 * Get a constrained view of this field given x, y, width, height parameters.
 * @memberof Grid
 * @instance
 * @name view
 * @param {number} x
 * @param {number} y
 * @param {number} width
 * @param {number} height
 * @returns {mapnik.Grid} a grid constrained to this new view
 */
Napi::Value Grid::view(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);
    if ((info.Length() != 4) || (!info[0].IsNumber() && !info[1].IsNumber() && !info[2].IsNumber() && !info[3].IsNumber()))
    {
        Napi::TypeError::New(env, "requires 4 integer arguments: x, y, width, height").ThrowAsJavaScriptException();
        return env.Undefined();
    }

    Napi::Number x = info[0].As<Napi::Number>();
    Napi::Number y = info[1].As<Napi::Number>();
    Napi::Number w = info[2].As<Napi::Number>();
    Napi::Number h = info[3].As<Napi::Number>();
    Napi::Value grid_obj = Napi::External<grid_ptr>::New(env, &grid_);
    Napi::Object obj = GridView::constructor.New({grid_obj, x, y, w, h});
    return scope.Escape(obj);
}

/**
 * Get a constrained view of this field given x, y, width, height parameters.
 * @memberof Grid
 * @instance
 * @name encodeSync
 * @param {Object} [options={ resolution: 4, features: false }]
 * @returns {Object} an encoded field with `grid`, `keys`, and `data` members.
 */

Napi::Value Grid::encodeSync(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);

    // defaults
    unsigned int resolution = 4;
    bool add_features = true;

    // options hash
    if (info.Length() >= 1)
    {
        if (!info[0].IsObject())
        {
            Napi::TypeError::New(env, "optional arg must be an options object").ThrowAsJavaScriptException();
            return env.Undefined();
        }

        Napi::Object options = info[0].As<Napi::Object>();

        if (options.Has("resolution"))
        {
            Napi::Value bind_opt = options.Get("resolution");
            if (!bind_opt.IsNumber())
            {
                Napi::TypeError::New(env, "'resolution' must be an Integer").ThrowAsJavaScriptException();
                return env.Undefined();
            }

            resolution = bind_opt.As<Napi::Number>().Int32Value();
            if (resolution == 0)
            {
                Napi::TypeError::New(env, "'resolution' can not be zero").ThrowAsJavaScriptException();
                return env.Undefined();
            }
        }

        if (options.Has("features"))
        {
            Napi::Value bind_opt = options.Get("features");
            if (!bind_opt.IsBoolean())
            {
                Napi::TypeError::New(env, "'features' must be an Boolean").ThrowAsJavaScriptException();
                return env.Undefined();
            }

            add_features = bind_opt.As<Napi::Boolean>();
        }
    }

    try
    {

        std::vector<node_mapnik::grid_line_type> lines;
        std::vector<mapnik::grid::lookup_type> key_order;
        node_mapnik::grid2utf<mapnik::grid>(*grid_, lines, key_order, resolution);

        // convert key order to proper javascript array
        Napi::Array keys_a = Napi::Array::New(env, key_order.size());
        std::vector<std::string>::iterator it;
        std::size_t i;
        for (it = key_order.begin(), i = 0; it < key_order.end(); ++it, ++i)
        {
            keys_a.Set(i, Napi::String::New(env, *it));
        }

        // gather feature data
        Napi::Object feature_data = Napi::Object::New(env);
        if (add_features)
        {
            node_mapnik::write_features<mapnik::grid>(env, *grid_,
                                                      feature_data,
                                                      key_order);
        }

        // Create the return hash.
        Napi::Object json = Napi::Object::New(env);
        Napi::Array grid_array = Napi::Array::New(env, lines.size());
        for (std::size_t j = 0; j < lines.size(); ++j)
        {
            node_mapnik::grid_line_type const& line = lines[j];
            grid_array.Set(j, Napi::String::New(env, (char*)line.get()));
        }
        json.Set("grid", grid_array);
        json.Set("keys", keys_a);
        json.Set("data", feature_data);
        return scope.Escape(json);
    }
    catch (std::exception const& ex)
    {
        // There is no known exception throws in the processing above
        // so simply removing the following from coverage
        // LCOV_EXCL_START
        Napi::Error::New(env, ex.what()).ThrowAsJavaScriptException();
        return env.Undefined();
        // LCOV_EXCL_STOP
    }
}

Napi::Value Grid::encode(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    // defaults
    unsigned int resolution = 4;
    bool add_features = true;

    // options hash
    if (info.Length() >= 1)
    {
        if (!info[0].IsObject())
        {
            Napi::TypeError::New(env, "optional arg must be an options object").ThrowAsJavaScriptException();
            return env.Undefined();
        }

        Napi::Object options = info[0].As<Napi::Object>();

        if (options.Has("resolution"))
        {
            Napi::Value bind_opt = options.Get("resolution");
            if (!bind_opt.IsNumber())
            {
                Napi::TypeError::New(env, "'resolution' must be an Integer").ThrowAsJavaScriptException();
                return env.Undefined();
            }

            resolution = bind_opt.As<Napi::Number>().Int32Value();
            if (resolution == 0)
            {
                Napi::TypeError::New(env, "'resolution' can not be zero").ThrowAsJavaScriptException();
                return env.Undefined();
            }
        }

        if (options.Has("features"))
        {
            Napi::Value bind_opt = options.Get("features");
            if (!bind_opt.IsBoolean())
            {
                Napi::TypeError::New(env, "'features' must be an Boolean").ThrowAsJavaScriptException();
                return env.Undefined();
            }

            add_features = bind_opt.As<Napi::Boolean>();
        }
    }

    // ensure callback is a function
    if (!info[info.Length() - 1].IsFunction())
    {
        Napi::TypeError::New(env, "last argument must be a callback function").ThrowAsJavaScriptException();
        return env.Undefined();
    }
    Napi::Function callback = info[info.Length() - 1].As<Napi::Function>();

    auto* worker = new detail::AsyncGridEncode{grid_, resolution, add_features, callback};
    worker->Queue();
    return env.Undefined();
}

#endif