/* $Id$ */

#include <presetHandler.hpp>
#define NUMPRESET_COLUMNS 10 //all columns of preset plus one extra for run status flag

string presetHeadings[NUMPRESET_COLUMNS] =  {"SECTION", "TYPE", "HARDWARE", "OS", "LICENSE",
							"SHELL", "FLAG", "SHORTNAME", "COMMAND" };

void presetHandler::loadPresetFile(CLIHandler * cHandle, outputHandler* oHandle)
{
	commonOutputHandle = oHandle;
	cliHandle = cHandle;
	string presetFileLocation = cliHandle->getPresetFileName();
	if(presetFileLocation == "")
	{
		presetFileLocation = "default preset";
		loadDefaultPreset(cliHandle);
	}
	else
	{
		loadUserDefinedPreset(presetFileLocation);
	}
	string log = "Loading preset information from " + presetFileLocation;
	commonOutputHandle->writeDataToLogFile("INFO", log);

	//update for include and exclude command
	updateForCLIOptions();
	logPresetDetails();
}
void presetHandler::loadDefaultPreset(CLIHandler *clihandle)
{
	perfstatPreset* preset = new perfstatPreset(clihandle);
	vector<string> vecPreset = (*preset).getPerfstatPreset();
	for(int i=0; i<(int)vecPreset.size(); i++)
	{
		createDataStructure(vecPreset[i]);
	}
	//print preset file
	commonOutputHandle->createPerfstatPreset(vecPreset);
	delete preset;
}
void presetHandler::loadUserDefinedPreset(string presetFileLocation)
{
	ifstream presetFile;
	string eachLine;
	vector<string> vecPreset;
	presetFile.open (presetFileLocation.c_str());
	if (presetFile.is_open())
	{
		while (!presetFile.eof())
		{
			getline (presetFile,eachLine);
			createDataStructure(eachLine);
			vecPreset.push_back(eachLine);
		}
		presetFile.close();
		//print preset file
		commonOutputHandle->createPerfstatPreset(vecPreset);
	}
	else
	{
		commonOutputHandle->writeDataToLogFile("ERROR", "Preset file not found. Exiting");
		commonOutputHandle->writeDataToLogFile("ERROR", "Please run \"perfstat8.exe -h\" for details on options.");
		exit(0);
	}
}
void presetHandler::createDataStructure(string eachLine)
{
	if(eachLine != "" && eachLine.length() != 0 && eachLine.at(0) != '#' )
	{
		presetMetaData metaData = tokenizeString(eachLine);
		vecPresetStats.push_back(metaData);

		//disbale all the flags by default
		string pflag = metaData.getFlag();
		if(!pflag.empty() && pflag.find("!")== string::npos)
		{
			updatePresetStats("FLAG", pflag, "false");
		}

	}
}

