/*
 * minus_eq.c
 *
 *  Created on: 26/01/2017

 *      Author: Pedro

 */

#ifndef __OPENCL_VERSION__

#include <stddef.h>
#include <stdio.h>

#include "minus_eq.h"

#include "../bitmaps.h"
#include "../config.h"
#include "../variables.h"

#endif

#include "../kernels/cl_aux_functions.h"
#if CL_D_TYPE == CL_BITMAP
#include "../kernels/cl_bitmaps.h"
#elif CL_D_TYPE == CL_INTERVAL
#include  "../kernels/cl_intervals.h"
#endif
#include "../kernels/cl_constraints.h"
#include "../kernels/cl_variables.h"
#include "../kernels/cl_ttl.h"

#ifndef __OPENCL_VERSION__

/*
 * Creates a new constraint of the minus_eq type and return the constraint ID
 * x − y = k
 * x_id - ID of variable x
 * y_id - ID of variable y
 * k - constant value for this constraint
 */
unsigned int c_minus_eq(unsigned int x_id, unsigned int y_id, int k) {

	// set to include in kernel compilation
	USE_CS[MINUS_EQ] = 1;
	USE_NON_CS_REIFI[MINUS_EQ] = 1;
	REV = 1;

	unsigned int c_vs[2];
	c_vs[0] = x_id;
	c_vs[1] = y_id;

	// creates a new generic constraint
	unsigned int c_id = c_new(c_vs, 2, NULL, 0, -1);

	// pointers to this type of constraint functions
	CS[c_id].kind = MINUS_EQ;
	CS[c_id].check_sol_f = &minus_eq_check;
	CS[c_id].constant_val = k;

	return c_id;
}

/*
 * Creates a new reified constraint of the minus_eq type and return the constraint ID
 * x − y = k
 * x_id - ID of variable x
 * y_id - ID of variable y
 * k - constant value for this constraint
 * reif_v_id - ID of the reification variable
 */
unsigned int c_minus_eq_reif(unsigned int x_id, unsigned int y_id, int k, int reif_v_id) {

	if (VS[reif_v_id].max > 1) {
		v_del_gt(&VS[reif_v_id], 1);

		if (VS[reif_v_id].n_vals == 0) {

			printf("\nConstraint MINUS_EQ_REIF makes model inconsistent at creation. No solution found.\n");

#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
			printf("\nPress any key to exit\n");
			int a = getchar();
#endif

			exit(0);

		}
	}

	// set to include in kernel compilation
	USE_CS[MINUS_EQ] = 1;
	USE_CS_REIFI[MINUS_EQ] = 1;
	REV = 1;

	unsigned int c_vs[2];
	c_vs[0] = x_id;
	c_vs[1] = y_id;

	// creates a new generic constraint
	unsigned int c_id = c_new(c_vs, 2, NULL, 0, reif_v_id);

	// pointers to this type of constraint functions
	CS[c_id].kind = MINUS_EQ;
	CS[c_id].check_sol_f = &minus_eq_check;
	CS[c_id].constant_val = k;

	return c_id;
}

/*
 * Return true if the minus_eq constraint is respected or false if not
 * x − y = k
 * c - constraint to check if is respected
 * explored - if the CSP was already explored, which mean that all the variables must already be singletons
 * */

bool minus_eq_check(constr *c, bool explored) {

	unsigned int i;

	if (!explored) {
		for (i = 0; i < c->n_c_vs; i++) {
			if (c->c_vs[i]->n_vals > 1) {
				return false;
			}
		}
	}

	if (c->reified && VS[c->reif_v_id].n_vals > 1) {
		if (explored) {
			fprintf(stderr, "\nError: Reification variable of constraint MINUS_EQ_REIF (%d) has 2 values.\n", c->c_id);
			return false;
		}
	}

	if (((!c->reified || (c->reified && VS[c->reif_v_id].min == 1)) && c->c_vs[0]->min - c->c_vs[1]->min != c->constant_val)
			|| (c->reified && VS[c->reif_v_id].min == 0 && c->c_vs[0]->min - c->c_vs[1]->min == c->constant_val)) {

		if (explored) {

			if (c->reified) {
				fprintf(stderr, "\nError: Constraint MINUS_EQ_REIF (%d) not respected:\n", c->c_id);
				fprintf(stderr, "Reif ID=%u -> minimum=%u, maximum=%u, number of values=%u\n\n", c->reif_v_id, b_get_min_val(&VS[c->reif_v_id].domain_b),
						b_get_max_val(&VS[c->reif_v_id].domain_b), b_cnt_vals(&VS[c->reif_v_id].domain_b));

			} else {
				fprintf(stderr, "\nError: Constraint MINUS_EQ (%d) not respected:\n", c->c_id);
			}

			fprintf(stderr, "Variable ID=%u -> minimum=%u, maximum=%u, number of values=%u\n\n", c->c_vs[0]->v_id, b_get_min_val(&c->c_vs[0]->domain_b),
					b_get_max_val(&c->c_vs[0]->domain_b), b_cnt_vals(&c->c_vs[0]->domain_b));
			fprintf(stderr, "Variable ID=%u -> minimum=%u, maximum=%u, number of values=%u\n\n", c->c_vs[1]->v_id, b_get_min_val(&c->c_vs[1]->domain_b),
					b_get_max_val(&c->c_vs[1]->domain_b), b_cnt_vals(&c->c_vs[1]->domain_b));
		}
		return false;
	}

	return true;
}

