#include "Project.h"
#include "FileSystemUtilities.h"
#include "ProcessUtilities.h"
#include "ProjectParser.h"
#include "ToolChain.h"

#include <fstream>
#include <iostream>
#include <sstream>

#include <stdlib.h>

static std::string getNamedString(int argc, char** argv, 
	const std::string& Key, const std::string& Default)
{
	std::string Sign = "--"+Key+"=";
	for (int i=1; i<argc; ++i)
	{
		std::string P(argv[i]);
		if (P.substr(0,Sign.length()) == Sign)
			return P.substr(Sign.length(),P.length()-Sign.length());
	}
	return Default;
}

static bool hasOption(int argc, char** argv, const std::string& Opt)
{
	std::string Sign = "--"+Opt;
	for (int i=1; i<argc; ++i)
	{
		if (Sign == argv[i])
			return true;
	}
	return false;
}

static std::string getArgument(int argc, char** argv, unsigned int idx)
{
	unsigned int Cur = 0;
	for (int i=1; i<argc; ++i)
	{
		std::string P(argv[i]);
		if (P.substr(0,2) != "--")
		{
			if (Cur == idx)
				return P;
			++Cur;
		}
	}
	return "";
}

Project* TheProject = 0;

Project& Project::it()
{
	return *TheProject;
}

Project::Project(int argc, char** argv)
: ProjectFile("Description.cc"), DiscoverMode(false)
{
	ProjectFile = getArgument(argc, argv, 0);
	std::cout << " PROJECTFILE = " << ProjectFile << std::endl;
	std::cout << " PATH PROJECTFILE = " << pathOf(ProjectFile) << std::endl;
	TheProject = this;

	configuration().setBuildDir(".");
	DiscoverMode = hasOption(argc,argv,"discover") || hasOption(argc,argv,"configure");
	readSystemConfiguration(!DiscoverMode);
	configuration().setSourcePath(pathOf(ProjectFile));
	readProjectFile(DiscoverMode);
}

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

void fatalErrorCantCreateBuildDir(const std::string& D)
{
	std::cerr << "Can't create build directory " << D << std::endl << 
		"Specify the correct directory with the --builddir= option" << std::endl <<
		"and make sure it has the appropriate permissions." << std::endl;
	exit(1);
}

void fatalErrorCantReadProjectFile(const std::string& F)
{
	std::cerr << "Can't open project file " << F << std::endl <<
		"Specify the correct project file with the --projectfile= option" << std::endl <<
		"and make sure it has the appropriate permissions." << std::endl;
	exit(1);
}

void Project::readProjectFile(bool DiscoveryMode)
{
	if (!fileExists(ProjectFile))
		fatalErrorCantReadProjectFile(ProjectFile);
	parse(*this,ProjectFile,DiscoveryMode);
}

void Project::run()
{
	configure();
	if (DiscoverMode)
	{
		systemConfiguration().writeTo(pathAppend(configuration().buildDir(),"makefest.cfg"));
		return;
	}
	// setup
	for (unsigned int i=0; i<Executables.size(); ++i)
		Executables[i]->readSystemConfiguration();
	// building
	unsigned int MaxTasks = 2;
	unsigned int TasksRunning = 0;
	bool TaskCreated;
	do
	{
		TaskCreated = false;
		TasksRunning = waitForProcessEvent();
		for (unsigned int i=TasksRunning; i<MaxTasks; ++i)
			TaskCreated = createNextTask() || TaskCreated;
	}
	while (TaskCreated || TasksRunning);
}

ProcessController* Project::createNextTask()
{
	ProcessController* T = 0;
	for (unsigned int i=0; !T && (i<Executables.size()); ++i)
		T = Executables[i]->createNextTask();
	return T;
}

void Project::error(const std::string& Error) const
{
	std::cout << Error << std::endl;
}

void Project::configure()
{
	for (unsigned int i=0; i<Executables.size(); ++i)
		Executables[i]->configure();
}

const SystemConfiguration& Project::systemConfiguration() const
{
	return System;
}

SystemConfiguration& Project::systemConfiguration()
{
	return System;
}

void Project::readSystemConfiguration(bool OnlyFromCache)
{
	if (!createDirectory(configuration().buildDir()))
		fatalErrorCantCreateBuildDir(configuration().buildDir());
	std::string PathName = pathAppend(configuration().buildDir(),"makefest.cfg");
	System.readFrom(PathName);
	if (ProjectFile.empty())
		ProjectFile = System.valueAsString(ProjectFile);
	System.configureKey(true,"projectfile",ProjectFile);
	System.configureComment("General library search paths");

	std::vector<std::string> IncludeSearchDirs(System.valueAsStringList("includesearchdir"));
	System.configureKey("includesearchdir",IncludeSearchDirs);
	for (unsigned int i=0; i<IncludeSearchDirs.size(); ++i)
		configuration().addIncludeSearchPath(IncludeSearchDirs[i]);

	std::vector<std::string> LibrarySearchDirs(System.valueAsStringList("librarysearchdir"));
	System.configureKey("librarysearchdir",LibrarySearchDirs);
	for (unsigned int i=0; i<LibrarySearchDirs.size(); ++i)
		configuration().addLibrarySearchPath(LibrarySearchDirs[i]);

	System.configureLn();
	std::string Default(ToolChain::discover(OnlyFromCache));
	configuration().setToolChain(Default);
}