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

typedef double elemento;

/* In questo modo se dovremo riusare il codice per allocare ad esempio delle matrici di 
long double bastera' cambiare la definizione di "elemento" come long double e tutto il 
resto del codice sara' riutilizzabile */

typedef elemento **Matrice;

Matrice AllocaMatrice(const int nrighe, const int ncol);
Matrice CreaMatrice(FILE *ifp,const int nrighe,const int ncol);
Matrice Somma(Matrice a, Matrice b, const int nrighe, const int ncol);
void DeallocaMatrice(Matrice a, const int nrighe);
Matrice Prodotto(Matrice a, const int nra, const int nca, Matrice b, const int nrb, const int ncb);
void TrovaDimensioni(FILE *ifp, int * nrighe, int * ncol);

int main(){

  int i=0,j=0,m=0,n=0;
  int ma=0,na=0,mb=0,nb=0,md=0,nd=0;
  const int MAXCHARS=1000;
  FILE *ifpa=NULL, *ifpb=NULL, *ofpc = NULL, *ifpd=NULL, *ofpe = NULL;
  Matrice a=NULL,b=NULL,c=NULL,d=NULL, e=NULL;
  char nomefile[MAXCHARS];



  printf("Introduci il nome del file per la matrice a\n");
  scanf("%s",nomefile);

  ifpa = fopen(nomefile,"r");
  if(ifpa==NULL) {
    fprintf(stderr,"File %s non trovato\n",nomefile);
    exit(1);
  }

  printf("Introduci il nome del file per la matrice b\n");
  scanf("%s",nomefile);

  ifpb = fopen(nomefile,"r");
  if(ifpb==NULL) {
    fprintf(stderr,"File %s non trovato\n",nomefile);
    exit(1);
  }
  printf("Introduci il nome del file per la matrice somma\n");
  scanf("%s",nomefile);

  ofpc = fopen(nomefile,"w");
  if(ofpc==NULL) {
    fprintf(stderr,"Non e' possibile creare il file %s\n",nomefile);
    exit(1);
  }

  /* Questo era richiesto nel quesito standard: 

  printf("Introduci il numero di righe e colonne di a e b\n");
  scanf("%d %d",&m,&n);

  */

  /* Sostituire le due righe precedenti con 
     queste per la risposta alla prima domanda facoltativa 
  */

  TrovaDimensioni(ifpa,&ma,&na);
  TrovaDimensioni(ifpb,&mb,&nb);

  if(ma != mb || na != nb){
    fprintf(stderr,"a e b hanno dimensioni diverse!\n");
    exit(1);
  }
  m = ma;
  n = na;

  /* Fine parte facoltativa */

  a = CreaMatrice(ifpa,m,n);
  fclose(ifpa);

  b = CreaMatrice(ifpb,m,n);
  fclose(ifpb);


  c = Somma(a,b,m,n);


  for(i=0;i<m;i++){
    for(j=0;j<n;j++){
      fprintf(ofpc, "%lf\t",c[i][j]);
    }
    fprintf(ofpc,"\n");
  }
  fclose(ofpc);

  DeallocaMatrice(a,m);
  DeallocaMatrice(b,m);

  /* Parte facoltativa; seconda domanda */

  printf("Introduci il nome del file per la matrice d\n");
  scanf("%s",nomefile);

  ifpd = fopen(nomefile,"r");
  if(ifpd==NULL) {
    fprintf(stderr,"File %s non trovato\n",nomefile);
    exit(1);
  }
  /* Questo se non si era fatta la parte di conteggio automatico...

  printf("Introduci il numero di righe e colonne della matrice d\n");
  scanf("%d %d",&md,&nd);

  */
  TrovaDimensioni(ifpd, &md,&nd);

  printf("Introduci il nome del file per la matrice prodotto\n");
  scanf("%s",nomefile);

  ofpe = fopen(nomefile,"w");
  if(ofpe==NULL) {
    fprintf(stderr,"Non e' possibile creare il file %s\n",nomefile);
    exit(1);
  }

  d = CreaMatrice(ifpd,md,nd);
  fclose(ifpd);
  e = Prodotto(c,m,n,d,md,nd);

  for(i=0;i<m;i++){
    for(j=0;j<nd;j++){
      fprintf(ofpe, "%lf\t",e[i][j]);
    }
    fprintf(ofpe,"\n");
  }
  fclose(ofpe);

  DeallocaMatrice(c,m);
  DeallocaMatrice(d,m);
  DeallocaMatrice(e,m);

  return 0;
}