#endif

#if CS_MINUS_EQ == 1
/*
 * Propagate the domain of the variable with the ID prop_v_id through all the other variables on the same c_numb ID minus_eq constraint
 * x − y = k

 * vs_per_c_idx - vector with all constrained variables ID per constraint, per constraint ID order
 * vs_prop_ - all CSP variables with current step values

 * current_cs - constraint that should be propagated for the variable with prop_v_id ID
 * vs_id_to_prop_ - circular vector with the ids of the variables to propagate

 * prop_ok - will be set to 1 or 0 if the constraint is respected or not
 * terms_mem - auxiliary buffer

 */

CUDA_FUNC void minus_eq_prop(CL_INTS_MEM int *vs_per_c_idx, CL_MEMORY VARS_PROP *vs_prop_, CL_CS_MEM cl_constr *current_cs,
		CL_MEMORY unsigned short *vs_id_to_prop_, bool *prop_ok, __global int *terms_mem CS_IGNORE_FUNC TTL_CTR) {

	int x_id = vs_per_c_idx[0];
	int y_id = vs_per_c_idx[1];
	int k = current_cs->constant_val;

	__global int *consts = terms_mem;
	int n_vals;
	int i;
	bool contains;
	bool changed;

	cl_v_del_lt_m(&changed, &vs_prop_[y_id], V_MIN(vs_prop_[x_id]) - k TTL_CTR_V);
	if (changed) {
		if (V_IS_EMPTY(vs_prop_[y_id])) {
			*prop_ok = 0;
			return;

		}

		v_add_to_prop(vs_id_to_prop_, vs_prop_, y_id);
	}

	cl_v_del_gt_m(&changed, &vs_prop_[y_id], V_MAX(vs_prop_[x_id]) - k TTL_CTR_V);
	if (changed) {
		if (V_IS_EMPTY(vs_prop_[y_id])) {
			*prop_ok = 0;
			return;

		}

		v_add_to_prop(vs_id_to_prop_, vs_prop_, y_id);

	}

	cl_v_del_lt_m(&changed, &vs_prop_[x_id], V_MIN(vs_prop_[y_id]) + k TTL_CTR_V);
	if (changed) {

		if (V_IS_EMPTY(vs_prop_[x_id])) {
			*prop_ok = 0;
			return;
		}

		v_add_to_prop(vs_id_to_prop_, vs_prop_, x_id);

	}

	cl_v_del_gt_m(&changed, &vs_prop_[x_id], V_MAX(vs_prop_[y_id]) + k TTL_CTR_V);
	if (changed) {

		if (V_IS_EMPTY(vs_prop_[x_id])) {
			*prop_ok = 0;
			return;
		}

		v_add_to_prop(vs_id_to_prop_, vs_prop_, x_id);
	}

	n_vals = V_N_VALS(vs_prop_[x_id]);
	cl_d_get_nth_vals_m3(&vs_prop_[x_id].prop_d, 1, n_vals, consts TTL_CTR_V);

	for (i = 0; i < n_vals; i++) {
		cl_v_contains_val_m(&contains, &vs_prop_[y_id], consts[i] - k TTL_CTR_V);

		if (!contains) {
			cl_v_del_val_m(&changed, &vs_prop_[x_id], consts[i]);

			if (changed) {

				if (V_IS_EMPTY(vs_prop_[x_id])) {
					*prop_ok = 0;
					return;
				}
				v_add_to_prop(vs_id_to_prop_, vs_prop_, x_id);
			}
		}
	}
	if (V_N_VALS(vs_prop_[x_id]) != V_N_VALS(vs_prop_[y_id])) {

		n_vals = V_N_VALS(vs_prop_[y_id]);
		cl_d_get_nth_vals_m3(&vs_prop_[y_id].prop_d, 1, n_vals, consts TTL_CTR_V);

		for (i = 0; i < n_vals; i++) {
			cl_v_contains_val_m(&contains, &vs_prop_[x_id], consts[i] + k TTL_CTR_V);

			if (!contains) {
				cl_v_del_val_m(&changed, &vs_prop_[y_id], consts[i]);

				if (changed) {

					if (V_IS_EMPTY(vs_prop_[y_id])) {
						*prop_ok = 0;
						return;
					}
					v_add_to_prop(vs_id_to_prop_, vs_prop_, y_id);
				}
			}
		}
	}

#if CL_CS_IGNORE
	if (V_N_VALS(vs_prop_[x_id]) == 1 && V_N_VALS(vs_prop_[y_id]) == 1) {
		cs_ignore[current_cs->c_id] = 1;
	}
#endif

}

