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

#include <String.h>


const char* kJobMode = "JobMode";
const char* kJob = "Job";

const char* kPrintingMode = "PrintingMode";
const char* kColor = "Color";
const char* kBlackAndWhite = "BW";

const char* kResolution = "Resolution";
const char* kFakeResolutionKey = "";

const char* kPageSize = "PageSize";

const char* kChannelBitDepth = "ChannelBitDepth";


GPParameterVisitor::GPParameterVisitor()
	:
	fVariables(NULL),
	fHasResolutionParameter(false)
{
}


GPParameterVisitor::~GPParameterVisitor()
{
}


void
GPParameterVisitor::Visit(const stp_printer_t* printer)
{
	// this code is based on Gutenprint printer_options.c
	const stp_vars_t* defaultVariables = stp_printer_get_defaults(printer);
	stp_vars_t* variables = stp_vars_create_copy(defaultVariables);
	fVariables = variables;

	stp_set_string_parameter(variables, kJobMode, kJob);

	stp_parameter_t printingMode;
	stp_describe_parameter(variables, kPrintingMode, &printingMode);
	bool isColorPrinter = stp_string_list_is_present(printingMode.bounds.str,
		kColor) != 0;
	stp_parameter_description_destroy(&printingMode);

	if (isColorPrinter)
		stp_set_string_parameter(variables, kPrintingMode, kColor);
	else
		stp_set_string_parameter(variables, kPrintingMode, kBlackAndWhite);

	stp_set_string_parameter(variables, kChannelBitDepth, "8");

	stp_parameter_list_t list = stp_get_parameter_list(variables);
	int size = stp_parameter_list_count(list);

	for (int i = 0; i < size; i ++) {
		const stp_parameter_t* parameter = stp_parameter_list_param(list, i);
		stp_parameter_t description;
		stp_describe_parameter(fVariables, parameter->name, &description);
		VisitParameter(list, parameter, &description);
		stp_parameter_description_destroy(&description);
	}

	// TODO check if this can really happen
	if (!fHasResolutionParameter) {
		AddMissingResolution();
	}

	EndVisit();

	stp_parameter_list_destroy(list);
	stp_vars_destroy(variables);
	fVariables = NULL;
}


void
GPParameterVisitor::AddMissingResolution()
{
	// some printer definitions don't have resolution parameter
	// however "libprint" needs to know it for rasterization

	// TODO find out if other parameters influence the resolution
	// e.g. color vs black and white
	int x, y;
	stp_describe_resolution(fVariables, &x, &y);

	BeginParameter(kResolution, "Resolution", STP_PARAMETER_CLASS_FEATURE);
	DefaultStringParameter(kResolution, kFakeResolutionKey);
	StringParameterSize(kResolution, 1);

	if (x <= 0 || y <= 0) {
		// TODO decide if more resolutions (150, 600) should be possible
		x = 300;
		y = 300;
	}

	BString displayName;
	if (x != y)
		displayName << x << " x " << y << " DPI";
	else
		displayName << x << " DPI";

	ResolutionParameter(kResolution, kFakeResolutionKey, displayName.String(),
		x, y);

	EndParameter(kResolution);
}


void
GPParameterVisitor::VisitParameter(stp_parameter_list_t list,
	const stp_parameter_t* parameter, stp_parameter_t* description)
{
	// TODO decide which parameters should be revealed to user
	// e.g. up to STP_PARAMETER_LEVEL_ADVANCED4;
	// const stp_parameter_level_t kMaxLevel = STP_PARAMETER_LEVEL_ADVANCED4;
	const stp_parameter_level_t kMaxLevel = STP_PARAMETER_LEVEL_BASIC;
	stp_parameter_class_t parameterClass = parameter->p_class;
	if (parameter->read_only ||
		(parameter->p_level > kMaxLevel
			&& strcmp(parameter->name, kResolution) != 0)
		|| (parameterClass != STP_PARAMETER_CLASS_OUTPUT
			&& parameterClass != STP_PARAMETER_CLASS_CORE
			&& parameterClass != STP_PARAMETER_CLASS_FEATURE))
		return;

	if (!description->is_active)
		return;

	switch (description->p_type) {
		case STP_PARAMETER_TYPE_STRING_LIST:
			if (!BeginParameter(description->name, description->text,
				parameterClass))
				return;
			VisitStringList(description);
			EndParameter(description->name);
			break;

		case STP_PARAMETER_TYPE_BOOLEAN:
			VisitBooleanParameter(description, parameterClass);
			break;

		case STP_PARAMETER_TYPE_DOUBLE:
			VisitDoubleParameter(description, parameterClass);
			break;

		case STP_PARAMETER_TYPE_INT:
			VisitIntParameter(description, parameterClass);
			break;

		case STP_PARAMETER_TYPE_DIMENSION:
			VisitDimensionParameter(description, parameterClass);
			break;

		default:
			break;
	}

}


