#ifndef TCLI_INCLUDED

#define TCLI_INCLUDED

#include <memory></memory>

//#include "tcommon.h"   contenuto in tconvert.h

#include "tconvert.h"

#include "tfilepath.h"

#undef DVAPI

#undef DVVAR

#ifdef TAPPTOOLS_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

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

//forward declaration

class TFilePath;

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

namespace TCli

{

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

inline bool fromStr(int &value, std::string s)

{

	if (isInt(s)) {

		value = toInt(s);

		return true;

	} else

		return false;

}

inline bool fromStr(double &value, std::string s)

{

	if (isDouble(s)) {

		value = toDouble(s);

		return true;

	} else

		return false;

}

inline bool fromStr(std::string &value, std::string s)

{

	value = s;

	return true;

}

inline bool fromStr(TFilePath &value, std::string s)

{

	value = TFilePath(s);

	return true;

}

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

class UsageError

{

	std::string m_msg;

public:

	UsageError(std::string msg) : m_msg(msg){};

	~UsageError(){};

	std::string getError() const { return m_msg; };

};

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

class DVAPI UsageElement

{

protected:

	std::string m_name, m_help;

	bool m_selected;

public:

	UsageElement(std::string name, std::string help);

	virtual ~UsageElement(){};

	std::string getName() const { return m_name; };

	bool isSelected() const { return m_selected; };

	void select() { m_selected = true; };

	virtual bool isHidden() const { return false; };

	virtual bool isSwitcher() const { return false; };

	virtual bool isArgument() const { return false; };

	virtual bool isMultiArgument() const { return false; };

	void setHelp(std::string help) { m_help = help; };

	virtual void print(std::ostream &out) const;

	virtual void printHelpLine(std::ostream &out) const;

	virtual void dumpValue(std::ostream &out) const = 0;

	virtual void resetValue() = 0;

private:

	// not implemented

	UsageElement(const UsageElement &);

	UsageElement &operator=(const UsageElement &);

};

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

class DVAPI Qualifier : public UsageElement

{

protected:

	bool m_switcher;

public:

	Qualifier(std::string name, std::string help)

		: UsageElement(name, help), m_switcher(false){};

	~Qualifier(){};

	virtual bool isSwitcher() const { return m_switcher; };

	virtual bool isHidden() const { return m_help == ""; };

	operator bool() const { return isSelected(); };

	virtual void fetch(int index, int &argc, char *argv[]) = 0;

	virtual void print(std::ostream &out) const;

};

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

class DVAPI SimpleQualifier : public Qualifier

{

public:

	SimpleQualifier(std::string name, std::string help)

		: Qualifier(name, help){};

	~SimpleQualifier(){};

	void fetch(int index, int &argc, char *argv[]);

	void dumpValue(std::ostream &out) const;

	void resetValue();

};

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

class DVAPI Switcher : public SimpleQualifier

{

public:

	Switcher(std::string name, std::string help)

		: SimpleQualifier(name, help) { m_switcher = true; };

	~Switcher(){};

};

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

template <class t=""></class>

class QualifierT : public Qualifier

{

	T m_value;

public:

	QualifierT<t>(std::string name, std::string help)</t>

		: Qualifier(name, help), m_value(){};

	~QualifierT<t>(){};</t>

	T getValue() const { return m_value; };

	virtual void fetch(int index, int &argc, char *argv[])

	{

		if (index + 1 >= argc)

			throw UsageError("missing argument");

		if (!fromStr(m_value, argv[index + 1]))

			throw UsageError(

				m_name + ": bad argument type /" + std::string(argv[index + 1]) + "/");

		for (int i = index; i < argc - 1; i++)

			argv[i] = argv[i + 2];

		argc -= 2;

	};

	void dumpValue(std::ostream &out) const

	{

		out << m_name << " = " << (isSelected() ? "on" : "off") << " : "

			<< m_value << "\n";

	};

	void resetValue()

	{

		m_value = T();

		m_selected = false;

	};

};

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

class DVAPI Argument : public UsageElement

{

public:

	Argument(std::string name, std::string help)

		: UsageElement(name, help){};

	~Argument(){};

	virtual void fetch(int index, int &argc, char *argv[]);

	virtual bool assign(char *) = 0;

	bool isArgument() const { return true; };

};

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

template <class t=""></class>

class ArgumentT : public Argument

{

	T m_value;

public:

	ArgumentT<t>(std::string name, std::string help) : Argument(name, help){};</t>

	~ArgumentT<t>(){};</t>

	operator T() const { return m_value; };

	T getValue() const { return m_value; };

