#pragma once

#ifndef TDOUBLEPARAM_H

#define TDOUBLEPARAM_H

#include <memory></memory>

// TnzCore includes

#include "tgeometry.h"

#include "tfilepath.h"

// TnzBase includes

#include "tparam.h"

#include "tparamchange.h"

// STD includes

#include <set></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>;</tdoubleparam>

#endif

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

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

//    TDoubleParam  declaration

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

class DVAPI TDoubleParam final : public TParam {

  PERSIST_DECLARATION(TDoubleParam)

  class Imp;

  std::unique_ptr<imp> m_imp;</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>

  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);</int,>

  //! 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;</tparamobserver>

  //! 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