/*
 * element_int_var.c
 *
 *  Created on: 17/04/2018
 *      Author: pedro
 */

#ifndef __OPENCL_VERSION__

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

#include "element_int_var.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 element_int_var type and return the constraint ID
 * 1 ≤ y <= n ∧ K[y] = z
 * K - vector with the integers whose index may be in the domain of y variable
 * n_consts - number of integers in K vector
 * y_id - ID of the variable whose domain are the index of the variables in elements vector
 * z_id - ID of the variable that should contain all the values in K[y]
 */
unsigned int c_element_int_var(int* K, unsigned int n_consts, unsigned int y_id, unsigned int z_id) {
	var* y = &VS[y_id];

	if (y->max > n_consts) {
		v_del_gt(y, (int)n_consts);
		if (y->n_vals == 0) {
			fprintf(stderr, "\nError: Constraint ELEMENT_INT_VAR makes model inconsistent at creation:\n");
			exit(-1);
		}
	}

	if (y->min == 0) {
		v_del_val(y, 0);
		if (y->n_vals == 0) {
			fprintf(stderr, "\nError: Constraint ELEMENT_INT_VAR makes model inconsistent at creation:\n");
			exit(-1);
		}
	}

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

	unsigned int c_vs[2];

	c_vs[0] = y_id;
	c_vs[1] = z_id;

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

	// pointers to this type of constraint functions
	CS[c_id].kind = ELEMENT_INT_VAR;
	CS[c_id].check_sol_f = &element_int_var_check;
	CS[c_id].constant_val = 0;

	return c_id;
}

/*
 * Creates a new reified constraint of the element_int_var type and return the constraint ID
 * 1 ≤ y <= n ∧ K[y] = z
 * K - vector with the integers whose index may be in the domain of y variable
 * n_consts - number of integers in K vector
 * y_id - ID of the variable whose domain are the index of the variables in elements vector
 * z_id - ID of the variable that should contain all the values in K[y]
 */
unsigned int c_element_int_var_reif(int* K, unsigned int n_consts, unsigned int y_id, unsigned int z_id, int reif_v_id) {
	var* y = &VS[y_id];

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

		if (VS[reif_v_id].n_vals == 0) {
			fprintf(stderr, "\nError: Constraint ELEMENT_INT_VAR_REIF makes model inconsistent at creation:\n");
			exit(-1);
		}
	}

	if (y->max > n_consts) {
		v_del_gt(y, (int)n_consts);
		if (y->n_vals == 0) {
			fprintf(stderr, "\nError: Constraint ELEMENT_INT_VAR makes model inconsistent at creation:\n");
			exit(-1);
		}
	}

	if (y->min == 0) {
		v_del_val(y, 0);
		if (y->n_vals == 0) {
			fprintf(stderr, "\nError: Constraint ELEMENT_INT_VAR makes model inconsistent at creation:\n");
			exit(-1);
		}
	}

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

	unsigned int c_vs[2];

	c_vs[0] = y_id;
	c_vs[1] = z_id;

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

	// pointers to this type of constraint functions
	CS[c_id].kind = ELEMENT_INT_VAR;
	CS[c_id].check_sol_f = &element_int_var_check;
	CS[c_id].constant_val = 0;

	return c_id;
}

/*
 * Return true if the element_int_var constraint is respected or false if not
 * 1 ≤ y <= n ∧ K[y] = z
 * 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 element_int_var_check(constr* c, bool explored) {
	int* K = c->c_consts;
	var* y = c->c_vs[0];
	var* z = c->c_vs[1];

	if (
#if CHECK_SOL_N_VALS
			(y->to_label && y->n_vals != 1) || (z->to_label && z->n_vals != 1) ||
#endif
			K[y->min - 1] != z->min) {

		if (explored) {
			fprintf(stderr, "\nError: Constraint ELEMENT_INT_VAR (%u) not respected:\n", c->c_id);

			fprintf(stderr, "Constant value=%u\n\n", K[y->min - 1]);
			fprintf(stderr, "Variable ID=%u -> minimum=%u, maximum=%u, number of values=%u\n\n", y->v_id_print, b_get_min_val(&y->domain_b),
					b_get_max_val(&y->domain_b), b_cnt_vals(&y->domain_b));
			fprintf(stderr, "Variable ID=%u -> minimum=%u, maximum=%u, number of values=%u\n\n", z->v_id_print, b_get_min_val(&z->domain_b),
					b_get_max_val(&z->domain_b), b_cnt_vals(&z->domain_b));
		}
		return false;
	}

	return true;
}

#endif

#if CS_ELEMENT_INT_VAR == 1
/*
 * Propagate the domain of the variable with the ID prop_v_id through all the other variables on the same c_numb ID element_int_var constraint
 * 1 ≤ y <= n ∧ K[y] = z
 * prop_ok will be set to 1 if success or to 0 if any domain became empty
 * 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 - variable ID to propagate
 * 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
 */
