/*
 * exactly.c
 *
 *  Created on: 12/03/2017

 *      Author: pedro

 */

#ifndef __OPENCL_VERSION__

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

#include "exactly.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 exactly type and return the constraint ID
 * #{i | X[i] = k} = c
 * X_ids - vector with the ID of the variables that may contain k
 * n_vs - maximum number of variables in X vector
 * c - number of variables in X that must contain k
 * k - Value that should be in X[i] domain
 */

unsigned int c_exactly(unsigned int* X_ids, unsigned int n_vs, unsigned int c, unsigned int k) {

	unsigned int i;

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

	unsigned int* c_vs = malloc(n_vs * sizeof(unsigned int));

	for (i = 0; i < n_vs; i++) {
		c_vs[i] = X_ids[i];
	}

	int consts[2];

	consts[0] = (int)k;
	consts[1] = (int)c;

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

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

	free(c_vs);

	return c_id;
}

/*
 * Creates a new reified constraint of the exactly type and return the constraint ID
 * #{i | X[i] = k} = c
 * X_ids - vector with the ID of the variables that may contain k
 * n_vs - maximum number of variables in X vector
 * c - number of variables in X that must contain k
 * k - Value that should be in X[i] domain
 * reif_v_id - ID of the reification variable
 */

unsigned int c_exactly_reif(unsigned int* X_ids, unsigned int n_vs, unsigned int c, unsigned int k, int reif_v_id) {

	unsigned int i;

	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 EXACTLY_REIF makes model inconsistent at creation:\n");
			exit(-1);
		}
	}

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

	REV = 1;

	unsigned int* c_vs = malloc(n_vs * sizeof(unsigned int));

	for (i = 0; i < n_vs; i++) {
		c_vs[i] = X_ids[i];
	}

	int consts[2];

	consts[0] = (int)k;
	consts[1] = (int)c;

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

	// pointers to this type of constraint functions
	CS[c_id].kind = EXACTLY;

	CS[c_id].check_sol_f = &exactly_check;
	CS[c_id].constant_val = 0;

	free(c_vs);

	return c_id;
}

/*
 * Return true if the exactly constraint is respected or false if not
 * #{i | X[i] = k} = c
 * 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 exactly_check(constr* c, bool explored) {
	var** X = c->c_vs;
	var* x;
	int k = c->c_consts[0];
	int co = c->c_consts[1];
	int set = 0;

	unsigned int i;

	for (i = 0; i < c->n_c_vs; i++) {

		x = X[i];

#if CHECK_SOL_N_VALS
		if (x->to_label && x->n_vals != 1) {

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

				for (i = 0; i < c->n_c_vs; i++) {

					fprintf(stderr, "Variable ID=%u -> minimum=%u, maximum=%u, number of values=%u\n\n", c->c_vs[i]->v_id, b_get_min_val(&c->c_vs[i]->domain_b),

							b_get_max_val(&c->c_vs[i]->domain_b), b_cnt_vals(&c->c_vs[i]->domain_b));
				}
			}
			return false;

		} else

#endif

		if (x->min == k) {
			set++;
		}
	}

	// if more than c variables are set to k

	if (set != co) {

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

			for (i = 0; i < c->n_c_vs; i++) {

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

			}
		}
		return false;
	}

	return true;
}

#endif

#if CS_EXACTLY == 1
/*
 * Propagate the domain of the variable with the ID prop_v_id through all the other variables on the same c_numb ID exactly constraint
 * #{i | X[i] = k} = c
 * 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
 * c_consts - vector with all constrained constants 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
 */
