#include "rgbpickertool.h"

#include "tvectorimage.h"
#include "ttoonzimage.h"
#include "tools/cursors.h"
#include "tcolorstyles.h"
#include "toonz/cleanupcolorstyles.h"
#include "trasterimage.h"
#include "tgl.h"
#include "tenv.h"
#include "tstroke.h"

#include "toonz/palettecontroller.h"
#include "toonz/tpalettehandle.h"
#include "toonz/tscenehandle.h"
#include "toonz/txshlevelhandle.h"
#include "toonz/stage2.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/preferences.h"

#include "toonzqt/icongenerator.h"
#include "toonzqt/dvdialog.h"
#include "toonzqt/lutcalibrator.h"

#include "tools/toolhandle.h"
#include "tools/stylepicker.h"
#include "tools/toolutils.h"
#include "tools/RGBpicker.h"

#define NORMAL_PICK L"Normal"
#define RECT_PICK L"Rectangular"
#define FREEHAND_PICK L"Freehand"
#define POLYLINE_PICK L"Polyline"

TEnv::StringVar PickVectorType("InknpaintPickVectorType", "Normal");
TEnv::IntVar PickPassive("InknpaintPickPassive", 0);

namespace RGBPicker {

//============================================================
// Pick RGB Tool
//------------------------------------------------------------

class UndoPickRGBM final : public TUndo {
  TPaletteP m_palette;
  int m_styleId;
  int m_styleParamIndex;
  TPixel32 m_oldValue, m_newValue;
  TXshSimpleLevelP m_level;
  bool m_colorAutoApplyEnabled;

public:
  UndoPickRGBM(TPalette *palette, int styleId, const TPixel32 newValue,
               const TXshSimpleLevelP &level)
      : m_palette(palette)
      , m_styleId(styleId)
      , m_newValue(newValue)
      , m_level(level)
      , m_colorAutoApplyEnabled(true) {
    PaletteController *controller =
        TTool::getApplication()->getPaletteController();
    m_colorAutoApplyEnabled = controller->isColorAutoApplyEnabled();
    m_styleParamIndex = controller->getCurrentPalette()->getStyleParamIndex();
    if (m_colorAutoApplyEnabled) {
      TColorStyle *cs = m_palette->getStyle(m_styleId);
      if (0 <= m_styleParamIndex &&
          m_styleParamIndex < cs->getColorParamCount())
        m_oldValue = cs->getColorParamValue(m_styleParamIndex);
      else
        m_oldValue = cs->getMainColor();
    } else {
      m_oldValue = controller->getColorSample();
    }
  }

  void setColor(const TPixel32 &color) const {
    PaletteController *controller =
        TTool::getApplication()->getPaletteController();
    if (m_colorAutoApplyEnabled) {
      TColorStyle *cs = m_palette->getStyle(m_styleId);
      if (0 <= m_styleParamIndex &&
          m_styleParamIndex < cs->getColorParamCount())
        cs->setColorParamValue(m_styleParamIndex, color);
      else
        cs->setMainColor(color);
      cs->invalidateIcon();
      controller->getCurrentPalette()->notifyColorStyleChanged();
      updateLevel();
    } else {
      controller->setColorSample(color);
    }
    TTool::Application *app = TTool::getApplication();
    TXshSimpleLevel *level  = app->getCurrentLevel()->getSimpleLevel();
    if (level) {
      std::vector<TFrameId> fids;
      level->getFids(fids);
      invalidateIcons(level, fids);
    }
  }

  void undo() const override { setColor(m_oldValue); }

  void redo() const override { setColor(m_newValue); }

  int getSize() const override { return sizeof(*this); }

