/*-------------------------------------------------------------------------
 * drawElements Quality Program Test Executor
 * ------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Batch result to XML export.
 *//*--------------------------------------------------------------------*/

#include "xeTestLogParser.hpp"
#include "xeTestResultParser.hpp"
#include "xeXMLWriter.hpp"
#include "xeTestLogWriter.hpp"
#include "deFilePath.hpp"
#include "deString.h"
#include "deStringUtil.hpp"
#include "deCommandLine.hpp"

#include <vector>
#include <string>
#include <map>
#include <cstdio>
#include <fstream>
#include <iostream>

using std::vector;
using std::string;
using std::map;

static const char*	CASELIST_STYLESHEET		= "caselist.xsl";
static const char*	TESTCASE_STYLESHEET		= "testlog.xsl";

enum OutputMode
{
	OUTPUTMODE_SEPARATE = 0,	//!< Separate
	OUTPUTMODE_SINGLE,

	OUTPUTMODE_LAST
};

namespace opt
{

DE_DECLARE_COMMAND_LINE_OPT(OutMode, OutputMode);

void registerOptions (de::cmdline::Parser& parser)
{
	using de::cmdline::Option;
	using de::cmdline::NamedValue;

	static const NamedValue<OutputMode> s_modes[] =
	{
		{ "single",		OUTPUTMODE_SINGLE	},
		{ "separate",	OUTPUTMODE_SEPARATE	}
	};

	parser << Option<OutMode>("m", "mode", "Output mode", s_modes, "single");
}

} // opt

struct CommandLine
{
	CommandLine (void)
		: outputMode(OUTPUTMODE_SINGLE)
	{
	}

	std::string		batchResultFile;
	std::string		outputPath;
	OutputMode		outputMode;
};

static bool parseCommandLine (CommandLine& cmdLine, int argc, const char* const* argv)
{
	de::cmdline::Parser			parser;
	de::cmdline::CommandLine	opts;

	opt::registerOptions(parser);

	if (!parser.parse(argc-1, argv+1, &opts, std::cerr) ||
		opts.getArgs().size() != 2)
	{
		printf("%s: [options] [testlog] [destination path]\n", argv[0]);
		parser.help(std::cout);
		return false;
	}

	cmdLine.outputMode		= opts.getOption<opt::OutMode>();
	cmdLine.batchResultFile	= opts.getArgs()[0];
	cmdLine.outputPath		= opts.getArgs()[1];

	return true;
}

static void parseBatchResult (xe::TestLogParser& parser, const char* filename)
{
	std::ifstream	in			(filename, std::ios_base::binary);
	deUint8			buf[2048];

	for (;;)
	{
		in.read((char*)&buf[0], sizeof(buf));
		int numRead = (int)in.gcount();

		if (numRead > 0)
			parser.parse(&buf[0], numRead);

		if (numRead < (int)sizeof(buf))
			break;
	}
}

// Export to single file

struct BatchResultTotals
{
	BatchResultTotals (void)
	{
		for (int i = 0;i < xe::TESTSTATUSCODE_LAST; i++)
			countByCode[i] = 0;
	}

	int countByCode[xe::TESTSTATUSCODE_LAST];
};

class ResultToSingleXmlLogHandler : public xe::TestLogHandler
{
public:
	ResultToSingleXmlLogHandler (xe::xml::Writer& writer, BatchResultTotals& totals)
		: m_writer	(writer)
		, m_totals	(totals)
	{
	}

	void setSessionInfo (const xe::SessionInfo&)
	{
	}

	xe::TestCaseResultPtr startTestCaseResult (const char* casePath)
	{
		return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath));
	}

	void testCaseResultUpdated (const xe::TestCaseResultPtr&)
	{
	}

	void testCaseResultComplete (const xe::TestCaseResultPtr& resultData)
	{
		xe::TestCaseResult result;

		xe::parseTestCaseResultFromData(&m_resultParser, &result, *resultData.get());

		// Write result.
		xe::writeTestResult(result, m_writer);

		// Record total
		XE_CHECK(de::inBounds<int>(result.statusCode, 0, xe::TESTSTATUSCODE_LAST));
		m_totals.countByCode[result.statusCode] += 1;
	}

