/*
 *  STPipe.cpp
 *
 *  Created by Stilianos Louca on 11/25/08
 *  Last modified on 2011.09.05
 *
 */

#ifndef ST_OUTPIPE_DEF
#define ST_OUTPIPE_DEF
#include "STPipe.h"
using namespace std;

namespace ST{

STPipe::STPipe(){
	fout 		= NULL;
	logStream 	= NULL;
	requirePipe = true;
}

STPipe::STPipe(ostream *_logStream){
	fout 		= NULL;
	logStream 	= _logStream;
	requirePipe = true;
}

STPipe::STPipe(string &command){
	commandUsedToOpenPipe = command+PIPE_APPENDIX;
	fout 		= popen(commandUsedToOpenPipe.c_str(), PIPE_WRITE_MODE);
	logStream 	= NULL;
	requirePipe = true;
}

STPipe::STPipe(string &command, ostream *_logStream){
	logStream = _logStream;
	commandUsedToOpenPipe = command+PIPE_APPENDIX;
	fout = popen(commandUsedToOpenPipe.c_str(), PIPE_WRITE_MODE);
	if((logStream != NULL) && (logStream->good())) (*logStream) << commandUsedToOpenPipe.c_str();
	requirePipe = true;
}


STPipe::STPipe(const string &command, const string &directory){
	ostringstream cmd;
	cmd << "cd " << directory << " && " << command << PIPE_APPENDIX;
	commandUsedToOpenPipe = cmd.str();
	fout = popen(commandUsedToOpenPipe.c_str(), PIPE_WRITE_MODE);
	logStream 	= NULL;
	requirePipe = true;
}

STPipe::STPipe(const string &command, const string &directory, ostream *_logStream){
	ostringstream cmd;
	logStream = _logStream;
	cmd << "cd " << directory << " && " << command << PIPE_APPENDIX;
	commandUsedToOpenPipe = cmd.str();
	fout = popen(commandUsedToOpenPipe.c_str(), PIPE_WRITE_MODE);
	if((logStream != NULL) && (logStream->good())) (*logStream) << commandUsedToOpenPipe;
	requirePipe = true;
}

//copy constructor
STPipe::STPipe(const STPipe &original){
	logStream	= original.logStream;
	requirePipe = original.requirePipe;
	commandUsedToOpenPipe = original.commandUsedToOpenPipe;
	fout		= (original.fout==NULL ? NULL : popen(commandUsedToOpenPipe.c_str(), PIPE_WRITE_MODE));
}

//assignment operator
STPipe &STPipe::operator=(const STPipe &original){
	close();
	logStream	= original.logStream;
	requirePipe = original.requirePipe;
	commandUsedToOpenPipe = original.commandUsedToOpenPipe;
	fout		= (original.fout==NULL ? NULL : popen(commandUsedToOpenPipe.c_str(), PIPE_WRITE_MODE));
	return *this;
}


STPipe::~STPipe(){
	close();
}


void STPipe::setLogStream(ostream *_logStream){
	logStream = _logStream;
}


void STPipe::open(const string &command){
	open(command.c_str());
}

void STPipe::open(const char *command){
	if(fout != NULL){
		pclose(fout);
	}
	commandUsedToOpenPipe = string(command)+PIPE_APPENDIX;
	fout = popen(commandUsedToOpenPipe.c_str(), PIPE_WRITE_MODE);
}

bool STPipe::isOpen() const{
	return (fout!=NULL);
}

void STPipe::close(){
	if(fout != NULL){
		pclose(fout);
		fout = NULL;
	}
}

bool STPipe::pipeIsReady() const{
	if(fout == NULL) return false;
	if(ferror(fout) != 0) { return false; }
	return true;
}


bool STPipe::write(const char *format, ...){
	va_list args;
	va_start(args, format);
	bool result = write(format, args);
	va_end(args);
	return result;
}


bool STPipe::write(const char *format, va_list args){
	//write to log
	va_list logArgumentList;
	va_copy(logArgumentList, args);
	if(logStream != NULL){
		if(logStream->good()){
			vstreamprintf(*logStream, format, logArgumentList);
		}
	}
	va_end(logArgumentList);	
	
	//write to pipe
	if(fout == NULL){
		return (!requirePipe);
	}else{
		bool result=(vfprintf(fout, format, args) >= 0);
		fflush(fout);
		return (result || requirePipe);
	}
}


bool STPipe::write(const string &message){
	//write to log
	if((logStream != NULL) && (logStream->good())) (*logStream) << message;	

	//write to pipe	
	if(fout == NULL){
		return (!requirePipe);
	}else{
		bool result = (fprintf(fout, message.c_str()) >= 0);
		fflush(fout);
		return (result || (!requirePipe));
	}
}

void STPipe::vstreamprintf(ostream &streamOut, const char *format, va_list argumentList){
	va_list temp;
	va_copy(temp, argumentList);
	char *buffer = new char[vsnprintf(NULL, 0, format, temp) + 1];
	va_end(temp);
	
	vsprintf(buffer, format, argumentList);
	streamOut << buffer;
	delete [] buffer;
}


void STPipe::setRequirePipe(bool require){
	requirePipe = require;
}




static inline std::string &rtrim(std::string &haystack){
        haystack.erase(find_if(haystack.rbegin(), haystack.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), haystack.end());
        return haystack;
}



bool getCommandOutput(const string &command, bool suppressErrors, string &output){
	FILE *pipe;
	const int PATH_MAX_LEN = 5096;
	char pathCStr[PATH_MAX_LEN];
	
	
	pipe = popen((command+(suppressErrors ? " 2>/dev/null" : "")).c_str(), "r");
	if (pipe == NULL) return false;
	if(fgets(pathCStr, PATH_MAX_LEN, pipe) == NULL){
		pclose(pipe);
		return false;
	}else if(pclose(pipe) == -1){
		return false;
	}else{
		output = string(pathCStr);
		return true;
	}
}


bool getProgramPath(const string &name, string &path){
	bool OK = getCommandOutput("which "+name, true, path);
	rtrim(path);
	return OK;
}






}//END OF NAMESPACE ST

#endif