#pragma once

#ifndef TOONZRASTERBRUSHTOOL_H

#define TOONZRASTERBRUSHTOOL_H

#include <tgeometry.h></tgeometry.h>

#include <tproperty.h></tproperty.h>

#include <trasterimage.h></trasterimage.h>

#include <ttoonzimage.h></ttoonzimage.h>

#include <tstroke.h></tstroke.h>

#include <toonz strokegenerator.h=""></toonz>

#include <toonz rasterstrokegenerator.h=""></toonz>

#include <tools tool.h=""></tools>

#include <tools cursors.h=""></tools>

#include <tools inputmanager.h=""></tools>

#include <tools modifierline.h="" modifiers=""></tools>

#include <tools modifiers="" modifiertangents.h=""></tools>

#include <tools modifierassistants.h="" modifiers=""></tools>

#include <tools modifiers="" modifiersegmentation.h=""></tools>

#ifndef NDEBUG

#include <tools modifiers="" modifiertest.h=""></tools>

#endif

#include "bluredbrush.h"

#include "mypainttoonzbrush.h"

#include <qcoreapplication></qcoreapplication>

#include <qradialgradient></qradialgradient>

#include <qelapsedtimer></qelapsedtimer>

//--------------------------------------------------------------

//  Forward declarations

class TTileSetCM32;

class TTileSaverCM32;

class RasterStrokeGenerator;

class BluredBrush;

class ToonzRasterBrushToolNotifier;

//--------------------------------------------------------------

//************************************************************************

//  Toonz Raster Brush Data declaration

//************************************************************************

struct BrushData final : public TPersist {

  PERSIST_DECLARATION(BrushData)

  // frameRange, snapSensitivity and snap are not included

  // Those options are not really a part of the brush settings,

  // just the overall tool.

  std::wstring m_name;

  double m_min, m_max, m_smooth, m_hardness, m_opacityMin, m_opacityMax;

  bool m_pencil, m_pressure;

  int m_drawOrder;

  double m_modifierSize, m_modifierOpacity;

  bool m_modifierEraser, m_modifierLockAlpha;

  bool m_assistants;

  BrushData();

  BrushData(const std::wstring &name);

  bool operator<(const BrushData &other) const { return m_name < other.m_name; }

  void saveData(TOStream &os) override;

  void loadData(TIStream &is) override;

};

//************************************************************************

//   Toonz Raster Brush Preset Manager declaration

//************************************************************************

class BrushPresetManager {

  TFilePath m_fp;                 //!< Presets file path

  std::set<brushdata> m_presets;  //!< Current presets container</brushdata>

public:

  BrushPresetManager() {}

  void load(const TFilePath &fp);

  void save();

  const TFilePath &path() { return m_fp; };

  const std::set<brushdata> &presets() const { return m_presets; }</brushdata>

  void addPreset(const BrushData &data);

  void removePreset(const std::wstring &name);

};

//************************************************************************

//    Smooth Stroke declaration

//    Brush stroke smoothing buffer.

//************************************************************************

class SmoothStroke {

public:

  SmoothStroke() {}

  ~SmoothStroke() {}

  // begin stroke

  // smooth is smooth strength, from 0 to 100

  void beginStroke(int smooth);

  // add stroke point

  void addPoint(const TThickPoint &point);

  // end stroke

  void endStroke();

  // Get generated stroke points which has been smoothed.

  // Both addPoint() and endStroke() generate new smoothed points.

  // This method will removed generated points

  void getSmoothPoints(std::vector<tthickpoint> &smoothPoints);</tthickpoint>

  // Remove all points - used for straight lines

  void clearPoints();

private:

  void generatePoints();

private:

  int m_smooth;

  int m_outputIndex;

  int m_readIndex;

  std::vector<tthickpoint> m_rawPoints;</tthickpoint>

  std::vector<tthickpoint> m_outputPoints;</tthickpoint>

  int m_resampledIndex;

  std::vector<tthickpoint> m_resampledPoints;</tthickpoint>

};

//************************************************************************

//   Toonz Raster Brush Tool declaration

//************************************************************************

