#pragma once

#ifndef TUNIT_INCLUDED
#define TUNIT_INCLUDED

#include "tcommon.h"

#undef DVAPI
#undef DVVAR
#ifdef TNZBASE_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 TUnitConverter
{
public:
	virtual ~TUnitConverter() {}
	virtual TUnitConverter *clone() const = 0;
	virtual double convertTo(double v) const = 0;
	virtual double convertFrom(double v) const = 0;
};

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

class DVAPI TSimpleUnitConverter : public TUnitConverter
{
	const double m_factor, m_offset;

public:
	TSimpleUnitConverter(double factor = 1, double offset = 0)
		: m_factor(factor), m_offset(offset) {}
	TUnitConverter *clone() const { return new TSimpleUnitConverter(*this); }
	double convertTo(double v) const { return v * m_factor + m_offset; }
	double convertFrom(double v) const { return (v - m_offset) / m_factor; }
};

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

class DVAPI TUnit
{
	std::wstring m_defaultExtension;
	std::vector<std::wstring> m_extensions;
	TUnitConverter *m_converter;

public:
	TUnit(std::wstring ext, TUnitConverter *converter = 0);
	TUnit(const TUnit &);
	~TUnit();

	TUnit *clone() const { return new TUnit(*this); }

	const std::vector<std::wstring> &getExtensions() const { return m_extensions; }
	void addExtension(std::wstring ext);
	bool isExtension(std::wstring ext) const;

	std::wstring getDefaultExtension() const { return m_defaultExtension; }
	void setDefaultExtension(std::wstring ext);

	double convertTo(double v) const { return m_converter->convertTo(v); }
	double convertFrom(double v) const { return m_converter->convertFrom(v); }

private:
	// not implemented
	TUnit &operator=(const TUnit &);
};

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

class DVAPI TMeasure
{
	std::string m_name;
	TUnit *m_mainUnit, *m_currentUnit, *m_standardUnit;
	std::map<std::wstring, TUnit *> m_extensions;
	double m_defaultValue;

public:
	TMeasure(std::string name, TUnit *mainUnit);
	TMeasure(const TMeasure &);
	~TMeasure();

	std::string getName() const { return m_name; }
	void setName(std::string name) { m_name = name; }

	void add(TUnit *unit);

	// main unit e' quella usata "internamente". puo' essere "strana"
	const TUnit *getMainUnit() const { return m_mainUnit; }

	// current unit e' quella ad es. definita in preferences
	const TUnit *getCurrentUnit() const { return m_currentUnit; }
	void setCurrentUnit(TUnit *unit);

	// standard unit e' quella usata nelle espressioni
	const TUnit *getStandardUnit() const { return m_standardUnit; }
	void setStandardUnit(TUnit *unit);

	TUnit *getUnit(std::wstring ext) const;

	// defaultValue e' espresso in main unit
	double getDefaultValue() const { return m_defaultValue; }
	void setDefaultValue(double v) { m_defaultValue = v; }

private:
	// not implemented
	TMeasure &operator=(const TMeasure &);
};

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

class DVAPI TMeasureManager
{ // singleton
	std::map<std::string, TMeasure *> m_measures;
	TMeasureManager();

public:
	static TMeasureManager *instance()
	{
		static TMeasureManager _instance;
		return &_instance;
	}

	void add(TMeasure *m);
	TMeasure *get(std::string name) const;

	typedef double CameraSizeProvider();
	void addCameraMeasures(CameraSizeProvider *cameraSizeProvider);
};

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

class DVAPI TMeasuredValue
{
	const TMeasure *m_measure;
	double m_value;

public:
	TMeasuredValue(std::string measureName);
	~TMeasuredValue();

	const TMeasure *getMeasure() const { return m_measure; }
	void setMeasure(const TMeasure *measure);
	void setMeasure(std::string measureName);

	enum UnitType { MainUnit,
					CurrentUnit };

	double getValue(UnitType uType) const
	{
		return uType == MainUnit ? m_value : m_measure->getCurrentUnit()->convertTo(m_value);
	}
	void setValue(UnitType uType, double value)
	{
		m_value = uType == MainUnit ? value : m_measure->getCurrentUnit()->convertFrom(value);
	}

	bool setValue(std::wstring s, int *pErr = 0); // if pErr != then *pErr contains error code. *pErr == 0 means OK
	std::wstring toWideString(int decimals = 7) const;

private:
	// not implemented
	TMeasuredValue(const TMeasuredValue &);
	TMeasuredValue &operator=(const TMeasuredValue &);
};

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

// bruttacchietto. L'aspect ratio della field guide viene usata nelle conversioni
// fra fld e inch sulla verticale

namespace UnitParameters
{

typedef std::pair<double, double> (*CurrentDpiGetter)();

DVAPI void setFieldGuideAspectRatio(double ar);
DVAPI double getFieldGuideAspectRatio();

DVAPI void setCurrentDpiGetter(CurrentDpiGetter f);
}

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

#ifdef _WIN32
#pragma warning(pop)
#endif

#endif