main.cpp

#include <wx/wx.h>
#include <wx/listctrl.h>
#include <sqlite3.h>
#include <thread>
#include "tsnsoft.xpm"

// Определение пользовательского события для асинхронной загрузки данных
wxDEFINE_EVENT(EVT_LOAD_DATA, wxThreadEvent);

// Класс главного окна приложения
class MyFrame : public wxFrame {
public:
    MyFrame()
        : wxFrame(nullptr, wxID_ANY, wxT("База данных дистрибутивов Linux"), wxDefaultPosition, wxSize(600, 400), wxDEFAULT_FRAME_STYLE & ~(wxRESIZE_BORDER | wxMAXIMIZE_BOX)) {
        // Центрирование окна на экране
        Centre();
        // Установка иконки приложения
        SetIcon(wxIcon(tsnsoft_xpm));

        // Создание текстового поля для фильтрации записей
        filterCtrl = new wxTextCtrl(this, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(300, -1));
        // Привязка события изменения текста в поле фильтра
        filterCtrl->Bind(wxEVT_TEXT, &MyFrame::OnFilterChanged, this);

        // Создание кнопки для добавления новой записи
        addBtn = new wxButton(this, wxID_ANY, wxT("Добавить запись"), wxDefaultPosition, wxSize(150, 30));
        // Привязка события нажатия на кнопку добавления
        addBtn->Bind(wxEVT_BUTTON, &MyFrame::OnAddRecord, this);

        // Создание кнопки для редактирования записи
        editBtn = new wxButton(this, wxID_ANY, wxT("Редактировать запись"), wxDefaultPosition, wxSize(150, 30));
        // Привязка события нажатия на кнопку редактирования
        editBtn->Bind(wxEVT_BUTTON, &MyFrame::OnEditRecord, this);

        // Создание кнопки для удаления записи
        deleteBtn = new wxButton(this, wxID_ANY, wxT("Удалить запись"), wxDefaultPosition, wxSize(150, 30));
        // Привязка события нажатия на кнопку удаления
        deleteBtn->Bind(wxEVT_BUTTON, &MyFrame::OnDeleteRecord, this);

        // Создание списка для отображения данных
        listCtrl = new wxListCtrl(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT);
        // Добавление колонок в список
        listCtrl->AppendColumn(wxT("ID"), wxLIST_FORMAT_LEFT, 50);
        listCtrl->AppendColumn(wxT("Название"), wxLIST_FORMAT_LEFT, 200);
        listCtrl->AppendColumn(wxT("Основатель"), wxLIST_FORMAT_LEFT, 200);
        listCtrl->AppendColumn(wxT("Год выпуска"), wxLIST_FORMAT_LEFT, 100);

        // Создание вертикального компоновщика
        wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
        // Создание горизонтального компоновщика для верхней части
        wxBoxSizer* topSizer = new wxBoxSizer(wxHORIZONTAL);
        // Добавление поля фильтра в верхний компоновщик
        topSizer->Add(filterCtrl, 1, wxALL | wxEXPAND, 5);
        // Добавление кнопки добавления в верхний компоновщик
        topSizer->Add(addBtn, 0, wxALL, 5);
        // Добавление кнопки редактирования в верхний компоновщик
        topSizer->Add(editBtn, 0, wxALL, 5);
        // Добавление кнопки удаления в верхний компоновщик
        topSizer->Add(deleteBtn, 0, wxALL, 5);
        // Добавление верхнего компоновщика в основной
        sizer->Add(topSizer, 0, wxEXPAND);
        // Добавление списка в основной компоновщик
        sizer->Add(listCtrl, 1, wxALL | wxEXPAND, 5);
        // Установка компоновщика для окна
        SetSizer(sizer);

        // Привязка события загрузки данных
        Bind(EVT_LOAD_DATA, &MyFrame::OnLoadData, this);

        // Инициализация базы данных
        InitDatabase();
        // Асинхронная загрузка данных
        LoadDataAsync();
    }

    // Деструктор для закрытия соединения с базой данных
    ~MyFrame() {
        sqlite3_close(db);
    }

private:
    // Указатель на список для отображения данных
    wxListCtrl* listCtrl;
    // Указатель на поле фильтрации
    wxTextCtrl* filterCtrl;
    // Указатель на кнопку добавления
    wxButton* addBtn;
    // Указатель на кнопку редактирования
    wxButton* editBtn;
    // Указатель на кнопку удаления
    wxButton* deleteBtn;
    // Указатель на объект базы данных SQLite
    sqlite3* db = nullptr;

