#include	"Reflection.h"
#include	"TypesWrapper.h"
#include	"Transformation.h"
#include	"TransformHelper.h"
#include	"Conversion.h"
#include	"ConversionHelper.h"

void	IReflection::Update(void* object)
{
	for (int i = 0; i < ObjectsNumber(); i++)
	{
		if (object == objects_ptr_[i].value())
		{
			ITransform*
			transform	= TransformHelper::Instance()->Get(objects_ptr_[i].type());
			if (transform)
			{
				transform->UpdateField(this,objects_ptr_[i]);
			}
		}
	}
}

void	IReflection::Exchange(
		IReflection* reflection, void* object)
{
	for (int i = 0; i < ObjectsNumber(); i++)
	{
		for (int j = 0; j < reflection->ObjectsNumber(); j++)
		{
			if (object == reflection->objects_ptr_[j].value())
			{
				if (objects_ptr_[i].type() == reflection->objects_ptr_[j].type()
				&&	objects_ptr_[i].name() == reflection->objects_ptr_[j].name())
				{
					ITransform*
					transform	= TransformHelper::Instance()->Get(objects_ptr_[i].type());
					if (transform)
					{
						transform->ExchangeTemp(this,reflection->Value(j),objects_ptr_[i]);
					}
				}
			}
		}
	}
}

void	IReflection::Exchange(
		IReflection* reflection)
{
	for (int i = 0; i < ObjectsNumber(); i++)
	{
		for (int j = 0; j < reflection->ObjectsNumber(); j++)
		{
			if (objects_ptr_[i].type() == reflection->objects_ptr_[j].type()
			&&	objects_ptr_[i].name() == reflection->objects_ptr_[j].name())
			{
				ITransform*
				transform	= TransformHelper::Instance()->Get(objects_ptr_[i].type());
				if (transform)
				{
					transform->ExchangeTemp(this,reflection->Value(j),objects_ptr_[i]);
				}
			}
		}
	}
}

bool	ExchangeManager::Distribution(IReflection* reflected, void* object)
{
	bool	result	= false
	;
	reflected->Update(object)
	;
	for (int i = 0; i < ObjectsNumber(); i++)
	{
		if (reflection_objects_[i] != reflected)
		{
			reflection_objects_[i]->Exchange(reflected,object);
		}
	}
	return	result;
}

bool	ExchangeManager::Initiation(IReflection* reflected)
{
	bool	result	= false;
	for (int i = 0; i < ObjectsNumber(); i++)
	{
		if (reflection_objects_[i] != reflected)
		{
			reflected->Exchange(reflection_objects_[i]);
			break;
		}
	}
	return	result;
}

template<typename T>
void	UpdateField(IReflection* theThis, object_ptr& objectPtr)
{
	T* inp_		= reinterpret_cast<T*>(objectPtr.value());
	if (objectPtr.call())
	  (*objectPtr.call())(objectPtr,theThis)
	;
}

template<typename T>
void	ExchangeTemp (IReflection* theThis, void* value, object_ptr& objectPtr)
{
	T* inp_	= reinterpret_cast<T*>(value);
	T* out_	= reinterpret_cast<T*>(objectPtr.value());
	*(out_)	= *(inp_)
	;
	if (objectPtr.call())
	  (*objectPtr.call())(objectPtr,theThis)
	;
}

TransformBase<Int>			transformInt;
TransformBase<Bool>			transformBool;
TransformBase<Long>			transformLong;
TransformBase<Double>		transformDouble;
TransformBase<String>		transformString;

ConversionBase<Int>			conversionInt;
ConversionBase<Bool>		conversionBool;
ConversionBase<Long>		conversionLong;
ConversionBase<Double>		conversionDouble;
ConversionBase<String>		conversionString;