#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
// add operation between 2 buffers
void addBuffers(char * buf1, char * buf2, int bufSize) {
  for(int i = 0; i < bufSize; ++i) {
    buf1[i] = (buf1[i] + buf2[i]);
  }
}
 
// substract operation between 2 buffers
void substractBuffers(char * buf1, char * buf2, int bufSize) {
  for(int i = 0; i < bufSize; ++i) {
    buf1[i] = (buf1[i] - buf2[i]);
  }
}
 
// make key match the block size
void securizeKey(char * keyBuf, char * key, int keySize, int chunkSize) {
  for (int i = 0, j = 0; i < chunkSize; ++i, ++j) {
    if (j > keySize) {
      j = 0;
    }
    keyBuf[i] = key[j];
  }
}
 
// generate pseudorandom buffer
char *allocate_random_heap_buffer(size_t size) {
  time_t current_time = time(NULL);
  srandom((unsigned int) current_time);
  char* allocatedMemory = (char *) malloc(size);
 
  for (int bufferIndex = 0; bufferIndex < size; bufferIndex++) {
    uint8_t randomNumber = (uint8_t) random();
    allocatedMemory[bufferIndex] = randomNumber;
  }
 
  return allocatedMemory;
}
 
// generate a pseudorandom IV
void generateIV(char * ivBuf, int chunkSize) {
  char * random = allocate_random_heap_buffer(chunkSize);
  for (int i = 0; i < chunkSize; ++i) {
    if (random[i] < chunkSize) {
      ivBuf[i] = random[random[i]];
    } else {
      ivBuf[i] = random[i];
    }
  }
}
 
char * GENERATED_IV;
// block cipher encryption
void cipherBlock(char * bufferBlock, char * bufferBlock2, char * key, int blockSize, int round) {
  if (round == 1) { // add IV to first block
    char IV[blockSize];
    generateIV(IV, blockSize);
    addBuffers(bufferBlock, IV, blockSize);
    GENERATED_IV = IV;
  } else { // add Last Block to Current Block
    addBuffers(bufferBlock, bufferBlock2, blockSize);
    addBuffers(bufferBlock, key, blockSize);
  }
}
 
 
// reverse
 
 
int main(int argc, char *argv[]) {
  /*** Fetch CLI Arguments */
  char * filename; int filenameSet = 0; // file to work on
  char * mode;     int modeSet = 0; // encrypt or decrypt
  char * key;      int keySet = 0; // simmetric key
  char * output;   int outputSet = 0; // file to output results on
  for(int i = 0; i < argc; ++i) {
    // -f or --file
    if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--file") == 0) {
      filename = argv[i + 1];
      filenameSet = 1;
    // -m or --mode
    } else if (strcmp(argv[i], "-m") == 0 || strcmp(argv[i], "--mode") == 0) {
      mode = argv[i + 1];
      modeSet = 1;
    // -k or --key
    } else if (strcmp(argv[i], "-k") == 0 || strcmp(argv[i], "--key") == 0) {
      key = argv[i + 1];
      keySet = 1;
    } else if (strcmp(argv[i], "-o") == 0 || strcmp(argv[i], "--output") == 0) {
      output = argv[i + 1];
      outputSet = 1;
    }
  }
 
  // Check if mandatory arguments are set 
  if (filenameSet != 1) {
    printf("Missing filename argument, use -f ./myFile");
    return 0;
  }
 
  if (modeSet != 1) {
    printf("Please select a mode, use -m cipher or use -m reverse");
    return 0;
  }
 
  if (keySet != 1) {
    printf("Missing key argument, use -k mySecretKey");
    return 0;
  }
 
  if (outputSet != 1) {
    printf("Missing output argument, use -o ./newFile");
    return 0;
  }
  /* Fetch CLI Arguments ***/
 
 
  #define BLOCK_SIZE 1024
  const int keySize = strlen(key);
  char keyBuf[BLOCK_SIZE];
  securizeKey(keyBuf, key, keySize, BLOCK_SIZE);
 
 
  if (strcmp(mode, "cipher") == 0) { // user selected encryption mode
    char buf[BLOCK_SIZE];
    char lastBuf[BLOCK_SIZE];
    FILE *file;
    size_t nread;
 
    file = fopen(filename, "r");
    FILE * encrypted = fopen(output, "w"); // file to output the encrypted file
    if (file) {
      int i = 0;
      while ((nread = fread(buf, 1, sizeof buf, file)) > 0) {
        cipherBlock(buf, lastBuf, keyBuf, BLOCK_SIZE, ++i);
        memcpy(lastBuf, buf, BLOCK_SIZE);
        fwrite(buf, 1, nread, encrypted);
      }
      fwrite(GENERATED_IV, 1, BLOCK_SIZE, encrypted);
 
      FILE * lastIV = fopen("./lastIV.txt", "w"); 
      fwrite(GENERATED_IV, 1, BLOCK_SIZE, lastIV); // debug IV
 
      if (ferror(file)) {
        // deal with error 
      }
      fclose(file);
    }
  } else if (strcmp(mode, "reverse") == 0) {
    /* TODO: READ REVERSE IN CHUNKS */
    char buf[BLOCK_SIZE];
    char lastBuf[BLOCK_SIZE];
    FILE *file;
    size_t nread;
 
    file = fopen(filename, "r");
    FILE * decrypted = fopen(output, "w"); // file to output the decrypted file
 
    if (file) {
      int i = 0;
      fseek(file, 0, SEEK_END);
      int sz = ftell(file); // file size
      char IV[BLOCK_SIZE];
 
      char aux[BLOCK_SIZE];
 
 
      for (int j = sz - BLOCK_SIZE; /* j > 0 */; j -= BLOCK_SIZE, ++i) {
        fseek(file, j, SEEK_SET);
	fread(aux, 1, BLOCK_SIZE, file);
        if (i == 0) {
          memcpy(IV, aux, BLOCK_SIZE);
          FILE * extractedIV = fopen("./extractedIV.txt", "w");
          fwrite(IV, 1, BLOCK_SIZE, extractedIV); // debug IV
          fclose(extractedIV);
          return 0;
        }
 
	if (j <= 0) {
          break;
	}
      }
      fclose(file);
    }
 
  } else {
    printf("Select -m cipher or -m reverse");
    return 0;
  }
  return 0;
}