#include "Configuration.h"
#include "FileSystemUtilities.h"

template<class Type>
Type getValue(ConfigData<Type> Configuration::*Data, const Configuration& Me)
{
	if ( (Me.*Data).isSet() )
		return (Me.*Data).get();
	if (Me.parent())
		return getValue<Type>(Data,*Me.parent());
	return (Me.*Data).get();
}

Configuration::Configuration()
: Parent(0), BuildDir(""), SourcePath(""), IncludeDebug(true), ToolChain("")
{
}

void Configuration::setParent(Configuration* aParent)
{
	Parent = aParent;
}

Configuration* Configuration::parent()
{
	return Parent;
}

const Configuration* Configuration::parent() const
{
	return Parent;
}

void Configuration::setPartName(const std::string& N)
{
	PartName = N;
}

const std::string& Configuration::partName() const
{
	return PartName;
}

void Configuration::setSourcePath(const std::string& S)
{
	SourcePath = S;
}

const std::string Configuration::sourcePath() const
{
	return getValue<std::string>(&Configuration::SourcePath,*this);
}

void Configuration::setBuildDir(const std::string& BD)
{
	BuildDir = BD;
}

const std::string Configuration::buildDir() const
{
	std::string SoFar;
	const Configuration* Current = this;
	while (Current)
	{
		if (Current->BuildDir.isSet())
			return pathAppend(Current->BuildDir.get(),SoFar);
		SoFar = pathAppend(SoFar,Current->PartName);
		Current = Current->parent();
	}
	return SoFar;
}

bool Configuration::includeDebugInformation() const
{
	return getValue<bool>(&Configuration::IncludeDebug,*this);
}

void Configuration::setIncludeDebugInformation(bool b)
{
	IncludeDebug = b;
}

void Configuration::setToolChain(const std::string& TC)
{
	ToolChain = TC;
}

const std::string Configuration::toolChain() const
{
	return getValue<std::string>(&Configuration::ToolChain,*this);
}

unsigned int additiveSize(std::vector<std::string> Configuration::*Data, const Configuration& Me)
{
	if (!Me.parent())
		return (Me.*Data).size();
	return (Me.*Data).size()+additiveSize(Data,*Me.parent());
}

std::string additiveGetValue(std::vector<std::string> Configuration::*Data, 
	const Configuration& Me, unsigned int idx)
{
	if (idx < (Me.*Data).size())
		return (Me.*Data)[idx];
	return additiveGetValue(Data, *Me.parent(), idx-(Me.*Data).size());
}

void additiveAdd(std::vector<std::string> Configuration::* Data,
	Configuration& Me, const std::string& Value)
{
	for (unsigned int i=0; i<additiveSize(Data,Me); ++i)
		if (Value == additiveGetValue(Data,Me,i))
			return;
	(Me.*Data).push_back(Value);
}

void Configuration::addIncludeDirectory(const std::string& D)
{
	additiveAdd(&Configuration::IncludeDirectories, *this, D);
}

unsigned int Configuration::includeDirectories() const
{
	return additiveSize(&Configuration::IncludeDirectories, *this);
}

std::string Configuration::includeDirectory(unsigned int i) const
{
	return additiveGetValue(&Configuration::IncludeDirectories, *this, i);
}

void Configuration::addLibraryDirectory(const std::string& D)
{
	additiveAdd(&Configuration::LibraryDirectories, *this, D);
}

unsigned int Configuration::libraryDirectories() const
{
	return additiveSize(&Configuration::LibraryDirectories, *this);
}

std::string Configuration::libraryDirectory(unsigned int i) const
{
	return additiveGetValue(&Configuration::LibraryDirectories, *this, i);
}

void Configuration::addLibrary(const std::string& D)
{
	additiveAdd(&Configuration::Libraries, *this, D);
}

unsigned int Configuration::libraries() const
{
	return additiveSize(&Configuration::Libraries, *this);
}

std::string Configuration::library(unsigned int i) const
{
	return additiveGetValue(&Configuration::Libraries, *this, i);
}

void Configuration::addDefine(const std::string& D)
{
	additiveAdd(&Configuration::Defines, *this, D);
}

unsigned int Configuration::defines() const
{
	return additiveSize(&Configuration::Defines, *this);
}

std::string Configuration::define(unsigned int i) const
{
	return additiveGetValue(&Configuration::Defines, *this, i);
}

void Configuration::addIncludeSearchPath(const std::string& D)
{
	additiveAdd(&Configuration::IncludeSearchPaths, *this, D);
}

unsigned int Configuration::includeSearchPaths() const
{
	return additiveSize(&Configuration::IncludeSearchPaths, *this);
}

std::string Configuration::includeSearchPath(unsigned int i) const
{
	return additiveGetValue(&Configuration::IncludeSearchPaths, *this, i);
}

void Configuration::addLibrarySearchPath(const std::string& D)
{
	additiveAdd(&Configuration::LibrarySearchPaths, *this, D);
}

unsigned int Configuration::librarySearchPaths() const
{
	return additiveSize(&Configuration::LibrarySearchPaths, *this);
}

std::string Configuration::librarySearchPath(unsigned int i) const
{
	return additiveGetValue(&Configuration::LibrarySearchPaths, *this, i);
}

/* CONFIGURABLE */

Configuration& Configurable::configuration()
{
	return Config;
}

const Configuration& Configurable::configuration() const
{
	return Config;
}