  QString getHistoryString() override {
    return QObject::tr("RGB Picker (R%1, G%2, B%3)")
        .arg(QString::number((int)m_newValue.r))
        .arg(QString::number((int)m_newValue.g))
        .arg(QString::number((int)m_newValue.b));
  }

private:
  void updateLevel() const {
    std::vector<TFrameId> fids;
    if (!m_level) return;
    m_level->getFids(fids);
    unsigned int i;
    for (i = 0; i < fids.size(); i++)
      IconGenerator::instance()->invalidate(m_level.getPointer(), fids[i]);
    IconGenerator::instance()->invalidateSceneIcon();
    TTool::getApplication()->getCurrentScene()->notifySceneChanged();
  }
};

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

void setCurrentColor(const TPixel32 &color) {
  PaletteController *controller =
      TTool::getApplication()->getPaletteController();
  TPaletteHandle *ph = controller->getCurrentPalette();

  TColorStyle *cs = ph->getStyle();
  if (!cs) return;

  if (controller->isColorAutoApplyEnabled()) {
    TCleanupStyle *ccs = dynamic_cast<TCleanupStyle *>(cs);
    if (ccs) ccs->setCanUpdate(true);

    int index = ph->getStyleParamIndex();
    if (0 <= index && index < cs->getColorParamCount())
      cs->setColorParamValue(index, color);
    else
      cs->setMainColor(color);

    cs->invalidateIcon();
    ph->notifyColorStyleChanged(false);

    // per le palette animate
    int styleIndex    = ph->getStyleIndex();
    TPalette *palette = ph->getPalette();
    if (palette && palette->isKeyframe(styleIndex, palette->getFrame()))
      palette->setKeyframe(styleIndex, palette->getFrame());

    if (ccs) ccs->setCanUpdate(false);
  } else
    controller->setColorSample(color);
}

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

void setCurrentColorWithUndo(const TPixel32 &color) {
  TTool::Application *app = TTool::getApplication();
  TPaletteHandle *ph      = app->getPaletteController()->getCurrentPalette();
  int styleId             = ph->getStyleIndex();
  TPalette *palette       = ph->getPalette();
  TXshSimpleLevel *level  = app->getCurrentLevel()->getSimpleLevel();
  if (palette)
    TUndoManager::manager()->add(
        new UndoPickRGBM(palette, styleId, color, level));

  setCurrentColor(color);

  if (level) {
    std::vector<TFrameId> fids;
    level->getFids(fids);
    invalidateIcons(level, fids);
  }
}

}  // namespace RGBPicker

using namespace RGBPicker;

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

RGBPickerTool::RGBPickerTool()
    : TTool("T_RGBPicker")
    , m_currentStyleId(0)
    , m_pickType("Type:")
    , m_drawingTrack()
    , m_workingTrack()
    , m_firstDrawingPos()
    , m_firstWorkingPos()
    , m_mousePosition()
    , m_thick(0.5)
    , m_stroke(0)
    , m_firstStroke(0)
    , m_makePick(false)
    , m_firstTime(true)
    , m_passivePick("Passive Pick", false)
    , m_toolOptionsBox(0)
    , m_mousePixelPosition() {
  bind(TTool::CommonLevels);
  m_prop.bind(m_pickType);
  m_pickType.addValue(NORMAL_PICK);
  m_pickType.addValue(RECT_PICK);
  m_pickType.addValue(FREEHAND_PICK);
  m_pickType.addValue(POLYLINE_PICK);
  m_pickType.setId("Type");

  m_prop.bind(m_passivePick);
  m_passivePick.setId("PassivePick");
}

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

void RGBPickerTool::setToolOptionsBox(RGBPickerToolOptionsBox *toolOptionsBox) {
  m_toolOptionsBox.push_back(toolOptionsBox);
}

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

void RGBPickerTool::updateTranslation() {
  m_pickType.setQStringName(tr("Type:"));
  m_pickType.setItemUIName(NORMAL_PICK, tr("Normal"));
  m_pickType.setItemUIName(RECT_PICK, tr("Rectangular"));
  m_pickType.setItemUIName(FREEHAND_PICK, tr("Freehand"));
  m_pickType.setItemUIName(POLYLINE_PICK, tr("Polyline"));

  m_passivePick.setQStringName(tr("Passive Pick"));
}

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

// Used to notify and set the currentColor outside the draw() methods:
// using special style there was a conflict between the draw() methods of the
// tool
// and the generation of the icon inside the style editor (makeIcon()) which use
// another glContext

