#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "sudoku.h"

void sudoku_setnumberofconstraints(sudoku *sdku, int x, int y, int num);
void sudoku_addconstraint(sudoku *sdku, int x, int y, int num);
int sudoku_hassolution(sudoku *sdku, int x, int y);
int sudoku_getsolution(sudoku *sdku, int x, int y);
void sudoku_setsolution(sudoku *sdku, int x, int y, int solution);
int sudoku_deducesolution(sudoku *sdku, int x, int y, int *psolution);

sudoku *opensudokufile(char *filename) {
	sudoku *sdku = NULL;
	FILE *file;
	char buffer[256];
	int gridsize = 9, blocksize = 3;		// default values
	int num_min = 1, num_max = 9;			// default values


	if (!(file = fopen(filename, "r"))) {
		perror("failed to open sudoku");
		exit(1);
	}

	while (fgets(buffer, sizeof(buffer) - 1, file)) {
		char *key = strtok(buffer, ":,; \t\r\n");
		if (key == NULL) continue;

		if (!strcmp(key, "grid")) {
			gridsize = atoi(strtok(NULL, ":,; \t\r\n"));
			blocksize = atoi(strtok(NULL, ":,; \t\r\n"));
		} else if (!strcmp(key, "range")) {
			num_min = atoi(strtok(NULL, ":,; \t\r\n"));
			num_max = atoi(strtok(NULL, ":,; \t\r\n"));
		} else if (!strcmp(key, "set")) {
			int x, y, num;

			x = strtol(strtok(NULL, ":,; \t\r\n"), NULL, 0);
			y = strtol(strtok(NULL, ":,; \t\r\n"), NULL, 0);
			num = strtol(strtok(NULL, ":,; \t\r\n"), NULL, 0);

			if (sdku == NULL) {
				sdku = sudoku_create(gridsize, blocksize, num_min, num_max);
			}
			sudoku_setsolution(sdku, x-1, y-1, num);
		}
	}

	fclose(file);
	return sdku;
}

void sudoku_print(sudoku *sdku) {
	int x, y;
	for (x = 0; x < sdku->gridsize; x++) {
		if (x % sdku->blocksize == 0) printf("\n");
		for (y = 0; y < sdku->gridsize; y++) {
			if (y % sdku->blocksize == 0) printf(" ");
			if (sudoku_hassolution(sdku, x, y)) {
				printf("%.1X ", sudoku_getsolution(sdku, x, y));
			} else {
				printf(". ");
			}
		}
		printf("\n");
	}
}

sudoku *sudoku_create(int gridsize, int blocksize, int num_min, int num_max) {
	sudoku* s1;                                                                  //s1 is een pointer naar een sudoku struct
	(*s1).(*constraints) = (int*) malloc(gridsize * sizeof(int));                //alloceer 9 rijen geheugen
	(*s1).(**constraints) = (int*) malloc(gridsize * sizeof(int));               //alloceer 9 kolommen geheugen
	(*s1).fields = (struct*) malloc(gridsize * gridsize * 3 * sizeof(int));      //alloceer 81 field structuren
	return s1;

}


void sudoku_delete(sudoku **psdku) {
//	??????
//	waarom is die fucking sudoku nu een dubbele pointer???
}


int sudoku_setnumberofconstraints(sudoku *sdku, int x, int y, int num) {
	((*sdku).fields[(*sdku).gridsize * x + y]).numconstraints = num;               //verander het aantal numconstraints van element (x,y)
	((*sdku).(*constraints[x][y])) = (int*) realloc(num * sizeof(int));            //reserveer geheugen voor de rij constraints van element (x,y)

//??????????????? wat moet ik hier returnen ????????
}


