#ifndef MPL_BACKEND_AGG_BASIC_TYPES_H
#define MPL_BACKEND_AGG_BASIC_TYPES_H

/* Contains some simple types from the Agg backend that are also used
   by other modules */

#include <pybind11/pybind11.h>

#include <unordered_map>
#include <vector>

#include "agg_color_rgba.h"
#include "agg_math_stroke.h"
#include "agg_trans_affine.h"
#include "path_converters.h"

#include "py_adaptors.h"

namespace py = pybind11;

struct ClipPath
{
    mpl::PathIterator path;
    agg::trans_affine trans;
};

struct SketchParams
{
    double scale;
    double length;
    double randomness;
};

class Dashes
{
    typedef std::vector<std::pair<double, double> > dash_t;
    double dash_offset;
    dash_t dashes;

  public:
    double get_dash_offset() const
    {
        return dash_offset;
    }
    void set_dash_offset(double x)
    {
        dash_offset = x;
    }
    void add_dash_pair(double length, double skip)
    {
        dashes.emplace_back(length, skip);
    }
    size_t size() const
    {
        return dashes.size();
    }

    template <class T>
    void dash_to_stroke(T &stroke, double dpi, bool isaa)
    {
        double scaleddpi = dpi / 72.0;
        for (auto [val0, val1] : dashes) {
            val0 = val0 * scaleddpi;
            val1 = val1 * scaleddpi;
            if (!isaa) {
                val0 = (int)val0 + 0.5;
                val1 = (int)val1 + 0.5;
            }
            stroke.add_dash(val0, val1);
        }
        stroke.dash_start(get_dash_offset() * scaleddpi);
    }
};

typedef std::vector<Dashes> DashesVector;

class GCAgg
{
  public:
    GCAgg()
        : linewidth(1.0),
          alpha(1.0),
          cap(agg::butt_cap),
          join(agg::round_join),
          snap_mode(SNAP_FALSE)
    {
    }

    ~GCAgg()
    {
    }

    double linewidth;
    double alpha;
    bool forced_alpha;
    agg::rgba color;
    bool isaa;

    agg::line_cap_e cap;
    agg::line_join_e join;

    agg::rect_d cliprect;

    ClipPath clippath;

    Dashes dashes;

    e_snap_mode snap_mode;

    mpl::PathIterator hatchpath;
    agg::rgba hatch_color;
    double hatch_linewidth;

    SketchParams sketch;

    bool has_hatchpath()
    {
        return hatchpath.total_vertices() != 0;
    }

  private:
    // prevent copying
    GCAgg(const GCAgg &);
    GCAgg &operator=(const GCAgg &);
};

namespace PYBIND11_NAMESPACE { namespace detail {
    template <> struct type_caster<agg::line_cap_e> {
    public:
        PYBIND11_TYPE_CASTER(agg::line_cap_e, const_name("line_cap_e"));

        bool load(handle src, bool) {
            const std::unordered_map<std::string, agg::line_cap_e> enum_values = {
                {"butt", agg::butt_cap},
                {"round", agg::round_cap},
                {"projecting", agg::square_cap},
            };
            value = enum_values.at(src.cast<std::string>());
            return true;
        }
    };

    template <> struct type_caster<agg::line_join_e> {
    public:
        PYBIND11_TYPE_CASTER(agg::line_join_e, const_name("line_join_e"));

        bool load(handle src, bool) {
            const std::unordered_map<std::string, agg::line_join_e> enum_values = {
                {"miter", agg::miter_join_revert},
                {"round", agg::round_join},
                {"bevel", agg::bevel_join},
            };
            value = enum_values.at(src.cast<std::string>());
            return true;
        }
    };

    template <> struct type_caster<ClipPath> {
    public:
        PYBIND11_TYPE_CASTER(ClipPath, const_name("ClipPath"));

        bool load(handle src, bool) {
            if (src.is_none()) {
                return true;
            }

            auto [path, trans] =
                src.cast<std::pair<std::optional<mpl::PathIterator>, agg::trans_affine>>();
            if (path) {
                value.path = *path;
            }
            value.trans = trans;

            return true;
        }
    };

    template <> struct type_caster<Dashes> {
    public:
        PYBIND11_TYPE_CASTER(Dashes, const_name("Dashes"));

        bool load(handle src, bool) {
            auto [dash_offset, dashes_seq_or_none] =
                src.cast<std::pair<double, std::optional<py::sequence>>>();

            if (!dashes_seq_or_none) {
                return true;
            }

            auto dashes_seq = *dashes_seq_or_none;

            auto nentries = dashes_seq.size();
            // If the dashpattern has odd length, iterate through it twice (in
            // accordance with the pdf/ps/svg specs).
            auto dash_pattern_length = (nentries % 2) ? 2 * nentries : nentries;

            for (py::size_t i = 0; i < dash_pattern_length; i += 2) {
                auto length = dashes_seq[i % nentries].cast<double>();
                auto skip = dashes_seq[(i + 1) % nentries].cast<double>();

                value.add_dash_pair(length, skip);
            }

            value.set_dash_offset(dash_offset);

            return true;
        }
    };

    template <> struct type_caster<SketchParams> {
    public:
        PYBIND11_TYPE_CASTER(SketchParams, const_name("SketchParams"));

        bool load(handle src, bool) {
            if (src.is_none()) {
                value.scale = 0.0;
                value.length = 0.0;
                value.randomness = 0.0;
                return true;
            }

            auto params = src.cast<std::tuple<double, double, double>>();
            std::tie(value.scale, value.length, value.randomness) = params;

            return true;
        }
    };

    template <> struct type_caster<GCAgg> {
    public:
        PYBIND11_TYPE_CASTER(GCAgg, const_name("GCAgg"));

        bool load(handle src, bool) {
            value.linewidth = src.attr("_linewidth").cast<double>();
            value.alpha = src.attr("_alpha").cast<double>();
            value.forced_alpha = src.attr("_forced_alpha").cast<bool>();
            value.color = src.attr("_rgb").cast<agg::rgba>();
            value.isaa = src.attr("_antialiased").cast<bool>();
            value.cap = src.attr("_capstyle").cast<agg::line_cap_e>();
            value.join = src.attr("_joinstyle").cast<agg::line_join_e>();
            value.dashes = src.attr("get_dashes")().cast<Dashes>();
            value.cliprect = src.attr("_cliprect").cast<agg::rect_d>();
            value.clippath = src.attr("get_clip_path")().cast<ClipPath>();
            value.snap_mode = src.attr("get_snap")().cast<e_snap_mode>();
            value.hatchpath = src.attr("get_hatch_path")().cast<mpl::PathIterator>();
            value.hatch_color = src.attr("get_hatch_color")().cast<agg::rgba>();
            value.hatch_linewidth = src.attr("get_hatch_linewidth")().cast<double>();
            value.sketch = src.attr("get_sketch_params")().cast<SketchParams>();

            return true;
        }
    };
}} // namespace PYBIND11_NAMESPACE::detail

#endif