    // Инициализация базы данных
    void InitDatabase() {
        // Открытие базы данных
        if (sqlite3_open("distributions.db", &db) != SQLITE_OK) {
            wxMessageBox(wxT("Не удалось открыть базу данных."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            return;
        }

        // SQL-запрос для создания таблицы, если она не существует
        const char* createTableSQL = "CREATE TABLE IF NOT EXISTS distributions(id INTEGER PRIMARY KEY, name TEXT, founder TEXT, year INTEGER);";
        // Выполнение запроса на создание таблицы
        if (sqlite3_exec(db, createTableSQL, nullptr, nullptr, nullptr) != SQLITE_OK) {
            wxMessageBox(wxT("Не удалось создать таблицу."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            return;
        }

        // Проверка наличия записей в таблице
        sqlite3_stmt* stmt;
        if (sqlite3_prepare_v2(db, "SELECT COUNT(*) FROM distributions;", -1, &stmt, nullptr) != SQLITE_OK) {
            wxMessageBox(wxT("Ошибка при проверке записей."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            return;
        }

        // Получение количества записей
        int count = 0;
        if (sqlite3_step(stmt) == SQLITE_ROW) {
            count = sqlite3_column_int(stmt, 0);
        }
        // Освобождение ресурсов запроса
        sqlite3_finalize(stmt);

        // Если таблица пуста, добавляем начальные данные
        if (count == 0) {
            // SQL-запрос для вставки начальных данных
            const char* insertSQL =
                "INSERT INTO distributions(name, founder, year) VALUES "
                "('Ubuntu', 'Mark Shuttleworth', 2004),"
                "('Debian', 'Ian Murdock', 1993),"
                "('Linux Mint', 'Clement Lefebvre', 2006),"
                "('Fedora', 'Warren Togami', 2003),"
                "('Arch Linux', 'Judd Vinet', 2002),"
                "('Red Hat Linux', 'Marc Ewing', 1993),"
                "('Red Hat Enterprise Linux', 'Marc Ewing', 2002),"
                "('SUSE Linux', 'Roland Dyroff', 1994),"
                "('Manjaro', 'Philip Müller', 2011),"
                "('elementary OS', 'Daniel Foré', 2011),"
                "('Kali Linux', 'Mati Aharoni', 2013),"
                "('Gentoo', 'Daniel Robbins', 2000),"
                "('Slackware', 'Patrick Volkerding', 1993);";

            // Выполнение запроса на вставку данных
            if (sqlite3_exec(db, insertSQL, nullptr, nullptr, nullptr) != SQLITE_OK) {
                wxMessageBox(wxT("Не удалось вставить начальные данные."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }
        }
    }

    // Асинхронная загрузка данных из базы
    void LoadDataAsync() {
        // Запуск отдельного потока для загрузки данных
        std::thread([this]() {
            // Создание события для передачи данных в основной поток
            wxThreadEvent event(EVT_LOAD_DATA);
            // Вектор для хранения данных
            std::vector<std::tuple<int, wxString, wxString, int>> data;

            // Подготовка SQL-запроса для выборки всех записей
            sqlite3_stmt* stmt;
            if (sqlite3_prepare_v2(db, "SELECT * FROM distributions", -1, &stmt, nullptr) != SQLITE_OK) {
                return;
            }

            // Чтение данных из результата запроса
            while (sqlite3_step(stmt) == SQLITE_ROW) {
                data.emplace_back(
                    sqlite3_column_int(stmt, 0), // ID
                    wxString::FromUTF8(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1))), // Название
                    wxString::FromUTF8(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2))), // Основатель
                    sqlite3_column_int(stmt, 3) // Год
                );
            }
            // Освобождение ресурсов запроса
            sqlite3_finalize(stmt);

            // Установка данных в событие
            event.SetPayload(data);
            // Отправка события в основной поток
            wxQueueEvent(this, event.Clone());
        }).detach();
    }

    // Обработчик события загрузки данных
    void OnLoadData(wxThreadEvent& event) {
        // Получение данных из события
        auto data = event.GetPayload<std::vector<std::tuple<int, wxString, wxString, int>>>();
        // Очистка списка перед загрузкой новых данных
        listCtrl->DeleteAllItems();

        // Заполнение списка данными
        for (size_t i = 0; i < data.size(); ++i) {
            int id, year;
            wxString name, founder;
            std::tie(id, name, founder, year) = data[i];

            // Добавление новой строки в список
            long index = listCtrl->InsertItem(listCtrl->GetItemCount(), wxString::Format(wxT("%d"), id));
            listCtrl->SetItem(index, 1, name);
            listCtrl->SetItem(index, 2, founder);
            listCtrl->SetItem(index, 3, wxString::Format(wxT("%d"), year));
        }
    }

    // Обработчик изменения текста в поле фильтра
    void OnFilterChanged(wxCommandEvent& event) {
        // Получение текста фильтра
        wxString filterText = filterCtrl->GetValue();

        // Подготовка SQL-запроса для фильтрации без учета регистра
        sqlite3_stmt* stmt;
        wxString query = wxT("SELECT * FROM distributions WHERE ");
        query += wxT("LOWER(name) LIKE ? OR ");
        query += wxT("LOWER(founder) LIKE ? OR ");
        query += wxT("CAST(year AS TEXT) LIKE ?;");
        if (sqlite3_prepare_v2(db, query.mb_str(wxConvUTF8), -1, &stmt, nullptr) != SQLITE_OK) {
            wxMessageBox(wxT("Ошибка при подготовке запроса фильтрации."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            return;
        }

        // Приведение текста фильтра к нижнему регистру и добавление символов подстановки
        wxString wildcardFilter = wxT("%") + filterText.Lower() + wxT("%");
        // Привязка параметров фильтра
        if (sqlite3_bind_text(stmt, 1, wildcardFilter.mb_str(wxConvUTF8), -1, SQLITE_TRANSIENT) != SQLITE_OK ||
            sqlite3_bind_text(stmt, 2, wildcardFilter.mb_str(wxConvUTF8), -1, SQLITE_TRANSIENT) != SQLITE_OK ||
            sqlite3_bind_text(stmt, 3, wildcardFilter.mb_str(wxConvUTF8), -1, SQLITE_TRANSIENT) != SQLITE_OK) {
            wxMessageBox(wxT("Ошибка при привязке параметров фильтрации."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            sqlite3_finalize(stmt);
            return;
        }

        // Вектор для хранения отфильтрованных данных
        std::vector<std::tuple<int, wxString, wxString, int>> data;
        // Чтение данных из результата запроса
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            data.emplace_back(
                sqlite3_column_int(stmt, 0),
                wxString::FromUTF8(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1))),
                wxString::FromUTF8(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2))),
                sqlite3_column_int(stmt, 3)
            );
        }
        // Освобождение ресурсов запроса
        sqlite3_finalize(stmt);

        // Очистка списка
        listCtrl->DeleteAllItems();
        // Заполнение списка отфильтрованными данными
        for (size_t i = 0; i < data.size(); ++i) {
            int id, year;
            wxString name, founder;
            std::tie(id, name, founder, year) = data[i];
            long index = listCtrl->InsertItem(listCtrl->GetItemCount(), wxString::Format(wxT("%d"), id));
            listCtrl->SetItem(index, 1, name);
            listCtrl->SetItem(index, 2, founder);
            listCtrl->SetItem(index, 3, wxString::Format(wxT("%d"), year));
        }
    }

    // Обработчик нажатия кнопки добавления записи
    void OnAddRecord(wxCommandEvent& event) {
        // Создание диалогового окна для добавления записи
        wxDialog addDialog(this, wxID_ANY, wxT("Добавить дистрибутив"));
        // Поля ввода для данных
        wxTextCtrl *nameCtrl = new wxTextCtrl(&addDialog, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(400, -1));
        wxTextCtrl *founderCtrl = new wxTextCtrl(&addDialog, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(400, -1));
        wxTextCtrl *yearCtrl = new wxTextCtrl(&addDialog, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(400, -1));

        // Создание компоновщика для диалога
        wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
        sizer->Add(new wxStaticText(&addDialog, wxID_ANY, wxT("Название:")), 0, wxALL, 5);
        sizer->Add(nameCtrl, 0, wxALL | wxEXPAND, 5);
        sizer->Add(new wxStaticText(&addDialog, wxID_ANY, wxT("Основатель:")), 0, wxALL, 5);
        sizer->Add(founderCtrl, 0, wxALL | wxEXPAND, 5);
        sizer->Add(new wxStaticText(&addDialog, wxID_ANY, wxT("Год выпуска:")), 0, wxALL, 5);
        sizer->Add(yearCtrl, 0, wxALL | wxEXPAND, 5);

        // Добавление кнопки сохранения
        sizer->Add(new wxButton(&addDialog, wxID_OK, wxT("Сохранить")), 0, wxALL | wxALIGN_CENTER, 5);
        addDialog.SetSizerAndFit(sizer);

        // Показ диалога и обработка результата
        if (addDialog.ShowModal() == wxID_OK) {
            // Получение данных из полей ввода
            wxString name = nameCtrl->GetValue();
            wxString founder = founderCtrl->GetValue();
            wxString yearStr = yearCtrl->GetValue();

            // Проверка заполнения всех полей
            if (name.IsEmpty() || founder.IsEmpty() || yearStr.IsEmpty()) {
                wxMessageBox(wxT("Пожалуйста, заполните все поля."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // Проверка корректности года
            long year;
            if (!yearStr.ToLong(&year)) {
                wxMessageBox(wxT("Год выпуска должен быть числом."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // Проверка диапазона года
            if (year < 1990 || year > 2025) {
                wxMessageBox(wxT("Год выпуска должен быть между 1990 и 2025."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // SQL-запрос для вставки новой записи
            const char* sql = "INSERT INTO distributions(name, founder, year) VALUES(?, ?, ?)";
            sqlite3_stmt* stmt;
            if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
                wxMessageBox(wxT("Ошибка при подготовке запроса вставки."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // Привязка параметров запроса
            if (sqlite3_bind_text(stmt, 1, name.mb_str(wxConvUTF8), -1, SQLITE_TRANSIENT) != SQLITE_OK ||
                sqlite3_bind_text(stmt, 2, founder.mb_str(wxConvUTF8), -1, SQLITE_TRANSIENT) != SQLITE_OK ||
                sqlite3_bind_int(stmt, 3, static_cast<int>(year)) != SQLITE_OK) {
                wxMessageBox(wxT("Ошибка при привязке параметров вставки."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                sqlite3_finalize(stmt);
                return;
            }

            // Выполнение запроса
            if (sqlite3_step(stmt) != SQLITE_DONE) {
                wxMessageBox(wxT("Не удалось добавить запись."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            }
            // Освобождение ресурсов запроса
            sqlite3_finalize(stmt);

            // Обновление данных в списке
            LoadDataAsync();
        }
    }

    // Обработчик нажатия кнопки редактирования записи
    void OnEditRecord(wxCommandEvent& event) {
        // Получение индекса выбранной строки
        long selectedIndex = listCtrl->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
        if (selectedIndex == -1) {
            wxMessageBox(wxT("Выберите запись для редактирования."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            return;
        }

        // Получение данных выбранной записи
        int id = wxAtoi(listCtrl->GetItemText(selectedIndex));
        wxString name = listCtrl->GetItemText(selectedIndex, 1);
        wxString founder = listCtrl->GetItemText(selectedIndex, 2);
        wxString year = listCtrl->GetItemText(selectedIndex, 3);

        // Создание диалогового окна для редактирования
        wxDialog editDialog(this, wxID_ANY, wxT("Редактировать дистрибутив"));
        // Поля ввода с текущими данными
        wxTextCtrl *nameCtrl = new wxTextCtrl(&editDialog, wxID_ANY, name, wxDefaultPosition, wxSize(400, -1));
        wxTextCtrl *founderCtrl = new wxTextCtrl(&editDialog, wxID_ANY, founder, wxDefaultPosition, wxSize(400, -1));
        wxTextCtrl *yearCtrl = new wxTextCtrl(&editDialog, wxID_ANY, year, wxDefaultPosition, wxSize(400, -1));

        // Создание компоновщика для диалога
        wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
        sizer->Add(new wxStaticText(&editDialog, wxID_ANY, wxT("Название:")), 0, wxALL, 5);
        sizer->Add(nameCtrl, 0, wxALL | wxEXPAND, 5);
        sizer->Add(new wxStaticText(&editDialog, wxID_ANY, wxT("Основатель:")), 0, wxALL, 5);
        sizer->Add(founderCtrl, 0, wxALL | wxEXPAND, 5);
        sizer->Add(new wxStaticText(&editDialog, wxID_ANY, wxT("Год выпуска:")), 0, wxALL, 5);
        sizer->Add(yearCtrl, 0, wxALL | wxEXPAND, 5);
        sizer->Add(new wxButton(&editDialog, wxID_OK, wxT("Сохранить")), 0, wxALL | wxALIGN_CENTER, 5);

        // Установка компоновщика
        editDialog.SetSizerAndFit(sizer);

        // Показ диалога и обработка результата
        if (editDialog.ShowModal() == wxID_OK) {
            // Получение новых данных
            wxString newName = nameCtrl->GetValue();
            wxString newFounder = founderCtrl->GetValue();
            wxString newYearStr = yearCtrl->GetValue();

            // Проверка заполнения всех полей
            if (newName.IsEmpty() || newFounder.IsEmpty() || newYearStr.IsEmpty()) {
                wxMessageBox(wxT("Пожалуйста, заполните все поля."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // Проверка корректности года
            long newYear;
            if (!newYearStr.ToLong(&newYear)) {
                wxMessageBox(wxT("Год выпуска должен быть числом."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // Проверка диапазона года
            if (newYear < 1990 || newYear > 2025) {
                wxMessageBox(wxT("Год выпуска должен быть между 1990 и 2025."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // SQL-запрос для обновления записи
            const char* sql = "UPDATE distributions SET name = ?, founder = ?, year = ? WHERE id = ?";
            sqlite3_stmt* stmt;
            if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
                wxMessageBox(wxT("Ошибка при подготовке запроса обновления."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // Привязка параметров запроса
            if (sqlite3_bind_text(stmt, 1, newName.mb_str(wxConvUTF8), -1, SQLITE_TRANSIENT) != SQLITE_OK ||
                sqlite3_bind_text(stmt, 2, newFounder.mb_str(wxConvUTF8), -1, SQLITE_TRANSIENT) != SQLITE_OK ||
                sqlite3_bind_int(stmt, 3, static_cast<int>(newYear)) != SQLITE_OK ||
                sqlite3_bind_int(stmt, 4, id) != SQLITE_OK) {
                wxMessageBox(wxT("Ошибка при привязке параметров обновления."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                sqlite3_finalize(stmt);
                return;
            }

            // Выполнение запроса
            if (sqlite3_step(stmt) != SQLITE_DONE) {
                wxMessageBox(wxT("Не удалось обновить запись."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            }
            // Освобождение ресурсов запроса
            sqlite3_finalize(stmt);

            // Обновление данных в списке
            LoadDataAsync();
        }
    }

    // Обработчик нажатия кнопки удаления записи
    void OnDeleteRecord(wxCommandEvent& event) {
        // Получение индекса выбранной строки
        long selectedIndex = listCtrl->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
        if (selectedIndex == -1) {
            wxMessageBox(wxT("Выберите запись для удаления."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            return;
        }

        // Получение ID записи
        int id = wxAtoi(listCtrl->GetItemText(selectedIndex));
        // Подтверждение удаления
        int response = wxMessageBox(wxT("Вы уверены, что хотите удалить эту запись?"), wxT("Подтверждение"), wxYES_NO | wxICON_WARNING);
        if (response == wxYES) {
            // SQL-запрос для удаления записи
            const char* sql = "DELETE FROM distributions WHERE id = ?";
            sqlite3_stmt* stmt;
            if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) != SQLITE_OK) {
                wxMessageBox(wxT("Ошибка при подготовке запроса удаления."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                return;
            }

            // Привязка параметра ID
            if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
                wxMessageBox(wxT("Ошибка при привязке параметра удаления."), wxT("Ошибка"), wxOK | wxICON_ERROR);
                sqlite3_finalize(stmt);
                return;
            }

            // Выполнение запроса
            if (sqlite3_step(stmt) != SQLITE_DONE) {
                wxMessageBox(wxT("Не удалось удалить запись."), wxT("Ошибка"), wxOK | wxICON_ERROR);
            }
            // Освобождение ресурсов запроса
            sqlite3_finalize(stmt);

            // Обновление данных в списке
            LoadDataAsync();
        }
    }
};

// Класс приложения
class MyApp : public wxApp {
public:
    // Инициализация приложения
    virtual bool OnInit() {
        // Создание и отображение главного окна
        MyFrame* frame = new MyFrame();
        frame->Show(true);
        return true;
    }
};

// Запуск приложения
wxIMPLEMENT_APP(MyApp);