void presetHandler::logPresetDetails()
{
	string totalCmd = "Total commands are : ";
	totalCmd.append(boost::lexical_cast<std::string>((int)vecPresetStats.size()));
	commonOutputHandle->writeDataToLogFile("INFO", totalCmd);

	totalCmd = "Total PRESTATS commands are : ";
	vector<presetMetaData>outputPrestats = getAllPrestatsCommands();
	totalCmd.append(boost::lexical_cast<std::string>((int)outputPrestats.size()));
	commonOutputHandle->writeDataToLogFile("INFO", totalCmd);

	totalCmd = "Total POSTSTATS commands are : ";
	outputPrestats = getAllPoststatsCommands();
	totalCmd.append(boost::lexical_cast<std::string>((int)outputPrestats.size()));
	commonOutputHandle->writeDataToLogFile("INFO", totalCmd);

	totalCmd = "Total PARALLEL commands are : ";
	outputPrestats = getAllParallelCommands();
	totalCmd.append(boost::lexical_cast<std::string>((int)outputPrestats.size()));
	commonOutputHandle->writeDataToLogFile("INFO", totalCmd);

	totalCmd = "Total PARALLEL_PRESTATS commands are : ";
	outputPrestats = getAllParallelPrestatsCommands();
	totalCmd.append(boost::lexical_cast<std::string>((int)outputPrestats.size()));
	commonOutputHandle->writeDataToLogFile("INFO", totalCmd);

	totalCmd = "Total PARALLEL_POSTSTATS commands are : ";
	outputPrestats = getAllParallelPoststatsCommands();
	totalCmd.append(boost::lexical_cast<std::string>((int)outputPrestats.size()));
	commonOutputHandle->writeDataToLogFile("INFO", totalCmd);

}
void presetHandler::updateForCLIOptions()
{
	map<string, vector<string> > includeCmds = cliHandle->getIncludeCommands();
	map<string, vector<string> > excludeCmds = cliHandle->getExcludeCommands();
	vector<string> enableFlag = cliHandle->getEnableFlagCommands();

	map<string, vector<string> >::iterator iter;
	vector<presetMetaData>outputPrestats;
	vector<presetMetaData>outputPoststats;
	vector<presetMetaData>outputParallel;

	if((int)includeCmds.size() ==0 && (int)excludeCmds.size() ==0 && (int)enableFlag.size() == 0)
	{
		return;
	}
	if((int)enableFlag.size() !=0)
	{
		for(int i=0; i<(int)enableFlag.size(); i++)
		{
			updatePresetStats("FLAG", enableFlag[i], "true");
			string flagtmp = "!";
			flagtmp.append(enableFlag[i]);
			updatePresetStats("FLAG", flagtmp, "false");
		}
	}

	if((int)includeCmds.size() !=0)
	{
		string runStat = "true";
		vector<presetMetaData>vecPresetStatsTmp;
		//for include option lets revert all the commands to "false"
		for(int i=0; i<(int)vecPresetStats.size(); i++)
		{
			presetMetaData metaData = vecPresetStats[i];
			metaData.setCmdRunStatus("false");
			vecPresetStatsTmp.push_back(metaData);
		}
		vecPresetStats = vecPresetStatsTmp;
		for(iter=includeCmds.begin();iter!=includeCmds.end();iter++ )
		{
			string key=(*iter).first;
			vector<string> value = ((*iter).second);

			for(int i=0; i<(int)value.size();i++)
			{
				updatePresetStats(key, value[i], runStat);
			}
		}
	}
	else if((int)excludeCmds.size() !=0)
	{
		string runStat = "false";
		for(iter=excludeCmds.begin();iter!=excludeCmds.end();iter++ )
		{
			string key=(*iter).first;
			vector<string> value = ((*iter).second);
			for(int i=0; i<(int)value.size();i++)
			{
				updatePresetStats(key, value[i], runStat);
			}
		}
	}
}
void presetHandler::updatePresetStats(string key, string value, string runStat)
{
	string metaStr;
	vector<presetMetaData>::iterator iter;
	std::transform(key.begin(), key.end(), key.begin(), (int(*)(int))std::toupper);
	std::transform(value.begin(), value.end(), value.begin(), (int(*)(int))std::toupper);
	for(int i=0; i<(int)vecPresetStats.size(); i++)
	{
		presetMetaData metadata = vecPresetStats[i];
		if(key.compare(presetHeadings[0])==0)
			metaStr = metadata.getSection();
		else if(key.compare(presetHeadings[1])==0)
			metaStr = metadata.getType();
		else if(key.compare(presetHeadings[2])==0)
			metaStr = metadata.getHardware();
		else if(key.compare(presetHeadings[3])==0)
			metaStr = metadata.getOS();
		else if(key.compare(presetHeadings[4])==0)
			metaStr = metadata.getLicense();
		else if(key.compare(presetHeadings[5])==0)
			metaStr = metadata.getShell();
		else if(key.compare(presetHeadings[6])==0)
			metaStr = metadata.getFlag();
		else if(key.compare(presetHeadings[7])==0)
			metaStr = metadata.getShortname();
		else if(key.compare(presetHeadings[8])==0)
			metaStr = metadata.getCommand();

		std::transform(metaStr.begin(), metaStr.end(), metaStr.begin(), (int(*)(int))std::toupper);
		iter = vecPresetStats.begin();
		if(metaStr.compare(value)==0)
		{
			metadata = vecPresetStats[i];
			metadata.setCmdRunStatus(runStat);
			vecPresetStats.erase(vecPresetStats.begin()+i);
			iter = vecPresetStats.begin();			// burt512859
			vecPresetStats.insert(iter+i,metadata);
		}
	}
}

