#pragma once

#ifndef TDOUBLEPARAM_H
#define TDOUBLEPARAM_H

#include <memory>

// TnzCore includes
#include "tgeometry.h"
#include "tfilepath.h"

// TnzBase includes
#include "tparam.h"
#include "tparamchange.h"

// STD includes
#include <set>

#undef DVAPI
#undef DVVAR
#ifdef TPARAM_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 TDoubleParam;
class TDoubleKeyframe;
class TMeasure;
class TExpression;
class TDoubleKeyframe;

namespace TSyntax {
class Grammar;
class CalculatorNodeVisitor;
}

#ifdef _WIN32
template class DVAPI TPersistDeclarationT<TDoubleParam>;
#endif

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

//**************************************************************************
//    TDoubleParam  declaration
//**************************************************************************

class DVAPI TDoubleParam final : public TParam {
  PERSIST_DECLARATION(TDoubleParam)

  class Imp;
  std::unique_ptr<Imp> m_imp;

public:
  TDoubleParam(double v = 0.0);
  TDoubleParam(const TDoubleParam &src);
  ~TDoubleParam();

  TDoubleParam &operator=(const TDoubleParam &);

  TParam *clone() const override { return new TDoubleParam(*this); }
  void copy(TParam *src) override;

  std::string getMeasureName() const;
  void setMeasureName(std::string name);
  TMeasure *getMeasure() const;

  void setValueRange(double min, double max, double step = 1.0);
  bool getValueRange(double &min, double &max, double &step) const;

  double getDefaultValue() const;
  void setDefaultValue(double value);

  double getValue(double frame, bool leftmost = false) const;
  // note: if frame is a keyframe separating two segments of different types
  // (e.g. expression and linear) then getValue(frame,true) can be !=
  // getValue(frame,false)

  bool setValue(double frame, double value);

  // returns the incoming speed vector for keyframe kIndex. kIndex-1 must be
  // speedinout
  // if kIndex is not speedinout and handle are linked then recomputes speed.y
  // taking
  // in account the next segment
  TPointD getSpeedIn(int kIndex) const;

  // returns the outcoming speed vector for keyframe kIndex. kIndex must be
  // speedinout
  TPointD getSpeedOut(int kIndex) const;

  // TPointD getSpeed(double frame);

  // a specific grammar defines expressions as 'peg2.ns' and allows to
  // create a link to the appropriate data source (e.g.
  // the correct stageobject tree)
  const TSyntax::Grammar *getGrammar() const;
  void setGrammar(const TSyntax::Grammar *grammar);  // doesn't get ownership.

  void accept(TSyntax::CalculatorNodeVisitor &visitor);

  //! cycle controls extrapolation after the last keyframe
  void enableCycle(bool enabled);
  bool isCycleEnabled() const;

  int getKeyframeCount() const;
  void getKeyframes(std::set<double> &frames) const override;
  double keyframeIndexToFrame(int index) const override;

  const TDoubleKeyframe &getKeyframe(int index) const;
  const TDoubleKeyframe &getKeyframeAt(double frame) const;

  //! assign k to the kIndex-th keyframe; postcondition: m_frame order is
  //! maintained
  void setKeyframe(int kIndex, const TDoubleKeyframe &k);

  //! call setKeyframe(it.first,it.second) for each it in ks; postcondition:
  //! m_frame order is maintained
  void setKeyframes(const std::map<int, TDoubleKeyframe> &ks);

  //! create a keyframe in k.m_frame (if is needed) and assign k to it
  void setKeyframe(const TDoubleKeyframe &k);

  bool isKeyframe(double frame) const override;
  bool hasKeyframes() const override;
  void deleteKeyframe(double frame) override;
  void clearKeyframes() override;

  int getClosestKeyframe(double frame) const;
  int getNextKeyframe(double frame) const override;
  int getPrevKeyframe(double frame) const override;

  void assignKeyframe(double frame, const TParamP &src, double srcFrame,
                      bool changedOnly) override;

  bool isAnimatable() const override { return true; }

  void addObserver(TParamObserver *observer) override;
  void removeObserver(TParamObserver *observer) override;

  const std::set<TParamObserver *> &observers() const;

  //! no keyframes, default value not changed
  bool isDefault() const;

  void loadData(TIStream &is) override;
  void saveData(TOStream &os) override;
  std::string getStreamTag() const;

  std::string getValueAlias(double frame, int precision) override;
};

DVAPI void splitSpeedInOutSegment(TDoubleKeyframe &k, TDoubleKeyframe &k0,
                                  TDoubleKeyframe &k1);

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

DEFINE_PARAM_SMARTPOINTER(TDoubleParam, double)

#endif  // TDOUBLEPARAM_H