CUDA_FUNC void exactly_prop(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 k = c_consts[0];
	int c = c_consts[1];

	int set = 0;

	int possible = 0;

	bool contains;

	bool changed = 0;
	int x_id;

	int i;

	for (i = 0; i < current_cs->n_c_vs; i++) {
		CHECK_TTL(ttl_ctr, 57)

		x_id = vs_per_c_idx[i];

		// if more than c variables are already set to k, return 0
		if (V_N_VALS(vs_prop_[x_id]) == 1 && V_MIN(vs_prop_[x_id]) == k) {
			if (++set > c) {
				*prop_ok = 0;
				return;
			}
			// number of variables that may be set to k
		} else {
			cl_v_contains_val_m(&contains, &vs_prop_[x_id], k TTL_CTR_V);
			if (contains) {
				possible++;
			}
		}
	}

	// if there are not enough variables to set to k
	if (set + possible < c) {
		*prop_ok = 0;
		return;
	}

	// if the sum of the variables that contain k are c, assign all of them to k
	if (set + possible == c) {

		for (i = 0; possible > 0; i++) {
			CHECK_TTL(ttl_ctr, 58)

			x_id = vs_per_c_idx[i];
			if (V_N_VALS(vs_prop_[x_id]) > 1) {

				cl_v_contains_val_m(&contains, &vs_prop_[x_id], k TTL_CTR_V);
				if (contains) {
					cl_v_del_all_except_val_m(&changed, &vs_prop_[x_id], k TTL_CTR_V);
					possible--;
					v_add_to_prop(vs_id_to_prop_, vs_prop_, x_id);
				}
			}
		}

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

	// if all the variables already assigned to k are c, remove k from the other variables
	if (set == c) {

		for (i = 0; possible > 0; i++) {
			CHECK_TTL(ttl_ctr, 59)
			x_id = vs_per_c_idx[i];

			if (V_N_VALS(vs_prop_[x_id]) > 1) {

				cl_v_del_val_m(&changed, &vs_prop_[x_id], k TTL_CTR_V);
				if (changed) {
					possible--;
					v_add_to_prop(vs_id_to_prop_, vs_prop_, x_id);
				}
			}
		}

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

#if CS_R_EXACTLY == 1
/*
 * Validate exactly constraint to be normally propagated, when reified
 * #{i | X[i] = k} = c
 * vs_per_c_idx - vector with all constrained variables ID per constraint, per constraint ID order
 * c_consts - vector with all constrained constants 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 exactly_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 k = c_consts[0];
	int c = c_consts[1];
	int set = 0;
	int possible = 0;

	bool contains;

	int x_id;
	int i;

	for (i = 0; i < current_cs->n_c_vs; i++) {

		CHECK_TTL(ttl_ctr, 60)
		x_id = vs_per_c_idx[i];

		// if more than c variables are already set to k
		if (V_N_VALS(vs_prop_[x_id]) == 1 && V_MIN(vs_prop_[x_id]) == k) {
			if (++set > c) {
				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
				return;
			}
			// number of variables that may be set to k
		} else {
			cl_v_contains_val_m(&contains, &vs_prop_[x_id], k TTL_CTR_V);
			if (contains) {
				possible++;

			}

		}
	}

	// if there are not enough variables to set to k
	if (set + possible < c) {
		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
		return;
	}

	// constraint already fixed
	if (set == c && possible == 0) {
		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));

#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 exactly opposite constraint
 * #{i | X[i] = k} != c
 * vs_per_c_idx - vector with all constrained variables ID per constraint, per constraint ID order

 * c_consts - vector with all constrained constants 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
 */
CUDA_FUNC void exactly_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_ CS_IGNORE_FUNC TTL_CTR) {

	int k = c_consts[0];
	int c = c_consts[1];
	int set = 0;

	int possible = 0;

	bool contains;

	bool changed = 0;
	int x_id;
	int i;

	for (i = 0; i < current_cs->n_c_vs; i++) {

		CHECK_TTL(ttl_ctr, 57)
		x_id = vs_per_c_idx[i];

		// if more than c variables are already set to k, return 1
		if (V_N_VALS(vs_prop_[x_id]) == 1 && V_MIN(vs_prop_[x_id]) == k) {
			if (++set > c) {
				return;
			}
			// number of variables that may be set to k
		} else {
			cl_v_contains_val_m(&contains, &vs_prop_[x_id], k TTL_CTR_V);
			if (contains) {
				possible++;
			}
		}
	}

	// if there are not enough variables to set to k
	if (set + possible < c) {

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

	// if the sum of the variables that are set to c are c and that contain c are c+1, assign it to k
	if (set == c && possible == 1) {

		for (i = 0; possible > 0; i++) {
			CHECK_TTL(ttl_ctr, 58)

			x_id = vs_per_c_idx[i];

			if (V_N_VALS(vs_prop_[x_id]) > 1) {

				cl_v_contains_val_m(&contains, &vs_prop_[x_id], k TTL_CTR_V);
				if (contains) {
					cl_v_del_all_except_val_m(&changed, &vs_prop_[x_id], k TTL_CTR_V);
					possible--;
					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

CUDA_FUNC void exactly_propagate(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 PROPAGATED_FUNC CS_IGNORE_FUNC TTL_CTR) {

#if CS_R_EXACTLY == 0
	exactly_prop(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
#elif CS_R_EXACTLY == 1
	if (current_cs->reified == 1) {
		if (V_N_VALS(vs_prop_[current_cs->reif_var_id]) > 1) {

			exactly_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) {
				exactly_prop(vs_per_c_idx, c_consts, vs_prop_, current_cs, vs_id_to_prop_, prop_ok CS_IGNORE_CALL TTL_CTR_V);
			} else {
				exactly_prop_opposite(vs_per_c_idx, c_consts, vs_prop_, current_cs, vs_id_to_prop_ CS_IGNORE_CALL TTL_CTR_V);
			}
#if CL_STATS == 1
			*propagated = true;
#endif

		}
	} else {
		exactly_prop(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

	}

#endif
}

#endif