Matrice AllocaMatrice(const int nrighe,const int ncol){
  Matrice p;
  int i;

  /* Alloca il puntatore alla matrice, cioe' ad un vettore di puntatori, uno per ciascuna riga */

  p=(Matrice)malloc(nrighe*sizeof(elemento*));

  /* Controlla che l'allocazione abbia avuto successo */
  
  if(p==NULL) {
    fprintf(stderr,"Non ho abbastanza spazio per allocare una matrice\n");
    exit(1);
  }
  for(i=0; i<nrighe;i++){

    /* Per ogni riga allochiamo spazio per gli elementi della matrice, inizializzandoli a zero */

    p[i]=(elemento*)calloc(ncol,sizeof(elemento));

    /*...e controlliamo che lo spazio ci sia effettivamente ...*/

    if(p[i]==NULL) {
      fprintf(stderr,"Non ho abbastanza spazio per allocare la riga %d di una matrice\n",i);
      exit(1);
    }
  }
  return(p);
} 


Matrice CreaMatrice(FILE *ifp,const int nrighe,const int ncol){
  int i,j;
  Matrice ma;
  /* Allocazione dinamica della matrice */
  ma=AllocaMatrice(nrighe,ncol);

  /* Copia dati dai file */

  for(i=0;i<nrighe;i++)
    {
      for(j=0;j<ncol;j++)
	{
	  fscanf(ifp,"%lf", &ma[i][j]);
	  if(feof(ifp)){ 
	    fprintf(stderr,"Il file non contiene abbastanza elementi !\n");
	    exit(1);
	  }
    }
    }
  /* IMPORTANTE: "riavvolgiamo" il file in modo da poter riutilizzare il puntatore */
  rewind(ifp);
  return(ma);
}

Matrice Somma(Matrice a, Matrice b, const int nrighe, const int ncol){
  Matrice somma;
  int i=0,j=0;
  /* Allocazione dinamica della matrice */
  somma = AllocaMatrice(nrighe, ncol);
  for(i=0;i<nrighe;i++){
    for(j=0;j<ncol;j++){
      somma[i][j]=a[i][j]+b[i][j];
    }
  }
  return(somma);
}

Matrice Prodotto(Matrice a, const int nra, const int nca, Matrice b, const int nrb, const int ncb){
  Matrice prodotto;
  int i=0,j=0,k=0;

  if(nrb != nca) {
    fprintf(stderr,"Impossibile calcolare il prodotto: dimensioni inconsistenti\n");
    exit(1);
  }
  /* Allocazione dinamica della matrice */
  prodotto = AllocaMatrice(nra,ncb);
  for(i=0;i<nra;i++){
    for(k=0;k<ncb;k++){
      for(j=0;j<nca;j++){
	prodotto[i][k] += a[i][j]*b[j][k];
      }
    }
  }
  return(prodotto);
}

void TrovaDimensioni(FILE * ifp, int * m, int * n){
  int spazio=0,riga=0,ch = 0;
  
  while((ch=fgetc(ifp))!=EOF){
    if(ch==' '){
      spazio++;
    }
    else{
      if(ch=='\n')
	riga++;
      
    }
  }
  *m = riga;
  *n = (spazio/riga)+1;
  /* IMPORTANTE ! "Riavvolge" il file in modo da poterlo poi rileggere */
  rewind(ifp);
  
}

void DeallocaMatrice(Matrice a, const int nrighe){
  int i=0;
  /* Dealloca ***PRIMA*** i puntatori alle righe...*/
  for(i=0;i<nrighe;i++){
    free(a[i]);
  }
  /* .. e ***POI*** quello a tutta la matrice...*/ 
  free(a);
}