/*
* Copyright 2010, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
*		Michael Pfeiffer
*/
#include "GPCapabilityExtractor.h"

#include "PrinterCap.h"


const char* kInputSlot = "InputSlot";


#if 1
#define GP_PRINT(...) \
	fprintf(stderr, __VA_ARGS__)
#else
#define GP_PRINT(...) \
	{}
#endif

GPCapabilityExtractor::GPCapabilityExtractor(GPCapabilities* capabilities)
	:
	fState(kIgnoreParameter),
	fCapabilities(capabilities),
	fIndex(0),
	fNextDriverSpecificCategoryID(PrinterCap::kDriverSpecificCapabilitiesBegin)
{

}


bool
GPCapabilityExtractor::BeginParameter(const char* name, const char* displayName,
	stp_parameter_class_t parameterClass)
{
	fState = kIgnoreParameter;
	if (strcmp(kPageSize, name) == 0) {
		GP_PRINT("Supported parameter: %s\n", name);
		fState = kExtractPageSizeParameter;
	} else if (strcmp(kResolution, name) == 0) {
		GP_PRINT("Supported parameter: %s\n", name);
		fState = kExtractResolutionParameter;
	} else if (strcmp(kInputSlot, name) == 0) {
		GP_PRINT("Supported parameter: %s\n", name);
		fState = kExtractInputSlotParameter;
	} else if (strcmp(kPrintingMode, name) == 0) {
		GP_PRINT("Supported parameter: %s\n", name);
		fState = kExtractPrintingModeParameter;
	} else {
		GP_PRINT("Parameter: %s - %s\n", name, displayName);
		if (!Supportsed(parameterClass))
			return false;

		fState = kExtractParameter;
		DriverSpecificCap* capability = new DriverSpecificCap(displayName,
			fNextDriverSpecificCategoryID, DriverSpecificCap::kList);
		capability->fKey = name;

		fDriverSpecificCategories.push_back(capability);
	}
	return true;
}


void
GPCapabilityExtractor::DefaultStringParameter(const char* name,
		const char* key)
{
	if (key == NULL)
		fDefaultKey = "";
	else
		fDefaultKey = key;
}


void
GPCapabilityExtractor::StringParameterSize(const char* name, int size)
{
	fIndex = 0;

	switch (fState) {
		case kExtractPageSizeParameter:
			fCapabilities->fPageSizes.SetSize(size);
			break;

		case kExtractResolutionParameter:
			fCapabilities->fResolutions.SetSize(size);
			break;

		case kExtractInputSlotParameter:
			fCapabilities->fInputSlots.SetSize(size);
			break;

		case kExtractPrintingModeParameter:
			fCapabilities->fPrintingModes.SetSize(size);
			break;

		case kExtractParameter:
			fState = kExtractListParameter;
			fCapabilities->fDriverSpecificCapabilities[
							 fNextDriverSpecificCategoryID].SetSize(size);
			break;

		default:
			break;
	}
}


void
GPCapabilityExtractor::StringParameter(const char* name, const char* key,
		const char* displayName)
{
	bool isDefault = fDefaultKey == key;
	EnumCap* capability;

	switch (fState) {
		case kExtractResolutionParameter:
			GP_PRINT("GPCapabilityExtractor: ResolutionParameter expected\n");
			break;

		case kExtractInputSlotParameter:
			capability = new PaperSourceCap(displayName, isDefault,
				static_cast<JobData::PaperSource>(fIndex));
			AddCapability(fCapabilities->fInputSlots, capability, key);
			break;

		case kExtractPrintingModeParameter:
			capability = new ColorCap(displayName, isDefault,
				static_cast<JobData::Color>(fIndex));
			AddCapability(fCapabilities->fPrintingModes, capability, key);
			break;

		case kExtractListParameter:
			capability = new ListItemCap(displayName, isDefault, fIndex);
			AddCapability(fCapabilities->fDriverSpecificCapabilities[
				 fNextDriverSpecificCategoryID], capability, key);
			break;

		default:
			break;
	}

}


void
GPCapabilityExtractor::ResolutionParameter(const char* name, const char* key,
		const char* displayName, int x, int y)
{
	bool isDefault = fDefaultKey == key;
	EnumCap* capability;
	int resolution;

	switch (fState) {
		case kExtractResolutionParameter:
			if (x <= 0 || y <= 0) {
				// usually this is the entry for the "Default" resolution
				// if we want to show this in the UI, we need a way to
				// determine the resolution (x and y) for it, because
				// libprint needs it for rasterization
				fCapabilities->fResolutions.DecreaseSize();
				break;
			}

			// TODO remove this workaround when libprint supports x != y too
			// for now use the maximum resolution to render the page bands
			resolution = max_c(x, y);

			capability = new ResolutionCap(displayName,	isDefault, fIndex,
				resolution, resolution);
			AddCapability(fCapabilities->fResolutions, capability, key);
			break;

		default:
			break;
	}
}


