/*-*- linux-c -*-*/

/*
 * ALSA <-> SOF PCM I/O plugin
 *
 * Copyright(c) 2022 Intel Corporation. All rights reserved.
 *
 * This library 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 library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdio.h>
#include <sys/poll.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <stddef.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <semaphore.h>
#include <assert.h>
#include <errno.h>
#include <alsa/asoundlib.h>
#include <alsa/pcm_external.h>

#include "plugin.h"
#include "common.h"

int plug_mq_cmd_tx_rx(struct plug_mq_desc *ipc_tx, struct plug_mq_desc *ipc_rx,
		      void *msg, size_t len, void *reply, size_t rlen)
{
	struct timespec ts;
	ssize_t ipc_size;
	char mailbox[IPC3_MAX_MSG_SIZE];
	int err;

	if (len > IPC3_MAX_MSG_SIZE) {
		SNDERR("ipc: message too big %d\n", len);
		return -EINVAL;
	}
	memset(mailbox, 0, IPC3_MAX_MSG_SIZE);
	memcpy(mailbox, msg, len);

	/* wait for sof-pipe reader to consume data or timeout */
	err = clock_gettime(CLOCK_REALTIME, &ts);
	if (err == -1) {
		SNDERR("ipc: cant get time: %s", strerror(errno));
		return -errno;
	}

	/* IPCs should be read under 10ms */
	plug_timespec_add_ms(&ts, 10);

	/* now return message completion status */
	err = mq_timedsend(ipc_tx->mq, mailbox, IPC3_MAX_MSG_SIZE, 0, &ts);
	if (err == -1) {
		SNDERR("error: timeout can't send IPC message queue %s : %s\n",
		       ipc_tx->queue_name, strerror(errno));
		return -errno;
	}

	/* wait for sof-pipe reader to consume data or timeout */
	err = clock_gettime(CLOCK_REALTIME, &ts);
	if (err == -1) {
		SNDERR("ipc: cant get time: %s", strerror(errno));
		return -errno;
	}

	/* IPCs should be processed under 20ms, but wait longer as
	 * some can take longer especially in valgrind
	 */
	plug_timespec_add_ms(&ts, 20);

	ipc_size = mq_timedreceive(ipc_rx->mq, mailbox, IPC3_MAX_MSG_SIZE, NULL, &ts);
	if (ipc_size == -1) {
		//fprintf(stderr, "dbg: timeout can't read IPC message queue %s : %s retrying\n",
		//	ipc->queue_name, strerror(errno));

		/* ok, its a long IPC or valgrind, wait longer */
		plug_timespec_add_ms(&ts, 800);

		ipc_size = mq_timedreceive(ipc_rx->mq, mailbox, IPC3_MAX_MSG_SIZE, NULL, &ts);
		if (ipc_size == -1) {
			SNDERR("error: timeout can't read IPC message queue %s : %s\n",
			       ipc_rx->queue_name, strerror(errno));
			return -errno;
		}

		/* needed for valgrind to complete MQ op before next client IPC */
		ts.tv_nsec = 20 * 1000 * 1000;
		ts.tv_sec = 0;
		nanosleep(&ts, NULL);
	}

	/* do the message work */
	if (rlen && reply)
		memcpy(reply, mailbox, rlen);

	return 0;
}

int plug_mq_cmd(struct plug_mq_desc *ipc, void *msg, size_t len, void *reply, size_t rlen)
{
	return plug_mq_cmd_tx_rx(ipc, ipc, msg, len, reply, rlen);
}

/*
 * Open an existing message queue using IPC object.
 */
int plug_mq_open(struct plug_mq_desc *ipc)
{
	/* now open new queue for Tx and Rx */
	ipc->mq = mq_open(ipc->queue_name,  O_RDWR);
	if (ipc->mq < 0) {
	//	SNDERR("failed to open IPC queue %s: %s\n",
	//		ipc->queue_name, strerror(errno));
		return -errno;
	}

	return 0;
}

/*
 * Open an existing semaphore using lock object.
 */
int plug_lock_open(struct plug_sem_desc *lock)
{
	lock->sem = sem_open(lock->name, O_RDWR);
	if (lock->sem == SEM_FAILED) {
		SNDERR("failed to open semaphore %s: %s\n", lock->name, strerror(errno));
		return -errno;
	}

	return 0;
}

#define itemsize(type, member) sizeof(((type *)0)->member)

static int parse_conf_long(snd_config_t *cfg, void *obj, size_t size)
{
	long val;

	if (snd_config_get_integer(cfg, &val) < 0)
		return -EINVAL;

	*((long *)obj) = val;
	return 0;
}

