#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "esparsas.h"

#define MAX_BUFFER_SIZE 1024 //a.k.a. arquivo de 1kb
#define MAX_NUMBER_SIZE 8 //o numero de caracteres entre um ';' ou um '\n'

typedef struct Noh{
	int linha, coluna;
	double valor;
	struct Noh *direito, *abaixo;
	int dirNull; // Mexi
} Noh;

//cria um noh com linha, coluna e valor especificados
Noh* criaNoh(int linha, int coluna, double valor){
	Noh* novo = (Noh*) malloc(sizeof(Noh));
	novo -> direito = NULL;
	novo -> abaixo  = NULL;
	novo -> linha   = linha;
	novo -> coluna  = coluna;
	novo -> valor   = valor;
	novo->dirNull = 0; // Mexi
	return novo;
}

Noh* cria(void){
	Noh* cabeca = (Noh*) malloc(sizeof(Noh));
	cabeca -> valor  = -1;
	cabeca -> linha  = -1;
	cabeca -> coluna = -1;
	return cabeca;
}

void ler(Noh* esparsa, FILE* matriz){

	//ambos partem do mesmo ponto inicial
	Noh* linhaAtual  = esparsa;
	Noh* colunaAtual = esparsa;
	Noh* anterior = NULL;

	char buffer[MAX_BUFFER_SIZE] = {0}; //buffer de todo o arquivo
	char auxBuffer[MAX_NUMBER_SIZE] = {0}; //buffer do numero (definido pelos caracteres separadores)
	int i = 0, k = 0, l = 0, size = 0, nLinhas = 0, nColunas = 0, aux = 0;
	double value;
	bool first = true;

	//calcula valores de linha e coluna, valida o tamanho da matriz e passa todos os dados do arquivo para um buffer
    while (!feof(matriz)){
    	buffer[i] = fgetc(matriz);

    	switch(buffer[i]){
    		case 59:
    			aux++;
    		break;

    		case 10:
    		case EOF:
    			aux++;
    			nLinhas++;
    			if(aux != nColunas && first == false){
    				printf("Tamanho da matriz invalido!");
    				return;
				}
    			nColunas = aux;
    			aux = 0;
    			first = false;
    		break;
		}
    	i++;
    	size++;
	}

	//ao inves de -1 para linha e coluna no noh principal, ele ira armazenar o tamanho da matriz
	esparsa -> linha  = nLinhas;
	esparsa -> coluna = nColunas;

	fclose(matriz);

	//cria todas as 'cabecas' para linhas e colunas baseado no tamanho adquirido anteriormente
	Noh* atual = esparsa;
	for(i = 0; i < nLinhas+1; i++){
		Noh* novaLinha = criaNoh(i, -1, -1);
		atual -> abaixo = novaLinha;
		atual = atual -> abaixo;
	} atual = esparsa;
	for(i = 0; i < nColunas+1; i++){
		Noh* novaLinha = criaNoh(-1, i, -1);
		atual -> direito = novaLinha;
		atual = atual -> direito;
	}
	free (atual);

	//logica para o posicionamento dos valores no TAD
	linhaAtual = linhaAtual -> abaixo;
	colunaAtual = colunaAtual -> direito;
	for(i = 0; i < nLinhas; i++){
		anterior = linhaAtual;

		for(int j = 0; j < nColunas; j++) {
			do{ //coloca no buffer auxiliar todos os caracteres que compoem o numero
				auxBuffer[l] = buffer[k];
				k++; l++;
			} while(buffer[k-1] != 59 && buffer[k-1] != 10 && buffer[k-1] && EOF);

			value = strtod(auxBuffer, NULL);
			l = 0; auxBuffer[0] = '\0';

			if(value != 0.0) {	//ele funciona, porem alocando os zeros, tentando acertar a logica dos zeros
				Noh* novoValor  = criaNoh(i, j, value); //cria um noh com os valores de linha e coluna dos dois FOR

				anterior -> direito = novoValor;
				if (colunaAtual != 0) {
					colunaAtual -> abaixo = anterior; //o noh gerado eh apontado pela cabeca da linha atual e da coluna atual
				}
				//anterior = anterior -> direito;
				if (anterior->direito != 0)
					anterior = anterior->direito;

				//colunaAtual = colunaAtual -> direito; //anda pelas cabecas das colunas
				if (colunaAtual->direito != 0)
					colunaAtual = colunaAtual->direito;
			} else {
				if (anterior->valor == -1) {
					linhaAtual->dirNull++;
				} else {
					anterior->dirNull++;
				}
				anterior->direito = 0;
				if (colunaAtual->direito != 0)
					colunaAtual = colunaAtual->direito;
				else
					colunaAtual = 0;
			}
		}
		colunaAtual = linhaAtual->direito;
		linhaAtual = linhaAtual->abaixo;
	}
}

void inverter(Noh* I, const Noh* A){
	//code
}

//uma funcao para testar os ponteiros das linhas e outro das colunas (ambas sucesso)

/*void imprimir(const Noh* esparsa){
	Noh* linhaAtual  = esparsa;
	Noh* colunaAtual = esparsa;

	for(int i = 0; i < esparsa -> linha; i++){
		linhaAtual = linhaAtual -> abaixo;
		colunaAtual = linhaAtual -> direito;
		for(int j = 0; j < esparsa -> coluna; j++){
			//printf("%.1lf\t", colunaAtual -> valor);
			printf("[%d][%d] = %.1lf\n", linhaAtual -> linha, colunaAtual -> coluna,  colunaAtual -> valor);
			colunaAtual = colunaAtual -> direito;
		}
		//puts("");
	}
} */

void imprimir(const Noh* esparsa){
	Noh* colunaAtual = esparsa->abaixo;
	Noh* linhaAtual  = colunaAtual;

	for(int i = 0; i < esparsa -> linha; i++){
		colunaAtual = linhaAtual;
		for(int j = 0; j < esparsa -> coluna; j++){
			if (colunaAtual->direito != 0) {
				if (colunaAtual->valor == -1) {
					for (int g = 0; g < colunaAtual->dirNull; g++)
						printf("0\t");
				}
				printf("%.1lf\t", colunaAtual->direito->valor);
				for (int i = 0; i < colunaAtual->direito->dirNull; i++)
					printf("0\t");
				colunaAtual = colunaAtual->direito;
			}
		}
		linhaAtual = linhaAtual -> abaixo;
		puts("");
	}
}

void transpor(Noh* T, const Noh* A){
	//code
}

void somar(Noh* S, const Noh* A, const Noh* B){
	//code
}

void multiplicar(Noh* M, const Noh* A, const Noh* B){
	//code
}


// função responsável pela verificação da esparsa (vazia)
/*bool underflow(const Noh* A) {

	if (A->direito == 0 || A->abaixo == 0) {
		return true;
	} else {
		return false;
	}

}*/

double getValueFromCoordinates(const Noh* A, int x, int y){


}