#pragma once
#include <string>

#include <string>
#include <memory>
#include "DIOS.Dev.MouldDefine.hpp"

namespace DIOS
{
namespace Dev
{
namespace COLLIMATOR
{
	class  ICollimatorControl
	{
	public:
		virtual ~ICollimatorControl() = default;

		virtual int  SetCollimatorSize(unsigned short xsize, unsigned short ysize);
		virtual int  SetCollimatorSID(unsigned short sid);
		virtual int  SetCollimatorFilter(unsigned short pParams);
		virtual int  SetCollimatorAngle(unsigned short pParams);
		virtual int  SetCollimatorMode(unsigned short pParams);
	};
	//-----------------------------------------------------------------------------
	//		CollimatorUnit
	//-----------------------------------------------------------------------------
	class XSIZEMould;
	class YSIZEMould;
	class FILTERMould;
	class SIDMould;
	class ANGLEMould;
	class MODEMould;
	class  CollimatorUnit
	{
		ICollimatorControl* m_pCollimatorDevice;

	public:
		CollimatorUnit(ICollimatorControl* pCollimatorDevice);
		virtual ~CollimatorUnit();
		int  SetCollimatorSize(std::string in, std::string & out);

		int  SetCollimatorSID(std::string in, std::string & out);

		int  SetCollimatorFilter(std::string in, std::string & out);

		int  SetCollimatorAngle(std::string in, std::string & out);

		int  SetCollimatorMode(std::string in, std::string & out);

		int SetTechParamsInfo(std::string in, std::string & out);
	public:
		std::unique_ptr<XSIZEMould> m_XSize;
		std::unique_ptr<YSIZEMould> m_YSize;
		std::unique_ptr<FILTERMould> m_Filter;
		std::unique_ptr<SIDMould> m_SID;
		std::unique_ptr<ANGLEMould> m_Angle;
		std::unique_ptr<MODEMould> m_Mode;
	};

	//-----------------------------------------------------------------------------
	//		CollimatorMould
	//-----------------------------------------------------------------------------
	namespace AttrKey
	{
		static const char* XSIZE = "XSize";
		static const char* YSIZE = "YSize";
		static const char* FILTER = "Filter";
		static const char* SID = "SID";
		static const char* ANGLE = "Angle";
		static const char* MODE = "Mode";
	}
	namespace MOD = DIOS::Dev::Mould;

	class XSIZEMould :public MOD::IntMould
	{
		using super = MOD::IntMould;
	public:
		XSIZEMould(MOD::INofity* pNotify, int initialvalue, int upper, int lower, float accuracy)
			:super(pNotify, AttrKey::XSIZE, "mm", initialvalue, upper, lower, accuracy)
		{}
		~XSIZEMould(){}
	};
	
	class YSIZEMould :public MOD::IntMould
	{
		using super = MOD::IntMould;
	public:
		YSIZEMould(MOD::INofity* pNotify, int initialvalue, int upper, int lower, float accuracy)
			:super(pNotify, AttrKey::YSIZE, "mm", initialvalue, upper, lower, accuracy)
		{}
		~YSIZEMould(){}
	};

	class FILTERMould :public MOD::IntMould
	{
		using super = MOD::IntMould;
	public:
		FILTERMould(MOD::INofity* pNotify, int initialvalue, int upper, int lower, float accuracy)
			:super(pNotify, AttrKey::FILTER, "", initialvalue, upper, lower, accuracy)
		{}
		~FILTERMould(){}
	};

	class SIDMould :public MOD::IntMould
	{
		using super = MOD::IntMould;
	public:
		SIDMould(MOD::INofity* pNotify, int initialvalue, int upper, int lower, float accuracy)
			:super(pNotify, AttrKey::SID, "mm", initialvalue, upper, lower, accuracy)
		{}
		~SIDMould(){}
	};

	class ANGLEMould :public MOD::IntMould
	{
		using super = MOD::IntMould;
	public:
		ANGLEMould(MOD::INofity* pNotify, int initialvalue, int upper, int lower, float accuracy)
			:super(pNotify, AttrKey::ANGLE, "", initialvalue, upper, lower, accuracy)
		{}
		~ANGLEMould(){}
	};

	class MODEMould :public MOD::IntMould
	{
		using super = MOD::IntMould;
	public:
		MODEMould(MOD::INofity* pNotify, int initialvalue, int upper, int lower, float accuracy)
			:super(pNotify, AttrKey::MODE, "", initialvalue, upper, lower, accuracy)
		{}
		~MODEMould(){}
	};
}
}
}