/*
 * Copyright 2008, Haiku.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		Michael Pfeiffer <laplace@users.sourceforge.net>
 */

#include "Parser.h"
#include "Test.h"

#include <StopWatch.h>
#include <stdio.h>

void TestParser()
{
	Parser parser(gPPDFile);
	if (parser.InitCheck() != B_OK) {
		fprintf(stderr, "Could not open ppd file %s\n", gPPDFile);
		return;
	}
	
	Statement* statement;
	do {
		statement = parser.Parse();
		if (statement != NULL) {
			statement->Print();
		}
		delete statement;
	} while (statement != NULL);
}

#include "PPDParser.h"

static PPD* OpenTestFile(bool all, bool timing)
{
	BStopWatch* stopWatch = NULL; 
	if (timing) {
		stopWatch = new BStopWatch("PPDParser");
	}
	PPDParser parser(gPPDFile);

	if (parser.InitCheck() != B_OK) {
		fprintf(stderr, "Could not open ppd file %s\n", gPPDFile);
		return NULL;
	}
	
	PPD* ppd = all ? parser.ParseAll() : parser.ParseHeader();

	delete stopWatch;
	
	if (ppd == NULL) {
		fprintf(stderr, "Parser returned NULL\n");
		fprintf(stderr, "%s\n", parser.GetErrorMessage());
		return NULL;
	}
	
	return ppd;
}

void TestPPDParser(bool all, bool verbose)
{
	PPD* ppd = OpenTestFile(all, !verbose);
	if (ppd == NULL) return;	
	if (verbose) {
		ppd->Print();
	}
	delete ppd;
}

void ExtractChildren(StatementList* list, int level);

void Indent(int level)
{
	for (; level > 0; level --) {
		printf("  ");
	} 
}

void PrintValue(const char* label, Value* arg, int level)
{	
	Indent(level);
	
	if (label != NULL) {
		printf("%s ", label);
	}
	
	if (arg != NULL) {
		BString* value = arg->GetValue();
		BString* translation = arg->GetTranslation();
		if (translation != NULL) {
			printf("%s", translation->String());
		}
		if (value != NULL) {
			printf(" [%s]", value->String());
		}
	} else {
		printf("NULL");
	}	
	
	printf("\n");
}

bool ExtractGroup(Statement* statement, int level)
{
	GroupStatement group(statement);
	if (group.IsOpenGroup()) {
		const char* translation = group.GetGroupTranslation();
		Indent(level);
		if (translation != NULL) {
			printf("%s", translation);
		}
		const char* name = group.GetGroupName();
		if (name != NULL) {
			printf("[%s]", name);
		}
		printf("\n");
		ExtractChildren(statement->GetChildren(), level+1);
		return true;
	}
	return false;
}

void ExtractChildren(StatementList* list, int level)
{
	if (list == NULL) return;
	for (int32 i = 0; i < list->Size(); i ++) {
		Statement* statement = list->StatementAt(i);
		if (!ExtractGroup(statement, level)) {
			if (statement->GetType() == Statement::kValue) {
				PrintValue(NULL, statement->GetOption(), level);
			} else if (statement->GetType() == Statement::kDefault) {
				PrintValue("Default", statement->GetValue(), level);			
			}
		}
	}	
}

void TestExtractUI()
{
	PPD* ppd = OpenTestFile(true, false);
	if (ppd == NULL) return;
	
	for (int32 i = 0; i < ppd->Size(); i++) {
		Statement* statement = ppd->StatementAt(i);
		ExtractGroup(statement, 0);
	}
}