void RGBPickerTool::onImageChanged() {
  TTool::Application *app = TTool::getApplication();
  TXshSimpleLevel *level  = app->getCurrentLevel()->getSimpleLevel();
  if (m_currentStyleId != 0 && m_makePick &&
      (m_pickType.getValue() == POLYLINE_PICK ||
       m_pickType.getValue() == RECT_PICK)) {
    TPaletteHandle *ph = app->getPaletteController()->getCurrentPalette();
    int styleId        = ph->getStyleIndex();
    TPalette *palette  = ph->getPalette();
    if (palette)
      TUndoManager::manager()->add(
          new UndoPickRGBM(palette, styleId, m_currentValue, level));
  }
  if (m_makePick) {
    setCurrentColor(m_currentValue);
    if (level) {
      std::vector<TFrameId> fids;
      level->getFids(fids);
      invalidateIcons(level, fids);
    }
  }
  m_makePick = false;
}

void RGBPickerTool::draw() {
  double pixelSize2 = getPixelSize() * getPixelSize();
  m_thick           = sqrt(pixelSize2) / 2.0;
  if (m_makePick) {
    if (m_currentStyleId != 0) {
      // Il pick in modalita' polyline e rectangular deve essere fatto soltanto
      // dopo aver cancellato il
      //"disegno" della polyline altrimenti alcuni pixels neri delle spezzate
      // che la
      // compongono vengono presi in considerazione nel calcolo del "colore
      // medio"
      if (m_pickType.getValue() == POLYLINE_PICK && m_drawingPolyline.empty())
        doPolylineFreehandPick();
      else if (m_pickType.getValue() == RECT_PICK && m_drawingRect.isEmpty())
        pickRect();
      else if (m_pickType.getValue() == NORMAL_PICK)
        pick();
      else if (m_pickType.getValue() == FREEHAND_PICK && m_stroke)
        doPolylineFreehandPick();
    }
    return;
  }
  if (m_passivePick.getValue() == true) {
    passivePick();
  }
  if (m_pickType.getValue() == RECT_PICK && !m_makePick) {
    TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg
                       ? TPixel32::White
                       : TPixel32::Red;
    ToolUtils::drawRect(m_drawingRect, color, 0x3F33, true);
  } else if (m_pickType.getValue() == POLYLINE_PICK &&
             !m_drawingPolyline.empty()) {
    TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg
                       ? TPixel32::White
                       : TPixel32::Black;
    tglColor(color);
    tglDrawCircle(m_drawingPolyline[0], 2);
    glBegin(GL_LINE_STRIP);
    for (UINT i = 0; i < m_drawingPolyline.size(); i++)
      tglVertex(m_drawingPolyline[i]);
    tglVertex(m_mousePosition);
    glEnd();
  } else if (m_pickType.getValue() == FREEHAND_PICK &&
             !m_drawingTrack.isEmpty()) {
    TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg
                       ? TPixel32::White
                       : TPixel32::Black;
    tglColor(color);
    m_drawingTrack.drawAllFragments();
  }
}

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

void RGBPickerTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e) {
  TTool::Application *app   = TTool::getApplication();
  TPaletteHandle *pltHandle = app->getPaletteController()->getCurrentPalette();
  m_currentStyleId          = pltHandle->getStyleIndex();
  if (m_currentStyleId == 0) return;

  TColorStyle *colorStyle = pltHandle->getStyle();

  if (colorStyle) m_oldValue = colorStyle->getMainColor();

  if (m_pickType.getValue() == RECT_PICK) {
    m_selectingRect.x0 = e.m_pos.x;
    m_selectingRect.y0 = e.m_pos.y;
    m_selectingRect.x1 = e.m_pos.x;
    m_selectingRect.y1 = e.m_pos.y;
    m_drawingRect.x0   = pos.x;
    m_drawingRect.y0   = pos.y;
    m_drawingRect.x1   = pos.x;
    m_drawingRect.y1   = pos.y;
    invalidate();
    return;
  } else if (m_pickType.getValue() == FREEHAND_PICK) {
    startFreehand(pos, e.m_pos);
    return;
  } else if (m_pickType.getValue() == POLYLINE_PICK) {
    addPointPolyline(pos, e.m_pos);
    return;
  } else {  // NORMAL_PICK
    m_mousePixelPosition = e.m_pos;
    m_makePick           = true;
    invalidate();
  }
}

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

void RGBPickerTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e) {
  if (m_currentStyleId == 0) return;
  if (m_pickType.getValue() == RECT_PICK) {
    m_selectingRect.x1 = e.m_pos.x;
    m_selectingRect.y1 = e.m_pos.y;
    m_drawingRect.x1   = pos.x;
    m_drawingRect.y1   = pos.y;
    invalidate();
    return;
  } else if (m_pickType.getValue() == FREEHAND_PICK) {
    freehandDrag(pos, e.m_pos);
    invalidate();
  }
}

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

void RGBPickerTool::leftButtonUp(const TPointD &pos, const TMouseEvent &) {
  if (m_currentStyleId == 0) return;
  if (m_pickType.getValue() == RECT_PICK) {
    m_makePick = true;
    m_drawingRect.empty();
  }
  if (m_pickType.getValue() == FREEHAND_PICK) {
    closeFreehand();
    m_makePick = true;
  }
  invalidate();
}

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

void RGBPickerTool::leftButtonDoubleClick(const TPointD &pos,
                                          const TMouseEvent &e) {
  if (m_currentStyleId == 0) return;
  if (m_pickType.getValue() == POLYLINE_PICK) {
    closePolyline(pos, e.m_pos);
    std::vector<TThickPoint> strokePoints;
    for (UINT i = 0; i < m_workingPolyline.size() - 1; i++) {
      strokePoints.push_back(TThickPoint(m_workingPolyline[i], 1));
      strokePoints.push_back(TThickPoint(
          0.5 * (m_workingPolyline[i] + m_workingPolyline[i + 1]), 1));
    }
    strokePoints.push_back(TThickPoint(m_workingPolyline.back(), 1));
    m_drawingPolyline.clear();
    m_workingPolyline.clear();
    m_stroke   = new TStroke(strokePoints);
    m_makePick = true;
    invalidate();
  }
}

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

void RGBPickerTool::mouseMove(const TPointD &pos, const TMouseEvent &e) {
  /*--- Pick color passively and display in the tool option bar ---*/
  if (m_passivePick.getValue() == true) {
    m_mousePixelPosition = e.m_pos;
    invalidate();
  }
  if (m_pickType.getValue() == POLYLINE_PICK && !m_drawingPolyline.empty()) {
    m_mousePosition = pos;
    invalidate();
  }
}

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

void RGBPickerTool::passivePick() {
  TImageP image = TImageP(getImage(false));
  if (!image) return;
  TRectD area = TRectD(m_mousePixelPosition.x, m_mousePixelPosition.y,
                       m_mousePixelPosition.x, m_mousePixelPosition.y);

  StylePicker picker(getViewer()->viewerWidget(), image);

  if (LutManager::instance()->isValid()) m_viewer->bindFBO();

  TPixel32 pix = picker.pickColor(area);

  if (LutManager::instance()->isValid()) m_viewer->releaseFBO();

  QColor col((int)pix.r, (int)pix.g, (int)pix.b);

  PaletteController *controller =
      TTool::getApplication()->getPaletteController();
  controller->notifyColorPassivePicked(col);
}

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

void RGBPickerTool::pick() {
  TImageP image = TImageP(getImage(false));

  TTool::Application *app = TTool::getApplication();
  TPaletteHandle *ph      = app->getPaletteController()->getCurrentPalette();
  int styleId             = ph->getStyleIndex();
  TPalette *palette       = ph->getPalette();
  if (!palette) return;

  TRectD area = TRectD(m_mousePixelPosition.x - 1, m_mousePixelPosition.y - 1,
                       m_mousePixelPosition.x + 1, m_mousePixelPosition.y + 1);
  StylePicker picker(getViewer()->viewerWidget(), image, palette);

  if (LutManager::instance()->isValid()) m_viewer->bindFBO();

  m_currentValue = picker.pickColor(area);

  if (LutManager::instance()->isValid()) m_viewer->releaseFBO();

  TXshSimpleLevel *level = app->getCurrentLevel()->getSimpleLevel();
  UndoPickRGBM *cmd = new UndoPickRGBM(palette, styleId, m_currentValue, level);
  TUndoManager::manager()->add(cmd);
}
//---------------------------------------------------------