presetMetaData presetHandler::tokenizeString(string dataStr)
{
	vector<string> output;
	size_t start = 0;
	string strTemp;
	size_t end = dataStr.find("\t", start);
	while (end!= string::npos)
	{
		strTemp = dataStr.substr(start, (end - start));
		output.push_back(strTemp);
		start = end + 1;
		end = dataStr.find("\t", start);
	}

	strTemp = dataStr.substr(start, dataStr.length());
	output.push_back(strTemp);
	output.push_back("true");
	if(output.size() != NUMPRESET_COLUMNS)
	{
		string temp = "invalid entry in preset file : " + dataStr;
		commonOutputHandle->writeDataToLogFile("ERROR", temp);
		commonOutputHandle->writeDataToLogFile("ERROR", "Invalid Preset file. Exiting");
		commonOutputHandle->writeDataToLogFile("ERROR", "Please run \"perfstat8.exe -h\" for details on options.");
		exit(0);
	}
	presetMetaData metadata = presetMetaData(output);

	return metadata;
}
vector<presetMetaData> presetHandler::getCommandsBySection(string section,string hardware)
{
	vector<presetMetaData> vecPreset;
	for(int i=0; i<(int)vecPresetStats.size(); i++)
	{
		presetMetaData metadata = vecPresetStats[i];
		string temp = metadata.getSection();
		string tmp = metadata.getHardware();
		string runStat = metadata.getCmdRunStatus();
		if(temp.compare(section)==0 && runStat.compare("true")==0)
		{
			if(hardware.compare("")==0)
			{
				vecPreset.push_back(vecPresetStats[i]);
			}
			else
			{
				if(tmp.compare(hardware)==0)
				{
				vecPreset.push_back(vecPresetStats[i]);
				}
			}
		}
	}
	return vecPreset;
}
vector<presetMetaData> presetHandler::getAllPrestatsCommands(string hardware)
{
	if(hardware.compare("")==0)
	return getCommandsBySection("PRESTATS");
	else
	return getCommandsBySection("PRESTATS",hardware);
}
vector<presetMetaData> presetHandler::getAllPoststatsCommands(string hardware)
{
	if(hardware.compare("")==0)
	return getCommandsBySection("POSTSTATS");
	else
	return getCommandsBySection("POSTSTATS",hardware);
}
vector<presetMetaData> presetHandler::getAllParallelCommands(string hardware)
{
	if(hardware.compare("")==0)
	return getCommandsBySection("PARALLEL");
	else
	return getCommandsBySection("PARALLEL",hardware);
}
vector<presetMetaData> presetHandler::getAllParallelPrestatsCommands()
{
	return getCommandsBySection("PARALLEL_PRESTATS");
}
vector<presetMetaData> presetHandler::getAllParallelPoststatsCommands()
{
	return getCommandsBySection("PARALLEL_POSTSTATS");
}
vector<presetMetaData> presetHandler::getCommandsByKey(string section, string key, string value)
{
	string metaStr;
	vector<presetMetaData> vecPreset = getCommandsBySection(section);
	vector<presetMetaData> vecPresetOutput;
	for(int i=0; i<(int)vecPreset.size(); i++)
	{
		presetMetaData metadata = vecPreset[i];
		if(key.compare(presetHeadings[0])==0)
			metaStr = metadata.getSection();
		else if(key.compare(presetHeadings[1])==0)
			metaStr = metadata.getType();
		else if(key.compare(presetHeadings[2])==0)
			metaStr = metadata.getHardware();
		else if(key.compare(presetHeadings[3])==0)
			metaStr = metadata.getOS();
		else if(key.compare(presetHeadings[4])==0)
			metaStr = metadata.getLicense();
		else if(key.compare(presetHeadings[5])==0)
			metaStr = metadata.getShell();
		else if(key.compare(presetHeadings[6])==0)
			metaStr = metadata.getFlag();
		else if(key.compare(presetHeadings[7])==0)
			metaStr = metadata.getShortname();
		else if(key.compare(presetHeadings[8])==0)
			metaStr = metadata.getCommand();

		if(metaStr.compare(value)==0)
		{
			vecPresetOutput.push_back(metadata);
		}
	}
	return vecPresetOutput;
}
vector<presetMetaData> presetHandler::getCommandsByKey(string section, string key, string value,string hardware)
{
        string metaStr;
        vector<presetMetaData> vecPreset = getCommandsBySection(section);
        vector<presetMetaData> vecPresetOutput;
        for(int i=0; i<(int)vecPreset.size(); i++)
        {
                presetMetaData metadata = vecPreset[i];
                if(key.compare(presetHeadings[0])==0)
                        metaStr = metadata.getSection();
                else if(key.compare(presetHeadings[1])==0)
                        metaStr = metadata.getType();
                else if(key.compare(presetHeadings[2])==0)
                        metaStr = metadata.getHardware();
                else if(key.compare(presetHeadings[3])==0)
                        metaStr = metadata.getOS();
                else if(key.compare(presetHeadings[4])==0)
                        metaStr = metadata.getLicense();
                else if(key.compare(presetHeadings[5])==0)
                        metaStr = metadata.getShell();
                else if(key.compare(presetHeadings[6])==0)
                        metaStr = metadata.getFlag();
                else if(key.compare(presetHeadings[7])==0)
                        metaStr = metadata.getShortname();
                else if(key.compare(presetHeadings[8])==0)
                        metaStr = metadata.getCommand();
                if(metaStr.compare(value)==0 && hardware.compare(metadata.getHardware())==0)
	           {
                        vecPresetOutput.push_back(metadata);
                }
        }
        return vecPresetOutput;
}
vector<presetMetaData> presetHandler::getPrestatsCommands(string key, string value)
{
	return getCommandsByKey("PRESTATS", key, value);
}
vector<presetMetaData> presetHandler::getPrestatsCommands(string key, string value, string hardware)
{
        return getCommandsByKey("PRESTATS", key, value, hardware);
}
vector<presetMetaData> presetHandler::getPoststatsCommands(string key, string value)
{
	return getCommandsByKey("POSTSTATS", key, value);
}
vector<presetMetaData> presetHandler::getPoststatsCommands(string key, string value, string hardware)
{
	return getCommandsByKey("POSTSTATS", key, value, hardware);
}
vector<presetMetaData> presetHandler::getParallelCommands(string key, string value)
{
	return getCommandsByKey("PARALLEL", key, value);
}
vector<presetMetaData> presetHandler::getParallelCommands(string key, string value, string hardware)
{
        return getCommandsByKey("PARALLEL", key, value);
}


// Added to support versioning
const vector<presetMetaData>& presetHandler :: getAllPresetCommands() const
{
    return vecPresetStats;
}

void presetHandler :: setAllPresetCommands(const vector<presetMetaData>& info)
{
    vecPresetStats = info;
}