#pragma once

#ifndef MYPAINT_HPP

#define MYPAINT_HPP

#include <cmath></cmath>

#include <algorithm></algorithm>

#include <string></string>

extern "C" {

  #include <mypaint-brush.h></mypaint-brush.h>

  #include <mypaint-surface.h></mypaint-surface.h>

  #include <mypaint-brush-settings.h></mypaint-brush-settings.h>

}

namespace mypaint {

  class Brush;

  //=======================================================

  //

  // Dab

  //

  //=======================================================

  class Dab {

  public:

    float x;

    float y;

    float radius;

    float colorR;

    float colorG;

    float colorB;

    float opaque;

    float hardness;

    float alphaEraser;

    float aspectRatio;

    float angle;

    float lockAlpha;

    float colorize;

    Dab():

      x(), y(), radius(),

      colorR(), colorG(), colorB(),

      opaque(), hardness(), alphaEraser(),

      aspectRatio(), angle(),

      lockAlpha(), colorize()

      { }

    Dab(

      float x, float y, float radius,

      float colorR = 0.f, float colorG = 0.f, float colorB = 0.f,

      float opaque = 1.f, float hardness = 0.5f, float alphaEraser = 1.f,

      float aspectRatio = 1.f, float angle = 0.f,

      float lockAlpha = 0.f, float colorize = 0.f

    ):

      x(x), y(y), radius(radius),

      colorR(colorR), colorG(colorG), colorB(colorB),

      opaque(opaque), hardness(hardness), alphaEraser(alphaEraser),

      aspectRatio(aspectRatio), angle(angle),

      lockAlpha(lockAlpha), colorize(lockAlpha)

      { }

    void clamp() {

      radius      = fabsf(radius);

      colorR      = std::min(std::max(colorR,      0.f), 1.f);

      colorG      = std::min(std::max(colorG,      0.f), 1.f);

      colorB      = std::min(std::max(colorB,      0.f), 1.f);

      opaque      = std::min(std::max(opaque,      0.f), 1.f);

      hardness    = std::min(std::max(hardness,    0.f), 1.f);

      alphaEraser = std::min(std::max(alphaEraser, 0.f), 1.f);

      aspectRatio = std::max(aspectRatio, 1.f);

      lockAlpha   = std::min(std::max(lockAlpha,   0.f), 1.f);

      colorize    = std::min(std::max(colorize,    0.f), 1.f);

    }

    Dab getClamped() const

      { Dab dab(*this); dab.clamp(); return dab; }

  };

  //=======================================================

  //

  // Surface

  //

  //=======================================================

  class Surface {

    friend class Brush;

    struct InternalSurface: public MyPaintSurface {

      Surface *m_owner;

    };

    InternalSurface m_surface;

    static int internalDrawDab(

        MyPaintSurface *self,

        float x, float y, float radius,

        float colorR, float colorG, float colorB,

        float opaque, float hardness, float alphaEraser,

        float aspectRatio, float angle,

        float lockAlpha, float colorize )

    {

      return static_cast<internalsurface*>(self)->m_owner->drawDab( Dab(</internalsurface*>

        x, y, radius,

        colorR, colorG, colorB,

        opaque, hardness, alphaEraser,

        aspectRatio, angle,

        lockAlpha, colorize ));

    }

    static void internalGetColor(

        MyPaintSurface *self,

        float x, float y, float radius,

        float *colorR, float *colorG, float *colorB, float *colorA )

    {

      static_cast<internalsurface*>(self)->m_owner->getColor(</internalsurface*>

        x, y,

        radius,

        *colorR, *colorG, *colorB, *colorA);

    }

  public:

    Surface():

      m_surface()

    {

      m_surface.m_owner = this;

      m_surface.draw_dab = internalDrawDab;

      m_surface.get_color = internalGetColor;

    }

    virtual ~Surface() { }

    virtual bool getColor(

        float x, float y, float radius,

        float &colorR, float &colorG, float &colorB, float &colorA ) = 0;

    virtual bool drawDab(const Dab &dab) = 0;

  };

  //=======================================================

  //

  // Brush

  //

  //=======================================================

  class Brush {

    MyPaintBrush *m_brush;

  public:

    Brush():

      m_brush(mypaint_brush_new())

    { fromDefaults(); }

    Brush(const Brush &other):

      m_brush(mypaint_brush_new())

    { fromBrush(other); }

    ~Brush()

    { mypaint_brush_unref(m_brush); }

    Brush& operator= (const Brush &other) {

      fromBrush(other);

      return *this;

    }

    void reset()

    { mypaint_brush_reset(m_brush); }

    void newStroke()

    { mypaint_brush_new_stroke(m_brush); }

    int strokeTo(Surface &surface, float x, float y,

                  float pressure, float xtilt, float ytilt, double dtime)

    {

      return mypaint_brush_stroke_to(m_brush, &surface.m_surface,

                                     x, y, pressure, xtilt, ytilt, dtime);

    }

    void setBaseValue(MyPaintBrushSetting id, float value)

    { mypaint_brush_set_base_value(m_brush, id, value); }

    float getBaseValue(MyPaintBrushSetting id) const

    { return mypaint_brush_get_base_value(m_brush, id); }

    bool isConstant(MyPaintBrushSetting id) const

    { return mypaint_brush_is_constant(m_brush, id); }

    int getInputsUsedN(MyPaintBrushSetting id) const

    { return mypaint_brush_get_inputs_used_n(m_brush, id); }

    void setMappingN(MyPaintBrushSetting id, MyPaintBrushInput input, int n)

