UserInterface.cpp

#include <sstream>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <filesystem>
#include <fstream>
#include "PasswordEntry.h"
#include "UserInterface.h"

using namespace std;

auto UserInterface::UserInterface::showMenuInfo() {
    cout << "Menu: " << endl;
    cout << "1. Search passwords." << endl;
    cout << "2. Sort passwords." << endl;
    cout << "3. Add password." << endl;
    cout << "4. Edit password." << endl;
    cout << "5. Delete password." << endl;
    cout << "6. Add category." << endl;
    cout << "7. Remove category." << endl;
    cout << "8. Save file." << endl;
    cout << "9. Display passwords." << endl;
    cout << "10. Show menu." << endl;
    cout << "11. Exit program." << endl;
}

void UserInterface::UserInterface::runMainMenu() {
    bool exit_loop = false;
    string choice;
    int choice_int;
    do {
        showMenuInfo();
        cout << "Please enter a number: ";
        cin >> choice;
        cout << endl;
        try {
            choice_int = stoi(choice);
        } catch (const invalid_argument argument) {
            choice_int = 0;
        }
        switch (choice_int) {
            case 1:
                cout << "1. Search passwords." << endl;
                cout << endl;
                searchPasswords();
                break;
            case 2:
                cout << "2. Sort passwords." << endl;
                cout << endl;
                sortPasswords();
                break;
            case 3: {
                cout << "3. Add password." << endl;
                PasswordEntry entry = *new PasswordEntry();
                if (entry.createNewPassword(categories)) {
                    password_entries.push_back(entry);
                }
                break;
            }
            case 4:
                cout << "4. Edit password." << endl;
                cout << endl;
                editPassword();
                break;
            case 5:
                cout << "5. Delete password." << endl;
                cout << endl;
                deletePasswords();
                break;
            case 6:
                cout << "6. Add category." << endl;
                addCategory();
                break;
            case 7:
                cout << "7. Remove category." << endl;
                removeCategory();
                break;
            case 8:
                cout << "8. Save file." << endl;
                saveFile();
                break;
            case 9:
                cout << "9. Display passwords." << endl;
                cout << endl;
                displayPasswords();
                break;
            case 10:
                showMenuInfo();
                cout << endl;
                break;
            case 11:
                cout << "Exiting program." << endl;
                cout << endl;
                exit_loop = true;
                break;
            default:
                cout << "Invalid choice. Please enter a valid option." << endl;
                cout << endl;
                break;
        }
    } while (!exit_loop);
}

void UserInterface::UserInterface::displayPasswords() {
    for (PasswordEntry entry : password_entries) {
        cout << entry.toDisplayString() << endl;
    }
}

void UserInterface::UserInterface::addCategory() {
    cout << "Please enter the category name to add:" << endl;
    cin.ignore();
    string category_name;
    std::getline(cin, category_name);
    categories.push_back(category_name);
}

void UserInterface::UserInterface::removeCategory() {
    cout << "Please enter the category name to remove:" << endl;
    cin.ignore();
    string category_name;
    std::getline(cin, category_name);
    vector<string>::iterator new_categories_end;
    new_categories_end = remove(categories.begin(), categories.end(), category_name);
    categories.erase(new_categories_end, categories.end());
    cout << "Categories after removal: " << endl;
    for (string cat : categories) {
        cout << cat << endl;
    }
    auto new_entries_end = remove_if(password_entries.begin(), password_entries.end(),
                                     [category_name](PasswordEntry entry_to_remove) {
                                         if (category_name == entry_to_remove.getCategory()) {
                                             cout << "Removing password: " + entry_to_remove.toStorageString()
                                                  << endl;
                                             return true;
                                         }
                                         return false;
                                     });
    if (new_entries_end != password_entries.end()) {
        password_entries.erase(new_entries_end, password_entries.end());
    }
}

void UserInterface::UserInterface::deletePasswords() {
    cout << "Please enter the name of the password to delete:" << endl;
    cin.ignore();
    string password_name;
    std::getline(cin, password_name);
    vector<string>::iterator entries_after_removal;
    auto new_entries_end = remove_if(password_entries.begin(), password_entries.end(),
                                     [password_name](PasswordEntry entry_to_remove) {
                                         if (password_name == entry_to_remove.getName()) {
                                             cout << "Removing password: " + entry_to_remove.toStorageString()
                                                  << endl;
                                             return true;
                                         }
                                         return false;
                                     });
    if (new_entries_end != password_entries.end()) {
        password_entries.erase(new_entries_end, password_entries.end());
    }
}

void UserInterface::UserInterface::searchPasswords() {
    cout << "Please enter the name of the password to search for:" << endl;
    cin.ignore();
    string search_term;
    std::getline(cin, search_term);
    for (PasswordEntry entry : password_entries) {
        if (search_term == entry.getName()) {
            cout << entry.toDisplayString() << endl;
        }
    }
}

void UserInterface::UserInterface::sortPasswords() {
    std::sort(password_entries.begin(), password_entries.end(), &PasswordEntry::compareEntries);
}

void UserInterface::UserInterface::editPassword() {
    displayPasswords();
    cout << "Enter the name of the password you want to edit: " << endl;
    string target_name;
    cin.ignore();
    std::getline(cin, target_name);
    vector<PasswordEntry>::iterator target_iter = std::find_if(password_entries.begin(), password_entries.end(),
                                                               [target_name](PasswordEntry const &entry) {
                                                                   return entry.getName() == target_name;
                                                               });
    if (target_iter != password_entries.end()) {
        target_iter->editEntry(categories);
    }
}