#if CS_IGNORE == 0
#ifndef __OPENCL_VERSION__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
#endif
CUDA_FUNC void element_int_var_prop(CL_INTS_MEM int* vs_per_c_idx, CL_INTS_MEM int* c_consts, 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 CS_IGNORE_FUNC TTL_CTR) {

	int y_id = vs_per_c_idx[0];	// ID of the variable whose domain are the index of the constants vector
	int z_id = vs_per_c_idx[1];	// ID of the variable that should contain all the values in all the K[y]
	CL_INTS_MEM int* K = c_consts;	// constants constrained by this constraint
	int k_id_min, k_id_max;
	int z_n_vals;
	__global int* consts_y = terms_mem;
	__global int* consts_z = &terms_mem[CL_D_MAX + 1];
	int val;
	DOMAIN_ d;
	bool empty;
	bool contains;
	bool changed;
	int i, j, k;

	// y to prop
	if (V_N_VALS(vs_prop_[y_id]) == 1) {

		cl_v_del_all_except_val_m(&changed, &vs_prop_[z_id], K[V_MIN(vs_prop_[y_id]) - 1] TTL_CTR_V);
		if (changed) {

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

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

		return;
	}

	k_id_min = V_MIN(vs_prop_[y_id]) - 1;	// minimum ID of the constant included in K
	k_id_max = V_MAX(vs_prop_[y_id]) - 1;	// maximum ID of the constant included in K

	// if z is to prop and is singleton (and y is not), remove from y all the indexes of constants that are not in z domain
	if (V_N_VALS(vs_prop_[z_id]) == 1) {
		val = V_MIN(vs_prop_[z_id]);

		j = 0;
		for (i = k_id_min; i <= k_id_max; i++) {
			if (val == K[i]) {
				consts_y[j++] = i + 1;
			}
		}

		if (j == 0) {
			*prop_ok = 0;
			return;
		}

		cl_d_new_vals_pg(&d, consts_y, j TTL_CTR_V);

		cl_d_intersect_d_mp(&changed, &vs_prop_[y_id].prop_d, &d TTL_CTR_V);
		if (changed) {
			// if the intersection between the domains of K[y] and z is empty
			cl_d_is_empty_m(&empty, &vs_prop_[y_id].prop_d TTL_CTR_V);
			if (empty) {
				*prop_ok = 0;
				return;
			}

			cl_v_calc_min_val_m(&vs_prop_[y_id] TTL_CTR_V);
			cl_v_calc_max_val_m(&vs_prop_[y_id] TTL_CTR_V);
			cl_v_cnt_vals_m(&vs_prop_[y_id] TTL_CTR_V);

			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;
	}

	//y and z are not singleton
	j = 0;
	for (i = k_id_min; i <= k_id_max; i++) {
		CHECK_TTL(ttl_ctr, 55)

		cl_v_contains_val_m(&contains, &vs_prop_[y_id], i + 1 TTL_CTR_V);

		if (contains) {
			consts_y[j++] = K[i];
		}
	}

	if (j == 0) {
		*prop_ok = 0;
		return;
	}

	cl_d_new_vals_pg(&d, consts_y, j TTL_CTR_V);

	bool equal;
	cl_ds_equal_pm(&equal, &d, &vs_prop_[z_id].prop_d TTL_CTR_V);
	if (!equal) {

	// prop_v_id = y_id
		if (prop_v_id == (unsigned int)y_id) {
			cl_d_intersect_d_mp(&changed, &vs_prop_[z_id].prop_d, &d TTL_CTR_V);

			if (changed) {
				// if the intersection between the domains of K[y] and z is empty
				cl_d_is_empty_m(&empty, &vs_prop_[z_id].prop_d TTL_CTR_V);
				if (empty) {
					*prop_ok = 0;
					return;
				}

				cl_v_calc_min_val_m(&vs_prop_[z_id] TTL_CTR_V);
				cl_v_calc_max_val_m(&vs_prop_[z_id] TTL_CTR_V);
				cl_v_cnt_vals_m(&vs_prop_[z_id] TTL_CTR_V);

				v_add_to_prop(vs_id_to_prop_, vs_prop_, z_id);
			}
			return;
		}

		// prop_v_id = z_id
		cl_d_intersect_d_pm(&changed, &d, &vs_prop_[z_id].prop_d TTL_CTR_V);
		if (changed) {
			cl_d_is_empty_n(&empty, &d TTL_CTR_V);
			if (empty) {
				*prop_ok = 0;
				return;
			}

			z_n_vals = V_N_VALS(vs_prop_[z_id]);
			cl_d_get_nth_vals_m3(&vs_prop_[z_id].prop_d, 1, z_n_vals, consts_z TTL_CTR_V);

			for (i = k_id_min; i <= k_id_max; i++) {
				CHECK_TTL(ttl_ctr, 55)

				for (k = 0; k < z_n_vals; k++) {
					if (consts_z[k] == K[i]) {
						break;
					}
				}
				if (k == z_n_vals) {
					cl_v_del_val_m(&changed, &vs_prop_[y_id], i + 1 TTL_CTR_V);

					if (changed) {
						if (V_N_VALS(vs_prop_[y_id]) == 0) {
							*prop_ok = 0;
							return;
						}
						v_add_to_prop(vs_id_to_prop_, vs_prop_, y_id);
					}
				}
			}
		}
	}
}
#ifndef __OPENCL_VERSION__
#if CS_IGNORE == 0
#pragma GCC diagnostic pop
#endif
#endif

#if CS_R_ELEMENT_INT_VAR == 1
/*
 * Validate element_int_var constraint to be normally propagated, when reified
 * 1 ≤ y <= n ∧ K[y] = z
 * 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
 */
CUDA_FUNC void element_int_var_reif( CL_INTS_MEM int* vs_per_c_idx, CL_INTS_MEM int* c_consts, CL_MEMORY VARS_PROP* vs_prop_, CL_CS_MEM cl_constr* current_cs,
		CL_MEMORY unsigned short* vs_id_to_prop_ CS_IGNORE_FUNC TTL_CTR) {

	int y_id = vs_per_c_idx[0];	// ID of the variable whose domain are the index of the constants vector
	int z_id = vs_per_c_idx[1];	// ID of the variable that should contain all the values in all the K[y]
	CL_INTS_MEM int* K = c_consts;	// constants constrained by this constraint

	if (V_N_VALS(vs_prop_[y_id]) == 1 && V_N_VALS(vs_prop_[z_id]) == 1) {

		if (V_MIN(vs_prop_[z_id]) == K[V_MIN(vs_prop_[y_id]) - 1]) {
			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));

		} else {
			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));
		}