class ToonzRasterBrushTool final : public TTool,

                                   public RasterController,

                                   public TInputHandler {

  Q_DECLARE_TR_FUNCTIONS(ToonzRasterBrushTool)

  void updateCurrentStyle();

  double restartBrushTimer();

public:

  ToonzRasterBrushTool(std::string name, int targetType);

  ToolType getToolType() const override { return TTool::LevelWriteTool; }

  ToolOptionsBox *createOptionsBox() override;

  void updateTranslation() override;

  void onActivate() override;

  void onDeactivate() override;

  bool preLeftButtonDown() override;

  void leftButtonDown(const TPointD &pos, const TMouseEvent &e) override;

  void leftButtonDrag(const TPointD &pos, const TMouseEvent &e) override;

  void leftButtonUp(const TPointD &pos, const TMouseEvent &e) override;

  void mouseMove(const TPointD &pos, const TMouseEvent &e) override;

  void inputMouseMove(const TPointD &position,

                      const TInputState &state) override;

  void inputSetBusy(bool busy) override;

  void inputPaintTrackPoint(const TTrackPoint &point, const TTrack &track,

                            bool firstTrack) override;

  void inputInvalidateRect(const TRectD &bounds) override { invalidate(bounds); }

  TTool *inputGetTool() override { return this; };

  void draw() override;

  void onEnter() override;

  void onLeave() override;

  int getCursorId() const override { return ToolCursor::PenCursor; }

  TPropertyGroup *getProperties(int targetType) override;

  bool onPropertyChanged(std::string propertyName) override;

  void onImageChanged() override;

  void setWorkAndBackupImages();

  void updateWorkAndBackupRasters(const TRect &rect);

  void initPresets();

  void loadPreset();

  void addPreset(QString name);

  void removePreset();

  void loadLastBrush();

  // return true if the pencil mode is active in the Brush / PaintBrush / Eraser

  // Tools.

  bool isPencilModeActive() override;

  void onColorStyleChanged();

  bool askRead(const TRect &rect) override;

  bool askWrite(const TRect &rect) override;

  bool isMyPaintStyleSelected() { return m_isMyPaintStyleSelected; }

private:

  enum MouseEventType { ME_DOWN, ME_DRAG, ME_UP, ME_MOVE };

  void handleMouseEvent(MouseEventType type, const TPointD &pos,

                        const TMouseEvent &e);

protected:

  TInputManager m_inputmanager;

#ifndef NDEBUG

  TSmartPointerT<tmodifiertest> m_modifierTest;</tmodifiertest>

#endif

  TSmartPointerT<tmodifierline> m_modifierLine;</tmodifierline>

  TSmartPointerT<tmodifiertangents> m_modifierTangents;</tmodifiertangents>

  TSmartPointerT<tmodifierassistants> m_modifierAssistants;</tmodifierassistants>

  TSmartPointerT<tmodifiersegmentation> m_modifierSegmentation;</tmodifiersegmentation>

  class MyPaintStroke: public TTrackToolHandler {

  public:

    MyPaintToonzBrush brush;

    inline MyPaintStroke(

      const TRaster32P &ras,

      RasterController &controller,

      const mypaint::Brush &brush,

      bool interpolation = false

    ): 

      brush(ras, controller, brush, interpolation)

    { }

  };

  class PencilStroke: public TTrackToolHandler {

  public:

    RasterStrokeGenerator brush;

    inline PencilStroke( const TRasterCM32P &raster, Tasks task,

                         ColorType colorType, int styleId, const TThickPoint &p,

                         bool selective, int selectedStyle, bool lockAlpha,

                         bool keepAntialias, bool isPaletteOrder = false

    ):

      brush(raster, task, colorType, styleId, p, selective, selectedStyle, lockAlpha, keepAntialias, isPaletteOrder)

    { }

  };

  class BluredStroke: public TTrackToolHandler {

  public:

    BluredBrush brush;

    inline BluredStroke( const TRaster32P &ras, int size,

                         const QRadialGradient &gradient, bool doDynamicOpacity

    ):

      brush(ras, size, gradient, doDynamicOpacity)

    { }

  };

  struct Painting {

    // initial painting input

    bool active = false;

    int styleId = 0;

    bool smooth = false;

    // 作業中のFrameIdをクリック時に保存し、マウスリリース時（Undoの登録時）に別のフレームに 移動していたときの不具合を修正する。

    TFrameId frameId;

    // common variables

    TTileSetCM32 *tileSet = nullptr;

    TTileSaverCM32 *tileSaver = nullptr;

    TRect affectedRect;

    SmoothStroke smoothStroke;

    struct Pencil {

      bool isActive = false;

      bool realPencil = false;

    } pencil;

    struct Blured {

      bool isActive = false;

    } blured;

    struct MyPaint {

      bool isActive = false;

      mypaint::Brush baseBrush;

      TRect strokeSegmentRect;

    } myPaint;

    // straight variables

    struct Straight {

      bool isStraight = false;

      TPointD firstPoint;

      TPointD lastPoint;

      double maxPressure = -1.0;

    } straight;

  } m_painting;

  TPropertyGroup m_prop[2];

  TDoublePairProperty m_rasThickness;

  TDoubleProperty m_smooth;

  TDoubleProperty m_hardness;

  TEnumProperty m_preset;

  TEnumProperty m_drawOrder;

  TBoolProperty m_pencil;

  TBoolProperty m_pressure;

  TDoubleProperty m_modifierSize;

  TBoolProperty m_modifierLockAlpha;

  double m_minThick, m_maxThick;

  int m_targetType;

  TPointD m_dpiScale,

      m_mousePos,  //!< Current mouse position, in world coordinates.

      m_brushPos;  //!< World position the brush will be painted at.

  QRadialGradient m_brushPad;

  TRasterCM32P m_backupRas;

  TRaster32P m_workRas;

  TRect m_workBackupRect;

  BrushPresetManager

      m_presetsManager;  //!< Manager for presets of this tool instance

  bool m_enabled,

      m_isPrompting,  //!< Whether the tool is prompting for spline

                      //! substitution.

      m_firstTime, m_presetsLoaded;

  ToonzRasterBrushToolNotifier *m_notifier;

  bool m_isMyPaintStyleSelected    = false;

  QElapsedTimer m_brushTimer;

  int m_minCursorThick, m_maxCursorThick;

  bool m_propertyUpdating = false;

protected:

  static void drawLine(const TPointD &point, const TPointD ¢re,

                       bool horizontal, bool isDecimal);

  static void drawEmptyCircle(TPointD point, int thick, bool isLxEven,

                              bool isLyEven, bool isPencil);

  TPointD getCenteredCursorPos(const TPointD &originalCursorPos);

};

//------------------------------------------------------------

class ToonzRasterBrushToolNotifier final : public QObject {

  Q_OBJECT

  ToonzRasterBrushTool *m_tool;

public:

  ToonzRasterBrushToolNotifier(ToonzRasterBrushTool *tool);

protected slots:

  // void onCanvasSizeChanged() { m_tool->onCanvasSizeChanged(); }

  void onColorStyleChanged() { m_tool->onColorStyleChanged(); }

};

#endif  // TOONZRASTERBRUSHTOOL_H