/*
	Copyright Jeroen Vreeken (pe1rxq@amsat.org), 2015
	Copyright Stichting C.A. Muller Radioastronomiestation, 2015

	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 3 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 <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <controller/controller_block.h>
#include <log/log.h>

/*
       inputs      outputs
       nr name     nr name

     ----------------------
     |                    |
  ---| 0  a          0  q |----
     |	                  |
  ---| 1  b               |
     |	                  |
     ----------------------
     
 */

struct controller_block_private {
	bool q;
	bool *i[0];
};

static void calculate_2(struct controller_block *block)
{
	struct controller_block_private *priv = block->private;

	priv->q = *priv->i[0] & *priv->i[1];
}

static void calculate_3(struct controller_block *block)
{
	struct controller_block_private *priv = block->private;

	priv->q = *priv->i[0] & *priv->i[1] & *priv->i[2];
}

static void calculate_4(struct controller_block *block)
{
	struct controller_block_private *priv = block->private;

	priv->q = *priv->i[0] & *priv->i[1] & *priv->i[2] & *priv->i[3];
}

static void calculate_5(struct controller_block *block)
{
	struct controller_block_private *priv = block->private;

	priv->q = *priv->i[0] & *priv->i[1] & *priv->i[2] & *priv->i[3] & *priv->i[4];
}

static struct controller_block_interm_list interms_2[] = {
	{ "a", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[0]) },
	{ "b", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[1]) },
	{ NULL }
};

static struct controller_block_interm_list interms_3[] = {
	{ "a", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[0]) },
	{ "b", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[1]) },
	{ "c", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[2]) },
	{ NULL }
};

static struct controller_block_interm_list interms_4[] = {
	{ "a", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[0]) },
	{ "b", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[1]) },
	{ "c", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[2]) },
	{ "d", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[3]) },
	{ NULL }
};

static struct controller_block_interm_list interms_5[] = {
	{ "a", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[0]) },
	{ "b", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[1]) },
	{ "c", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[2]) },
	{ "d", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[3]) },
	{ "e", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, i[4]) },
	{ NULL }
};

static struct controller_block_outterm_list outterms[] = {
	{ "q", CONTROLLER_BLOCK_TERM_BOOL, offsetof(struct controller_block_private, q) },
	{ NULL }
};


static struct controller_block * block_and(struct controller_block *block)
{
	block->private->q = false;

	if (controller_block_outterm_list_init(block, outterms))
		goto err_block;

	if (controller_block_add(block))
		goto err_block;
	
	return block;

err_block:
	controller_block_free(block);
	return NULL;
}

static struct controller_block *block_err(struct controller_block *block)
{
	controller_block_free(block);
	return NULL;
}

static struct controller_block * block_and2_create(char *name, int argc, va_list val)
{
	struct controller_block *block;
	
	if (!(block = controller_block_alloc("and2", name, sizeof(struct controller_block_private) + sizeof(bool *) * 2)))
		return NULL;

	if (controller_block_interm_list_init(block, interms_2))
		return block_err(block);

	block->calculate = calculate_2;
	
	return block_and(block);
}

BLOCK_CREATE(and2) = {
	.create = block_and2_create,
	.args = { NULL },
};


static struct controller_block * block_and3_create(char *name, int argc, va_list val)
{
	struct controller_block *block;
	
	if (!(block = controller_block_alloc("and3", name, sizeof(struct controller_block_private) + sizeof(bool *) * 3)))
		return NULL;

	if (controller_block_interm_list_init(block, interms_3))
		return block_err(block);

	block->calculate = calculate_3;
	
	return block_and(block);
}

BLOCK_CREATE(and3) = {
	.create = block_and3_create,
	.args = { NULL },
};

static struct controller_block * block_and4_create(char *name, int argc, va_list val)
{
	struct controller_block *block;

	if (!(block = controller_block_alloc("and4", name, sizeof(struct controller_block_private) + sizeof(bool *) * 4)))
		return NULL;

	if (controller_block_interm_list_init(block, interms_4))
		return block_err(block);

	block->calculate = calculate_4;
	
	return block_and(block);
}

BLOCK_CREATE(and4) = {
	.create = block_and4_create,
	.args = { NULL },
};

static struct controller_block * block_and5_create(char *name, int argc, va_list val)
{
	struct controller_block *block;

	if (!(block = controller_block_alloc("and5", name, sizeof(struct controller_block_private) + sizeof(bool *) * 5)))
		return NULL;

	if (controller_block_interm_list_init(block, interms_5))
		return block_err(block);

	block->calculate = calculate_5;
	
	return block_and(block);
}

BLOCK_CREATE(and5) = {
	.create = block_and5_create,
	.args = { NULL },
};