#include "ClCompiler.h"
#include "CCSource.h"
#include "Component.h"
#include "Executable.h"
#include "FileSystemUtilities.h"
#include "MakeDependencyFile.h"
#include "Project.h"

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

/* CLCOMPILATION */

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

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

	private:
		CCSource& theSource;
		bool MayIgnoreNextEmpty;

		std::string DepList;
};



ClCompilation::ClCompilation(const std::string& CompilerPath, CCSource& aSource)
: theSource(aSource), MayIgnoreNextEmpty(false)
{
	createDirectoryForFile(theSource.objectName());
	createDirectoryForFile(theSource.dependencyName());
	std::vector<std::string> Args;
	if (theSource.configuration().includeDebugInformation())
		Args.push_back("/Zi");
	Args.push_back("/showIncludes");
	Args.push_back("/EHs");
	Args.push_back("/c");
	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(theSource.sourceName());
	Args.push_back("/Fo\""+theSource.objectName()+"\"");
	launchProcess(this,CompilerPath,Args);
	whisper(CompilerPath);
	for (unsigned int i=0; i<Args.size(); ++i)
		whisper(" "+Args[i]);
	whisperLn("");
	std::ostringstream Format;
	Format << "\"" << theSource.objectName() << "\" : \\" << std::endl
		<< "\"" << theSource.sourceName()+"\" \\" << std::endl;
	DepList = Format.str();
}

void ClCompilation::finished(int ret)
{
	LineProcessController::finished(ret);
	if (ret)
	{
		std::ostringstream str;
		str << "Non zero return :  " << ret << std::endl;
		sayLn(str.str());
	}
	yieldFloor();
	theSource.compilationFinished(ret == 0);
	std::ofstream DepFile(theSource.dependencyName().c_str());
	DepFile << DepList;
}

void ClCompilation::standardErrorByLine(const std::string& Out)
{
	// Suppress copyright information
	if (Out.substr(0,13) == "Microsoft (R)")
	{
		MayIgnoreNextEmpty = true;
		return;
	}
	if (Out.substr(0,13) == "Copyright (C)")
	{
		MayIgnoreNextEmpty = true;
		return;
	}
	if (!MayIgnoreNextEmpty || (Out != eolTextSequence()))
		sayLn(Out);
	MayIgnoreNextEmpty = false;
}

void ClCompilation::standardOutputByLine(const std::string& Out)
{
	if (Out.substr(0, 22) == "Note: including file: ")
	{
		std::string::size_type np = Out.find_first_not_of(" ",22);
		if (np != std::string::npos)
		{
			std::ostringstream Format;
			Format << "\"" << Out.substr(np) << "\" \\" << std::endl;
			DepList += Format.str();
		}
	}
	else
		sayLn(Out);
}

void ClCompilation::failed()
{
}

/* GCC4LINKAGE */

class ClLinkage : public LineProcessController, public LoudMouth
{
	public:
		ClLinkage(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:
		Executable& theExecutable;
		bool MayIgnoreNextEmpty;
};


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

void ClLinkage::finished(int ret)
{
	yieldFloor();
}

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

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

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


/* CLTOOLCHAIN */

ClToolChain::ClToolChain(const std::string& Name, const std::string& aCompilerPath, const std::string& aLinkerPath)
: ToolChain(Name), CompilerPath(aCompilerPath), LinkerPath(aLinkerPath)
{
	findType();
}

void ClToolChain::findType()
{
	if (!isValid()) return;
	if (CompilerPath.length())
	{
		std::string StdOut,StdErr;
		int ret = syncExecuteProcess(CompilerPath,std::vector<std::string>(),StdOut,StdErr);
		if (ret)
			StdErr = "";
		std::string::size_type idx = StdErr.find("Compiler Version");
		if (idx == std::string::npos)
			StdErr = "Compiler Version 00", idx = 0;
		StdErr = StdErr.substr(idx+16,3);
		if (StdErr == " 16")
			Type = "msvc2010";
		else if (StdErr == " 15")
			Type = "msvc2008";
		else if (StdErr == " 14")
			Type = "msvc2005";
	}
}

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

bool ClToolChain::isValid() const
{
	return (CompilerPath.length() != 0) || (LinkerPath.length() != 0);
}

std::string ClToolChain::type() const
{
	return Type;
}

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

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

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

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

void ClToolChain::storeToCache() const
{
	SystemConfiguration& Cache(Project::it().systemConfiguration());
	std::string Prefix("toolchain."+name()+".");
	Cache.configureComment("Microsoft Visual C/C++ compiler");
	Cache.configureKey(isValid(),"toolchain."+name()+".type",type());
	if (CompilerPath.length() != 0)
		Project::it().systemConfiguration().configureKey(true,Prefix+"cc_compiler",CompilerPath);
	else
		Project::it().systemConfiguration().configureKey(false,Prefix+"cc_compiler",
			"<full Microsoft Visual C/C++ compiler executable path>");
	if (LinkerPath.length() != 0)
		Project::it().systemConfiguration().configureKey(true,Prefix+"cc_linker",LinkerPath);
	else
		Project::it().systemConfiguration().configureKey(false,Prefix+"cc_linker",
			"<full Microsoft Visual C/C++ linker executable path>");
}

SharedPtr<ToolChain> ClToolChain::discover(const std::string& Name)
{
	std::string ExecutableCompiler = findExecutableInPath("cl.exe");
	std::string ExecutableLinker = findExecutableInPath("link.exe");
	SharedPtr<ToolChain> Result(new ClToolChain(Name,ExecutableCompiler,ExecutableLinker));
	if (Result->type() == Name)
		return Result;
	return new ClToolChain(Name,"","");
}

SharedPtr<ToolChain> ClToolChain::createFromCache(const VariablePtr& Item, const std::string& Name)
{
	std::string ExecutableCompiler(stringValue(childOrVoid(Item,"cc_compiler")));
	if (ExecutableCompiler.length() == 0)
		std::cerr << "warning : toolchain does not contain a compiler" << std::endl;
	std::string ExecutableLinker(stringValue(childOrVoid(Item,"cc_linker")));
	if (ExecutableLinker.length() == 0)
		std::cerr << "warning : toolchain does not contain a linker" << std::endl;
	if ( (ExecutableLinker.length() != 0) || (ExecutableCompiler.length() != 0) )
		return SharedPtr<ToolChain>(new ClToolChain(Name,ExecutableCompiler,ExecutableLinker));
	return SharedPtr<ToolChain>();
}