/*
 * Copyright (C) 2010  Miroslav Lichvar <mlichvar@redhat.com>
 * 
 * This program 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.
 * 
 * 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "generator.h"

static void syntax_assert(bool condition) {
	if (!condition) {
		fprintf(stderr, "syntax error\n");
		exit(1);
	}
}

Generator::Generator(const vector<Generator *> *input) {
	if (input)
		this->input = *input;
	constant = false;
}

Generator::~Generator() {
	while (!input.empty()) {
		delete input.back();
		input.pop_back();
	}
}

bool Generator::is_constant() const {
	return constant;
}

Generator_float::Generator_float(double f): Generator(NULL) {
	this->f = f;
	constant = true;
}

double Generator_float::generate(const Generator_variables *variables) {
	return f;
}

Generator_variable::Generator_variable(string name): Generator(NULL) {
	this->name = name;
}

double Generator_variable::generate(const Generator_variables *variables) {
	Generator_variables::const_iterator iter;

	syntax_assert(variables);
	iter = variables->find(name);
	syntax_assert(iter != variables->end());

	return iter->second;
}

Generator_random_uniform::Generator_random_uniform(const vector<Generator *> *input):
	Generator(NULL) {
	syntax_assert(!input || input->size() == 0);
}

double Generator_random_uniform::generate(const Generator_variables *variables) {
	double x;

	x = ((random() & 0x7fffffff) + 1) / 2147483649.0;
	x = ((random() & 0x7fffffff) + x) / 2147483648.0;

	return x;
}

Generator_random_normal::Generator_random_normal(const vector<Generator *> *input):
	Generator(NULL), uniform(NULL) {
	syntax_assert(!input || input->size() == 0);
}

double Generator_random_normal::generate(const Generator_variables *variables) {
	/* Marsaglia polar method */

	double x, y, s;

	do {
		x = 2.0 * uniform.generate(variables) - 1.0;
		y = 2.0 * uniform.generate(variables) - 1.0;
		s = x * x + y * y;
	} while (s >= 1.0);

	x *= sqrt(-2.0 * log(s) / s);

	return x;
}

Generator_random_exponential::Generator_random_exponential(const vector<Generator *> *input):
	Generator(NULL), uniform(NULL) {
	syntax_assert(!input || input->size() == 0);
}

double Generator_random_exponential::generate(const Generator_variables *variables) {
	return -log(uniform.generate(variables));
}

Generator_random_poisson::Generator_random_poisson(const vector<Generator *> *input):
	Generator(NULL), uniform(NULL) {
	double lambda;

	syntax_assert(input && input->size() == 1 && (*input)[0]->is_constant());

	lambda = (*input)[0]->generate(NULL);
	syntax_assert(lambda >= 1 && lambda <= 20);
	L = exp(-lambda);
}

double Generator_random_poisson::generate(const Generator_variables *variables) {
	double p;
	int k;

	for (p = 1.0, k = 0; k < 100; k++) {
		p *= uniform.generate(variables);
		if (p <= L)
			break;
	}

	return k;
}

Generator_file::Generator_file(const char *file): Generator(NULL) {
	input = fopen(file, "r");
	if (!input) {
		fprintf(stderr, "can't open %s\n", file);
		exit(1);
	}
}

Generator_file::~Generator_file() {
	fclose(input);
}

double Generator_file::generate(const Generator_variables *variables) {
	double x;

	while (1) {
		if (fscanf(input, "%lf", &x) != 1) {
			if (feof(input)) {
				fseek(input, 0, SEEK_SET);
				continue;
			}
			assert(0);
		}
		break;
	}
	return x;
}

Generator_wave_pulse::Generator_wave_pulse(const vector<Generator *> *input):
	Generator(NULL) {
	syntax_assert(input && input->size() == 2 &&
			(*input)[0]->is_constant() && (*input)[1]->is_constant());
	high = (*input)[0]->generate(NULL);
	low = (*input)[1]->generate(NULL);
	counter = 0;
}

