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

#define BLOCK_DIM     64 // dimensione di un blocco di caratteri
#define BUFFER_BLOCKS 16 // blocchi di caratteri in un buffer

// cifrario a trasposizione di Giulio Cesare
char GC(char c, int N)
{
 N = N%26; // normalizzazione trasposizione

 if (c >= 'a' && c <= 'z')
   {
    c = c + N;
    if (c > 'z')
      c = 'a' + (c - 'z') - 1;
    return c;
   }
 if (c >= 'A' && c <= 'Z')
   {
    c = c + N;
    if (c > 'Z')
      c = 'A' + (c - 'Z') - 1;
    return c;
   }
 return c;
}


FILE *origine, *destinazione;
int eof_flag;
char input_buffer[BUFFER_BLOCKS*BLOCK_DIM];
int input_buffer_write_index; // indice per la scrittura nel buffer
int input_buffer_read_index; // indice per la lettura dal buffer
int input_buffer_count; // numero di blocchi nel buffer
char output_buffer[BUFFER_BLOCKS*BLOCK_DIM];
int output_buffer_write_index; // indice per la scrittura nel buffer
int output_buffer_read_index; // indice per la lettura dal buffer
int output_buffer_count; // numero di blocchi nel buffer
int N; // valore della trasposizione di Cesare

// oggetti per implementazione sezioni critiche di codice
CRITICAL_SECTION input_buffer_mutex;
CRITICAL_SECTION output_buffer_mutex;


unsigned long WINAPI read_thread(void* arg) // lettura da file
{
 int count;

 // lettura di un blocco di dati dal file
 memset(&input_buffer[input_buffer_write_index*BLOCK_DIM], 0, BLOCK_DIM);
 fread(&input_buffer[input_buffer_write_index*BLOCK_DIM], BLOCK_DIM, 1, origine);
 EnterCriticalSection(&input_buffer_mutex);
 // incremento indice di scrittura nel buffer di input
 input_buffer_write_index = ( input_buffer_write_index + 1) % BUFFER_BLOCKS;
 // incremento contatore blocchi di dati nel buffer di input
 input_buffer_count++;
 LeaveCriticalSection(&input_buffer_mutex);
 while (!feof(origine))
      {
       // attesa disponibilita’ spazio nel buffer per nuovi dati
       do {
           EnterCriticalSection(&input_buffer_mutex);
           count = input_buffer_count;
           LeaveCriticalSection(&input_buffer_mutex);
          } while (count >= BUFFER_BLOCKS);
       // lettura di un blocco di dati dal file
       memset(&input_buffer[input_buffer_write_index*BLOCK_DIM], 0, BLOCK_DIM);
       fread(&input_buffer[input_buffer_write_index*BLOCK_DIM], BLOCK_DIM, 1, origine);
       EnterCriticalSection(&input_buffer_mutex);
       // incremento indice di scrittura nel buffer di input
       input_buffer_write_index = (input_buffer_write_index + 1) % BUFFER_BLOCKS;
       // incremento contatore blocchi dati nel buffer di input
       input_buffer_count++;
       LeaveCriticalSection(&input_buffer_mutex);
      }
 // attesa elaborazione dati presenti nel buffer di input
 do {
     EnterCriticalSection(&input_buffer_mutex);
     count = input_buffer_count;
     LeaveCriticalSection(&input_buffer_mutex);
    } while (count > 0);
 // attesa scrittura dati presenti nel buffer di output
 do {
     EnterCriticalSection(&output_buffer_mutex);
     count = output_buffer_count;
     LeaveCriticalSection(&output_buffer_mutex);
    } while (count > 0);
 eof_flag = TRUE;
 ExitThread(0);
}

