/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*LINTLIBRARY*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <papi_impl.h>


papi_status_t
papiAttributeListAddLPString(papi_attribute_t ***list, int flags, char *name,
		char *value)
{
	papi_status_t result = PAPI_BAD_ARGUMENT;

	if ((list != NULL) && (name != NULL) && (value != NULL) &&
	    (value[0] != '\0'))
		result = papiAttributeListAddString(list, flags, name, value);
	return (result);
}

papi_status_t
papiAttributeListAddLPStrings(papi_attribute_t ***list, int flags, char *name,
				char **values)
{
	papi_status_t result = PAPI_OK;
	int i, flgs = flags;

	if ((list == NULL) || (name == NULL) || (values == NULL))
		result = PAPI_BAD_ARGUMENT;

	for (i = 0; ((result == PAPI_OK) && (values[i] != NULL));
		i++, flgs = PAPI_ATTR_APPEND)
		result = papiAttributeListAddString(list, flgs, name,
							values[i]);

	return (result);
}

void
papiAttributeListGetLPString(papi_attribute_t **attributes, char *key,
				char **string)
{
	char *value = NULL;

	papiAttributeListGetString(attributes, NULL, key,  &value);
	if (value != NULL) {
		if (*string != NULL)
			free(*string);
		*string = strdup(value);
	}
}

void
papiAttributeListGetLPStrings(papi_attribute_t **attributes, char *key,
				char ***strings)
{
	papi_status_t status;
	char **values = NULL;
	char *value = NULL;
	void *iter = NULL;

	for (status = papiAttributeListGetString(attributes, &iter,
				key, &value);
	    status == PAPI_OK;
	    status = papiAttributeListGetString(attributes, &iter,
				NULL, &value))
		addlist(&values, value);

	if (values != NULL) {
		if (*strings != NULL)
			freelist(*strings);
		*strings = values;
	}
}

char *
printer_name_from_uri_id(char *uri, int32_t id)
{
	REQUEST *request = NULL;
	char *result = "";

	if (uri != NULL) {
		if ((result = strrchr(uri, '/')) != NULL) {
			result += 1;
		} else
			result = (char *)uri;

		if ((strcmp(result, "jobs") == 0) ||
		    (strcmp(result, "any") == 0) ||
		    (strcmp(result, "all") == 0))
			result = "";
	}

	if ((result[0] == '\0') && (id != -1)) {
		char path[32];

		snprintf(path, sizeof (path), "%d-0", id);
		if ((request = getrequest(path)) != NULL)
			result = request->destination;
	}

	result = strdup(result);

	if (request != NULL)
		freerequest(request);

	return (result);
}

/*
 * LP content type <-> MIME type conversion table. (order dependent)
 */
static struct {
	char *mime_type;
	char *lp_type;
} type_map[] = {
	{ "text/plain", "simple" },
	{ "application/octet-stream", "raw" },
	{ "application/octet-stream", "any" },
	{ "application/postscript", "postscript" },
	{ "application/postscript", "ps" },
	{ "application/x-cif", "cif" },
	{ "application/x-dvi", "dvi" },
	{ "application/x-plot", "plot" },
	{ "application/x-ditroff", "troff" },
	{ "application/x-troff", "otroff" },
	{ "application/x-pr", "pr" },
	{ "application/x-fortran", "fortran" },
	{ "application/x-raster", "raster" },
	{ NULL, NULL}
};

char *
mime_type_to_lp_type(char *mime_type)
{
	int i;

	if (mime_type == NULL)
		return ("simple");

	for (i = 0; type_map[i].mime_type != NULL; i++)
		if (strcasecmp(type_map[i].mime_type, mime_type) == 0)
			return (type_map[i].lp_type);

	return (mime_type);
}

char *
lp_type_to_mime_type(char *lp_type)
{
	int i;

	if (lp_type == NULL)
		return ("text/plain");

	for (i = 0; type_map[i].lp_type != NULL; i++)
		if (strcasecmp(type_map[i].lp_type, lp_type) == 0)
			return (type_map[i].mime_type);

	return (lp_type);
}