	bool assign(char *src) { return fromStr(m_value, src); };

	void dumpValue(std::ostream &out) const

	{

		out << m_name << " = " << m_value << "\n";

	};

	void resetValue()

	{

		m_value = T();

		m_selected = false;

	};

};

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

class DVAPI MultiArgument : public Argument

{

protected:

	int m_count, m_index;

public:

	MultiArgument(std::string name, std::string help)

		: Argument(name, help), m_count(0), m_index(0){};

	~MultiArgument(){};

	int getCount() const { return m_count; };

	virtual void fetch(int index, int &argc, char *argv[]);

	bool isMultiArgument() const { return true; };

	virtual void allocate(int count) = 0;

};

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

template <class t=""></class>

class MultiArgumentT : public MultiArgument

{

	std::unique_ptr<t[]> m_values;</t[]>

public:

	MultiArgumentT(std::string name, std::string help)

		: MultiArgument(name, help) {}

	T operator[](int index)

	{

		assert(0 <= index && index < m_count);

		return m_values[index];

	};

	virtual bool assign(char *src)

	{

		assert(0 <= m_index && m_index < m_count);

		return fromStr(m_values[m_index], src);

	};

	void dumpValue(std::ostream &out) const

	{

		out << m_name << " = {";

		for (int i = 0; i < m_count; i++)

			out << " " << m_values[i];

		out << "}" << std::endl;

	};

	void resetValue()

	{

		m_values.reset();

		m_count = m_index = 0;

	};

	void allocate(int count)

	{

		m_values.reset((count > 0) ? new T[count] : nullptr);

		m_count = count;

		m_index = 0;

	};

};

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

typedef UsageElement *UsageElementPtr;

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

class DVAPI UsageLine

{

protected:

	std::unique_ptr<usageelementptr[]> m_elements;</usageelementptr[]>

	int m_count;

public:

	UsageLine();

	virtual ~UsageLine();

	UsageLine(const UsageLine &ul);

	UsageLine &operator=(const UsageLine &ul);

	UsageLine(int count);

	UsageLine(const UsageLine &, UsageElement &elem);

	UsageLine(UsageElement &elem);

	UsageLine(UsageElement &a, UsageElement &b);

	UsageLine operator+(UsageElement &);

	int getCount() const { return m_count; };

	UsageElementPtr &operator[](int index) { return m_elements[index]; };

	const UsageElementPtr &operator[](int index) const { return m_elements[index]; };

};

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

DVAPI UsageLine operator+(UsageElement &a, UsageElement &b);

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

class DVAPI Optional : public UsageLine

{

public:

	Optional(const UsageLine &ul);

	~Optional(){};

};

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

DVAPI UsageLine operator+(const UsageLine &a, const Optional &b);

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

class UsageImp;

class DVAPI Usage

{

	std::unique_ptr<usageimp> m_imp;</usageimp>

public:

	Usage(std::string progName);

	~Usage();

	void add(const UsageLine &);

	void print(std::ostream &out) const;

	void dumpValues(std::ostream &out) const; // per debug

	bool parse(int argc, char *argv[], std::ostream &err = std::cerr);

	bool parse(const char *argvString, std::ostream &err = std::cerr);

	void clear(); // per debug

private:

	//not implemented

	Usage(const Usage &);

	Usage &operator=(const Usage &);

};

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

typedef QualifierT<int> IntQualifier;</int>

typedef QualifierT<double> DoubleQualifier;</double>

typedef QualifierT<std::string> StringQualifier;</std::string>

typedef ArgumentT<int> IntArgument;</int>

typedef ArgumentT<double> DoubleArgument;</double>

typedef ArgumentT<std::string> StringArgument;</std::string>

typedef ArgumentT<tfilepath> FilePathArgument;</tfilepath>

typedef MultiArgumentT<int> IntMultiArgument;</int>

typedef MultiArgumentT<double> DoubleMultiArgument;</double>

typedef MultiArgumentT<std::string> StringMultiArgument;</std::string>

typedef MultiArgumentT<tfilepath> FilePathMultiArgument;</tfilepath>

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

class DVAPI RangeQualifier : public Qualifier

{

	int m_from, m_to;

public:

	RangeQualifier();

	~RangeQualifier(){};

	int getFrom() const { return m_from; };

	int getTo() const { return m_to; };

	bool contains(int frame) const

	{

		return m_from <= frame && frame <= m_to;

	};

	void fetch(int index, int &argc, char *argv[]);

	void dumpValue(std::ostream &out) const;

	void resetValue();

};

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

} // namespace TCli

#endif // TCLI_INCLUDED