void
GPParameterVisitor::VisitStringList(stp_parameter_t* parameter)
{
	stp_string_list_t* list = parameter->bounds.str;
	int count = stp_string_list_count(list);
	if (count <= 0)
		return;

	const char* name = parameter->name;
	if (parameter->is_mandatory)
		DefaultStringParameter(name, parameter->deflt.str);
	else
		DefaultStringParameter(name, NULL);

	StringParameterSize(name, count);

	for (int i = 0; i < count; i ++) {
		const stp_param_string_t* entry = stp_string_list_param(list, i);
		const char* key = entry->name;
		const char* displayName = entry->text;
		if (strcmp(name, kResolution) == 0) {
			stp_set_string_parameter(fVariables, kResolution, key);

			int x, y;
			stp_describe_resolution(fVariables, &x, &y);

			ResolutionParameter(name, key, displayName, x, y);

			fHasResolutionParameter = true;
		} else if (strcmp(name, kPageSize) == 0) {
			stp_set_string_parameter(fVariables, kPageSize, key);

			stp_dimension_t width;
			stp_dimension_t height;
			stp_get_media_size(fVariables, &width, &height);
			BSize pageSize(width, height);

			stp_dimension_t left, right, top, bottom;
			stp_get_imageable_area(fVariables, &left, &right, &bottom, &top);
			BRect imageableArea(left, top, right, bottom);

			PageSizeParameter(name, key, displayName, pageSize, imageableArea);
		} else {
			StringParameter(name, key, displayName);
		}
	}
}


void
GPParameterVisitor::VisitBooleanParameter(stp_parameter_t* description,
	stp_parameter_class_t parameterClass)
{
	bool defaultValue = true;
	if (description->is_mandatory)
		defaultValue = description->deflt.boolean;
	BooleanParameter(description->name, description->text, defaultValue,
		parameterClass);
}


void
GPParameterVisitor::VisitDoubleParameter(stp_parameter_t* description,
			stp_parameter_class_t parameterClass)
{
	const char* name = description->name;
	const char* text = description->text;
	double lower = description->bounds.dbl.lower;
	double upper = description->bounds.dbl.upper;
	double defaultValue = description->deflt.dbl;
	if (lower <= defaultValue && defaultValue <= upper)
		DoubleParameter(name, text, lower, upper, defaultValue, parameterClass);
}


void
GPParameterVisitor::VisitIntParameter(stp_parameter_t* description,
			stp_parameter_class_t parameterClass)
{
	const char* name = description->name;
	const char* text = description->text;
	int lower = description->bounds.integer.lower;
	int upper = description->bounds.integer.upper;
	int defaultValue = description->deflt.integer;
	if (lower <= defaultValue && defaultValue <= upper)
		IntParameter(name, text, lower, upper, defaultValue, parameterClass);
}


void
GPParameterVisitor::VisitDimensionParameter(stp_parameter_t* description,
			stp_parameter_class_t parameterClass)
{
	const char* name = description->name;
	const char* text = description->text;
	double lower = description->bounds.dimension.lower;
	double upper = description->bounds.dimension.upper;
	double defaultValue = description->deflt.dimension;
	if (lower <= defaultValue && defaultValue <= upper)
		DimensionParameter(name, text, lower, upper, defaultValue,
			parameterClass);
}