#include <stdio.

h>
#include <stdlib.h>

void clean_the_buffer(){
char c = getchar();
while(c!='\n' && c!= EOF){ // continuiamo a pulire il buffer con ciò che non è
necessario
c = getchar();
}
}

int get_integer_from_stdin_with_min_bound(int min, int max, char *error_msg);

// la procedura precedente verrà utilizzata per prendere dalla stdin un intero
// tra un minimo obbligatorio e un massimo solo se desiderato

void print_instructions();
int check_if_user_wants_to_play();
void print_sum_of_diagonals(int dim_mat, int matrix[dim_mat][dim_mat]);
void print_sum_of_columns(int num_row, int num_col, int matrix[num_row][num_col]);
void print_sum_of_rows(int num_row, int num_col, int matrix[num_row][num_col]);
void print_matrix(int num_row, int num_col, int matrix[num_row][num_col]);
int get_matrix_dimension();

int main(){
printf("Welcome to the matrix world!\n");
print_instructions();

int user_wants_to_play = 1;
while(user_wants_to_play){
int dim_mat;
printf("Inserisci la dimensione della matrice quadrata: ");
dim_mat = get_matrix_dimension();

int min_value = 99, max_value = 0, sum = 0;

int matrix[dim_mat][dim_mat];
float avg;

int cell_value;
for(int i = 0; i < dim_mat; i++){
for(int j = 0; j < dim_mat; j++){
cell_value = rand() % 100;
matrix[i][j] = cell_value;
if (cell_value < min_value) min_value = cell_value;
if (cell_value > max_value) max_value = cell_value;
sum += cell_value;
}
}
print_matrix(dim_mat, dim_mat, matrix);

avg = sum / (dim_mat * dim_mat);

printf("Statistiche calcolate:\nmin=%d\tmax=%d\tavg=%.2f\n", min_value,
max_value, avg);
printf("Somma di tutti gli elementi: %d\n", sum);
print_sum_of_rows(dim_mat, dim_mat, matrix);
print_sum_of_columns(dim_mat, dim_mat, matrix);
print_sum_of_diagonals(dim_mat, matrix);

printf("Vuoi effettuare una nuova esecuzione?\n");

printf("Inserire 1 per continuare, 0 per uscire: ");
 user_wants_to_play = check_if_user_wants_to_play();
}// end of while

printf("See you next time! Alla prossima\n");

return 0;
} // end of main

int get_integer_from_stdin_with_min_bound(int min, int max, char *error_msg){

// se max<min questa procedura restituisce un intero >= del minimo fornito,
// altrimenti, se max >= min, un intero compreso tra i due
int input, input_is_valid = 0;
while(!input_is_valid){ // continuiamo ad iterare fino a quando l'user inserisce
un input corretto
if ((scanf("%d",&input) == 1) && input >= min){
if (max < min) input_is_valid = 1; // il chiamante di questa procedura non
vuole upper bound

if (max >= min){

// se max >= min devo controllare anche che l'input sia coerente col max
input_is_valid = (input <= max) ? 1 : 0;
if (!input_is_valid){ // vogliamo un intero tra un min e un max ma l'utente
inserisce input > max
fprintf(stderr, "%s\n", error_msg);
printf("Riprova ad inserire la scelta: ");
}
}

}else { // se non si inserisce un intero o se l'intero è < min

clean_the_buffer();
fprintf(stderr, "%s\n", error_msg); // stampiamo un errore nella stderr
printf("Riprova ad inserire la scelta: ");
}
} // end of while
return input;
}
/* Usiamo la procedura precedente per leggere gli input di tipo intero inseriti
dall' utente nella stdin e stampiamo errori adhoc dipendenti dalle specifiche
delle procedure che la utilizzano
*/

int get_matrix_dimension(){
return(get_integer_from_stdin_with_min_bound(1, -1, "La dimensione della matrice"
"deve essere un intero
positivo!"));
// Qui min = 1 e max = -1 perchè vogliamo tutti gli interi n>=1 e quindi usiamo
// la procedura precedente senza upper bound
}

int check_if_user_wants_to_play(){
return get_integer_from_stdin_with_min_bound(0, 1, "Scegliere esclusivamente 1 o
0!");
}

void print_matrix(int num_row, int num_col, int matrix[num_row][num_col]){

for(int i = 0; i < num_row; i++){
for(int j = 0; j < num_col; j++){
printf("%d\t",matrix[i][j]);
 }
printf("\n"); // new line dopo una riga
}
}

void print_sum_of_rows(int num_row, int num_col, int matrix[num_row][num_col]){

int row_sum = 0;
for(int i = 0; i < num_row; i++){
for(int j = 0; j < num_col; j++){
row_sum += matrix[i][j];
}
printf("La somma della riga %d è %d\n",i, row_sum);
row_sum = 0; // risettiamo la somma a 0 per la prossima iterazione
}
}

void print_sum_of_columns(int num_row, int num_col, int matrix[num_row][num_col]){

int col_sum = 0;
for(int j = 0; j < num_col; j++){
for(int i = 0; i < num_row; i++){
col_sum += matrix[i][j];
}
printf("La somma della colonna %d è %d\n", j, col_sum);
col_sum = 0;
}
}

void print_sum_of_diagonals(int dim_mat, int matrix[dim_mat][dim_mat]){

int sum_principal = 0, sum_secondary = 0;
for(int i = 0; i < dim_mat; i++){
sum_principal += matrix[i][i];
sum_secondary += matrix[i][dim_mat - (i + 1)];
}
printf("Le somme delle diagonali sono %d e %d\n", sum_principal, sum_secondary);
}

void print_instructions(){
printf("Questo programma genera una matrice casuale con valori da 0 e 99 e"
"calcola le seguenti info statistiche : minimo, massimo, media e somme
varie di valori\n");
}