void sudoku_addconstraint(sudoku *sdku, int x, int y, int num) {
	(*sdku).(constraints[x][y][((*sdku).fields[(*sdku).gridsize * x + y]).numconstraints-1] = num;   //voeg num toe aan de rij op plaats (x,y). We zoeken daarvoor eerst op hoeveel elementen er in die rij zitten (finja, hoeveel geheugen er gereserveerd is in de functie hierboven). -1 want rijen tellen vanaf 0.
													     // !!! We zullen dus altijd eerst setnumberofconstraints moeten uitvoeren (allocatie) VOOR we addconstraint uitvoeren !!!
}


int sudoku_hassolution(sudoku *sdku, int x, int y) {
	return ((*sdku).fields[(*sdku).gridsize * x + y]).hassolution;
}


int sudoku_getsolution(sudoku *sdku, int x, int y) {
	return ((*sdku).fields[(*sdku).gridsize * x + y]).solution;
}


void sudoku_setsolution(sudoku *sdku, int x, int y, int solution) {
	int i;
	int j;
	int rij_ondergrens = (x / (*sdku).blocksize) * (*sdku).blocksize;
	int rij_bovengrens = rij_ondergrens + blocksize;
	int kolom_ondergrens = (y / (*sdku).blocksize) * (*sdku).blocksize;
	int kolom_bovengrens = kolom_ondergrens + blocksize;

//pas de constraints aan van de overeenkomstige rij

	for(i=0; i<(*sdku).gridsize; i++) {

		if(i != y) {

			sudoku_setnumberofconstraints(*sdku, x, i, (((*sdku).fields[(*sdku).gridsize * x + i]).numconstraints)+1));     //aantal numconstraints dat er al was +1
			sudoku_addconstraint(*sdku, x, i, solution);
		}
		else {
			sudoku_setnumberofconstraints(*sdku, x, i, 0);                                       //op de plaats waar je de oplossing vond, mag je het aantal constraints op 0 zetten, en moet je niet langer geheugen reserveren.
			((*sdku).fields[(*sdku).gridsize * x + y]).solution = solution;                      //vul de oplossing in
			((*sdku).fields[(*sdku).gridsize * x + y]).hassolution = 1;
		}
	}

//pas de constraints aan van de overeenkomstige kolom

	for(j=0; j<(*sdku).gridsize; j++) {

		if(j != x) {

			sudoku_setnumberofconstraints(*sdku, j, y, (((*sdku).fields[(*sdku).gridsize * j + y]).numconstraints)+1));
			sudoku_addconstraint(*sdku, j, y, solution);
		}
		//geen else, je hebt het "oplossingsvakje" al aangepast
	}

//pas de constraints aan van het overeenkomstige blokje

	for(i=rij_ondergrens; i<rij_bovengrens+1; i++) {
		for(j=kolom_ondergrens; j<kolom_bovengrens; j++) {
			while((j != y) && (i != x) {       //de elementen op de rij en kolom van (x,y) zijn al aangepast!
				sudoku_setnumberofconstraints(*sdku, i, j, (((*sdku).fields[(*sdku).gridsize * x + i]).numconstraints)+1));
				sudoku_addconstraint(*sdku, i, j, solution);
			}
		}
	}
}


int sudoku_deducesolution(sudoku *sdku, int x, int y, int *psolution) {
	int i;
	int sum=0;
	if(((*sdku).fields[(*sdku).gridsize * x + y]).numconstraints) == 8) {       //als er 8 elementen zijn die het niet kunnen zijn, dan weet je wat het wel is.
		for(i=1; i<9; i++) {
			sum += (*sdku).constraints[x][y][i];               //tel alle elementen uit uw rij constraints samen
			switch(45-sum) {
				case 1 : *psolution=1;
				case 2 : *psolution=2;
				case 3 : *psolution=3;
				case 4 : *psolution=4;
				case 5 : *psolution=5;
				case 6 : *psolution=6;
				case 7 : *psolution=7;
				case 8 : *psolution=8;
				case 9 : *psolution=9;
			}

		}
		return 1;
	}
	else {                          //else omvat beide andere gevallen: als er niet exact 8 getallen zijn die het niet kunnen zijn, is de oplossing ofwel reeds bekend (0) of hebben we onvoldoende informatie (0-7)
		return 0;
	}
}

void sudoku_solve(sudoku *sdku) {
	int i;
	int j;
	int changed = 1;
	int* psolution;

	while(changed) {
		changed = 0;

		for(i=0; i<9; i++) {
			for(j=0; j<9; j++) {
				if (sudoku_deducesolution(*sdku, i, j, psolution)) {
					sudoku_setsolution(*sdku, i, j, *psolution);
					changed = 1;                                       //zodra we 1 keer een oplossing kunnen deducen zetten we de changed op 1
				}
			}
		}
	}
}