static int parse_conf_str(snd_config_t *cfg, void *obj, size_t size)
{
	const char *id;

	if (snd_config_get_id(cfg, &id) < 0)
		return -EINVAL;
	strncpy(obj, id, size);

	return 0;
}

static int parse_conf_format(snd_config_t *cfg, void *obj, size_t size)
{
	const char *id;

	if (snd_config_get_string(cfg, &id) < 0)
		return -EINVAL;

	if (!strcmp("S16_LE", id)) {
		*((long *)obj) = SND_PCM_FORMAT_S16_LE;
		return 0;
	}
	if (!strcmp("S32_LE", id)) {
		*((long *)obj) = SND_PCM_FORMAT_S32_LE;
		return 0;
	}
	if (!strcmp("S24_4LE", id)) {
		*((long *)obj) = SND_PCM_FORMAT_S24_LE;
		return 0;
	}
	if (!strcmp("FLOAT", id)) {
		*((long *)obj) = SND_PCM_FORMAT_FLOAT_LE;
		return 0;
	}

	/* not found */
	SNDERR("error: cant find format: %s", id);
	return -EINVAL;
}

struct config_item {
	char *name;
	size_t size;
	size_t offset;
	int (*copy)(snd_config_t *cfg, void *obj, size_t size);
};

struct config_item config_items[] = {
	{"name", itemsize(struct plug_config, name),
		offsetof(struct plug_config, name), parse_conf_str},
	{"rate", itemsize(struct plug_config, rate),
		offsetof(struct plug_config, rate), parse_conf_long},
	{"format", itemsize(struct plug_config, format),
		offsetof(struct plug_config, format), parse_conf_format},
	{"channels", itemsize(struct plug_config, channels),
		offsetof(struct plug_config, channels), parse_conf_long},
	{"period_time", itemsize(struct plug_config, period_time),
		offsetof(struct plug_config, period_time), parse_conf_long},
	{"period_frames", itemsize(struct plug_config, period_frames),
		offsetof(struct plug_config, period_frames), parse_conf_long},
	{"buffer_time", itemsize(struct plug_config, buffer_time),
		offsetof(struct plug_config, buffer_time), parse_conf_long},
	{"buffer_frames", itemsize(struct plug_config, buffer_frames),
		offsetof(struct plug_config, buffer_frames), parse_conf_long},
};

static int parse_item(snd_config_t *cfg, const char *id, struct plug_config *dest_cfg)
{
	void *dest = dest_cfg;
	int i;

	for (i = 0; i < ARRAY_SIZE(config_items); i++) {
		/* does ID match */
		if (strcmp(id, config_items[i].name))
			continue;

		/* now get the value */
		return config_items[i].copy(cfg, dest + config_items[i].offset,
					    config_items[i].size);
	}

	/* not found - non fatal */
	return 0;
}

static int parse_slave_configs(snd_sof_plug_t *plug, snd_config_t *n)
{
	snd_config_iterator_t si1, si2, snext1, snext2;
	struct plug_config *config;
	const char *id;

	fprintf(stdout, "Parsing ALSA conf for configs\n");

	snd_config_for_each(si1, snext1, n) {
		snd_config_t *sn1 = snd_config_iterator_entry(si1);

		config = &plug->config[plug->num_configs];

		/* get config name */
		if (parse_item(sn1, "name", config) < 0) {
			SNDERR("error: cant find config name");
			return -EINVAL;
		}

		/* now get item values in each config */
		snd_config_for_each(si2, snext2, sn1) {
			snd_config_t *sn2 = snd_config_iterator_entry(si2);

			if (snd_config_get_id(sn2, &id) < 0)
				continue;

			if (parse_item(sn2, id, config) < 0) {
				SNDERR("error: malformed config:  %s", id);
				return -EINVAL;
			}
		}

		fprintf(stdout, " config %d: %s\n", plug->num_configs,
			config->name);

		/* next config */
		plug->num_configs++;
		if (plug->num_configs >= PLUG_MAX_CONFIG) {
			SNDERR("error: too many configs");
			return -EINVAL;
		}
	}

	return 0;
}

/*
 * Parse the client cmdline. Format is
 * tplg:pcm:card:dev:config[dai_pipe:card:dev:config]...]
 */