void RGBPickerTool::pickRect() {
  TImageP image = TImageP(getImage(false));

  TTool::Application *app = TTool::getApplication();
  TPaletteHandle *ph      = app->getPaletteController()->getCurrentPalette();
  int styleId             = ph->getStyleIndex();
  TPalette *palette       = ph->getPalette();
  TRectD area             = m_selectingRect;
  if (!palette) return;
  if (m_selectingRect.x0 > m_selectingRect.x1) {
    area.x1 = m_selectingRect.x0;
    area.x0 = m_selectingRect.x1;
  }
  if (m_selectingRect.y0 > m_selectingRect.y1) {
    area.y1 = m_selectingRect.y0;
    area.y0 = m_selectingRect.y1;
  }
  m_selectingRect.empty();
  if (area.getLx() <= 1 || area.getLy() <= 1) return;
  StylePicker picker(getViewer()->viewerWidget(), image, palette);

  if (LutManager::instance()->isValid()) m_viewer->bindFBO();

  m_currentValue = picker.pickColor(area);

  if (LutManager::instance()->isValid()) m_viewer->releaseFBO();
}

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

void RGBPickerTool::pickStroke() {
  TImageP image = TImageP(getImage(false));

  TTool::Application *app = TTool::getApplication();
  TPaletteHandle *ph      = app->getPaletteController()->getCurrentPalette();
  int styleId             = ph->getStyleIndex();
  TPalette *palette       = ph->getPalette();
  if (!palette) return;

  StylePicker picker(getViewer()->viewerWidget(), image, palette);
  TStroke *stroke = new TStroke(*m_stroke);

  if (LutManager::instance()->isValid()) m_viewer->bindFBO();

  m_currentValue = picker.pickColor(stroke);

  if (LutManager::instance()->isValid()) m_viewer->releaseFBO();

  if (!(m_pickType.getValue() == POLYLINE_PICK)) {
    TXshSimpleLevel *level = app->getCurrentLevel()->getSimpleLevel();
    TUndoManager::manager()->add(
        new UndoPickRGBM(palette, styleId, m_currentValue, level));
  }
}

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

bool RGBPickerTool::onPropertyChanged(std::string propertyName) {
  if (propertyName == m_pickType.getName())
    PickVectorType = ::to_string(m_pickType.getValue());
  else if (propertyName == m_passivePick.getName())
    PickPassive = m_passivePick.getValue();
  return true;
}

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

void RGBPickerTool::onActivate() {
  if (m_firstTime) {
    m_pickType.setValue(::to_wstring(PickVectorType.getValue()));
    m_passivePick.setValue(PickPassive ? 1 : 0);
    m_firstTime = false;
  }
}

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

TPropertyGroup *RGBPickerTool::getProperties(int targetType) { return &m_prop; }

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

int RGBPickerTool::getCursorId() const {
  int currentStyleId = getApplication()
                           ->getPaletteController()
                           ->getCurrentPalette()
                           ->getStyleIndex();
  if (currentStyleId == 0) return ToolCursor::ForbiddenCursor;
  if (ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg)
    return ToolCursor::PickerRGBWhite;
  else
    return ToolCursor::PickerRGB;
}

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

void RGBPickerTool::doPolylineFreehandPick() {
  if (m_stroke && (m_pickType.getValue() == POLYLINE_PICK ||
                   m_pickType.getValue() == FREEHAND_PICK)) {
    pickStroke();
    delete m_stroke;
    m_stroke = 0;
  }
}

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