private:
	xe::xml::Writer&		m_writer;
	BatchResultTotals&		m_totals;
	xe::TestResultParser	m_resultParser;
};

static void writeTotals (xe::xml::Writer& writer, const BatchResultTotals& totals)
{
	using xe::xml::Writer;

	int totalCases = 0;

	writer << Writer::BeginElement("ResultTotals");

	for (int code = 0; code < xe::TESTSTATUSCODE_LAST; code++)
	{
		writer << Writer::Attribute(xe::getTestStatusCodeName((xe::TestStatusCode)code), de::toString(totals.countByCode[code]).c_str());
		totalCases += totals.countByCode[code];
	}

	writer << Writer::Attribute("All", de::toString(totalCases).c_str())
		   << Writer::EndElement;
}

static void batchResultToSingleXmlFile (const char* batchResultFilename, const char* dstFileName)
{
	std::ofstream				out			(dstFileName, std::ios_base::binary);
	xe::xml::Writer				writer		(out);
	BatchResultTotals			totals;
	ResultToSingleXmlLogHandler	handler		(writer, totals);
	xe::TestLogParser			parser		(&handler);

	XE_CHECK(out.good());

	out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
		<< "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n";

	writer << xe::xml::Writer::BeginElement("BatchResult")
		   << xe::xml::Writer::Attribute("FileName", de::FilePath(batchResultFilename).getBaseName());

	// Parse and write individual cases
	parseBatchResult(parser, batchResultFilename);

	// Write ResultTotals
	writeTotals(writer, totals);

	writer << xe::xml::Writer::EndElement;
	out << "\n";
}

// Export to separate files

class ResultToXmlFilesLogHandler : public xe::TestLogHandler
{
public:
	ResultToXmlFilesLogHandler (vector<xe::TestCaseResultHeader>& resultHeaders, const char* dstPath)
		: m_resultHeaders	(resultHeaders)
		, m_dstPath			(dstPath)
	{
	}

	void setSessionInfo (const xe::SessionInfo&)
	{
	}

	xe::TestCaseResultPtr startTestCaseResult (const char* casePath)
	{
		return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath));
	}

	void testCaseResultUpdated (const xe::TestCaseResultPtr&)
	{
	}

	void testCaseResultComplete (const xe::TestCaseResultPtr& resultData)
	{
		xe::TestCaseResult result;

		xe::parseTestCaseResultFromData(&m_resultParser, &result, *resultData.get());

		// Write result.
		{
			de::FilePath	casePath	= de::FilePath::join(m_dstPath, (result.casePath + ".xml").c_str());
			std::ofstream	out			(casePath.getPath(), std::ofstream::binary|std::ofstream::trunc);
			xe::xml::Writer	xmlWriter	(out);

			if (!out.good())
				throw xe::Error(string("Failed to open ") + casePath.getPath());

			out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
				<< "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n";
			xe::writeTestResult(result, xmlWriter);
			out << "\n";
		}

		m_resultHeaders.push_back(xe::TestCaseResultHeader(result));
	}

private:
	vector<xe::TestCaseResultHeader>&	m_resultHeaders;
	std::string							m_dstPath;
	xe::TestResultParser				m_resultParser;
};

typedef std::map<const xe::TestCase*, const xe::TestCaseResultHeader*> ShortTestResultMap;

