#include <iostream>

#include <coin/OsiClpSolverInterface.hpp>
#include <coin/CoinBuild.hpp>
#include <coin/CbcModel.hpp>

using namespace std;

#define NUM (144)

/** Definition of variable start ranges */
#define OFFSET_BIN1 (0)
#define OFFSET_BIN2 (OFFSET_BIN1 + NUM)
#define OFFSET_BIN3 (OFFSET_BIN2 + NUM)
#define OFFSET_DBL1 (OFFSET_BIN3 + NUM)
#define OFFSET_DBL2 (OFFSET_DBL1 + NUM)
#define OFFSET_DBL3 (OFFSET_DBL2 + NUM)
#define OFFSET_DBL4 (OFFSET_DBL3 + NUM)

#define OFFSET_DBL5 (OFFSET_DBL4 + NUM)
#define OFFSET_DBL6 (OFFSET_DBL5 + NUM)

#define OFFSET_DBL7 (OFFSET_DBL6 + NUM)

#define OFFSET_DBL8 (OFFSET_DBL7 + NUM)
#define OFFSET_DBL9 (OFFSET_DBL8 + NUM)
#define OFFSET_DBL10 (OFFSET_DBL9 + NUM)
#define OFFSET_DBL11 (OFFSET_DBL10 + NUM)
#define COUNT (OFFSET_DBL11 + NUM)

double param1;
double param2;
double param3;
double param4;
double param5;
double param6;
double param7;
double param8;
int param9;

double param10;
double param11;
double param12;

int param13[NUM];
double param14;
double param15;
double param16;

double param17;
double param18;
double param19;
double param20;
double param21;
double param22[NUM];

double param23[NUM];
double param24[NUM];

void addColumns(OsiSolverInterface *solver) {
	int i;
	for (i = OFFSET_BIN1; i < OFFSET_BIN1 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, 1, 0);
		solver->setInteger(i);
	}
	for (i = OFFSET_BIN2; i < OFFSET_BIN2 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, 1, 0);
		solver->setInteger(i);
	}
	for (i = OFFSET_BIN3; i < OFFSET_BIN3 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, 1, 0);
		solver->setInteger(i);
	}
	for (i = OFFSET_DBL1; i < OFFSET_DBL1 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, COIN_DBL_MAX, 0);
	}
	for (i = OFFSET_DBL2; i < OFFSET_DBL2 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, COIN_DBL_MAX, 0);
	}
	for (i = OFFSET_DBL3; i < OFFSET_DBL3 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, COIN_DBL_MAX, 0);
	}
	for (i = OFFSET_DBL4; i < OFFSET_DBL4 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, COIN_DBL_MAX, 0);
	}

	for (i = OFFSET_DBL5; i < OFFSET_DBL5 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, param12 * 0.25, 0);
	}
	for (i = OFFSET_DBL6; i < OFFSET_DBL6 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, COIN_DBL_MAX, 0);
	}

	for (i = OFFSET_DBL7; i < OFFSET_DBL7 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, param16 * 0.25, 0);
	}

	for (i = OFFSET_DBL8; i < OFFSET_DBL8 + NUM; i++) {
		solver->addCol(0, NULL, NULL, param17 * -0.25, param17 * 0.25, 0);
	}
	for (i = OFFSET_DBL9; i < OFFSET_DBL9 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, param20 * param22[i - OFFSET_DBL9], 0);
	}

	for (i = OFFSET_DBL10; i < OFFSET_DBL10 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, COIN_DBL_MAX, 0);
	}
	for (i = OFFSET_DBL11; i < OFFSET_DBL11 + NUM; i++) {
		solver->addCol(0, NULL, NULL, 0, COIN_DBL_MAX, 0);
	}
}

void setZero(double *array) {
	int i;
	for (i = 0; i < COUNT; i++) {
		array[i] = 0;
	}
}

