#include "mapnik_datasource.hpp"
#include "mapnik_featureset.hpp"
#include "utils.hpp"
#include "ds_emitter.hpp"

// mapnik
#include <mapnik/attribute_descriptor.hpp> // for attribute_descriptor
#include <mapnik/geometry/box2d.hpp>       // for box2d
#include <mapnik/datasource.hpp>           // for datasource, datasource_ptr, etc
#include <mapnik/datasource_cache.hpp>     // for datasource_cache
#include <mapnik/feature_layer_desc.hpp>   // for layer_descriptor
#include <mapnik/params.hpp>               // for parameters
#include <mapnik/query.hpp>                // for query

// stl
#include <exception>
#include <vector>

Napi::FunctionReference Datasource::constructor;

Napi::Object Datasource::Initialize(Napi::Env env, Napi::Object exports, napi_property_attributes prop_attr)
{
    // clang-format off
    Napi::Function func = DefineClass(env, "Datasource", {
            InstanceMethod<&Datasource::parameters>("parameters", prop_attr),
            InstanceMethod<&Datasource::describe>("describe", prop_attr),
            InstanceMethod<&Datasource::featureset>("featureset", prop_attr),
            InstanceMethod<&Datasource::extent>("extent", prop_attr),
            InstanceMethod<&Datasource::fields>("fields", prop_attr)

        });
    // clang-format on
    constructor = Napi::Persistent(func);
    constructor.SuppressDestruct();
    exports.Set("Datasource", func);
    return exports;
}

/**
 * **`mapnik.Datasource`**
 *
 * A Datasource object. This is the connector from Mapnik to any kind
 * of file, network, or database source of geographical data.
 *
 * @class Datasource
 */

Datasource::Datasource(Napi::CallbackInfo const& info)
    : Napi::ObjectWrap<Datasource>(info)
{
    Napi::Env env = info.Env();
    if (info.Length() != 1)
    {
        Napi::TypeError::New(env, "accepts only one argument, an object of key:value datasource options").ThrowAsJavaScriptException();
        return;
    }

    if (info[0].IsExternal())
    {
        auto ext = info[0].As<Napi::External<datasource_ptr>>();
        if (ext)
        {
            datasource_ = *ext.Data();
            if (datasource_->type() == mapnik::datasource::Raster)
                info.This().As<Napi::Object>().Set("type", "raster");
            else
                info.This().As<Napi::Object>().Set("type", "vector");
        }
        return;
    }

    if (!info[0].IsObject())
    {
        Napi::TypeError::New(env, "Must provide an object, eg {type: 'shape', file : 'world.shp'}").ThrowAsJavaScriptException();
        return;
    }

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

    mapnik::parameters params;
    Napi::Array names = options.GetPropertyNames();
    unsigned int length = names.Length();
    for (unsigned index = 0; index < length; ++index)
    {
        std::string name = names.Get(index).As<Napi::String>();
        Napi::Value value = options.Get(name);
        // TODO - don't treat everything as strings (FIXME ??)
        params[name] = value.ToString().Utf8Value();
    }

    try
    {
        datasource_ = mapnik::datasource_cache::instance().create(params);
    }
    catch (std::exception const& ex)
    {
        Napi::Error::New(env, ex.what()).ThrowAsJavaScriptException();
        return;
    }

    if (datasource_->type() == mapnik::datasource::Raster)
        info.This().As<Napi::Object>().Set("type", "raster");
    else
        info.This().As<Napi::Object>().Set("type", "vector");
}

Napi::Value Datasource::parameters(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);
    Napi::Object params = Napi::Object::New(env);
    for (auto const& kv : datasource_->params())
    {
        node_mapnik::params_to_object(env, params, std::get<0>(kv), std::get<1>(kv));
    }
    return scope.Escape(params);
}

/**
 * Get the Datasource's extent
 *
 * @name extent
 * @memberof Datasource
 * @instance
 * @returns {Array<number>} extent [minx, miny, maxx, maxy] order feature extent.
 */
Napi::Value Datasource::extent(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);
    mapnik::box2d<double> bbox;
    try
    {
        bbox = datasource_->envelope();
    }
    catch (std::exception const& ex)
    {
        // The only time this could possibly throw is situations
        // where a plugin dynamically calculated extent such as
        // postgis plugin. Therefore this makes this difficult
        // to add to testing. Therefore marking it with exclusion
        // LCOV_EXCL_START
        Napi::Error::New(env, ex.what()).ThrowAsJavaScriptException();
        return env.Undefined();
        // LCOV_EXCL_STOP
    }

    Napi::Array arr = Napi::Array::New(env, 4);
    arr.Set(0u, Napi::Number::New(env, bbox.minx()));
    arr.Set(1u, Napi::Number::New(env, bbox.miny()));
    arr.Set(2u, Napi::Number::New(env, bbox.maxx()));
    arr.Set(3u, Napi::Number::New(env, bbox.maxy()));
    return scope.Escape(arr);
}

