/* short.c */

#include <stdio.h>		/* C input/output                       */
#include <stdlib.h>		/* C standard library                   */
#include <glpk.h>		/* GNU GLPK linear/mixed integer solver */
#include <string.h>
#include "test.h"


int col_num = 1;
int num_col_sp = 1;


void add_column(glp_prob *lp, float coef) {
	glp_add_cols(lp, 1);
	char name[10] = "";
	snprintf(name, sizeof name, "rouleau%d", col_num);
	glp_set_col_name(lp, col_num, name);
	glp_set_col_bnds(lp, col_num, GLP_LO, 0.0, 0.0);
	glp_set_obj_coef(lp, col_num, coef);

	col_num++;
}

void add_column_sp(glp_prob *lp) {
	glp_add_cols(lp, 1);
	char name[10] = "";
	snprintf(name, sizeof name, "rouleau%d", num_col_sp);
	glp_set_col_name(lp, num_col_sp, name);
	glp_set_col_bnds(lp, num_col_sp, GLP_LO, 0.0, 0.0);
	glp_set_obj_coef(lp, num_col_sp, 1.0);
	num_col_sp++;
}

void column_generator(int y1, int y2, int y3, int y4, int a[static 4]) {
	glp_prob *sous_prob;
	int ia[1 + 1000];
	int ja[1 + 1000];
	double ar[1 + 1000];
	/* double z, x1, x2, x3, x4; */

	/* create problem */
	sous_prob = glp_create_prob();
	glp_set_prob_name(sous_prob, "rouleaux-parfaits");
	glp_set_obj_dir(sous_prob, GLP_MAX);

	/* fill problem */
	glp_add_rows(sous_prob, 4);
	glp_set_row_name(sous_prob, 1, "taille0");
	glp_set_row_bnds(sous_prob, 1, GLP_UP,  0.0, 100.0);

	num_col_sp = 1;

	const double coeffs[] = {45.0, 36.0, 31.0, 14.0};
	for (int i = 1; i < 5; i++) {
		add_column_sp(sous_prob);
		glp_set_col_kind(sous_prob, i, GLP_IV);
		ia[i] = 1;
		ja[i] = i;
		ar[i] = coeffs[i];
	}
	glp_load_matrix(sous_prob, 4, ia, ja, ar);

	/* solve problem */
	glp_simplex(sous_prob, NULL);
	glp_intopt(sous_prob, NULL);

	a[0] = glp_get_obj_val(sous_prob);
	a[1] = glp_mip_col_val(sous_prob, 1);
	a[2] = glp_mip_col_val(sous_prob, 2);
	a[3] = glp_mip_col_val(sous_prob, 3);
	a[4] = glp_mip_col_val(sous_prob, 4);

	printf("a1 = %d; a2 = %d; a3 = %d; a4 = %d\n", a[1], a[2], a[3], a[4]);
	/* housekeeping */
	glp_delete_prob(sous_prob);
	glp_free_env();
	//glp_intopt(glp_prob *mip, const glp_iocp *parm);

}

int perfect_rolls() {
	/* declare variables */
	glp_prob *lp;
	int ia[1 + 1000] = {0}, ja[1 + 1000] = {0};
	double ar[1 + 1000] = {0}, z, x1, x2, x3, x4;
	/* create problem */
	lp = glp_create_prob();
	glp_set_prob_name(lp, "rouleaux-parfaits");
	glp_set_obj_dir(lp, GLP_MIN);
	/* fill problem */
	glp_add_rows(lp, 4);

	char name[8] = "";
	const double bounds[4] = {97, 610, 395, 211};
	for (int i = 1; i < 5; i++) {
		snprintf(name, sizeof name, "taille%d", i);
		glp_set_row_name(lp, 1, name);
		glp_set_row_bnds(lp, 1, GLP_LO,  bounds[i-1], 0.0);
		add_column(lp, 1.0);
		ia[i] = i;
		ja[i] = i;
		ar[i] = 1;
	}

	int nb_coeffs = 4;
	double y1, y2, y3, y4;
	int a[4] = {0};
	while (1) {
		printf("nb_coeffs=%d\n", nb_coeffs);
		for (int i = 0; i < nb_coeffs + 4; i++) {
			printf("ar[%d]=%g\n", i, ar[i]);
		}
		printf("\n");

		glp_load_matrix(lp, nb_coeffs, ia, ja, ar);
		printf("col_num=%d\n", col_num);

		/* solve problem */
		glp_prob *tmp_prob = glp_create_prob();
		glp_copy_prob(tmp_prob, lp, GLP_ON);
		glp_simplex(tmp_prob, NULL);
		y1 = glp_get_row_dual(tmp_prob, 1);
		y2 = glp_get_row_dual(tmp_prob, 2);
		y3 = glp_get_row_dual(tmp_prob, 3);
		y4 = glp_get_row_dual(tmp_prob, 4);

		column_generator(y1, y2, y3, y4, a);
		if (a[0] > 1) {
			for (int i = 1; i <= 4; i++) {
				printf("a[%d]=%d\n", i, a[i]);
			}
			add_column(lp, 1.0);
			for (int i = 1; i < 5; i++) {
				/* a[col_num, i] = a[i] */
				nb_coeffs++;
				ia[nb_coeffs] = i;
				ja[nb_coeffs] = col_num-1;
				ar[nb_coeffs] = a[i];
			}
		}
		else {
			break;
		}
	}

	/* recover and display results */
	z = glp_get_obj_val(lp);
	x1 = glp_get_col_prim(lp, 1);
	x2 = glp_get_col_prim(lp, 2);
	x3 = glp_get_col_prim(lp, 3);
	x4 = glp_get_col_prim(lp, 4);
	printf("z = %g; x1 = %g; x2 = %g; x3 = %g; x4 = %g\n", z, x1, x2, x3, x4);

	/* housekeeping */
	glp_delete_prob(lp);
	glp_free_env();

	return z;
}

int main(void) {
	perfect_rolls();
	return 0;
}