void iterate(int *array) {
	int i;
	for (i = 0; i < COUNT; i++) {
		array[i] = i;
	}
}
void setConstraints(OsiSolverInterface *solver) {
	double row[COUNT];
	int indizes[COUNT];
	CoinBuild build(0);

	iterate(indizes);

	for (int p = 0; p < NUM; p++) {

		setZero(row);
		row[OFFSET_DBL3 + p] = 1;
		row[OFFSET_DBL7 + p] = param15;
		row[OFFSET_DBL5 + p] = 1;
		row[OFFSET_DBL8 + p] = 1;
		row[OFFSET_DBL10 + p] = 1;
		row[OFFSET_DBL11 + p] = -1;

		build.addRow(COUNT, indizes, row, param23[p], param23[p]);

		if (p > 0) {
			setZero(row);
			row[OFFSET_BIN1 + p - 1] = -1;
			row[OFFSET_BIN1 + p] = 1;
			row[OFFSET_BIN3 + p] = -1;
			row[OFFSET_BIN2 + p] = 1;

			build.addRow(COUNT, indizes, row, 0, 0);
		}

		setZero(row);
		row[OFFSET_BIN3 + p] = 1;
		row[OFFSET_BIN2 + p] = 1;
		build.addRow(COUNT, indizes, row, 0, 1);

		setZero(row);
		row[OFFSET_DBL2 + p] = 1;
		row[OFFSET_BIN1 + p] = -param5 * 0.25;
		build.addRow(COUNT, indizes, row, COIN_DBL_MIN, 0);

		setZero(row);
		row[OFFSET_DBL2 + p] = 1;
		row[OFFSET_BIN1 + p] = -param6 * 0.25;
		build.addRow(COUNT, indizes, row, 0, COIN_DBL_MAX);

		setZero(row);
		row[OFFSET_DBL3 + p] = 1;
		row[OFFSET_DBL2 + p] = -1.0 / param7;
		build.addRow(COUNT, indizes, row, 0, 0);

		setZero(row);
		row[OFFSET_DBL1 + p] = 1;
		row[OFFSET_DBL3 + p] = -1;
		row[OFFSET_DBL2 + p] = -1;
		build.addRow(COUNT, indizes, row, 0, 0);

		setZero(row);
		row[OFFSET_DBL4 + p] = 1;
		row[OFFSET_DBL1 + p] = -1.0 / param8;
		build.addRow(COUNT, indizes, row, 0, 0);

		setZero(row);
		row[OFFSET_DBL6 + p] = 1;
		row[OFFSET_DBL5 + p] = -1.0 / param11;
		build.addRow(COUNT, indizes, row, 0, 0);

		if (p > 0) {
			setZero(row);
			row[OFFSET_DBL9 + p] = 1;
			row[OFFSET_DBL9 + p - 1] = -param19;
			row[OFFSET_DBL8 + p] = -1;
			build.addRow(COUNT, indizes, row, -param18 * 0.25, -param18 * 0.25);
		}
	}

	setZero(row);
	row[OFFSET_BIN1] = 1;
	row[OFFSET_BIN3] = -1;
	row[OFFSET_BIN2] = 1;
	build.addRow(COUNT, indizes, row, param9, param9);

	setZero(row);
	row[OFFSET_DBL9] = 1;
	row[OFFSET_DBL8] = -1;
	build.addRow(COUNT, indizes, row, param21 * param19, param21 * param19);

	solver->addRows(build);

}

void setObjective(OsiSolverInterface *solver) {
	double row[COUNT];
	int indizes[COUNT];
	setZero(row);
	iterate(indizes);

	for (int p = 0; p < NUM; p++) {
		row[OFFSET_DBL7 + p] = param13[p] * param14 + param24[p];
		row[OFFSET_DBL4 + p] = param3;
		row[OFFSET_DBL6 + p] = param10;
		row[OFFSET_BIN3 + p] = param4;
		row[OFFSET_DBL10 + p] = param1;
		row[OFFSET_DBL11 + p] = param1;
		row[OFFSET_DBL2 + p] = -param2 - param24[p];
	}

	solver->setObjective(row);
}