/**
 * Describe the datasource's contents and type.
 *
 * @name describe
 * @memberof Datasource
 * @instance
 * @returns {Object} description: an object with type, fields, encoding,
 * geometry_type, and proj4 code
 */
Napi::Value Datasource::describe(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);
    Napi::Object description = Napi::Object::New(env);
    try
    {
        node_mapnik::describe_datasource(env, description, datasource_);
    }
    catch (std::exception const& ex)
    {
        // The only time this could possibly throw is situations
        // where a plugin dynamically calculated extent such as
        // postgis plugin. Therefore this makes this difficult
        // to add to testing. Therefore marking it with exclusion
        // LCOV_EXCL_START
        Napi::Error::New(env, ex.what()).ThrowAsJavaScriptException();
        return env.Undefined();
        // LCOV_EXCL_STOP
    }
    return scope.Escape(description);
}

/**
 * Get features from this dataset using an iterator.
 *
 * @name featureset
 * @memberof Datasource
 * @instance
 * @param {Object} [options]
 * @param {Array<number>} [options.extent=[minx,miny,maxx,maxy]]
 * @returns {Object} an iterator with a `.next()` method that returns
 * features from a dataset.
 * @example
 * var features = [];
 * var featureset = ds.featureset();
 * var feature;
 * while ((feature = featureset.next())) {
 *     features.push(feature);
 * }
 */

Napi::Value Datasource::featureset(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);
    mapnik::box2d<double> extent = datasource_->envelope();

    if (info.Length() > 0)
    {
        // options object
        if (!info[0].IsObject())
        {
            Napi::TypeError::New(env, "optional second argument must be an options object").ThrowAsJavaScriptException();
            return env.Undefined();
        }
        Napi::Object options = info[0].As<Napi::Object>();
        if (options.Has("extent"))
        {
            Napi::Value extent_opt = options.Get("extent");
            if (!extent_opt.IsArray())
            {
                Napi::TypeError::New(env, "extent value must be an array of [minx,miny,maxx,maxy]").ThrowAsJavaScriptException();
                return env.Undefined();
            }
            Napi::Array bbox = extent_opt.As<Napi::Array>();
            auto len = bbox.Length();
            if (!(len == 4))
            {
                Napi::TypeError::New(env, "extent value must be an array of [minx,miny,maxx,maxy]").ThrowAsJavaScriptException();
                return env.Undefined();
            }
            Napi::Value minx = bbox.Get(0u);
            Napi::Value miny = bbox.Get(1u);
            Napi::Value maxx = bbox.Get(2u);
            Napi::Value maxy = bbox.Get(3u);
            if (!minx.IsNumber() || !miny.IsNumber() || !maxx.IsNumber() || !maxy.IsNumber())
            {
                Napi::Error::New(env, "max_extent [minx,miny,maxx,maxy] must be numbers").ThrowAsJavaScriptException();
                return env.Null();
            }
            extent = mapnik::box2d<double>(minx.As<Napi::Number>().DoubleValue(), miny.As<Napi::Number>().DoubleValue(),
                                           maxx.As<Napi::Number>().DoubleValue(), maxy.As<Napi::Number>().DoubleValue());
        }
    }

    mapnik::featureset_ptr fs;
    try
    {
        mapnik::query q(extent);
        mapnik::layer_descriptor ld = datasource_->get_descriptor();
        auto const& desc = ld.get_descriptors();
        for (auto const& attr_info : desc)
        {
            q.add_property_name(attr_info.get_name());
        }

        fs = datasource_->features(q);
    }
    catch (std::exception const& ex)
    {
        // The only time this could possibly throw is situations
        // where a plugin dynamically calculated extent such as
        // postgis plugin. Therefore this makes this difficult
        // to add to testing. Therefore marking it with exclusion
        Napi::Error::New(env, ex.what()).ThrowAsJavaScriptException();
        return env.Undefined();
    }

    if (fs && !mapnik::is_empty(fs))
    {
        Napi::Value arg = Napi::External<mapnik::featureset_ptr>::New(env, &fs);
        Napi::Object obj = Featureset::constructor.New({arg});
        return scope.Escape(obj);
    }
    return env.Null(); // an empty Featureset
}

/**
 * Get only the fields metadata from a dataset.
 *
 * @name fields
 * @memberof Datasource
 * @instance
 * @returns {Object} an object that maps from a field name to it type
 * @example
 * var fields = ds.fields();
 * // {
 * //     FIPS: 'String',
 * //     ISO2: 'String',
 * //     ISO3: 'String',
 * //     UN: 'Number',
 * //     NAME: 'String',
 * //     AREA: 'Number',
 * //     POP2005: 'Number',
 * //     REGION: 'Number',
 * //     SUBREGION: 'Number',
 * //     LON: 'Number',
 * //     LAT: 'Number'
 * // }
 */

Napi::Value Datasource::fields(Napi::CallbackInfo const& info)
{
    Napi::Env env = info.Env();
    Napi::EscapableHandleScope scope(env);
    Napi::Object fields = Napi::Object::New(env);
    node_mapnik::get_fields(env, fields, datasource_);
    return scope.Escape(fields);
}