#pragma once

#ifndef ASSISTANT_INCLUDED
#define ASSISTANT_INCLUDED

// TnzTools includes
#include <tools/track.h>

// TnzCore includes
#include <tsmartpointer.h>
#include <tgeometry.h>
#include <tmetaimage.h>
#include <tproperty.h>

// Qt includes
#include <QCoreApplication>

// std includes
#include <vector>
#include <string>
#include <map>


#undef DVAPI
#undef DVVAR
#ifdef TNZTOOLS_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif


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

//  Forward declarations

class TProperty;
class TPropertyGroup;

class TToolViewer;
class TAssistant;
class TAssistantPoint;
class TGuideline;

typedef TSmartPointerT<TGuideline> TGuidelineP;
typedef std::vector<TGuidelineP> TGuidelineList;
typedef std::map<TStringId, TAssistantPoint> TAssistantPointMap;
typedef std::vector<const TAssistantPoint*> TAssistantPointOrder;

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


//*****************************************************************************************
//    TGuideline definition
//*****************************************************************************************

class DVAPI TGuideline : public TSmartObject {
public:
  const bool enabled;
  const double magnetism;

  TGuideline(bool enabled, double magnetism):
    enabled(enabled), magnetism(magnetism) { }

  virtual TTrackPoint transformPoint(const TTrackPoint &point) const
    { return point; }
  
  // this function uses in calcTrackWeight to select best guideline,
  // does not use for drawing
  virtual TPointD nearestPoint(const TPointD &point) const
    { return transformPoint(TTrackPoint(point)).position; }
  
  virtual void draw(bool active, bool enabled) const
    { }
  
  void draw(bool active = false) const
    { draw(active, true); }

  TTrackPoint smoothTransformPoint(const TTrackPoint &point, double magnetism = 1.0) const {
    return enabled
         ? TTrack::interpolationLinear(point, transformPoint(point), magnetism*this->magnetism)
         : point;
  }

  void drawSegment(
    const TPointD &p0,
    const TPointD &p1,
    double pixelSize,
    bool active,
    bool enabled = true) const;

  double calcTrackWeight(const TTrack &track, const TAffine &toScreen, bool &outLongEnough) const;
  static TGuidelineP findBest(const TGuidelineList &guidelines, const TTrack &track, const TAffine &toScreen, bool &outLongEnough);
};


//*****************************************************************************************
//    TAssistantPoint definition
//*****************************************************************************************

class DVAPI TAssistantPoint {
public:
  enum Type {
    Circle,
    CircleFill,
    CircleCross,
    CircleDots,
    CircleDoubleDots,
  };

  const TStringId name;
  const TPointD defPosition;

  Type type;
  TPointD position;
  double radius;
  bool visible;

  mutable bool selected;

  explicit TAssistantPoint(const TStringId &name, const TPointD &defPosition = TPointD());
};


//*****************************************************************************************
//    TAssistantType definition
//*****************************************************************************************

class DVAPI TAssistantType: public TMetaObjectType {
public:
  TAssistantType(const TStringId &name):
    TMetaObjectType(name) { }
  TMetaObjectHandler* createHandler(TMetaObject &obj) const override;
  virtual TAssistant* createAssistant(TMetaObject &obj) const
    { return 0; }
};


//*****************************************************************************************
//    TAssistantTypeT definition
//*****************************************************************************************

template<typename T>
class TAssistantTypeT: public TAssistantType {
public:
  typedef T Type;

  explicit TAssistantTypeT(
    const TStringId &name,
    const TStringId &alias1 = TStringId(),
    const TStringId &alias2 = TStringId(),
    const TStringId &alias3 = TStringId(),
    const TStringId &alias4 = TStringId(),
    const TStringId &alias5 = TStringId()
  ):
    TAssistantType(TStringId(name))
  {
    if (alias1) registerAlias(alias1);
    if (alias2) registerAlias(alias2);
    if (alias3) registerAlias(alias3);
    if (alias4) registerAlias(alias4);
    if (alias5) registerAlias(alias5);
  }

  explicit TAssistantTypeT(
    const std::string &name,
    const std::string &alias1 = std::string(),
    const std::string &alias2 = std::string(),
    const std::string &alias3 = std::string(),
    const std::string &alias4 = std::string(),
    const std::string &alias5 = std::string()
  ):
    TAssistantType(TStringId(name))
  {
    if (!alias1.empty()) registerAlias(TStringId(alias1));
    if (!alias2.empty()) registerAlias(TStringId(alias2));
    if (!alias3.empty()) registerAlias(TStringId(alias3));
    if (!alias4.empty()) registerAlias(TStringId(alias4));
    if (!alias5.empty()) registerAlias(TStringId(alias5));
  }

  TAssistant* createAssistant(TMetaObject &obj) const override
    { return new Type(obj); }
  QString getLocalName() const override {
    QString localName = Type::getLocalName();
    return localName.isEmpty() ? QString::fromStdString(name.str()) : localName;
  }
};


//*****************************************************************************************
//    TAssistant definition
//*****************************************************************************************

class DVAPI TAssistant : public TMetaObjectHandler {
  Q_DECLARE_TR_FUNCTIONS(TAssistant)
protected:
  const TStringId m_idEnabled;
  const TStringId m_idPoints;
  const TStringId m_idX;
  const TStringId m_idY;
  const TStringId m_idMagnetism;