bool UserInterface::UserInterface::selectFile() {
    std::string folder_path = std::filesystem::current_path();
    vector<std::string> file_paths;
    cout << "Files in the current application directory: " << endl << endl;
    for (const auto &item : std::filesystem::directory_iterator(folder_path)) {
        file_paths.push_back(item.path());
        std::cout << item.path() << std::endl;
    }
    cout << "Please enter the file path:" << endl;
    getline(cin, file_path);
    fstream file_stream(file_path);
    if (!file_stream.good()) {
        cout << "No file exists at the specified path. A new file will be created." << endl;
        file_stream.open(file_path, std::fstream::out);
        file_stream.close();
        return true;
    } else {
        return loadFile();
    }
    return false;
}

void UserInterface::UserInterface::saveFile() {
    cout << "Please enter the encryption key: " << endl;
    string encryption_key;
    cin >> encryption_key;
    ofstream output_stream(file_path);
    output_stream << embedModificationDate(encrypt(control_text, encryption_key)) << endl;

    for (PasswordEntry entry : password_entries) {
        output_stream << encrypt(entry.toStorageString(), encryption_key) << endl;
    }
    output_stream.close();
}

void UserInterface::UserInterface::testEncryption() {
    cout << "Please enter the encryption password: " << endl;
    string encryption_key;
    cin.ignore();
    getline(cin, encryption_key);
    cout << control_text << endl;
    string encrypted_control = encrypt(control_text, encryption_key);
    cout << encrypted_control << endl;
    cout << decrypt(encrypted_control, encryption_key) << endl;
}

bool UserInterface::UserInterface::loadFile() {
    cout << "Please enter the decryption key: " << endl;
    string decryption_key;
    cin >> decryption_key;
    ifstream input_stream(file_path);
    string decrypted_line;
    string encrypted_line;
    getline(input_stream, encrypted_line);
    encrypted_line = removeModificationDate(encrypted_line);
    decrypted_line = decrypt(encrypted_line, decryption_key);
    if (decrypted_line == control_text) {
        while (getline(input_stream, encrypted_line)) {
            decrypted_line = decrypt(encrypted_line, decryption_key);
            PasswordEntry entry;
            entry.setFieldsFromStorageLine(decrypted_line);
            password_entries.push_back(entry);
            categories.push_back(entry.getCategory());
        }
        return true;
    } else {
        vector<string> file_contents;
        file_contents.push_back(embedModificationDate(encrypted_line));
        while (getline(input_stream, encrypted_line)) {
            file_contents.push_back(encrypted_line);
        }
        ofstream output_stream(file_path);
        for (string line : file_contents) {
            output_stream << line << endl;
        }
        output_stream.close();
    }
    return false;
}

string UserInterface::UserInterface::embedModificationDate(string line) {

    std::chrono::system_clock::time_point current_time = std::chrono::system_clock::now();
    std::time_t time_value = std::chrono::system_clock::to_time_t(current_time);

    std::tm* local_time = std::localtime(&time_value);

    int year = local_time->tm_year + 1900;
    int month = local_time->tm_mon + 1;
    int day = local_time->tm_mday;
    int hour = local_time->tm_hour;
    int minute = local_time->tm_min;
    int second = local_time->tm_sec;

    line.insert(0, to_string(year));
    line.insert(6, zeroPad(month));
    line.insert(10, zeroPad(day));
    line.insert(14, zeroPad(hour));
    line.insert(18, zeroPad(minute));
    line.insert(22, zeroPad(second));

    return line;
}

string UserInterface::UserInterface::removeModificationDate(string line) {
    line.erase(22, 2);
    line.erase(18, 2);
    line.erase(14, 2);
    line.erase(10, 2);
    line.erase(6, 2);
    line.erase(0, 4);

    return line;
}

std::string UserInterface::UserInterface::zeroPad(int time_unit) {
    std::ostringstream oss;
    oss << std::setw(2) << std::setfill('0') << time_unit;
    return oss.str();
}

string UserInterface::UserInterface::encrypt(string plaintext, string key) {
    int key_index = 0;
    string ciphertext;
    for (char plain_char : plaintext) {
        if (key_index >= key.size()) {
            key_index = 0;
        }
        char encrypted_char = xorChars(plain_char, key.at(key_index));
        ciphertext += to_string(int(encrypted_char)) + ";";
        key_index++;
    }
    return ciphertext;
}


char UserInterface::UserInterface::xorChars(char char1, char char2) {
    return char(unsigned(char1 ^ char2));
}

std::string UserInterface::UserInterface::decrypt(std::string ciphertext, std::string key) {
    std::stringstream token_stream(ciphertext);
    std::string token;
    std::string raw_bytes;
    while (std::getline(token_stream, token, ';')) {
        int ascii_value = stoi(token);
        raw_bytes += char(ascii_value);
    }
    int key_index = 0;
    string plaintext;
    for (char encrypted_char : raw_bytes) {
        if (key_index >= key.size()) {
            key_index = 0;
        }
        char decrypted_char = xorChars(encrypted_char, key.at(key_index));
        plaintext += decrypted_char;
        key_index++;
    }
    return plaintext;
}


int main() {

    UserInterface::UserInterface ui_manager;
    if (ui_manager.selectFile()) {
        cout << endl;
        ui_manager.runMainMenu();
    }
}