/*
 * Analogy for Linux, test program for waveform generation
 *
 * Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org>
 * Copyright (C) 2008 Alexis Berlemont <alexis.berlemont@free.fr>
 *
 * Xenomai is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Xenomai 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Xenomai; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <getopt.h>
#include <string.h>

#include "wf_facilities.h"

static void do_print_usage(void)
{
	fprintf(stdout, "usage:\twf_generate [OPTS]\n");
	fprintf(stdout, "\tOPTS:\t -v, --verbose: verbose output\n");
	fprintf(stdout,
		"\t\t -t, --type: waveform type "
		"(sine, sawtooth, triangular, steps\n");
	fprintf(stdout, "\t\t -f, --frequency: waveform frequency\n");
	fprintf(stdout, "\t\t -a, --amplitude: waveform amplitude\n");
	fprintf(stdout, "\t\t -o, --offset: waveform offet\n");
	fprintf(stdout, "\t\t -s, --sampling-frequency: sampling frequency\n");
	fprintf(stdout, "\t\t -O, --outpout: output file (or stdout)\n");
	fprintf(stdout, "\t\t -h, --help: print this help\n");
}

static struct option opts[] = {
	{"verbose", no_argument, NULL, 'v'},
	{"type", required_argument, NULL, 't'},
	{"frequency", required_argument, NULL, 'f'},
	{"amplitude", required_argument, NULL, 'a'},
	{"offset", required_argument, NULL, 'o'},
	{"sampling-frequency", required_argument, NULL, 's'},
	{"output", required_argument, NULL, 'O'},
	{"help", no_argument, NULL, 'h'},
	{0},
};

static int select_type(struct waveform_config *config, char *arg)
{
	int err = 0;

	if (!strcmp(arg, "sine"))
		config->wf_kind = WAVEFORM_SINE;
	else if (!strcmp(arg, "sawtooth"))
		config->wf_kind = WAVEFORM_SAWTOOTH;
	else if (!strcmp(arg, "triangular"))
		config->wf_kind = WAVEFORM_TRIANGULAR;
	else if (!strcmp(arg, "steps"))
		config->wf_kind = WAVEFORM_STEPS;
	else {
		fprintf(stderr, "Error: type %s is not recognized\n", arg);
		err = -EINVAL;
	}

	return err;
}

struct config {
	int verbose;
	char *filename;
	FILE *output;
	struct waveform_config wf;
};

static void cleanup_config(struct config *cfg)
{
	if (cfg->output && strcmp(cfg->filename, "stdout")) {
		fclose(cfg->output);
	}
}

static int init_config(struct config *cfg, int argc, char *argv[])
{
	int err = 0;

	memset(cfg, 0, sizeof(struct config));

	cfg->wf.wf_kind = WAVEFORM_SINE;
	cfg->wf.wf_frequency = 500.0;
	cfg->wf.wf_amplitude = 1.0;
	cfg->wf.wf_offset = 0.0;
	cfg->wf.spl_frequency = 1000.0;
	cfg->wf.spl_count = 0;

	while ((err = getopt_long(argc,
				  argv, "vt:f:a:o:s:O:h", opts, NULL)) >= 0) {

		switch (err) {

		case 'v':
			cfg->verbose = 1;
			break;
		case 't':
			err = select_type(&cfg->wf, optarg);
			if (err < 0)
				goto out;
			break;
		case 'f':
			errno = 0;
			cfg->wf.wf_frequency = strtod(optarg, NULL);
			if (errno) {
				err = -errno;
				goto bad_conversion;
			}
			break;
		case 'a':
			errno = 0;
			cfg->wf.wf_amplitude = strtod(optarg, NULL);
			if (errno) {
				err = -errno;
				goto bad_conversion;
			}
			break;
		case 'o':
			errno = 0;
			cfg->wf.wf_offset = strtod(optarg, NULL);
			if (errno) {
				err = -errno;
				goto bad_conversion;
			}
			break;
		case 's':
			errno = 0;
			cfg->wf.spl_frequency = strtod(optarg, NULL);
			if (errno) {
				err = -errno;
				goto bad_conversion;
			}
			break;
		case 'O':
			cfg->filename = optarg;
			break;
		case 'h':
		default:
			err = -EINVAL;
			do_print_usage();
			goto out;
		}
	}

	err = 0;

	if (cfg->filename != NULL) {
		cfg->output = fopen(cfg->filename, "w");
		if (cfg->output == NULL) {
			err = -errno;
			fprintf(stderr, "%s: %s\n", cfg->filename, strerror(errno));
			goto out;
		}
	} else {
		cfg->output = stdout;
		cfg->filename = "stdout";
	}

	if (isatty(fileno(cfg->output))) {
		err = -EINVAL;
		fprintf(stderr,
			"Error: output terminals are not allowed (%s)\n",
			cfg->filename);
		goto out;
	}

out:
	if (err < 0)
		cleanup_config(cfg);

	return err;

bad_conversion:
	fprintf(stderr, "Error:  bad option(s) value(s)\n");
	do_print_usage();
	return err;
}

int main(int argc, char *argv[])
{
	int err = 0;
	struct config cfg;
	double *values = NULL;

	err = init_config(&cfg, argc, argv);
	if (err < 0)
		goto out;

	err = a4l_wf_check_config(&cfg.wf);
	if (err < 0)
		goto out;

	a4l_wf_set_sample_count(&cfg.wf);

	if (cfg.verbose) {
		char *types[] = {"sine", "sawtooth", "triangular", "steps"};
		fprintf(stderr, "Waveform type: %s\n", types[cfg.wf.wf_kind]);
		fprintf(stderr, "Amplitude: %F\n", cfg.wf.wf_amplitude);
		fprintf(stderr, "Frequency: %F\n", cfg.wf.wf_frequency);
		fprintf(stderr, "Offset: %F\n", cfg.wf.wf_offset);
		fprintf(stderr,
			"Sampling frequency: %F\n", cfg.wf.spl_frequency);
		fprintf(stderr, "Samples count: %d\n", cfg.wf.spl_count);
		fprintf(stderr, "Output file: %s\n", cfg.filename);
	}

	values = malloc(cfg.wf.spl_count * sizeof(double));
	if (!values) {
		err = -ENOMEM;
		fprintf(stderr, "Error: values allocations failed\n");
		goto out;
	}

	a4l_wf_init_values(&cfg.wf, values);

	err = fwrite(values, sizeof(double), cfg.wf.spl_count, cfg.output);
	if (err != cfg.wf.spl_count) {
		err = -errno;
		perror("Error: output file write: )");
		goto out;
	}

	if (cfg.verbose) {
		int i;

		fprintf(stderr, "Dumping values:\n");
		for (i = 0; i < cfg.wf.spl_count; i++)
			fprintf(stderr, "[%d]: %F\n", i, values[i]);
	}

out:
	cleanup_config(&cfg);

	return err;
}