  TAssistantPointMap m_points;
  TAssistantPointOrder m_pointsOrder;
  TAssistantPoint* m_basePoint;

  mutable TPropertyGroup m_properties;

public:
  TAssistant(TMetaObject &object);

  static QString getLocalName()
    { return QString(); }

  inline const TAssistantPointMap& points() const
    { return m_points; }
  inline const TAssistantPointOrder& pointsOrder() const
    { return m_pointsOrder; }

  inline const TAssistantPoint* findPoint(const TStringId &name) const {
    TAssistantPointMap::const_iterator i = points().find(name);
    return i == points().end() ? 0 : &i->second;
  }

  void fixPoints();
  bool move(const TPointD &position);
  bool movePoint(const TStringId &name, const TPointD &position);
  void setPointSelection(const TStringId &name, bool selected) const;
  void setAllPointsSelection(bool selected) const;

  bool getEnabled() const
    { return data()[m_idEnabled].getBool(); }
  void setEnabled(bool x)
    { if (getEnabled() != x) data()[m_idEnabled].setBool(x); }

  double getMagnetism() const
    { return data()[m_idMagnetism].getDouble(); }
  void setMagnetism(double x)
    { if (getMagnetism() != x) data()[m_idMagnetism].setDouble(x); }

  inline void selectPoint(const TStringId &name) const
    { setPointSelection(name, true); }
  inline void deselectPoint(const TStringId &name) const
    { setPointSelection(name, false); }
  inline void selectAll() const
    { setAllPointsSelection(true); }
  inline void deselectAll() const
  { setAllPointsSelection(false); }

  TPropertyGroup& getProperties() const
    { return m_properties; }
  void propertyChanged(const TStringId &name)
    { onPropertyChanged(name); }

  const TAssistantPoint& getBasePoint() const;

protected:
  TAssistantPoint& addPoint(
    const TStringId &name,
    TAssistantPoint::Type type,
    const TPointD &defPosition,
    bool visible,
    double radius );

  TAssistantPoint& addPoint(
    const TStringId &name,
    TAssistantPoint::Type type = TAssistantPoint::Circle,
    const TPointD &defPosition = TPointD(),
    bool visible               = true );

  inline TAssistantPoint& addPoint(
    const std::string &name,
    TAssistantPoint::Type type,
    const TPointD &defPosition,
    bool visible,
    double radius )
      { return addPoint(TStringId(name), type, defPosition, visible, radius); }

  inline TAssistantPoint& addPoint(
    const std::string &name,
    TAssistantPoint::Type type = TAssistantPoint::Circle,
    const TPointD &defPosition = TPointD(),
    bool visible               = true )
      { return addPoint(TStringId(name), type, defPosition, visible); }

  //! usually called when meta-object created
  void onSetDefaults() override;
  //! called when part of variant data changed
  void onDataChanged(const TVariant &value) override;
  //! called when field of root struct of variant data changed
  virtual void onDataFieldChanged(const TStringId &name, const TVariant &value);
  //! load object data from variant
  virtual void onAllDataChanged();
  //! fix positions of all points (as like as all points moved)
  virtual void onFixPoints();
  //! try to move point
  virtual void onMovePoint(TAssistantPoint &point, const TPointD &position);
  //! save object data to variant
  virtual void onFixData();
  //! load all properties from variant
  virtual void updateProperties();
  //! load single property from variant
  virtual void updateProperty(const TStringId &name, const TVariant &value);
  //! put value from property to variant
  virtual void onPropertyChanged(const TStringId &name);

  double getDrawingAlpha(bool enabled = true) const;
  double getDrawingGridAlpha() const;

  void drawSegment(const TPointD &p0, const TPointD &p1, double pixelSize, double alpha) const;
  void drawMark(const TPointD &p, const TPointD &normal, double pixelSize, double alpha) const;
  void drawDot(const TPointD &p, double alpha) const;
  void drawPoint(const TAssistantPoint &point, double pixelSize) const;

  inline void drawSegment(const TPointD &p0, const TPointD &p1, double pixelSize) const
    { drawSegment(p0, p1, pixelSize, getDrawingAlpha()); }
  inline void drawDot(const TPointD &p) const
    { drawDot(p, getDrawingAlpha()); }

  void addProperty(TProperty *p);
  void setTranslation(const TStringId &name, const QString &localName) const;

public:
  virtual void updateTranslation() const;
  virtual void getGuidelines(const TPointD &position, const TAffine &toTool, TGuidelineList &outGuidelines) const;
  virtual void draw(TToolViewer *viewer, bool enabled) const;
  void draw(TToolViewer *viewer) const { draw(viewer, true); }
  virtual void drawEdit(TToolViewer *viewer) const;

  static bool calcPerspectiveStep(
    double minStep,
    double minX,
    double maxX,
    double x0,
    double x1,
    double x2,
    double &outK,
    double &outMin,
    double &outMax );
};


//*****************************************************************************************
//    export template implementations for win32
//*****************************************************************************************

#ifdef _WIN32
template class DVAPI TSmartPointerT<TGuideline>;
#endif


#endif