Менеджер паролей. помощь с графическим интерфейсом

#include <iostream>
#include <string>
#include <random>
#include "sqlite3.h"
#include <conio.h>
#include <locale>
#include "sqlite3.h"
 
 
const char set_lowercase[] = "abcdefghijklmnopqrstuvwxyz";
const char set_uppercase[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char set_digits[] = "0123456789";
const char set_special[] = "!@#$%^&*_";
namespace MySQLite {
    const char* errmsg(sqlite3*);
}
 
class Database {
public:
    sqlite3* db;
    int openStatus, execStatus;
 
    Database() {
        openStatus = sqlite3_open("passwords.db", &db);
        if (openStatus != SQLITE_OK) {
            std::cerr << "Database Error: " << sqlite3_errmsg(db) << std::endl;
            // Обработайте ошибку, возможно, вызвав исключение или выйдя из программы.
            throw std::runtime_error("Failed to open the database.");
        }
        else {
            std::string sql = "CREATE TABLE IF NOT EXISTS passwords(ID INTEGER PRIMARY KEY AUTOINCREMENT, PASSWORD TEXT NOT NULL);";
            execStatus = sqlite3_exec(db, sql.c_str(), 0, 0, 0);
            if (execStatus != SQLITE_OK) {
                std::cerr << "Create Table Error!" << std::endl;
                // Обработайте ошибку, возможно, вызвав исключение или выйдя из программы.
                throw std::runtime_error("Failed to create the table.");
            }
        }
    }
 
    int savePassword(std::string password) {
        std::string sql = "INSERT INTO passwords (PASSWORD) VALUES ('" + password + "')";
        execStatus = sqlite3_exec(db, sql.c_str(), 0, 0, 0);
        if (execStatus != SQLITE_OK)
            return -1;
        return 0;
    }
 
    ~Database() {
        sqlite3_close(db);
    }
};
class PasswordGenerator {
    std::random_device rd{};
    std::mt19937 rng{ rd() };
public:
    std::string generate(size_t length, bool flag_lowercase, bool flag_uppercase, bool flag_digits, bool flag_special) {
        std::string set_result, password;
        if (!flag_lowercase && !flag_uppercase && !flag_digits && !flag_special)
            return "";
        if (flag_lowercase)
            set_result += set_lowercase;
        if (flag_uppercase)
            set_result += set_uppercase;
        if (flag_digits)
            set_result += set_digits;
        if (flag_special)
            set_result += set_special;
        std::uniform_int_distribution<int> dist(0, set_result.length() - 1);
        for (size_t i = 0; i < length; i++) {
            password += set_result[dist(rng)];
        }
        return password;
    }
};

#include <iostream>
#include <string>
#include <random>
#include "cxxopts.hpp"
#include "sqlite3.h"
#include <locale>
#include <set>
#include <vector>
#include "Source.cpp"
 
class UniquePasswordGenerator : public PasswordGenerator {
public:
    std::string generateUniquePassword(size_t length, bool useLower, bool useUpper, bool useDigits, bool useSpecial);
    void runTests();
private:
    std::vector<std::string> generatedPasswords;
};
 
std::string UniquePasswordGenerator::generateUniquePassword(size_t length, bool useLower, bool useUpper, bool useDigits, bool useSpecial) {
    std::string password;
    do {
        password = generate(length, useLower, useUpper, useDigits, useSpecial);
    } while (std::find(generatedPasswords.begin(), generatedPasswords.end(), password) != generatedPasswords.end());
 
    generatedPasswords.push_back(password);
    return password;
}
 
void UniquePasswordGenerator::runTests() {
    const size_t testCount = 10000;
    for (size_t i = 0; i < testCount; ++i) {
        std::string password = generateUniquePassword(8, true, true, true, true);
        if (std::find(generatedPasswords.begin(), generatedPasswords.end(), password) != generatedPasswords.end()) {
            std::cerr << "Ошибка: во время теста создан повторяющийся пароль." << std::endl;
            return;
        }
        generatedPasswords.push_back(password);
    }
    std::cout << "All tests passed successfully." << std::endl;
}
 
int main() {
    setlocale(LC_ALL, "rus");
 
    Database db;
    UniquePasswordGenerator uniquePg;
 
    // Run tests before generating passwords
    uniquePg.runTests();
 
    char action;
    do {
        // Ввод параметров генерации от пользователя
        size_t count, length;
        bool useLower, useUpper, useDigits, useSpecial;
 
        std::cout << "Введите количество паролей для генерации: ";
        std::cin >> count;
 
        std::cout << "Введите длину пароля: ";
 
        std::cin >> length;
 
        std::cout << "Использовать строчные буквы (1 - да, 0 - нет): ";
        std::cin >> useLower;
 
        std::cout << "Использовать прописные буквы (1 - да, 0 - нет): ";
        std::cin >> useUpper;
 
        std::cout << "Использовать цифры (1 - да, 0 - нет): ";
        std::cin >> useDigits;
 
        std::cout << "Использовать спецсимволы (1 - да, 0 - нет): ";
        std::cin >> useSpecial;
 
        // Генерация паролей
        std::vector<std::string> generatedPasswords;
        for (size_t i = 0; i < count; i++) {
            std::string password = uniquePg.generateUniquePassword(length, useLower, useUpper, useDigits, useSpecial);
            generatedPasswords.push_back(password);
            db.savePassword(password);
        }
 
        // Вывод уникальных паролей
        std::set<std::string> uniqueSet(generatedPasswords.begin(), generatedPasswords.end());
        std::cout << "Уникальные пароли:" << std::endl;
        for (const auto& password : uniqueSet) {
            std::cout << password << std::endl;
        }
 
        // Вывод повторяющихся паролей
        std::cout << "Повторы:" << std::endl;
        std::set<std::string> duplicateSet;
        for (const auto& password : generatedPasswords) {
            if (uniqueSet.count(password) > 1 && duplicateSet.count(password) == 0) {
                std::cout << password << " (повтор)" << std::endl;
                duplicateSet.insert(password);
            }
        }
 
        std::cout << "Press 'Y' to generate more passwords, any other key to exit..." << std::endl;
        std::cin >> action;
 
    } while (action == 'Y' || action == 'y');
 
    return 0;
}