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

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


void operazioni_con_stringhe_di_caratteri() {

	// leggere una stringa di caratteri da stdin
	// scanf()

	// scrivere una stringa di caratteri su stdout
	// printf()

	char * str = "12345";

	// lunghezza di stringa di caratteri:
	// strlen

	int str_len = strlen(str);

	printf("la stringa '%s' ha lunghezza %d\nil vettore di char dove la stringa è "
			"immagazzinata ha dimensione %d\n\n", str, str_len, str_len + 1);

	// confrontare due stringhe di caratteri
    char * str_a = "aa";
	char * str_b = "AA";

	printf("%c %c\n%d %d\n",'A', 'B','A', 'B');

	printf("%c %c\n%d %d\n",'A', 'a','A', 'a');

	int res;

	if ( (res = strcmp(str_a, str_b)) == 0) {
		printf("str_a == str_b\n");
	} else if (res < 0) {
		printf("str_a < str_b %d\n", res);
	} else {
		printf("str_a > str_b %d\n", res);
	}

	// duplicare una stringa di caratteri

	char * clone_di_str;

	clone_di_str = strdup(str); // duplica la stringa di caratteri

	printf("str=%p clone_di_str=%p\n", str, clone_di_str);

	printf("str == clone_di_str ? %d %s\n", !strcmp(str, clone_di_str),
			!strcmp(str, clone_di_str) ? "VERO" : "FALSO");

	// in alternativa:
	res = strcmp(str, clone_di_str);

	if (res == 0) {
		printf("str == clone_di_str ? VERO\n");
	} else {
		printf("str == clone_di_str ? FALSO\n");
	}

	// copia di stringhe: copiare una stringa su un'altra
	str = "12345"; // ricopio il comando per comodità

	char * str2;

	// allocare la memoria per str2
	// quanta memoria devo chiedere? per poter poi copiarci i contenuti di str?
	str2 = malloc( (strlen(str) + 1) * sizeof(char) );

	if (str2 == NULL) {
		printf("errore con malloc()\n");
		exit(1);
	}

	strcpy(str2, str);

	printf("str2 == str? %s\n\n", !strcmp(str, str2) ? "VERO" : "FALSO");

	// concatenazione di stringhe

	char str1[16] = { 0 }; // che stringa è? la stringa vuota
    //char * str_a = "aa";
	//char * str_b = "AA";

	printf("str1 = %s\n", str1);
	printf("strlen(str1) = %d\n", strlen(str1));

	// concateniamo str1 e str_a e scriverlo in str1

	strcat(str1, str_a);

	printf("str1 = %s\n", str1);

	strcat(str1, str_b);

	printf("str1 = %s\n", str1);

	// in generale:
	// strlen(str_a) + strlen(str_b) + 1

	free(str2); // restituisco la zona di memoria allocata con malloc più sopra

	str2 = malloc( (strlen(str_a) + strlen(str_b) + 1) * sizeof(char) );

	str2[0] = 0; // inizializzo str2 a stringa vuota

	strcat(str2, str_a);
	strcat(str2, str_b);

	printf("str2 = %s\n", str2);


}


// scriviamo una funzione che prende come parametri due array di int (con le rispettive dimensioni)
// e questa restituisce un array che è la concatenazione dei due array

int * concatena_array_di_int(int * par_array1, int dim_par_array1, int * par_array2, int dim_par_array2) {

	// allocare una zona di memoria di dimensione (dim_par_array1 + dim_par_array2)
	// poi copiamo i contenuti dei due array

	int dim_total = dim_par_array1 + dim_par_array2;

	int * result;


	result = malloc(dim_total * sizeof(int));

	if (result == NULL) {
		printf("problema con malloc()");
		return NULL;
	}

	memcpy(result, par_array1, dim_par_array1 * sizeof(int));
	// sono stati scritti gli elementi di result dalla posizione 0 alla posizione dim_par_array1-1

	// dove vado a copiare il secondo array?
	memcpy(&result[dim_par_array1], par_array2, dim_par_array2 * sizeof(int));

	return result;
}

void operazioni_con_array() {


	// allochiamo un array di int sulla memoria heap

	int dim_array = 1024;

	int * iarray;

	printf("vogliamo allocare un array di int, di dimensione %d\n",dim_array);
	printf("dobbiamo allocare %d elementi di tipo int (sizeof(int)=%d)\nquindi un totale di %d bytes\n",
			dim_array, sizeof(int), dim_array * sizeof(int));

	iarray = malloc( dim_array * sizeof(int) ); // parametro: il numero di bytes da allocare
	// malloc NON inizializza

	//iarray = calloc( dim_array, sizeof(int) ); // come sopra, ma in più calloc inizializza a 0 la zona di memoria allocata

	if (iarray == NULL) {
		printf("errore con malloc()");
		exit(1);
	}

	// inizializzo la zona di memoria
	// devo specificare la dimensione in bytes della zona di memoria
	memset(iarray, 0, dim_array * sizeof(int));

	// possiamo cambiare la dimensione della memoria allocata sulla heap

	dim_array = dim_array * 16;

	iarray = realloc(iarray, dim_array);
	if (iarray == NULL) {
		printf("errore con realloc()");
		exit(1);
	}

	// finisco di utilizzare l'array, restituisco la memoria:
	free(iarray); // dopo free NON posso più utilizzare la zona di memoria, anche se salvo l'indirizzo

	//
	dim_array = 1024;

	iarray = calloc( dim_array, sizeof(int) );


	// my_function(iarray, dim_array);

	// scriviamo una funzione a cui diamo come parametri due array di int (con le dimensioni)
	// e questa restituisce un array che è la concatenazione dei due array



}

int main() {

	// operazioni_con_stringhe_di_caratteri();

	// array

	// operazioni_con_array()

	// "scriviamo" un file
	// ipotesi: il file su cui scrivere esiste già
	// oppure:
	// il file su cui scrivere va creato
	// oppure:
	// il file su cui scrivere va creato o se esiste i suoi contenuti vanno eliminati

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

//	// chiedo al kernel di aprire il file ESISTENTE per scriverci
//	fd = open(filename, O_WRONLY);
//
//	if (fd == -1) {
//		printf("problema con open!\n");
//		perror("open");
//		exit(1);
//	}

	// chiediamo al kernel di creare il file che appartiene a "noi" su cui avremo i permessi di lettura e scrittura
	fd = open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);

	if (fd == -1) {
		printf("problema con open!\n");
		perror("open");
		exit(1);
	}

	printf("ok abbiamo creato il file!\n");

	// scriviamo qualcosa nel file

	char * msg = "ciao!";
	int msg_len = strlen(msg);
	int bytes_written;

	// da usare il while!
	bytes_written = write(fd, msg, msg_len);

	printf("il kernel ha scritto %d bytes nel files\n", bytes_written);


	close(fd);


	return 0;
}