static void writeTestCaseListNode (const xe::TestNode* testNode, const ShortTestResultMap& resultMap, xe::xml::Writer& dst)
{
	using xe::xml::Writer;

	bool	isGroup		= testNode->getNodeType() == xe::TESTNODETYPE_GROUP;
	string	fullPath;
	testNode->getFullPath(fullPath);

	if (isGroup)
	{
		const xe::TestGroup* group = static_cast<const xe::TestGroup*>(testNode);

		dst << Writer::BeginElement("TestGroup")
			<< Writer::Attribute("Name", testNode->getName());

		for (int childNdx = 0; childNdx < group->getNumChildren(); childNdx++)
			writeTestCaseListNode(group->getChild(childNdx), resultMap, dst);

		dst << Writer::EndElement;
	}
	else
	{
		DE_ASSERT(testNode->getNodeType() == xe::TESTNODETYPE_TEST_CASE);

		const xe::TestCase*					testCase	= static_cast<const xe::TestCase*>(testNode);
		ShortTestResultMap::const_iterator	resultPos	= resultMap.find(testCase);
		const xe::TestCaseResultHeader*		result		= resultPos != resultMap.end() ? resultPos->second : DE_NULL;

		DE_ASSERT(result);

		dst << Writer::BeginElement("TestCase")
			<< Writer::Attribute("Name", testNode->getName())
			<< Writer::Attribute("Type", xe::getTestCaseTypeName(result->caseType))
			<< Writer::Attribute("StatusCode", xe::getTestStatusCodeName(result->statusCode))
			<< Writer::Attribute("StatusDetails", result->statusDetails.c_str())
			<< Writer::EndElement;
	}
}

static void writeTestCaseList (const xe::TestRoot& root, const ShortTestResultMap& resultMap, xe::xml::Writer& dst)
{
	using xe::xml::Writer;

	dst << Writer::BeginElement("TestRoot");

	for (int childNdx = 0; childNdx < root.getNumChildren(); childNdx++)
		writeTestCaseListNode(root.getChild(childNdx), resultMap, dst);

	dst << Writer::EndElement;
}

static void batchResultToSeparateXmlFiles (const char* batchResultFilename, const char* dstPath)
{
	xe::TestRoot						testRoot;
	vector<xe::TestCaseResultHeader>	shortResults;
	ShortTestResultMap					resultMap;

	// Initialize destination directory.
	if (!de::FilePath(dstPath).exists())
		de::createDirectoryAndParents(dstPath);
	else
		XE_CHECK_MSG(de::FilePath(dstPath).getType() == de::FilePath::TYPE_DIRECTORY, "Destination is not directory");

	// Parse batch result and write out test cases.
	{
		ResultToXmlFilesLogHandler	handler		(shortResults, dstPath);
		xe::TestLogParser			parser		(&handler);

		parseBatchResult(parser, batchResultFilename);
	}

	// Build case hierarchy & short result map.
	{
		xe::TestHierarchyBuilder hierarchyBuilder(&testRoot);

		for (vector<xe::TestCaseResultHeader>::const_iterator result = shortResults.begin(); result != shortResults.end(); result++)
		{
			xe::TestCase* testCase = hierarchyBuilder.createCase(result->casePath.c_str(), result->caseType);
			resultMap.insert(std::make_pair(testCase, &(*result)));
		}
	}

	// Create caselist.
	{
		de::FilePath	indexPath	= de::FilePath::join(dstPath, "caselist.xml");
		std::ofstream	out			(indexPath.getPath(), std::ofstream::binary|std::ofstream::trunc);
		xe::xml::Writer	xmlWriter	(out);

		XE_CHECK_MSG(out.good(), "Failed to open caselist.xml");

		out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
			<< "<?xml-stylesheet href=\"" << CASELIST_STYLESHEET << "\" type=\"text/xsl\"?>\n";
		writeTestCaseList(testRoot, resultMap, xmlWriter);
		out << "\n";
	}
}

int main (int argc, const char* const* argv)
{
	try
	{
		CommandLine cmdLine;
		if (!parseCommandLine(cmdLine, argc, argv))
			return -1;

		if (cmdLine.outputMode == OUTPUTMODE_SINGLE)
			batchResultToSingleXmlFile(cmdLine.batchResultFile.c_str(), cmdLine.outputPath.c_str());
		else
			batchResultToSeparateXmlFiles(cmdLine.batchResultFile.c_str(), cmdLine.outputPath.c_str());
	}
	catch (const std::exception& e)
	{
		printf("%s\n", e.what());
		return -1;
	}

	return 0;
}