#if CL_CS_IGNORE
		cs_ignore[current_cs->c_id] = 1;
#endif
	}
}

/*
 * Propagate the domain of the variable with the ID prop_v_id through all the other variables on the same c_numb ID element_int_var opposite constraint
 * 1 ≤ y <= n ∧ K[y] = z
 * 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 - variable ID to propagate
 * 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
 */
#if CS_IGNORE == 0
#ifndef __OPENCL_VERSION__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
#endif
CUDA_FUNC void element_int_var_prop_opposite(CL_INTS_MEM int* vs_per_c_idx, CL_INTS_MEM int* c_consts, CL_MEMORY VARS_PROP* vs_prop_, CL_CS_MEM cl_constr* current_cs,
		CL_MEMORY unsigned short* vs_id_to_prop_, bool* prop_ok CS_IGNORE_FUNC TTL_CTR) {

	int y_id = vs_per_c_idx[0];	// ID of the variable whose domain are the index of the constants vector
	int z_id = vs_per_c_idx[1];	// ID of the variable that should contain all the values in all the K[y]
	CL_INTS_MEM int* K = c_consts;	// constants constrained by this constraint
	bool changed;

	if (V_N_VALS(vs_prop_[y_id]) == 1) {
		cl_v_del_val_m(&changed, &vs_prop_[z_id], K[V_MIN(vs_prop_[y_id]) - 1] TTL_CTR_V);
		if (changed) {

			// if the intersection between the domains of K[y] and z is empty
			if (V_IS_EMPTY(vs_prop_[z_id])) {
				*prop_ok = 0;
				return;
			}
			v_add_to_prop(vs_id_to_prop_, vs_prop_, z_id);
		}
#if CL_CS_IGNORE
		cs_ignore[current_cs->c_id] = 1;
#endif
	}
}
#if CS_IGNORE == 0
#ifndef __OPENCL_VERSION__
#pragma GCC diagnostic pop
#endif
#endif

#endif

CUDA_FUNC void element_int_var_propagate(CL_INTS_MEM int* vs_per_c_idx, CL_INTS_MEM int* c_consts, 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_ELEMENT_INT_VAR == 0
	element_int_var_prop(vs_per_c_idx, c_consts, vs_prop_, prop_v_id, 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_ELEMENT_INT_VAR == 1
	if (current_cs->reified == 1) {
		if (prop_v_id != current_cs->reif_var_id) {
			if (V_N_VALS(vs_prop_[current_cs->reif_var_id]) > 1) {
				element_int_var_reif(vs_per_c_idx, c_consts, vs_prop_, current_cs, vs_id_to_prop_ CS_IGNORE_CALL TTL_CTR_V);

			} else {
				if (V_MIN(vs_prop_[current_cs->reif_var_id]) == 1) {
					element_int_var_prop(vs_per_c_idx, c_consts, vs_prop_, prop_v_id, current_cs, vs_id_to_prop_, prop_ok, terms_mem CS_IGNORE_CALL TTL_CTR_V);
				} else {
					element_int_var_prop_opposite(vs_per_c_idx,  c_consts, vs_prop_, current_cs, vs_id_to_prop_, prop_ok CS_IGNORE_CALL TTL_CTR_V);
				}
#if CL_STATS == 1
				*propagated = true;
#endif
			}
		}
	} else {
		element_int_var_prop(vs_per_c_idx, c_consts, vs_prop_, prop_v_id, 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