void
GPCapabilityExtractor::PageSizeParameter(const char* name, const char* key,
	const char* displayName, BSize pageSize, BRect imageableArea)
{
	bool isDefault = fDefaultKey == key;
	EnumCap* capability;

	switch (fState) {
		case kExtractPageSizeParameter:
			capability = new PaperCap(displayName, isDefault,
				static_cast<JobData::Paper>(fIndex),
				BRect(0, 0, pageSize.width, pageSize.height),
				imageableArea);
			AddCapability(fCapabilities->fPageSizes, capability, key);
			break;

		default:
			break;
	}
}


void
GPCapabilityExtractor::EndParameter(const char* name)
{
	if (fState == kExtractListParameter) {
		fNextDriverSpecificCategoryID ++;
	}
}


void
GPCapabilityExtractor::BooleanParameter(const char* name,
	const char* displayName, bool defaultValue,
	stp_parameter_class_t parameterClass)
{
	if (!Supportsed(parameterClass))
		return;

	BooleanCap* capability = new BooleanCap(displayName, defaultValue);
	AddDriverSpecificCapability(name, displayName, DriverSpecificCap::kBoolean,
		capability);
}


void
GPCapabilityExtractor::DoubleParameter(const char* name,
	const char* displayName, double lower, double upper, double defaultValue,
	stp_parameter_class_t parameterClass)
{
	if (!Supportsed(parameterClass))
		return;

	DoubleRangeCap* capability = new DoubleRangeCap(displayName, lower, upper,
		defaultValue);
	AddDriverSpecificCapability(name, displayName,
		DriverSpecificCap::kDoubleRange, capability);
}


void
GPCapabilityExtractor::IntParameter(const char* name, const char* displayName,
	int lower, int upper, int defaultValue,
	stp_parameter_class_t parameterClass)
{
	if (!Supportsed(parameterClass))
		return;

	IntRangeCap* capability = new IntRangeCap(displayName, lower, upper,
		defaultValue);
	AddDriverSpecificCapability(name, displayName, DriverSpecificCap::kIntRange,
		capability);
}


void
GPCapabilityExtractor::DimensionParameter(const char* name,
	const char* displayName, int lower, int upper, int defaultValue,
	stp_parameter_class_t parameterClass)
{
	if (!Supportsed(parameterClass))
		return;

	IntRangeCap* capability = new IntRangeCap(displayName, lower, upper,
		defaultValue);
	AddDriverSpecificCapability(name, displayName,
		DriverSpecificCap::kIntDimension, capability);
}


void
GPCapabilityExtractor::EndVisit()
{
	if (fCapabilities->fInputSlots.Size() == 0)
		AddDefaultInputSlot();
	SetDriverSpecificCategories();
}


bool
GPCapabilityExtractor::Supportsed(stp_parameter_class_t parameterClass)
{
	return parameterClass == STP_PARAMETER_CLASS_FEATURE
		|| parameterClass == STP_PARAMETER_CLASS_OUTPUT;
}


void
GPCapabilityExtractor::AddDefaultInputSlot()
{
	BeginParameter(kInputSlot, "Input Slot", STP_PARAMETER_CLASS_FEATURE);
	DefaultStringParameter(kInputSlot, "");
	StringParameterSize(kInputSlot, 1);
	StringParameter(kInputSlot, "", "Default");
	EndParameter(kInputSlot);
}


void
GPCapabilityExtractor::SetDriverSpecificCategories()
{
	int size = fDriverSpecificCategories.size();
	if (size == 0)
		return;

	fCapabilities->fDriverSpecificCategories.SetSize(size);
	struct BaseCap** array = fCapabilities->fDriverSpecificCategories.Array();
	list<DriverSpecificCap*>::iterator it = fDriverSpecificCategories.begin();
	for (int index = 0; it != fDriverSpecificCategories.end(); it ++,
		index ++) {
		array[index] = *it;
	}
}

void
GPCapabilityExtractor::AddCapability(GPArray<struct BaseCap>& array,
	EnumCap* capability, const char* key)
{
	capability->fKey = key;
	array.Array()[fIndex] = capability;
	fIndex ++;
}


void
GPCapabilityExtractor::AddDriverSpecificCapability(const char* name,
	const char*	displayName, DriverSpecificCap::Type type, BaseCap* capability)
{
	DriverSpecificCap* parent = new DriverSpecificCap(displayName,
		fNextDriverSpecificCategoryID, type);
	parent->fKey = name;

	fDriverSpecificCategories.push_back(parent);

	GPArray<struct BaseCap>& array = fCapabilities->fDriverSpecificCapabilities
		[fNextDriverSpecificCategoryID];
	array.SetSize(1);
	array.Array()[0] = capability;

	fNextDriverSpecificCategoryID++;
}