#pragma once

#ifndef TNZ_TEXTFIELD_INCLUDED
#define TNZ_TEXTFIELD_INCLUDED

#include "tw/tw.h"
#include "tw/textlistener.h"

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

#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4251)
#endif

class DVAPI TTextField : public TWidget, public TTextListener {
public:
  class Action {
  public:
    virtual ~Action() {}
    virtual void sendCommand(std::wstring) = 0;
  };

  class Listener {
  public:
    virtual void onKeyPressed(int key){};
    virtual void onFocusChange(bool on){};
    virtual ~Listener() {}
  };

protected:
  std::wstring m_text, m_oldText;
  int m_pos;
  int m_sel0, m_sel1;
  int m_off;
  bool m_mouseDown;
  int xToIndex(int x);

  std::vector<Action *> m_actions;
  std::vector<Action *> m_commitActions;
  Listener *m_listener;

  void updateOffset();

public:
  TTextField(TWidget *parent, std::string name = "textfield");
  ~TTextField();

  virtual void commit() {}

  void draw();
  void keyDown(int, TUINT32, const TPoint &);
  void onDrop(std::wstring s);

  void leftButtonDoubleClick(const TMouseEvent &e);

  void leftButtonDown(const TMouseEvent &e);
  void leftButtonDrag(const TMouseEvent &e);
  void leftButtonUp(const TMouseEvent &e);

  std::wstring getText() const;
  void setText(std::wstring s);
  void setText(std::string s);
  // NON invoca l'azione registrata

  void select(int s0, int s1);
  void selectAll();

  void addAction(Action *action);
  void addCommitAction(Action *action);
  void setListener(Listener *listener);

  void onFocusChange(bool status);
  FocusHandling getFocusHandling() const { return LISTEN_TO_FOCUS; }

  virtual void pasteText(std::wstring text);
  virtual std::wstring copyText();
  virtual std::wstring cutText();

  virtual void drawFieldText(const TPoint &origin, std::wstring text);

#ifndef MACOSX
  // pezza dovuta al baco del gcc3.3.1. Togliere quando lo si aggiorna al 3.3.2
  // o superiori
  bool getCaret(TPoint &p, int &height);
#endif

  // toppa per aggiustare una bruttura grafica in Tab.
  // va ripensata tutta la logica del posizionamento del
  // testo
  int m_dy;

  virtual void sendCommand();
  virtual void sendCommitCommand();
};

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

template <class T>
class TTextFieldAction : public TTextField::Action {
  typedef void (T::*Method)(std::wstring text);
  T *m_target;
  Method m_method;

public:
  TTextFieldAction(T *target, Method method)
      : m_target(target), m_method(method) {}
  void sendCommand(std::wstring s) { (m_target->*m_method)(s); }
};

template <class T>
void tconnect(TTextField *fld, T *target, void (T::*method)(std::wstring s)) {
  fld->addCommitAction(new TTextFieldAction<T>(target, method));
}

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

class DVAPI TNumField : public TTextField {
public:
  class Event {
  public:
    TNumField *m_field;
    double m_value;
    enum Reason { KeyPressed, FocusChange, ReturnPressed };
    Reason m_reason;
    Event(TNumField *field)
        : m_field(field), m_value(field->getValue()), m_reason(KeyPressed) {}
  };

  class Action {
  public:
    virtual ~Action() {}
    virtual void sendCommand(const Event &ev) = 0;
  };

private:
  double m_minValue, m_maxValue;
  std::vector<Action *> m_numActions;
  bool m_isInteger;
  int m_precision;

protected:
  double m_value;
  virtual void valueToText();
  virtual void textToValue();

  void sendCommand();

public:
  TNumField(TWidget *parent, std::string name = "numfield");
  ~TNumField();

  void keyDown(int, TUINT32, const TPoint &);

  bool getIsInteger() const { return m_isInteger; }
  void setIsInteger(bool isInteger);

  void setRange(double minValue, double maxValue);
  void getRange(double &minValue, double &maxValue);

  void setPrecision(int precision) { m_precision = precision; }
  int getPrecision() { return m_precision; }

  double getValue() const { return m_value; }
  void setValue(double value);
  // NON invoca l'azione registrata

  void addAction(Action *action);

  void onFocusChange(bool status);
  void pasteText(std::wstring text);
};

template <class T>
class TNumFieldAction : public TNumField::Action {
  T *m_target;
  typedef void (T::*Method)(const TNumField::Event &e);
  Method m_method;

public:
  TNumFieldAction(T *target, Method method)
      : m_target(target), m_method(method) {}
  void sendCommand(const TNumField::Event &e) { (m_target->*m_method)(e); }
};

template <class T>
void tconnect(TNumField *nf, T *target,
              void (T::*method)(const TNumField::Event &e)) {
  nf->addAction(new TNumFieldAction<T>(target, method));
}

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

class TMeasuredValue;

class DVAPI TMeasuredValueField : public TTextField {
public:
  class Action {
  public:
    virtual ~Action() {}
    virtual void sendCommand(TMeasuredValueField *field) = 0;
  };

private:
  TMeasuredValue *m_value;
  std::vector<Action *> m_actions;

public:
  TMeasuredValueField(TWidget *parent, std::string name = "numfield");
  ~TMeasuredValueField();

  void setMeasure(std::string name);

  TMeasuredValue *getMeasuredValue() const { return m_value; }

  void setValue(double v);
  double getValue() const;

  void addAction(Action *action);

  // void onFocusChange(bool status);
  // void pasteText(wstring text);

  void commit();
};

template <class T>
class TMeasuredValueFieldAction : public TMeasuredValueField::Action {
  typedef void (T::*Method)(TMeasuredValueField *fld);
  T *m_target;
  Method m_method;

public:
  TMeasuredValueFieldAction(T *target, Method method)
      : m_target(target), m_method(method) {}
  void sendCommand(TMeasuredValueField *fld) { (m_target->*m_method)(fld); }
};

template <class T>
void tconnect(TMeasuredValueField *fld, T *target,
              void (T::*method)(TMeasuredValueField *fld)) {
  fld->addAction(new TMeasuredValueFieldAction<T>(target, method));
}

#ifdef WIN32
#pragma warning(pop)
#endif

#endif