#include "Gcc4Compiler.h"
#include "CCSource.h"
#include "Component.h"
#include "Executable.h"
#include "FileSystemUtilities.h"
#include "MakeDependencyFile.h"
#include "Project.h"
#include "SystemConfiguration.h"

#include <iostream>
#include <sstream>

class Gcc4Compilation : public ProcessController, public LoudMouth
{
	public:
		Gcc4Compilation(const std::string& CompilerPath, CCSource& aSource);

		virtual void finished(int ret);
		virtual void standardOutput(const std::string& aString);
		virtual void standardError(const std::string& aString);
		virtual void failed();
	private:
		Gcc4Compilation& operator=(const Gcc4Compilation&) { return *this; }
		CCSource& theSource;
};


Gcc4Compilation::Gcc4Compilation(const std::string& CompilerPath, CCSource& aSource)
: theSource(aSource)
{
	std::vector<std::string> Args;
	if (theSource.configuration().includeDebugInformation())
		Args.push_back("-g");
	for (unsigned int i=0; i<theSource.configuration().defines(); ++i)
		Args.push_back("-D"+theSource.configuration().define(i));
	for (unsigned int i=0; i<theSource.configuration().includeDirectories(); ++i)
		Args.push_back("-I"+theSource.configuration().includeDirectory(i));
	Args.push_back("-MMD");
	Args.push_back("-MF");
	Args.push_back(theSource.dependencyName());
	Args.push_back("-c");
	Args.push_back(theSource.sourceName());
	Args.push_back("-o");
	Args.push_back(theSource.objectName());
	createDirectoryForFile(theSource.objectName());
	createDirectoryForFile(theSource.dependencyName());
	launchProcess(this,CompilerPath,Args);
	whisper("g++ ");
	for (unsigned int i=0; i<Args.size(); ++i)
		whisper(Args[i]+" ");
	whisper("\n");
}

void Gcc4Compilation::finished(int ret)
{
	if (ret)
	{
		std::ostringstream str;
		str << "Non zero return :  " << ret << std::endl;
		say(str.str());
	}
	yieldFloor();
	theSource.compilationFinished(ret == 0);
}

void Gcc4Compilation::standardError(const std::string& Out)
{
	say(Out);
}

void Gcc4Compilation::standardOutput(const std::string& Out)
{
	say(Out);
}

void Gcc4Compilation::failed()
{
	std::cout << "failed" << std::endl;
}



/* GCC4LINKAGE */

class Gcc4Linkage : public LineProcessController, public LoudMouth
{
	public:
		Gcc4Linkage(const std::string& LinkerPath, Executable& anExec);

		virtual void finished(int ret);
		virtual void standardOutputByLine(const std::string& aString);
		virtual void standardErrorByLine(const std::string& aString);
		virtual void failed();

	private:
		Gcc4Linkage& operator=(const Gcc4Linkage&) { return *this; }
		Executable& theExecutable;
		bool MayIgnoreNextEmpty;
};


Gcc4Linkage::Gcc4Linkage(const std::string& LinkerPath, Executable& anExec)
: theExecutable(anExec)
{
	std::vector<std::string> Args;
	for (unsigned int i=0; i<theExecutable.configuration().libraryDirectories(); ++i)
		Args.push_back("-L"+theExecutable.configuration().libraryDirectory(i));
	for (unsigned int i=0; i<theExecutable.ccSources(); ++i)
		Args.push_back(theExecutable.getCcSource(i)->objectName());
	for (unsigned int i=0; i<theExecutable.configuration().libraries(); ++i)
		Args.push_back("-l"+theExecutable.configuration().library(i));
	Args.push_back("-o");
	Args.push_back(theExecutable.executableName());
	launchProcess(this,LinkerPath,Args);
	whisper(LinkerPath);
	for (unsigned int i=0; i<Args.size(); ++i)
		whisper(" "+Args[i]);
	whisper("\n");
}

void Gcc4Linkage::finished(int)
{
	yieldFloor();
}

void Gcc4Linkage::standardErrorByLine(const std::string& Out)
{
	sayLn(Out);
}

void Gcc4Linkage::standardOutputByLine(const std::string& Out)
{
	sayLn(Out);
}

void Gcc4Linkage::failed()
{
	std::cout << "failed" << std::endl;
}


/* GCC4TOOLCHAIN */

Gcc4ToolChain::Gcc4ToolChain(const std::string& Name, bool anIsMingW, const std::string& aPath)
: ToolChain(Name), IsMingW(anIsMingW), Path(aPath)
{
}