unsigned long WINAPI process_thread(void* arg) // elaborazione dati
{
 int in_count, out_count, i;

 while (!eof_flag)
      {
       // verifica presenza dati nel buffer di lettura e disponbilita’ spazio nel buffer per scrittura nuovi dati
       EnterCriticalSection(&input_buffer_mutex);
       in_count = input_buffer_count;
       LeaveCriticalSection(&input_buffer_mutex);
       EnterCriticalSection(&output_buffer_mutex);
       out_count = output_buffer_count;
       LeaveCriticalSection(&output_buffer_mutex);
       if (in_count>0 && out_count<BUFFER_BLOCKS)
         {
          for (i=0; i<BLOCK_DIM; i++)
             //output_buffer[output_buffer_write_index*BLOCK_DIM+i] = input_buffer[input_buffer_read_index*BLOCK_DIM+i];
             output_buffer[output_buffer_write_index*BLOCK_DIM+i] = GC(input_buffer[input_buffer_read_index*BLOCK_DIM+i], N);
          EnterCriticalSection(&input_buffer_mutex);
          // incremento indice di lettura nel buffer di input
          input_buffer_read_index = (input_buffer_read_index + 1) % BUFFER_BLOCKS;
          // decremento contatore blocchi dati nel buffer di input
          input_buffer_count--;
          LeaveCriticalSection(&input_buffer_mutex);
          EnterCriticalSection(&output_buffer_mutex);
          // incremento indice di scrittura nel buffer di output
          output_buffer_write_index = (output_buffer_write_index + 1) % BUFFER_BLOCKS;
          // incremento contatore blocchi dati nel buffer di output
          output_buffer_count++;
          LeaveCriticalSection(&output_buffer_mutex);
         }
      }
 ExitThread(0);
}

unsigned long WINAPI write_thread(void* arg) // scruttura su file
{
 int count;
 while (!eof_flag)
      {
       // verifica presenza dati nel buffer di scrittura
       EnterCriticalSection(&output_buffer_mutex);
       count = output_buffer_count;
       LeaveCriticalSection(&output_buffer_mutex);
       if (count>0)
         {
          // scrittura di un blocco di caratteri nel file
          fwrite(&output_buffer[output_buffer_read_index*BLOCK_DIM], BLOCK_DIM, 1, destinazione);
          EnterCriticalSection(&output_buffer_mutex);
          // incremento indice di lettura nel buffer di output
          output_buffer_read_index = (output_buffer_read_index + 1) % BUFFER_BLOCKS;
          // decremento contatore blocchi dati nel buffer di output
          output_buffer_count--;
          LeaveCriticalSection(&output_buffer_mutex);
         }
       }
 ExitThread(0);
}




void main (int argc, char* argv[])
{
 HANDLE R_thread, P_thread, W_thread;

 if (argc != 4)
   {
    printf( "Uso: %s file-origine file-destinazione valore-trasposizione\r\n",argv[0]);
    return;
   }
 // apertura in lettura file di origine
 origine = fopen(argv[1], "rb");
 if (origine == NULL)
   {
    printf("Errore apertura file \"%s\"\r\n",argv[1]);
    return;
   }
 // apertura in scrittura file di destinazione
 destinazione = fopen(argv[2], "wb");
 if (destinazione == NULL)
   {
    printf("Errore apertura file \"%s\"\r\n",argv[2]);
    fclose(origine);
    return;
   }
 // impostazione valore trasposizione
 N = atoi(argv[3]);

 input_buffer_count = 0;
 input_buffer_write_index = 0;
 input_buffer_read_index = 0;
 output_buffer_count = 0;
 output_buffer_write_index = 0;
 output_buffer_read_index = 0;
 eof_flag = FALSE;
 // creazione degli oggetti mutex per l’accesso alle sezioni critiche
 InitializeCriticalSection(&input_buffer_mutex);
 InitializeCriticalSection(&output_buffer_mutex);
 // creazione dei thread corrispondenti alle funzioni di lettura, elaborazione e scrittura
 R_thread = CreateThread(NULL, 1024, &read_thread, NULL, 0, NULL);
 P_thread = CreateThread(NULL, 1024, &process_thread, NULL, 0, NULL);
 W_thread = CreateThread(NULL, 1024, &write_thread, NULL, 0, NULL);
 // attesa della terminazione dei thread
 WaitForSingleObject(R_thread, INFINITE);
 WaitForSingleObject(P_thread, INFINITE);
 WaitForSingleObject(W_thread, INFINITE);
 // distruzione oggetti mutex per accesso sezioni critiche
 DeleteCriticalSection(&input_buffer_mutex);
 DeleteCriticalSection(&output_buffer_mutex);
 // chiusura file
 fclose(origine);
 fclose(destinazione);
 return;
}