double Generator_wave_pulse::generate(const Generator_variables *variables) {
	counter++;
	if (counter > high + low)
		counter = 1;
	if (counter <= high)
		return 1.0;
	return -1.0;
}

Generator_wave_sine::Generator_wave_sine(const vector<Generator *> *input):
	Generator(NULL) {
	syntax_assert(input && input->size() == 1 && (*input)[0]->is_constant());
	length = (*input)[0]->generate(NULL);
	counter = 0;
}

double Generator_wave_sine::generate(const Generator_variables *variables) {
	return sin(counter++ / length * 2 * M_PI);
}

Generator_wave_cosine::Generator_wave_cosine(const vector<Generator *> *input):
	Generator(NULL) {
	syntax_assert(input && input->size() == 1 && (*input)[0]->is_constant());
	length = (*input)[0]->generate(NULL);
	counter = 0;
}

double Generator_wave_cosine::generate(const Generator_variables *variables) {
	return cos(counter++ / length * 2 * M_PI);
}

Generator_wave_triangle::Generator_wave_triangle(const vector<Generator *> *input):
	Generator(NULL) {
	syntax_assert(input && input->size() == 1 && (*input)[0]->is_constant());
	length = (*input)[0]->generate(NULL);
	counter = 0;
}

double Generator_wave_triangle::generate(const Generator_variables *variables) {
	double phase;
	phase = counter / length - floor(counter / length);
	counter++;
	return -4.0 * (fabs(phase - 0.5) - 0.25);

}

Generator_sum::Generator_sum(const vector<Generator *> *input):
	Generator(input) {
	sum = 0.0;
}

double Generator_sum::generate(const Generator_variables *variables) {
	unsigned int i;

	for (i = 0; i < input.size(); i++)
		sum += input[i]->generate(variables);
	return sum;
}

Generator_multiply::Generator_multiply(const vector<Generator *> *input):
	Generator(input) {
}

double Generator_multiply::generate(const Generator_variables *variables) {
	unsigned int i;
	double x = 1.0;

	for (i = 0; i < input.size(); i++)
		x *= input[i]->generate(variables);
	return x;
}

Generator_add::Generator_add(const vector<Generator *> *input):
	Generator(input) {
}

double Generator_add::generate(const Generator_variables *variables) {
	unsigned int i;
	double x = 0.0;

	for (i = 0; i < input.size(); i++)
		x += input[i]->generate(variables);
	return x;
}

Generator_modulo::Generator_modulo(const vector<Generator *> *input):
	Generator(input) {
	syntax_assert(input && input->size() > 0);
}

double Generator_modulo::generate(const Generator_variables *variables) {
	unsigned int i;
	double x = input[0]->generate(variables);

	for (i = 1; i < input.size(); i++)
		x = fmod(x, input[i]->generate(variables));

	return x;
}

Generator_equal::Generator_equal(const vector<Generator *> *input):
	Generator(input) {
	syntax_assert(input && input->size() > 0);
}

double Generator_equal::generate(const Generator_variables *variables) {
	unsigned int i;
	double x, min = 0.0, max = 0.0, epsilon = input[0]->generate(variables);

	for (i = 1; i < input.size(); i++) {
		x = input[i]->generate(variables);
		if (i == 1 || min > x)
			min = x;
		if (i == 1 || max < x)
			max = x;
	}

	return max - min <= epsilon ? 1.0 : 0.0;
}

Generator_max::Generator_max(const vector<Generator *> *input):
	Generator(input) {
	syntax_assert(input && input->size() > 0);
}

double Generator_max::generate(const Generator_variables *variables) {
	unsigned int i;
	double x, max = 0.0;

	for (i = 0; i < input.size(); i++) {
		x = input[i]->generate(variables);
		if (!i || max < x)
			max = x;
	}

	return max;
}

Generator_min::Generator_min(const vector<Generator *> *input):
	Generator(input) {
	syntax_assert(input && input->size() > 0);
}

