#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>



void test_scanf() {
	int i;
	int res;

	res = scanf("%d", &i);

	if (res == 1) {
		// OK
	} else {
		// problema
	}

	printf("i = %d  res=%d \n", i, res);
}

int my_getchar(int fd) {

	int ch;
	int res;

	res = read(fd, &ch, 1); // system call
	// 1 è il numero di bytes da leggere (al massimo)

	if (res == 1) {
		// read ha avuto successo, ha letto 1 byte
		return ch;
	} else if (res == 0) {
		// EOF
		return EOF;
	} else { // -1
		// errore
		return EOF;
	}

}

int my_putchar(int fd, int ch) {
	int res;

	res = write(fd, &ch, 1); // system call
	// dice al kernel di scrivere 1 byte (contenuto in ch) sul file individuato da fd

    if (res == 1) {
    	// tutto ok
    	return ch;
    } else {
    	// errore
    	return -1;
    }

}

void my_copy_file() {
    int ch = 'A';

    int res;

    // cosa vuol dire copiare un file

/*    ch = getchar();

    while (ch != EOF) {
    	putchar(ch);
    	ch = getchar();
    }*/

    while ( (ch = my_getchar(0)) != EOF ) {
    	my_putchar(1, ch);
    }

}

void getcwd_example() {
	char * str;

	str = getcwd(NULL, 0);
	// passiamo NULL a getcwd perchè sarà la funzione ad allocare la memoria in cui scrivere la stringa di caratteri

	// l'indirizzo è un intero a 8 byte
    printf("la cartella di lavoro corrente del processo è %s", str);
}

void getcwd_example2() {
    char str[256];

    getcwd(str, 256);

    printf("la cartella di lavoro corrente del processo è %s", str);
}


//int esempio() {
//
//	if (...) {
//		// devo fare terminare il programma
//
//		exit(1);
//	}
//}

char buffer[1024];

void read_small_file() {


	char * file_name = "prova.txt";
	int fd;

	fd = open(file_name, O_RDONLY);

	if (fd == -1) {
		perror("open()");

		exit(EXIT_FAILURE);
	}

	printf("fd = %d\n", fd);

    int position = 0; // posizione in buffer dove scriverò i dati
    int bytes_read; // numero di byte letti da read()

    // IPOTESI: il file che leggeremo ha dimensione <= 1024 bytes

    while ( (bytes_read = read(fd, &buffer[position], 1024-position) ) > 0) {
    	printf("read() ha restituito %d bytes\n", bytes_read);

    	position += bytes_read;

    	printf("position = %d\n", position);
    }

    if (bytes_read == 0) {
    	printf("ok, siamo a EOF ed abbiamo letto complessivamente %d bytes\n", position);
    } else {
    	perror("problema con read()");
    }

    // facciamo qualcosa con i dati ora nella memoria del processo
    // ....
    // scriviamo su stdout il contenuto del file letto, byte per byte

    for (int i = 0; i < position; i++) {
    	printf("buffer[%d] = %u    %c\n", i, buffer[i], buffer[i]); // %u : intero senza segno
    }


    if (close(fd) == -1) {
    	perror("problema con close()");
    }

    // quando il processo termina, eventuali file aperti vengono chiusi automaticamente dal kernel

}


int my_function(char param1 [], unsigned int len_bytes) {

	printf("l'indirizzo di param1 è %p e la dimensione in byes è %u\n", param1, len_bytes);

	// a questo punto, my_function può operare suila zona di memoria

}

int main() {

	// test_scanf();
	// my_copy_file() ;
	// getcwd_example();

	// leggiamo un file con open etc

	// apriamo un file regolare già esistente
	// perchè vogliamo caricare in memoria i suoi contenuti
	// per poi farci qualcosa

	//esempio();

	//char buf[256]; // la dimensione è fissa

	char * buf;
	unsigned int buf_size = 1024*1024;

	// memoria "heap" (o memoria dinamica)

	buf = malloc(buf_size); // la zona di memoria restituita da malloc NON è inizializzata
	// calloc

	if (buf == NULL) {
		perror("problema con malloc()");
		exit(1);
	} else {
		printf("è stata allocata una zona di memoria di dimensione %u bytes\n", buf_size);
	}

	for (int i = 0; i < buf_size; i++)
		buf[i] = 0;

	my_function(buf, buf_size); // il parametro passato è l'indirizzo della zona di memoria allocata con malloc ed
	// immagazzinata in buf

	// quando la zona di memoria non serve più, la restituisco

	buf = realloc(buf, buf_size*2);

	if (buf == NULL) {
		perror("problema con realloc()");
		exit(1);
	}

	buf_size = buf_size * 2;

	my_function(buf, buf_size);


	free(buf);


	return 0; // qui è equivalente a exit(0);
}