#if CS_R_MINUS_EQ == 1
/*
 * Validate minus_eq constraint to be normally propagated, when reified
 * x − y = k
 * vs_per_c_idx - vector with all constrained variables ID per constraint, per constraint ID order
 * vs_prop_ - all CSP variables with current step values

 * prop_v_id - ID of the variable marked for propagation in this constraint

 * current_cs - constraint that should be propagated for the variable with prop_v_id ID
 * vs_id_to_prop_ - circular vector with the ids of the variables to propagate
 */

CUDA_FUNC void minus_eq_reif( CL_INTS_MEM int *vs_per_c_idx, CL_MEMORY VARS_PROP *vs_prop_, unsigned int prop_v_id, CL_CS_MEM cl_constr *current_cs,
		CL_MEMORY unsigned short *vs_id_to_prop_ TTL_CTR) {

	int x_id = vs_per_c_idx[0];
	VARS_PROP x;
	int y_id = vs_per_c_idx[1];
	VARS_PROP y;
	int k = current_cs->constant_val;
	bool changed = 0;

	// constraint already fixed
	if (V_N_VALS(vs_prop_[x_id]) == 1 && V_N_VALS(vs_prop_[y_id]) == 1 && V_MIN(vs_prop_[x_id]) - V_MIN(vs_prop_[y_id]) == k) {
		cl_v_bool_del_val_m(&vs_prop_[current_cs->reif_var_id], 0 TTL_CTR_V);

		v_add_to_prop(vs_id_to_prop_, vs_prop_, convert_int (current_cs->reif_var_id));

		return;
	}

	// if the variable have only one value on its domain

	if (prop_v_id == (unsigned int) x_id) {

		cl_v_copy_pm(&y, &vs_prop_[y_id] TTL_CTR_V);

		cl_v_del_lt_n(&changed, &y, V_MIN(vs_prop_[x_id]) - k TTL_CTR_V);
		if (V_IS_EMPTY(y)) {
			cl_v_bool_del_val_m(&vs_prop_[current_cs->reif_var_id], 1 TTL_CTR_V);

			v_add_to_prop(vs_id_to_prop_, vs_prop_, convert_int (current_cs->reif_var_id));

			return;
		}

		cl_v_del_gt_n(&changed, &y, V_MAX(vs_prop_[x_id]) - k TTL_CTR_V);
		if (V_IS_EMPTY(y)) {
			cl_v_bool_del_val_m(&vs_prop_[current_cs->reif_var_id], 1 TTL_CTR_V);

			v_add_to_prop(vs_id_to_prop_, vs_prop_, convert_int (current_cs->reif_var_id));

		}
		return;

	}

	// if prop_v_id == y_id
	cl_v_copy_pm(&x, &vs_prop_[x_id] TTL_CTR_V);

	cl_v_del_lt_n(&changed, &x, V_MIN(vs_prop_[y_id]) + k TTL_CTR_V);
	if (V_IS_EMPTY(x)) {
		cl_v_bool_del_val_m(&vs_prop_[current_cs->reif_var_id], 1 TTL_CTR_V);

		v_add_to_prop(vs_id_to_prop_, vs_prop_, convert_int (current_cs->reif_var_id));

		return;
	}

	cl_v_del_gt_n(&changed, &x, V_MAX(vs_prop_[y_id]) + k TTL_CTR_V);
	if (V_IS_EMPTY(x)) {
		cl_v_bool_del_val_m(&vs_prop_[current_cs->reif_var_id], 1 TTL_CTR_V);

		v_add_to_prop(vs_id_to_prop_, vs_prop_, convert_int (current_cs->reif_var_id));

	}
}

/*
 * Propagate the domain of the variable with the ID prop_v_id through all the other variables on the same c_numb ID minus_eq opposite constraint
 * x − y != k
 * vs_per_c_idx - vector with all constrained variables ID per constraint, per constraint ID order
 * vs_prop_ - all CSP variables with current step values

 * prop_v_id - ID of the variable marked for propagation in this constraint

 * current_cs - constraint that should be propagated for the variable with prop_v_id ID
 * vs_id_to_prop_ - circular vector with the ids of the variables to propagate

 * prop_ok - will be set to 1 or 0 if the constraint is respected or not

 */

