#include "ProcessUtilities.h"

#include <sys/wait.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <vector>

class ProcessInfo
{
	public:
		int PID;
		int StdOutput;
		int StdError;
		ProcessController* Master;

		bool cycleStandardOutput();
		bool cycleStandardError();
		void waitForFinish();
};

void ProcessInfo::waitForFinish()
{
	int ret=0;
	waitpid(PID,&ret,0);
	if (WIFEXITED(ret))
	{
		ret = WEXITSTATUS(ret);
		Master->finished(ret);
		for (unsigned int i=0; i<Master->Public.size(); ++i)
			Master->Public[i]->processTerminated(Master,ret);
	}
}

bool ProcessInfo::cycleStandardOutput()
{
	char Buffer[1025];
	int res = read(StdOutput,Buffer,1024);
	if (res < 0)
		std::cout << "Read failed" << std::endl;
	else if (res == 0)
	{
		waitForFinish();
		return true;
	}
	else
		Master->standardOutput(std::string(Buffer,res));
	return false;
}

bool ProcessInfo::cycleStandardError()
{
	char Buffer[1025];
	int res = read(StdError,Buffer,1024);
	if (res < 0)
		std::cout << "Read failed" << std::endl;
	else if (res == 0)
	{
	}
	else
		Master->standardError(std::string(Buffer,res));
	return false;
}


std::vector<ProcessInfo> Processes;

bool launchProcess(ProcessController* theController,
	const std::string& Executable, const std::vector<std::string>& Args)
{
/*	std::cout << "EXEC : " << Executable;
	for (unsigned int i=0; i<Args.size(); ++i)
		std::cout << " {.} " << Args[i];
	std::cout << std::endl; */
	int tubeStandardOutput[2];
	int result = pipe(tubeStandardOutput);
	if (result < 0)
	{
		theController->failed();
		std::cerr << "Failed to create pipe stdout " << errno << std::endl;
		return false;
	}
	int tubeStandardError[2];
	result = pipe(tubeStandardError);
	if (result < 0)
	{
		close(tubeStandardOutput[0]);
		close(tubeStandardOutput[1]);
		theController->failed();
		std::cerr << "Failed to create pipe stderr " << errno << std::endl;
		return false;
	}
	pid_t pid = fork();
	if (pid < 0)
	{
		close(tubeStandardOutput[0]);
		close(tubeStandardOutput[1]);
		close(tubeStandardError[0]);
		close(tubeStandardError[1]);
		theController->failed();
		std::cerr << "Failed to fork" << std::endl;
		return false;
	}
	else if (pid)
	{
		// parent
		close(tubeStandardOutput[1]);
		close(tubeStandardError[1]);
		ProcessInfo PI;
		PI.Master = theController;
		PI.PID = pid;
		PI.StdOutput = tubeStandardOutput[0];
		PI.StdError = tubeStandardError[0];
		Processes.push_back(PI);
		return true;

	}
	else
	{
		// child
		close(tubeStandardOutput[0]);
		close(tubeStandardError[0]);
		int res = dup2(tubeStandardOutput[1],STDOUT_FILENO);
		if (res < 0)
		{
			std::cerr << "Failed to dup2 standard output" << std::endl;
			close(tubeStandardOutput[1]);
			close(tubeStandardError[1]);
			exit(1);	
		}
		res = dup2(tubeStandardError[1],STDERR_FILENO);
		if (res < 0)
		{
			std::cerr << "Failed to dup2 standard error" << std::endl;
			close(tubeStandardOutput[1]);
			close(tubeStandardError[1]);
			exit(1);	
		}
		char** args = (char**)malloc(sizeof(char*)*(Args.size()+2));
		args[0] = (char*)malloc(sizeof(char)*Executable.length()+1);
		strcpy(args[0],Executable.c_str());
		for (unsigned int i=0; i<Args.size(); ++i)
		{
			args[i+1] = (char*)malloc(sizeof(char)*Args[i].length()+1);
			strcpy(args[i+1],Args[i].c_str());
		}
		args[Args.size()+1] = 0;
		int err = execvp(Executable.c_str(),args);
		exit(42);
	};
}

unsigned int waitForProcessEvent()
{
	if (!Processes.size()) return Processes.size();
	int MaxId = 0;
	fd_set ReadSignals;
	FD_ZERO(&ReadSignals);
	for (unsigned int i=0; i<Processes.size(); ++i)
	{
		FD_SET(Processes[i].StdOutput,&ReadSignals);
		if (MaxId < Processes[i].StdOutput)
			MaxId = Processes[i].StdOutput;
		FD_SET(Processes[i].StdError,&ReadSignals);
		if (MaxId < Processes[i].StdError)
			MaxId = Processes[i].StdError;
	}
	timeval tv;
	tv.tv_sec = 1;
	tv.tv_usec = 0;
	int res = select(MaxId+1, &ReadSignals ,NULL,NULL,&tv);
	if (res < 0)
	{
		std::cout << "Select failed" << std::endl;
		return Processes.size();
	}
	for (unsigned int i=Processes.size(); i; --i)
	{
		if (FD_ISSET(Processes[i-1].StdOutput,&ReadSignals))
		{
			if (Processes[i-1].cycleStandardOutput())
			{
				Processes.erase(Processes.begin()+(i-1));
			}
		}
		if (FD_ISSET(Processes[i-1].StdError,&ReadSignals))
		{
			if (Processes[i-1].cycleStandardError())
			{
				Processes.erase(Processes.begin()+(i-1));
			}
		}
	}
	return Processes.size();
}

bool isShellRedirective(const std::string& S)
{
	return (S=="|") || (S=="<") || (S==">");
}

bool shellLaunchProcess(ProcessController* theController,
	const std::string& Executable, const std::vector<std::string>& Args)
{
	unsigned int i=0;
	for (i=0; i<Args.size(); ++i)
		if (isShellRedirective(Args[i]))
			break;
	if (i==Args.size())
		return launchProcess(theController, Executable, Args);
	std::string ShellCommand(Executable);
	for (unsigned int i=0; i<Args.size(); ++i)
	{
		ShellCommand += " ";
		ShellCommand += Args[i];
	}
	std::vector<std::string> NewArgs;
	NewArgs.push_back("-c");
	NewArgs.push_back(ShellCommand);
	return launchProcess(theController, "/bin/sh", NewArgs);
}