double Generator_min::generate(const Generator_variables *variables) {
	unsigned int i;
	double x, min = 0.0;

	for (i = 0; i < input.size(); i++) {
		x = input[i]->generate(variables);
		if (!i || min > x)
			min = x;
	}

	return min;
}

Generator_generator::Generator_generator() {
}

Generator_generator::~Generator_generator() {
}

Generator *Generator_generator::generate(char *code) const {
	const char *ws = " \t\n\r", *wsp = " \t\n\r()";
	int len, paren;
	Generator *ret;
	vector<Generator *> generators;
	char *arg, *name, *end, *string = NULL;

	//printf("code: |%s|\n", code);
	len = strlen(code);
	end = code + len;

	if (code[0] == '(') {
		syntax_assert(len > 2 && code[len - 1] == ')');
		code[len - 1] = '\0';
		code++;
		end = code + len - 2;
	}

	code += strspn(code, ws);
	
	name = code;

	code += strcspn(code, wsp);
	code[0] = '\0';
	code++;

	code += strspn(code, ws);

	while (code < end) {
		arg = code;

		if (arg[0] == '(') {
			code = ++arg;
			for (paren = 1; code < end; code++) {
				if (code[0] == '(')
					paren++;
				else if (code[0] == ')')
					paren--;
				if (paren == 0)
					break;
			}

			syntax_assert(paren == 0 && code[0] == ')');
			code[0] = '\0';
			code++;

			//printf("generator: %s\n", arg);
			generators.push_back(generate(arg));
			syntax_assert(generators.back());
		} else if (arg[0] == '"') {
			string = code = ++arg;
			code += strcspn(code, "\"");
			syntax_assert(code[0] == '"');
			code[0] = '\0';
			code++;
			//printf("string: |%s|\n", string);
		} else {
			code += strcspn(code, wsp);
			syntax_assert(code[0] != ')' && code[0] != '(');
			code[0] = '\0';
			code++;
			if (isalpha(arg[0])) {
				generators.push_back(new Generator_variable(arg));
				//printf("variable: %s\n", arg);
			} else {
				generators.push_back(new Generator_float(atof(arg)));
				//printf("float: %f\n", generators.back()->generate());
			}
		}

		code += strspn(code, ws);
	}

	if (strcmp(name, "*") == 0)
		ret = new Generator_multiply(&generators);
	else if (strcmp(name, "+") == 0)
		ret = new Generator_add(&generators);
	else if (strcmp(name, "%") == 0)
		ret = new Generator_modulo(&generators);
	else if (strcmp(name, "sum") == 0)
		ret = new Generator_sum(&generators);
	else if (strcmp(name, "uniform") == 0)
		ret = new Generator_random_uniform(&generators);
	else if (strcmp(name, "normal") == 0)
		ret = new Generator_random_normal(&generators);
	else if (strcmp(name, "exponential") == 0)
		ret = new Generator_random_exponential(&generators);
	else if (strcmp(name, "poisson") == 0)
		ret = new Generator_random_poisson(&generators);
	else if (strcmp(name, "file") == 0)
		ret = new Generator_file(string);
	else if (strcmp(name, "pulse") == 0)
		ret = new Generator_wave_pulse(&generators);
	else if (strcmp(name, "sine") == 0)
		ret = new Generator_wave_sine(&generators);
	else if (strcmp(name, "cosine") == 0)
		ret = new Generator_wave_cosine(&generators);
	else if (strcmp(name, "triangle") == 0)
		ret = new Generator_wave_triangle(&generators);
	else if (strcmp(name, "equal") == 0)
		ret = new Generator_equal(&generators);
	else if (strcmp(name, "max") == 0)
		ret = new Generator_max(&generators);
	else if (strcmp(name, "min") == 0)
		ret = new Generator_min(&generators);
	else {
		ret = NULL;
		syntax_assert(0);
	}

	return ret;
}