std::string Gcc4ToolChain::staticLibraryName(const std::string& Stem) const
{
	return "lib"+Stem+".a";
}

bool Gcc4ToolChain::isValid() const
{
	return Path.length() != 0;
}

std::string Gcc4ToolChain::type() const
{
	return IsMingW?"mingw":"gcc4";
}

void Gcc4ToolChain::initResultNames(CCSource& theSource) const
{
	theSource.setObjectName(pathAppend(
			theSource.configuration().buildDir(),
			theSource.name()+".o"));
	theSource.setDependencyName(pathAppend(
			theSource.configuration().buildDir(),
			theSource.name()+".d"));
}

ProcessController* Gcc4ToolChain::createCompilation(CCSource& aSource)
{
	MakeDependencyFile mf(aSource.dependencyName());
	if (!mf.upToDate())
		return new Gcc4Compilation(Path, aSource);
	else
	{
		aSource.compilationFinished(true);
		return 0;
	}
}

void Gcc4ToolChain::initResultNames(Executable& theExec) const
{
	if (IsMingW)
		theExec.setExecutableName(pathAppend(
				theExec.configuration().buildDir(),
				theExec.name()+".exe"));
	else
		theExec.setExecutableName(pathAppend(
				theExec.configuration().buildDir(),	theExec.name()));
}

ProcessController* Gcc4ToolChain::createLinking(Executable& aExec)
{
	for (unsigned int i=0; i<aExec.ccSources(); ++i)
		if (fileIsNewer(aExec.getCcSource(i)->objectName(),aExec.executableName()))
			return new Gcc4Linkage(Path, aExec);
	return 0;
}

void Gcc4ToolChain::storeToCache() const
{
	SystemConfiguration& Cache(Project::it().systemConfiguration());
	std::string Prefix("toolchain."+name()+".");
	Cache.configureComment("GNU Compiler Collection 4");
	Cache.configureKey(isValid(),"toolchain."+name()+".type",IsMingW?"mingw":"gcc4");
	if (Path.length() != 0)
		Project::it().systemConfiguration().configureKey(true,Prefix+"cc_compiler",Path);
	else
		Project::it().systemConfiguration().configureKey(false,Prefix+"cc_compiler",
			"<full gcc4 executable path>");
}

static bool discoverCcFromProcessName(bool LookForMingW, const std::string& ProcessName)
{
	if (!ProcessName.length())
		return false;
	std::string StdOut, StdErr;
	std::vector<std::string> Args;
	Args.push_back("-v");
	int r = syncExecuteProcess(ProcessName,Args,StdOut,StdErr);
	if (r)
		return false;
	bool IsMingW = (StdErr.find("--target=mingw32") != std::string::npos)
		|| (StdErr.find("Target: mingw32") != std::string::npos);
	if (IsMingW != LookForMingW)
		return false;
	return true;
}

SharedPtr<ToolChain> Gcc4ToolChain::discoverMingW(const std::string& Name)
{
	std::string CompilerProcessName(findExecutableInPath("g++.exe", "c:\\MinGW\\bin\\"));
	if (!discoverCcFromProcessName(true, CompilerProcessName))
		CompilerProcessName = ""; 
	return SharedPtr<ToolChain>(new Gcc4ToolChain(Name,true,CompilerProcessName));
}

SharedPtr<ToolChain> Gcc4ToolChain::discoverRegular(const std::string& Name)
{
	std::string CompilerProcessName(findExecutableInPath("g++"));
	if (!discoverCcFromProcessName(false, CompilerProcessName))
		CompilerProcessName = ""; 
	return SharedPtr<ToolChain>(new Gcc4ToolChain(Name,false,CompilerProcessName));
}

SharedPtr<ToolChain> Gcc4ToolChain::createFromCache(const VariablePtr& Item, const std::string& Name)
{
	std::string Type(stringValue(childOrVoid(Item,"type")));
	bool IsMingW;
	if (Type == "mingw")
		IsMingW = true;
	else if (Type == "gcc4")
		IsMingW = false;
	else
		return SharedPtr<ToolChain>();
	std::string ExecutableCompiler(stringValue(childOrVoid(Item,"cc_compiler")));
	if ( ExecutableCompiler.length() != 0)
		return SharedPtr<ToolChain>(new Gcc4ToolChain(Name,IsMingW,ExecutableCompiler));
	return SharedPtr<ToolChain>();
}