#include "chunk_array.h"
#include "stdbool.h"

/*
void chunk_array_free(chunk_array_t* chunk_array) {
  	fclose(chunk_array->fp);
	free(chunk_array->data);
	free(chunk_array);  
}


bool chunk_array_update(chunk_array_t* chunk_array, size_t pos) {

    int init_pos = pos/chunk_array->chunk_size;

    fseek(chunk_array->fp, init_pos * chunk_array->chunk_size * sizeof(double), SEEK_SET);
    
    chunk_array->init_pos = init_pos;
}

bool chunk_array_update_read(chunk_array_t* chunk_array, size_t pos) {

    chunk_array_update(chunk_array, pos);
    
    size_t newLen = fread(chunk_array->data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
    chunk_array->init_pos += newLen;
}


/*bool chunk_array_get(chunk_array_t* chunk_array, size_t pos, double *valor) {
	if (pos<chunk_array->init_pos || pos>((chunk_array->init_pos + chunk_array->chunk_size)-1)) {
        chunk_array_update_read(chunk_array, pos);
	}
    *valor=chunk_array->data[pos%chunk_array->chunk_size];
    return true;
}


bool chunk_array_save(chunk_array_t* chunk_array, size_t pos, double valor) {
	if (pos<chunk_array->init_pos || pos>((chunk_array->init_pos + chunk_array->chunk_size)-1)) {
		chunk_array_flush(chunk_array);
        chunk_array_update(chunk_array, pos);
	}
	chunk_array->data[pos%chunk_array->chunk_size]=valor;
	return true;
}


chunk_array_t* chunk_array_create(char* filename, size_t total_size, size_t chunk_size) {
    chunk_array_t* chunk_array = (chunk_array_t*)malloc(sizeof(chunk_array_t));

    chunk_array->fp = fopen(filename, "w+");

    if (chunk_array == NULL || chunk_array->fp == NULL) {
        return NULL;
    }

    chunk_array->data = malloc(chunk_size * sizeof(double));

    if (chunk_size > 0 && chunk_array->data == NULL) {
        free(chunk_array);
        return NULL;
    }

    chunk_array->init_pos = 0;
    chunk_array->chunk_size = chunk_size;
    chunk_array->total_size = total_size;
    return chunk_array;
}

void chunk_array_read(chunk_array_t* chunk_array) {
    rewind(chunk_array->fp);
    chunk_array->init_pos = 0;
    size_t newLen = fread(chunk_array->data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
}


void chunk_array_write(chunk_array_t* chunk_array, char* filename) {
    chunk_array->fp = fopen(filename, "w");
    if (chunk_array->fp == NULL) {
        fclose(chunk_array->fp);
        chunk_array->fp = fopen(filename, "w");
    }
    chunk_array->init_pos = 0;
}

void chunk_array_flush(chunk_array_t* chunk_array) {
    size_t newLen = fwrite(chunk_array->data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
    chunk_array->init_pos += newLen;
}


bool chunk_array_get(chunk_array_t* chunk_array, size_t pos, double *valor) {
	fseek(chunk_array->fp, pos * sizeof(double), SEEK_SET);
    fread(valor, sizeof(double), 1, chunk_array->fp);
    return true;
}

bool chunk_array_save(chunk_array_t* chunk_array, size_t pos, double valor) {
	fseek(chunk_array->fp, pos * sizeof(double), SEEK_SET);
    fwrite(&valor, sizeof(double), 1, chunk_array->fp);
	return true;
}
*/

void chunk_array_free(chunk_array_t* chunk_array) {
  	fclose(chunk_array->fp);
	free(chunk_array->read_data);
    free(chunk_array->write_data);
	free(chunk_array);  
}

void chunk_array_update_write(chunk_array_t* chunk_array, size_t pos) {
    //printf("entre a update_write con pos %d\n", pos);
    int init_write = pos/chunk_array->chunk_size;

    fseek(chunk_array->fp, init_write * chunk_array->chunk_size * sizeof(double), SEEK_SET);
    
    chunk_array->init_write = init_write * chunk_array->chunk_size;

    fwrite(chunk_array->write_data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
    fread(chunk_array->write_data, sizeof(double), MAX_CHUNK_SIZE, chunk_array->fp);

    //size_t newLen = fread(chunk_array->read_data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
    //chunk_array->init_write += newLen;
}

void chunk_array_flush(chunk_array_t* chunk_array) {
    //printf("entre a flush\n");
    fwrite(chunk_array->write_data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
}

bool chunk_array_update_read(chunk_array_t* chunk_array, size_t pos) {
    //printf("entre a update_read %d\n", pos);
    int init_read = pos/chunk_array->chunk_size;

    fseek(chunk_array->fp, init_read * chunk_array->chunk_size * sizeof(double), SEEK_SET);
    
    chunk_array->init_read = init_read * chunk_array->chunk_size;
    
    fread(chunk_array->read_data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
}

chunk_array_t* chunk_array_create(char* filename, size_t total_size) {
    chunk_array_t* chunk_array = (chunk_array_t*)malloc(sizeof(chunk_array_t));

    chunk_array->fp = fopen(filename, "w+");

    if (chunk_array == NULL || chunk_array->fp == NULL) {
        return NULL;
    }

    chunk_array->read_data = malloc(MAX_CHUNK_SIZE * sizeof(double));

    if (MAX_CHUNK_SIZE > 0 && chunk_array->read_data == NULL) {
        free(chunk_array);
        return NULL;
    }

    fread(chunk_array->read_data, sizeof(double), MAX_CHUNK_SIZE, chunk_array->fp);
    fread(chunk_array->write_data, sizeof(double), MAX_CHUNK_SIZE, chunk_array->fp);

    chunk_array->write_data = malloc(MAX_CHUNK_SIZE * sizeof(double));

    if (MAX_CHUNK_SIZE > 0 && chunk_array->write_data == NULL) {
        free(chunk_array);
        free(chunk_array->read_data);
        return NULL;
    }

    chunk_array->init_read = 0;
    chunk_array->init_write = 0;
    chunk_array->chunk_size = MAX_CHUNK_SIZE;
    chunk_array->total_size = total_size;
    return chunk_array;
}

bool chunk_array_get(chunk_array_t* chunk_array, size_t pos, double *valor) {
    if (pos > chunk_array->init_write && pos < chunk_array->init_write + chunk_array->chunk_size) {
        *valor=chunk_array->write_data[pos%chunk_array->chunk_size];
        printf("[READ] Del write valor = %f\n", *valor);
        return true;
    }
	if (pos<chunk_array->init_read || pos>chunk_array->init_read + chunk_array->chunk_size) {
        printf("[READ] actualizo porq pos = %d y init_read = %d\n", pos, chunk_array->init_read);
        chunk_array_update_read(chunk_array, pos);
	}
    *valor=chunk_array->read_data[pos%chunk_array->chunk_size];
    printf("[READ] Del read valor = %f\n", *valor);
    return true;
}


bool chunk_array_save(chunk_array_t* chunk_array, size_t pos, double valor) {
	if (pos<chunk_array->init_write || pos>chunk_array->init_write + chunk_array->chunk_size) {
		printf("[WRITE] actualizo porq pos = %d y init_write = %d\n", pos, chunk_array->init_write);
        chunk_array_update_write(chunk_array,pos);
	}
	chunk_array->write_data[pos%chunk_array->chunk_size]=valor;
	return true;
}