void setTestValues() {
	double param23_tmp[] = { 11.767, 11.767, 11.767, 11.767, 12.518, 12.518,
			12.518, 12.518, 12.718, 12.718, 12.718, 12.718, 13.719, 13.719,
			13.719, 13.719, 17.011, 17.011, 17.011, 17.011, 25.392, 25.392,
			25.392, 25.392, 25.291, 25.291, 25.291, 25.291, 24.589, 24.589,
			24.589, 24.589, 24.318, 24.318, 24.318, 24.318, 23.817, 23.817,
			23.817, 23.817, 23.165, 23.165, 23.165, 23.165, 22.362, 22.362,
			22.362, 22.362, 22.162, 22.162, 22.162, 22.162, 22.112, 22.112,
			22.112, 22.112, 22.212, 22.212, 22.212, 22.212, 22.413, 22.413,
			22.413, 22.413, 23.365, 23.365, 23.365, 23.365, 24.167, 24.167,
			24.167, 24.167, 24.669, 24.669, 24.669, 24.669, 24.619, 24.619,
			24.619, 24.619, 24.067, 24.067, 24.067, 24.067, 22.011, 22.011,
			22.011, 22.011, 19.003, 19.003, 19.003, 19.003, 13.939, 13.939,
			13.939, 13.939, 13.208, 13.208, 13.208, 13.208, 14.051, 14.051,
			14.051, 14.051, 14.276, 14.276, 14.276, 14.276, 15.4, 15.4, 15.4,
			15.4, 19.053, 19.053, 19.053, 19.053, 28.439, 28.439, 28.439,
			28.439, 28.327, 28.327, 28.327, 28.327, 27.54, 27.54, 27.54, 27.54,
			27.259, 27.259, 27.259, 27.259, 26.697, 26.697, 26.697, 26.697,
			25.966, 25.966, 25.966, 25.966, 25.067, 25.067, 25.067, 25.067 };
	for (int i = 0; i < NUM; i++) {
		param23[i] = param23_tmp[i] * 0.25;
	}

	for (int i = 0; i < NUM; i++) {
		param22[i] = 1.0;
		param13[i] = 0;
	}

	double param24_tmp[] = { 0.46, 0.4, 0.33, 0.24, 0.42, 0.37, 0.34, 0.29,
			0.39, 0.34, 0.33, 0.36, 0.35, 0.34, 0.34, 0.36, 0.28, 0.31, 0.36,
			0.42, 0.27, 0.31, 0.4, 0.45, 0.26, 0.4, 0.52, 0.67, 0.34, 0.51, 0.6,
			0.7, 0.57, 0.61, 0.56, 0.51, 0.64, 0.58, 0.54, 0.48, 0.62, 0.57,
			0.5, 0.46, 0.49, 0.55, 0.51, 0.45, 0.5, 0.45, 0.48, 0.5, 0.49, 0.51,
			0.47, 0.48, 0.41, 0.44, 0.52, 0.53, 0.46, 0.5, 0.51, 0.56, 0.47,
			0.51, 0.57, 0.64, 0.55, 0.58, 0.59, 0.59, 0.6, 0.5, 0.54, 0.51,
			0.46, 0.51, 0.48, 0.4, 0.6, 0.51, 0.38, 0.3, 0.48, 0.42, 0.36, 0.32,
			0.46, 0.43, 0.36, 0.14, 0.4, 0.37, 0.23, 0.21, 0.42, 0.34, 0.29,
			0.19, 0.34, 0.32, 0.31, 0.27, 0.33, 0.3, 0.31, 0.3, 0.28, 0.29,
			0.29, 0.32, 0.22, 0.3, 0.34, 0.37, 0.2, 0.24, 0.34, 0.42, 0.2, 0.35,
			0.53, 0.63, 0.33, 0.41, 0.51, 0.62, 0.52, 0.54, 0.53, 0.47, 0.59,
			0.55, 0.51, 0.45, 0.53, 0.4, 0.41, 0.42, 0.41, 0.4, 0.48, 0.42 };

	memcpy(&param24, &param24_tmp, sizeof param24);

	param1 = 10;

	param2 = 0.2222;
	param3 = 0.077509;
	param4 = 0;
	param5 = 19;
	param6 = 10;
	param7 = 0.55;
	param8 = 0.9;
	param9 = 0;

	param10 = 0.03809;
	param11 = 0.9;
	param12 = 340;

	param14 = 1;
	param15 = 1;
	param16 = 0;

	param17 = 1500;
	param18 = 8.995;
	param19 = 0.9957;
	param20 = 81.427;
	param21 = 40;

}

int main(void) {

	setTestValues();

	OsiClpSolverInterface solver1;

	OsiSolverInterface *solver = &solver1;
	addColumns(solver);
	setConstraints(solver);
	setObjective(solver);
	solver->writeLp("test");

	CbcModel model(*solver);
	model.setAllowablePercentageGap(3);
	model.initialSolve();
	model.branchAndBound(2);


	return 0;
}