/* -*- mode: c; c-file-style: "bsd"; -*- */
/*
 *  Copyright (C) 2004 Jack O'Quin
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation; either version 2.1 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#include <config.h>

#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#include <jack/intclient.h>
#include <jack/uuid.h>

#include "internal.h"
#include "varargs.h"

#include "local.h"

static int
jack_intclient_request (RequestType type, jack_client_t *client,
			const char* client_name, jack_options_t options,
			jack_status_t *status, jack_intclient_t uuid, jack_varargs_t *va)
{
	jack_request_t req;

	memset (&req, 0, sizeof(req));

	if (strlen (client_name) >= sizeof(req.x.intclient.name)) {
		jack_error ("\"%s\" is too long for a JACK client name.\n"
			    "Please use %lu characters or less.",
			    client_name, sizeof(req.x.intclient.name));
		return -1;
	}

	if (va->load_name
	    && (strlen (va->load_name) > sizeof(req.x.intclient.path) - 1)) {
		jack_error ("\"%s\" is too long for a shared object name.\n"
			    "Please use %lu characters or less.",
			    va->load_name, sizeof(req.x.intclient.path) - 1);
		*status |= (JackFailure | JackInvalidOption);
		return -1;
	}

	if (va->load_init
	    && (strlen (va->load_init) > sizeof(req.x.intclient.init) - 1)) {
		jack_error ("\"%s\" is too long for internal client init "
			    "string.\nPlease use %lu characters or less.",
			    va->load_init, sizeof(req.x.intclient.init) - 1);
		*status |= (JackFailure | JackInvalidOption);
		return -1;
	}

	req.type = type;
	req.x.intclient.options = options;
	strncpy (req.x.intclient.name, client_name,
		 sizeof(req.x.intclient.name));
	if (va->load_name) {
		strncpy (req.x.intclient.path, va->load_name,
			 sizeof(req.x.intclient.path));
	}
	if (va->load_init) {
		strncpy (req.x.intclient.init, va->load_init,
			 sizeof(req.x.intclient.init));
	}

	jack_client_deliver_request (client, &req);

	*status |= req.status;

	if (*status & JackFailure) {
		return -1;
	}

	jack_uuid_copy (&uuid, req.x.intclient.uuid);
	return 0;
}

char *
jack_get_internal_client_name (jack_client_t *client,
			       jack_intclient_t intclient)
{
	jack_request_t req;
	char *name;

	memset (&req, 0, sizeof(req));
	req.type = IntClientName;
	req.x.intclient.options = JackNullOption;
	jack_uuid_copy (&req.x.intclient.uuid, intclient);

	jack_client_deliver_request (client, &req);

	if (req.status & JackFailure) {
		return NULL;
	}

	/* allocate storage for returning the name */
	if ((name = strdup (req.x.intclient.name)) == NULL) {
		return NULL;
	}

	return name;
}

int
jack_internal_client_handle (jack_client_t *client,
			     const char *client_name,
			     jack_status_t *status,
			     jack_intclient_t *handle)
{
	jack_request_t req;
	jack_status_t my_status;

	if (status == NULL) {           /* no status from caller? */
		status = &my_status;    /* use local status word */
	}
	*status = 0;

	memset (&req, 0, sizeof(req));
	req.type = IntClientHandle;
	req.x.intclient.options = JackNullOption;
	strncpy (req.x.intclient.name, client_name,
		 sizeof(req.x.intclient.name));

	*status = jack_client_deliver_request (client, &req);

	if (!jack_uuid_empty (req.x.intclient.uuid)) {
		jack_uuid_copy (handle, req.x.intclient.uuid);
		return 0;
	}

	return -1;
}

int
jack_internal_client_load_aux (jack_client_t *client,
			       const char *client_name,
			       jack_options_t options,
			       jack_status_t *status,
			       jack_intclient_t handle, va_list ap)
{
	jack_varargs_t va;
	jack_status_t my_status;

	if (status == NULL) {           /* no status from caller? */
		status = &my_status;    /* use local status word */
	}
	*status = 0;

	/* validate parameters */
	if ((options & ~JackLoadOptions)) {
		*status |= (JackFailure | JackInvalidOption);
		return -1;
	}

	/* parse variable arguments */
	jack_varargs_parse (options, ap, &va);

	return jack_intclient_request (IntClientLoad, client, client_name,
				       options, status, handle, &va);
}

int
jack_internal_client_load (jack_client_t *client,
			   const char *client_name,
			   jack_options_t options,
			   jack_status_t *status,
			   jack_intclient_t handle, ...)
{
	va_list ap;

	va_start (ap, handle);
	int res = jack_internal_client_load_aux (client, client_name, options, status, handle, ap);
	va_end (ap);
	return res;
}

jack_status_t
jack_internal_client_unload (jack_client_t *client,
			     jack_intclient_t intclient)
{
	jack_request_t req;
	jack_status_t status;

	if (intclient) {

		memset (&req, 0, sizeof(req));
		req.type = IntClientUnload;
		req.x.intclient.options = JackNullOption;
		jack_uuid_copy (&req.x.intclient.uuid, intclient);
		jack_client_deliver_request (client, &req);
		status = req.status;

	} else {                        /* intclient is null */
		status = (JackNoSuchClient | JackFailure);
	}

	return status;
}