    { mypaint_brush_set_mapping_n(m_brush, id, input, n); }

    int getMappingN(MyPaintBrushSetting id, MyPaintBrushInput input) const

    { return mypaint_brush_get_mapping_n(m_brush, id, input); }

    void setMappingPoint(MyPaintBrushSetting id, MyPaintBrushInput input, int index, float x, float y)

    { mypaint_brush_set_mapping_point(m_brush, id, input, index, x, y); }

    void getMappingPoint(MyPaintBrushSetting id, MyPaintBrushInput input, int index, float &x, float &y) const

    { mypaint_brush_get_mapping_point(m_brush, id, input, index, &x, &y); }

    float getState(MyPaintBrushState i) const

    { return mypaint_brush_get_state(m_brush, i); }

    void setState(MyPaintBrushState i, float value)

    { return mypaint_brush_set_state(m_brush, i, value); }

    double getTotalStrokePaintingTime() const

    { return mypaint_brush_get_total_stroke_painting_time(m_brush); }

    void setPrintInputs(bool enabled)

    { mypaint_brush_set_print_inputs(m_brush, enabled); }

    void fromDefaults() {

      mypaint_brush_from_defaults(m_brush);

    }

    void fromBrush(const Brush &other) {

      for(int i = 0; i < MYPAINT_BRUSH_SETTINGS_COUNT; ++i) {

        MyPaintBrushSetting id = (MyPaintBrushSetting)i;

        setBaseValue(id, other.getBaseValue(id));

        for(int j = 0; j < MYPAINT_BRUSH_INPUTS_COUNT; ++j) {

          MyPaintBrushInput input = (MyPaintBrushInput)j;

          int n = other.getMappingN(id, input);

          setMappingN(id, input, n);

          for(int index = 0; index < n; ++index) {

            float x = 0.f, y = 0.f;

            other.getMappingPoint(id, input, index, x, y);

            setMappingPoint(id, input, index, x, y);

          }

        }

      }

    }

    bool fromString(const std::string &s) {

      return mypaint_brush_from_string(m_brush, s.c_str());

    }

  };

  //=======================================================

  //

  // Setting

  //

  //=======================================================

  class Setting final {

  public:

    MyPaintBrushSetting id;

    std::string key;

    std::string name;

    std::string tooltip;

    bool constant;

    float min;

    float def;

    float max;

  private:

    Setting():               id(), constant(), min(), def(), max() { }

    Setting(const Setting&): id(), constant(), min(), def(), max() { }

  public:

    static const Setting* all() {

      static bool initialized = false;

      static Setting settings[MYPAINT_BRUSH_SETTINGS_COUNT];

      if (!initialized) {

        for(int i = 0; i < MYPAINT_BRUSH_SETTINGS_COUNT; ++i) {

          const MyPaintBrushSettingInfo *info = mypaint_brush_setting_info((MyPaintBrushSetting)i);

          settings[i].id       = (MyPaintBrushSetting)i;

          settings[i].key      = info->cname;

          settings[i].name     = mypaint_brush_setting_info_get_name(info);

          settings[i].tooltip  = mypaint_brush_setting_info_get_tooltip(info);

          settings[i].constant = info->constant;

          settings[i].min      = info->min;

          settings[i].def      = info->def;

          settings[i].max      = info->max;

        }

      }

      return settings;

    }

    static const Setting& byId(MyPaintBrushSetting id)

      { return all()[id]; }

    static const Setting* findByKey(const std::string &key) {

      const Setting* settings = all();

      for(int i = 0; i < MYPAINT_BRUSH_SETTINGS_COUNT; ++i)

        if (settings[i].key == key)

          return &settings[i];

      return 0;

    }

  };

  //=======================================================

  //

  // Input

  //

  //=======================================================

  class Input final {

  public:

    MyPaintBrushInput id;

    std::string key;

    std::string name;

    std::string tooltip;

    float hardMin;

    float softMin;

    float normal;

    float softMax;

    float hardMax;

  private:

    Input():             id(), hardMin(), softMin(), normal(), softMax(), hardMax() { }

    Input(const Input&): id(), hardMin(), softMin(), normal(), softMax(), hardMax() { }

  public:

    static const Input* all() {

      static bool initialized = false;

      static Input inputs[MYPAINT_BRUSH_INPUTS_COUNT];

      if (!initialized) {

        for(int i = 0; i < MYPAINT_BRUSH_INPUTS_COUNT; ++i) {

          const MyPaintBrushInputInfo *info = mypaint_brush_input_info((MyPaintBrushInput)i);

          inputs[i].id       = (MyPaintBrushInput)i;

          inputs[i].key      = info->cname;

          inputs[i].name     = mypaint_brush_input_info_get_name(info);

          inputs[i].tooltip  = mypaint_brush_input_info_get_tooltip(info);

          inputs[i].hardMin = info->hard_min;

          inputs[i].softMin = info->soft_min;

          inputs[i].normal  = info->normal;

          inputs[i].softMax = info->soft_max;

          inputs[i].hardMax = info->hard_max;

        }

      }

      return inputs;

    }

    static const Input& byId(MyPaintBrushInput id) {

      return all()[id];

    }

    static const Input* findByKey(const std::string &key) {

      const Input* inputs = all();

      for(int i = 0; i < MYPAINT_BRUSH_INPUTS_COUNT; ++i)

        if (inputs[i].key == key)

          return &inputs[i];

      return 0;

    }

  };

}

#endif  // MYPAINT_HPP