#include <iostream>
#include <fstream>
#include <chrono>
#include <random>
#include <algorithm>
using namespace std;

struct file_buffer_wrapper {
    char* buffer;
    unsigned int length;
};

file_buffer_wrapper read_file(string file_path) {
    ifstream input_stream;
    unsigned int file_length;
    input_stream.open(file_path);
    if (input_stream.is_open()) {
        input_stream.seekg(0, ios::end);
        file_length = input_stream.tellg();
        input_stream.seekg(0, ios::beg);
        char* buffer;
        buffer = new char[file_length];
        input_stream.read(buffer, file_length);
        input_stream.close();
        file_buffer_wrapper wrapper;
        wrapper.buffer = buffer;
        wrapper.length = file_length;
        return wrapper;
    } else {
        throw "Could not open the file!";
    }
}

void write_resource_file(string file_name, file_buffer_wrapper wrapper) {
    ofstream output_stream;
    output_stream.open("resources/" + file_name);
    output_stream.write(wrapper.buffer, wrapper.length);
    output_stream.close();
}

void make_key(char* alphabet, unsigned int alphabet_length) {
    unsigned seed = chrono::system_clock::now().time_since_epoch().count();
    shuffle (alphabet, alphabet + alphabet_length, default_random_engine(seed));
}

file_buffer_wrapper encrypt_text(char* text, unsigned int text_length, char* alphabet, unsigned int alphabet_length, char* key) {
    char* pos;
    char* result_buffer = new char[text_length];
    unsigned int result_length = 0;
    file_buffer_wrapper result;
    for (int i = 0; i < text_length; i++) {
         pos = find(alphabet, alphabet + alphabet_length, text[i]);
        if(pos != alphabet + alphabet_length) {
            result_buffer[result_length] = key[pos - alphabet];
            result_length++;
        }
    }
    result.buffer = result_buffer;
    result.length = result_length;
    return result;
}

file_buffer_wrapper decrypt_text(char* text, unsigned int text_length, char* alphabet, unsigned int alphabet_length, char* key) {
    char* pos;
    char* result_buffer = new char[text_length];
    file_buffer_wrapper result;
    for (int i = 0; i < text_length; i++) {
        pos = find(key, key + alphabet_length, text[i]);
        result_buffer[i] = alphabet[pos - key];
    }
    result.buffer = result_buffer;
    result.length = text_length;
    return result;
}

int main() {
    file_buffer_wrapper alphabet = read_file("resources/alphabet.txt");
    file_buffer_wrapper key = read_file("resources/alphabet.txt");
    make_key(key.buffer, key.length);
    write_resource_file("key.txt", key);
    file_buffer_wrapper text = read_file("resources/text.txt");
    file_buffer_wrapper encrypted_text;
    encrypted_text = encrypt_text(text.buffer, text.length, alphabet.buffer, alphabet.length, key.buffer);
    write_resource_file("encrypted_text.txt", encrypted_text);
    file_buffer_wrapper decrypted_text = decrypt_text(encrypted_text.buffer, encrypted_text.length, alphabet.buffer, alphabet.length, key.buffer);
    write_resource_file("decrypted_text.txt", decrypted_text);
    return 0;
}