CUDA_FUNC void minus_eq_prop_opposite( CL_INTS_MEM int *vs_per_c_idx, CL_MEMORY VARS_PROP *vs_prop_, unsigned int prop_v_id, CL_CS_MEM cl_constr *current_cs,
		CL_MEMORY unsigned short *vs_id_to_prop_, bool *prop_ok CS_IGNORE_FUNC TTL_CTR) {

	int x_id = vs_per_c_idx[0];
	int y_id = vs_per_c_idx[1];
	bool changed = 0;

	// if the variable have only one value on its domain
	if (V_N_VALS(vs_prop_[prop_v_id]) == 1) {

		if (prop_v_id == (unsigned int) x_id) {

			// prune domain
			cl_v_del_val_m(&changed, &vs_prop_[y_id], V_MIN(vs_prop_[x_id]) - current_cs->constant_val TTL_CTR_V);
			if (changed) {

				// if the removal of the value resulted in an empty domain return 0
				if (V_IS_EMPTY(vs_prop_[y_id])) {
					*prop_ok = 0;
					return;
				}
				// Add variable to the vector that contains the variables that must be propagated
				v_add_to_prop(vs_id_to_prop_, vs_prop_, y_id);
			}

#if CL_CS_IGNORE
			cs_ignore[current_cs->c_id] = 1;
#endif

			return;
		}

		if (prop_v_id == (unsigned int) y_id) {
			cl_v_del_val_m(&changed, &vs_prop_[x_id], V_MIN(vs_prop_[y_id]) + current_cs->constant_val TTL_CTR_V);
			if (changed) {

				// if the removal of the value resulted in an empty domain return 0
				if (V_IS_EMPTY(vs_prop_[x_id])) {
					*prop_ok = 0;
					return;
				}
				// Add variable to the vector that contains the variables that must be propagated
				v_add_to_prop(vs_id_to_prop_, vs_prop_, x_id);

			}

#if CL_CS_IGNORE

			cs_ignore[current_cs->c_id] = 1;

#endif

		}

	}
}
#endif

/*
 * Decides the propagator to call for this constraint
 * vs_per_c_idx - vector with all constrained variables ID per constraint, per constraint ID order
 * vs_prop_ - all CSP variables with current step values
 * prop_v_id - ID of the variable marked for propagation in this constraint
 * current_cs - constraint that should be propagated for the variable with prop_v_id ID
 * vs_id_to_prop_ - circular vector with the ids of the variables to propagate
 * prop_ok - will be set to 1 or 0 if the constraint is respected or not
 * terms_mem - auxiliary buffer
 */
CUDA_FUNC void minus_eq_propagate( CL_INTS_MEM int *vs_per_c_idx, CL_MEMORY VARS_PROP *vs_prop_, unsigned int prop_v_id, CL_CS_MEM cl_constr *current_cs,
		CL_MEMORY unsigned short *vs_id_to_prop_, bool *prop_ok, __global int *terms_mem PROPAGATED_FUNC CS_IGNORE_FUNC TTL_CTR) {

#if CS_R_MINUS_EQ == 0

	minus_eq_prop(vs_per_c_idx, vs_prop_, current_cs, vs_id_to_prop_, prop_ok, terms_mem CS_IGNORE_CALL TTL_CTR_V);

#if CL_STATS == 1
	*propagated = true;
#endif

#elif CS_R_MINUS_EQ == 1
	if (current_cs->reified == 1) {

		if (V_N_VALS(vs_prop_[current_cs->reif_var_id]) > 1) {
			minus_eq_reif(vs_per_c_idx, vs_prop_, prop_v_id, current_cs, vs_id_to_prop_ TTL_CTR_V);

		} else {
			if (V_MIN(vs_prop_[current_cs->reif_var_id]) == 1) {
				minus_eq_prop(vs_per_c_idx, vs_prop_, current_cs, vs_id_to_prop_, prop_ok, terms_mem CS_IGNORE_CALL TTL_CTR_V);
			} else {
				minus_eq_prop_opposite(vs_per_c_idx, vs_prop_, prop_v_id, current_cs, vs_id_to_prop_, prop_ok CS_IGNORE_CALL TTL_CTR_V);

			}

#if CL_STATS == 1

			*propagated = true;

#endif

		}
	} else {

		minus_eq_prop(vs_per_c_idx, vs_prop_, current_cs, vs_id_to_prop_, prop_ok, terms_mem CS_IGNORE_CALL TTL_CTR_V);

#if CL_STATS == 1
		*propagated = true;
#endif
	}
#endif
}

#endif