#include "Executable.h"
#include "Component.h"
#include "FileSystemUtilities.h"
#include "Gcc4Compiler.h"
#include "ClCompiler.h"
#include "MakeDependencyFile.h"
#include "Project.h"
#include "ToolChain.h"

Executable::Executable(const std::string& aName)
: Name(aName), ExecutableName(aName), Linked(false), DiscoveryChecked(false), FullyDiscovered(false)
{
	configuration().setPartName(Name);
}

Executable::~Executable()
{
}

void Executable::add(SharedPtr<Component> aComponent)
{
	UsedLibs.push_back(aComponent);
}

bool Executable::isFullyDiscovered()
{
	if (DiscoveryChecked)
		return FullyDiscovered;
	DiscoveryChecked = false;
	FullyDiscovered = true;
	for (unsigned int i=0; i<UsedLibs.size(); ++i)
	{
		SharedPtr<ConfiguredComponent> CC(UsedLibs[i]->configuredFor(*this));
		if (CC.isNull())
		{
			FullyDiscovered = false;
			continue;
		}
		for (unsigned int j=0; j<CC->includeDirectories().size(); ++j)
			configuration().addIncludeDirectory(CC->includeDirectories()[j]);
		for (unsigned int j=0; j<CC->linkDirectories().size(); ++j)
			configuration().addLibraryDirectory(CC->linkDirectories()[j]);
		for (unsigned int j=0; j<CC->linkParts().size(); ++j)
			configuration().addLibrary(CC->linkParts()[j]);
	}
	return FullyDiscovered;
}

void Executable::setExecutableName(const std::string& N)
{
	ExecutableName = N;
}

const std::string& Executable::executableName() const
{
	return ExecutableName;
}

unsigned int Executable::ccSources() const
{
	return CCFiles.size();
}

SharedPtr<CCSource> Executable::getCcSource(unsigned int i)
{
	return CCFiles[i];
}

const std::string& Executable::name() const
{
	return Name;
}

void Executable::setName(const std::string& aName)
{
	Name = aName;
	configuration().setPartName(Name);
}

void Executable::setFromParentConfiguration(const Configuration& Parent)
{
}

Executable& Executable::add(const SharedPtr<CCSource> aFile)
{
	CCFiles.push_back(aFile);
	CCFiles[CCFiles.size()-1]->configuration().setParent(&(this->configuration()));
	return *this;
}


ProcessController* Executable::createNextTask()
{
	if (!isFullyDiscovered()) return 0;
	if (Linked) return 0;
	bool AllCompiled = true;
	for (unsigned int i=0; i<CCFiles.size(); ++i)
	{
		if (ProcessController* NextTask = CCFiles[i]->createNextTask())
			return NextTask;
		if (!CCFiles[i]->objectFileIsCorrect())
			AllCompiled = false;
	}
	if (AllCompiled)
	{
		Linked = true;
		SharedPtr<ToolChain> Current(ToolChain::createByName(configuration().toolChain()));
		Current->initResultNames(*this);
		return Current->createLinking(*this);
	}
	return 0;
}

void Executable::configure()
{
	// now start discovery
	SharedPtr<ToolChain> Tools(ToolChain::createByName(configuration().toolChain()));
	if (Tools.isNull())	// TODO print error message?
		return;
	isFullyDiscovered();
	Project::it().systemConfiguration().configureComment("Configuration for executable "+Name);
	Project::it().systemConfiguration().configureLn();
/*	// first setup up my previous configuration
	std::vector<std::string> Paths(
		Project::it().systemConfiguration().valueAsStringList(Name+".includesearchpaths"));
	for (unsigned int i=0; i<Paths.size(); ++i)
		configuration().addIncludeSearchPath(Paths[i]);
	Paths = Project::it().systemConfiguration().valueAsStringList("default.includesearchpaths");
	for (unsigned int i=0; i<Paths.size(); ++i)
		configuration().addIncludeSearchPath(Paths[i]); */
}

void Executable::readSystemConfiguration()
{
}

unsigned int Executable::components() const
{
	return UsedLibs.size();
}

SharedPtr<Component> Executable::getComponent(unsigned int i)
{
	return UsedLibs[i];
}