static int parse_client_cmdline(snd_sof_plug_t *plug, char *cmdline)
{
	struct plug_cmdline_item *cmd_item;
	char *tplg, *next, *card, *dev, *config, *pcm;
	char *tplg_path = getenv("SOF_PLUGIN_TOPOLOGY_PATH");
	char tplg_file[128];
	int ret;
	int i;

	if (!tplg_path) {
		SNDERR("Invalid topology path. Please set the SOF_PLUGIN_TOPOLOGY_PATH env variable\n");
		return -EINVAL;
	}

	/* get topology file */
	tplg = strtok_r(cmdline, ":", &next);
	if (!tplg) {
		SNDERR("invalid cmdline, cant find topology %s", cmdline);
		return -EINVAL;
	}

	/* now convert to filename and add the topology path */
	ret = snprintf(tplg_file, sizeof(tplg_file), "%ssof-%s.tplg", tplg_path, tplg);
	if (ret < 0) {
		SNDERR("invalid cmdline topology file %s", tplg);
		return -EINVAL;
	}
	plug->tplg_file = strdup(tplg_file);
	if (!plug->tplg_file)
		return -ENOMEM;

	/* get PCM ID */
	pcm = strtok_r(next, ":", &next);
	if (!pcm) {
		SNDERR("invalid cmdline, cant find PCM %s", pcm);
		return -EINVAL;
	}
	plug->pcm_id = atoi(pcm);

	fprintf(stdout, "Parsing cmd line\n");

	cmd_item = &plug->cmdline[plug->num_cmdline];
	card = strtok_r(next, ":", &next);
	if (!card) {
		SNDERR("Invalid card name\n");
		return -EINVAL;
	}
	dev = strtok_r(next, ":", &next);
	if (!dev) {
		SNDERR("Invalid dev name\n");
		return -EINVAL;
	}
	config = strtok_r(next, ":", &next);

	/* tuple needs all three, any missing ? */
	if (!config) {
		SNDERR("invalid cmdline, expected pcm(%s):card(%s):dev(%s):config(%s) from %s",
		       pcm, card, dev, config, tplg);
		return -EINVAL;
	}

	cmd_item->pcm = atoi(pcm);
	strncpy(cmd_item->card_name, card, sizeof(cmd_item->card_name));
	strncpy(cmd_item->dev_name, dev, sizeof(cmd_item->dev_name));
	strncpy(cmd_item->config_name, config, sizeof(cmd_item->config_name));

	/*
	 * dev name is special, we cant use "," in the command line
	 * so need to replace it with a "." and then later change it
	 * back to ","
	 */
	for (i = 0; i < sizeof(cmd_item->dev_name); i++) {
		if (cmd_item->dev_name[i] != '.')
			continue;
		cmd_item->dev_name[i] = ',';
		break;
	}

	fprintf(stdout, " cmd %d: for pcm %d uses %s with PCM %s:%s\n",
		plug->num_cmdline, cmd_item->pcm, cmd_item->config_name,
		cmd_item->card_name, cmd_item->dev_name);

	plug->num_cmdline++;

	printf("plug: topology file %s with pipe %ld\n", plug->tplg_file, plug->tplg_pipeline);
	return 0;
}

/*
 * Parse the ALSA conf for the SOF plugin and construct the command line options
 * to be passed into the SOF pipe executable.
 * TODO: verify all args
 * TODO: validate all args.
 * TODO: contruct sof pipe cmd line.
 */
int plug_parse_conf(snd_sof_plug_t *plug, const char *name, snd_config_t *root,
		    snd_config_t *conf)
{
	snd_config_iterator_t i, next;
	const char *tplg = NULL;

	/*
	 * The topology filename and topology PCM need to be passed in.
	 * i.e. aplay -Dsof:tplg:pcm:[card:dev:config]...]
	 */
	snd_config_for_each(i, next, conf) {
		snd_config_t *n = snd_config_iterator_entry(i);
		const char *id;

		if (snd_config_get_id(n, &id) < 0)
			continue;

		/* dont care */
		if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 ||
		    strcmp(id, "hint") == 0)
			continue;

		/* client command line topology */
		if (strcmp(id, "tplg") == 0) {
			if (snd_config_get_string(n, &tplg) < 0) {
				SNDERR("Invalid type for %s", id);
				return -EINVAL;
			} else if (!*tplg) {
				tplg = NULL;
			}
			continue;
		}

		/* topology PCM configurations */
		if (strcmp(id, "config") == 0) {
			if (parse_slave_configs(plug, n))
				return -EINVAL;
			continue;
		}

		/* not fatal - carry on and verify later */
		SNDERR("Unknown field %s", id);
	}

	/* verify mandatory inputs are specified */
	if (!tplg) {
		SNDERR("Missing topology topology");
		return -EINVAL;
	}

	/* parse the client command line */
	if (parse_client_cmdline(plug, (char *)tplg)) {
		SNDERR("invalid sof cmd line");
		return -EINVAL;
	}

	return 0;
}