//! Viene aggiunto \b pos a \b m_track e disegnato il primo pezzetto del lazzo.
//! Viene inizializzato \b m_firstPos
void RGBPickerTool::startFreehand(const TPointD &drawingPos,
                                  const TPointD &workingPos) {
  m_drawingTrack.clear();
  m_workingTrack.clear();
  m_firstDrawingPos = drawingPos;
  m_firstWorkingPos = workingPos;
  double pixelSize2 = getPixelSize() * getPixelSize();
  m_drawingTrack.add(TThickPoint(drawingPos, m_thick), pixelSize2);
  m_workingTrack.add(TThickPoint(workingPos, m_thick), pixelSize2);
#if defined(MACOSX)
// m_viewer->prepareForegroundDrawing();
#endif
}

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

//! Viene aggiunto \b pos a \b m_track e disegnato un altro pezzetto del lazzo.
void RGBPickerTool::freehandDrag(const TPointD &drawingPos,
                                 const TPointD &workingPos) {
#if defined(MACOSX)
// getViewer()->enableRedraw(false);
#endif

  double pixelSize2 = getPixelSize() * getPixelSize();
  m_drawingTrack.add(TThickPoint(drawingPos, m_thick), pixelSize2);
  m_workingTrack.add(TThickPoint(workingPos, m_thick), pixelSize2);
}

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

//! Viene chiuso il lazzo (si aggiunge l'ultimo punto ad m_track) e viene creato
//! lo stroke rappresentante il lazzo.
void RGBPickerTool::closeFreehand() {
#if defined(MACOSX)
// getViewer()->enableRedraw(true);
#endif
  if (m_drawingTrack.isEmpty() || m_workingTrack.isEmpty()) return;
  double pixelSize2 = getPixelSize() * getPixelSize();
  m_drawingTrack.add(TThickPoint(m_firstDrawingPos, m_thick), pixelSize2);
  m_workingTrack.add(TThickPoint(m_firstWorkingPos, m_thick), pixelSize2);
  m_workingTrack.filterPoints();
  double error = (30.0 / 11) * sqrt(pixelSize2);
  m_stroke     = m_workingTrack.makeStroke(error);
  m_stroke->setStyle(1);

  m_drawingTrack.clear();
  m_workingTrack.clear();
}

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

//! Viene aggiunto un punto al vettore m_polyline.
void RGBPickerTool::addPointPolyline(const TPointD &drawingPos,
                                     const TPointD &workingPos) {
  m_mousePosition = drawingPos;
  /*---drawingPosは中心からの座標 workingPosは画面左下からの座標---*/
  m_drawingPolyline.push_back(drawingPos);
  m_workingPolyline.push_back(workingPos);
}

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

//! Agginge l'ultimo pos a \b m_polyline e chiude la spezzata (aggiunge \b
//! m_polyline.front() alla fine del vettore)
void RGBPickerTool::closePolyline(const TPointD &drawingPos,
                                  const TPointD &workingPos) {
  if (m_drawingPolyline.size() <= 1 || m_workingPolyline.size() <= 1) return;
  if (m_drawingPolyline.back() != drawingPos)
    m_drawingPolyline.push_back(drawingPos);
  if (m_workingPolyline.back() != workingPos)
    m_workingPolyline.push_back(workingPos);
  if (m_drawingPolyline.back() != m_drawingPolyline.front())
    m_drawingPolyline.push_back(m_drawingPolyline.front());
  if (m_workingPolyline.back() != m_workingPolyline.front())
    m_workingPolyline.push_back(m_workingPolyline.front());
}

//---------------------------------------------------------
/*! Flipbook上でPassive Pickを有効にする
 */
void RGBPickerTool::showFlipPickedColor(const TPixel32 &pix) {
  if (m_passivePick.getValue()) {
    QColor col((int)pix.r, (int)pix.g, (int)pix.b);
    PaletteController *controller =
        TTool::getApplication()->getPaletteController();
    controller->notifyColorPassivePicked(col);
  }
}

RGBPickerTool RGBpicktool;

// TTool *getPickRGBMTool() {return &pickRBGMTool;}