#include "ubl-settings-diskquota.h"
using namespace std;

const string path_app = "/usr/bin/";
const string path_glade = "/usr/share/ubl-settings-diskquota/ui/ubl-settings-diskquota.glade";
const string app_name = "ubl-settings-diskquota";
const string path_locale = "/usr/share/locale/";
const string path_css = "/usr/share/ubl-settings-diskquota/css/ubl-settings-diskquota.css";
const string path_img_head_background = "/usr/share/ubl-settings-diskquota/images/logo-background.png";

int socket_ext_id_I = 0;
int socket_trd_id_I = 0;

string version_application = "1.0";

MainWindow::MainWindow(BaseObjectType* obj, Glib::RefPtr<Gtk::Builder> const& builder)
    : Gtk::ApplicationWindow(obj), builder{builder} {
        this->builder = builder;
        this->settings();  
}

MainWindow::MainWindow(Glib::RefPtr<Gtk::Builder> const& builder) {
    this->builder =  builder;
    this->settings();
}

void MainWindow::settings() {
    this->get_builder();
    this->lacalization();
    this->add_CSS();
    btnBoxAboutDialog->set_visible(false);
    this->entry_generalGroupsEnableCheck();
    this->entry_generalUsersEnableCheck();
    map_device = obj_device.get_parted();
    this->filling_device_combo_box_template(generalDeviceCombo, map_device);
    this->filling_device_combo_box_template(groupsDeviceCombo, map_device);
    this->filling_device_combo_box_template(usersDeviceCombo, map_device);
    this->filling_device_combo_box_template(quotegroupDeviceCombo, map_device);
    this->entry_combo_box_temp(generalDeviceCombo,lblFstypeGeneralSettings);
    this->entry_combo_box_temp(groupsDeviceCombo, lblFstypeGroups);
    this->entry_combo_box_temp(usersDeviceCombo, lblFstypeUsers);
    this->entry_combo_box_temp(quotegroupDeviceCombo, lblEditWndFsys);
    this->init_tree_view();
    this->init_spin_all();
    check_limit(quotegroupSizeSoftLimitCheck
        ,quotegroupSizeSoftLimitSpin
        ,quotegroupSizeSoftLimitCombo);
    check_limit(quotegroupSizeHardLimitCheck
        ,quotegroupSizeHardLimitSpin
        ,quotegroupSizeHardLimitCombo);
    check_limit(quotegroupFilesSoftLimitCheck
        ,quotegroupFilesSoftLimitSpin
        ,quotegroupFilesSoftLimitlabel);
    check_limit(quotegroupFilesHardLimitCheck
        ,quotegroupFilesHardLimitSpin
        ,quotegroupFilesHarLimitLabel);
    obj_quotas_sys.set_map_gui(map_gui_cfg);
    obj_quotas_ubconfig.set_map_gui(map_gui_cfg);
    if (geteuid() == 0) {
        this->load_system_cfg();
        this->load_global_cfg();
        this->event();
    }
    else {
        boxFuncs->set_sensitive(false);
        btnSave->set_sensitive(false);
        btnLoad->set_sensitive(false);
        imgInfo->set_from_icon_name("com.ublinux.ubl-settings-diskquota.warning", Gtk::ICON_SIZE_MENU);
        info_status_app("boxInfoMessError");
        lblWarning->set_text(_("The program must be run as root"));
    }
    Gtk::Widget *boxWidget;
    builder->get_widget("boxColor", boxWidget);
    HeadOverlay->add_overlay(*boxWidget);
    ubl_make_plugs(boxSave, boxButton, socket_ext_id_I, socket_trd_id_I);
}

void MainWindow::init_spin_all() {
    generalGroupsSizeWeeksSpi->set_range(0, 52);
    generalGroupsSizeWeeksSpi->set_increments(1.0, 1.0);
    generalGroupsSizeWeeksSpi->set_value(0);

    generalGroupsFileWeeksSpin->set_range(0, 52);
    generalGroupsFileWeeksSpin->set_increments(1.0, 1.0);
    generalGroupsFileWeeksSpin->set_value(0);

    generalUsersSizWeeksSpin->set_range(0, 52);
    generalUsersSizWeeksSpin->set_increments(1.0, 1.0);
    generalUsersSizWeeksSpin->set_value(0);

    generalUsersFileWeeksSpin->set_range(0, 52);
    generalUsersFileWeeksSpin->set_increments(1.0, 1.0);
    generalUsersFileWeeksSpin->set_value(0);

    generalGroupsSizeDaySpin->set_range(0, 31);
    generalGroupsSizeDaySpin->set_increments(1.0, 1.0);
    generalGroupsSizeDaySpin->set_value(0);

    generalGroupsFilesDaySpin->set_range(0, 31);
    generalGroupsFilesDaySpin->set_increments(1.0, 1.0);
    generalGroupsFilesDaySpin->set_value(0);

    generalUsersSizeDaySpin->set_range(0, 31);
    generalUsersSizeDaySpin->set_increments(1.0, 1.0);
    generalUsersSizeDaySpin->set_value(0);

    generalUsersFilesDaySpin->set_range(0, 31);
    generalUsersFilesDaySpin->set_increments(1.0, 1.0);
    generalUsersFilesDaySpin->set_value(0);

    generalGroupsSizeHourSpin->set_range(0, 23);
    generalGroupsSizeHourSpin->set_increments(1.0, 1.0);
    generalGroupsSizeHourSpin->set_value(0);
    
    generalGroupsFilesHourSpin->set_range(0, 23);
    generalGroupsFilesHourSpin->set_increments(1.0, 1.0);
    generalGroupsFilesHourSpin->set_value(0);

    generalUsersSizeHourSpin->set_range(0, 23);
    generalUsersSizeHourSpin->set_increments(1.0, 1.0);
    generalUsersSizeHourSpin->set_value(0);
    
    generalUsersFilesHoursSpin->set_range(0, 23);
    generalUsersFilesHoursSpin->set_increments(1.0, 1.0);
    generalUsersFilesHoursSpin->set_value(0); 
    
    generalGroupsSizeMinuteSpin->set_range(0, 59);
    generalGroupsSizeMinuteSpin->set_increments(1.0, 1.0);
    generalGroupsSizeMinuteSpin->set_value(0);  
    
    generalGroupsFilesMinuteSpin->set_range(0, 59);
    generalGroupsFilesMinuteSpin->set_increments(1.0, 1.0);
    generalGroupsFilesMinuteSpin->set_value(0); 
    
    generalUsersSizeMinuteSpin->set_range(0, 59);
    generalUsersSizeMinuteSpin->set_increments(1.0, 1.0);
    generalUsersSizeMinuteSpin->set_value(0);  
    
    generalUsersFilesMinutesSpin->set_range(0, 59);
    generalUsersFilesMinutesSpin->set_increments(1.0, 1.0);
    generalUsersFilesMinutesSpin->set_value(0);    
}

void MainWindow::init_tree_view() {
    this->view_add_columns(*usersQuotasTree);
    this->view_add_columns(*groupsQuotasTree);
}

void MainWindow::lacalization() {
    time_t now = time(0);
    tm *ltm = localtime(&now);
    unsigned int year = 1900 + ltm->tm_year;
    string str_authors = string(_("Copyright © UBSoft LLC, 2022 - ")) + to_string(year); 
    aboutWindows->set_copyright(str_authors);
    aboutWindows->set_comments(_("Setting user quotas"));
    aboutWindows->set_website(_("https://wiki.ublinux.com"));
    aboutWindows->set_version(gettext(version_application.c_str()));
    aboutWindows->set_website_label(_("Project Home Page"));
    generalTabLabel->set_text(_("General settings"));
    GroupsTabLabel->set_text(_("Groups"));
    headerAboutTopic->set_label(_(app_name.c_str()));
    headerTopic->set_label(_("ubl-settings-diskquota"));
    UsersTabLabel->set_text(_("Users"));
    generalDeviceLabel->set_text(_("Device:"));
    generalFileSystemLabel->set_text(_("File system:"));
    generalGroupsFrameLabel->set_text(_("Quotas for groups"));
    generalGroupsEnableCheck->set_label(_("Enable"));
    generalUsersEnableCheck->set_label(_("Enable"));
    generalUsersFrameLabel->set_label(_("Quotas for users"));
    generalGroupsSizeLabel->set_text(_("Excess size delay period"));
    generalGroupsFilesLabel->set_text(_("Excess files delay period"));
    generalUsersSizeLabel->set_text(_("Excess size delay period"));
    generalUsersFilesLabel->set_text(_("Excess files delay period"));
    generalGroupsSizeWeeksLabel->set_text(_("weeks"));
    generalGroupsFilesWeeksLabel->set_text(_("weeks"));
    generalUsersSizeWeeksLabel->set_text(_("weeks"));
    generalUsersFilesWeeksLabel->set_text(_("weeks"));
    generalGroupsSizeDaysLabel->set_text(_("days"));
    generalGroupsFilesDaysLabel->set_text(_("days"));
    generalUsersSizeDaysLabel->set_text(_("days"));
    generalUsersFilesDaysLabel->set_text(_("days"));
    generalGroupsSizeHoursLabel->set_text(_("hours"));
    generalGroupsFilesHoursLabel->set_text(_("hours"));
    generalUsersSizeHoursLabel->set_text(_("hours"));
    generalUsersFilesHoursLabel->set_text(_("hours"));
    generalGroupsSizeMinutesLabel->set_text(_("minutes"));
    generalGroupsFilesMinutesLabel->set_text(_("minutes"));
    generalUsersSizeMinutesLabel->set_text(_("minutes"));
    generalUsersFilesMinutesLabel->set_text(_("minutes"));
    groupsFileSystemLabel->set_text(_("File system:"));
    usersFileSystemLabel->set_text(_("File system:"));
    usersFiltersButton->set_label(_("Filters"));
    groupsFiltersButton->set_label(_("Filters"));
    lblLoad->set_text(_("Load"));
    lblSave->set_text(_("Save"));
    groupsDeviceLabel->set_label(_("Device:")); 
    usersDeviceLabel->set_label(_("Device:")); 
    headLabel->set_label(_("Configuration of disk quotas parameters for system groups and users"));   
    filtersNameFilterCheckbox->set_label(_("Name"));
    filtersQuotasFilterCheckbox->set_label(_("Quotas"));
    filtersSizeFilterCheckbox->set_label(_("Size"));
    filtersSoftSizeFilterCheckbox->set_label(_("Soft limit (size)"));
    filtersHardSizeFilterCheckbox->set_label(_("Hard limit (size)"));
    filtersHardSizeDelayFilterCheckbox->set_label(_("Deferring a hard limit (size)"));
    filtersHardSizeActivationFilterCheckbox->set_label(_("Hard limit activation time (size)"));
    filtersFilesFilterCheckbox->set_label(_("Files"));
    filtersSoftFilesFilterCheckbox->set_label(_("Soft Restriction (files)"));
    filtersHardFilesFilterCheckbox->set_label(_("Severe limitation (files)"));
    filtersHardFilesDelayFilterCheckbox->set_label(_("Deferring a hard limit (files)"));
    filtersHardFilesActivationFilterCheckbox->set_label(_("Hard limit (file) activation time")); 
    quotegroupDeviceLabel->set_text(_("Device:"));
    quotegroupDiskQuotasLabel->set_text(_("Disk quotas for this device:"));
    quotegroupGroupQuotasLabel->set_text(_("Group quotas for this device:"));
    quotegroupSizeFrameLabel->set_text(_("Size"));
    quotegroupFilesFrameLabel->set_text(_("Files"));
    quotegroupSizeCurrentlyLabel->set_text(_("Currently using:"));
    quotegroupSizeSoftLimitLabel->set_text(_("Soft limit"));
    quoteSizeHardLimitLabel->set_text(_("Hard limit"));
    quoteFilesHardLimitLabel->set_text(_("Hard limit"));
    quotegroupFilesSoftLimitLabel->set_text(_("Soft limit"));
    quotegroupFilesCurrentlyLabel->set_text(_("Currently using:"));
    quoteuserDiskQuotasLabel->set_text(_("Disk quotas for this device:"));
    quoteuserDeviceLabel->set_text(_("Device:"));
    quoteuserGroupQuotasLabel->set_text(_("User quotas for this device: "));
    quoteuserSizeFrameLabel->set_text(_("Size"));
    quoteuserSizeCurrentlyLabel->set_text(_("Currently using:"));
    quoteuserSizeSoftLimitLabel->set_text(_("Soft limit"));
    quoteuserSizeHardLimitLabel1->set_text(_("Hard limit"));
    quoteuserFileSystemLabel->set_text(_("File system:"));
    quoteuserFilesFrameLabel->set_text(_("Files"));
    quoteuserFilesCurrentlyLabel->set_text(_("Currently using: "));
    quoteuserFilesSoftLimitLabel->set_text(_("Soft limit"));
    quoteFilesHardLimitLabel1->set_text(_("Hard limit"));
    quoteuserFilesHarLimitLabel->set_text(_("files"));
    quoteuserFilesSoftLimitlabel->set_text(_("files"));
    quotegroupFileSystemLabel->set_text(_("File system:"));
    btnLoadGlob->set_label(_("Load from global configuration"));
    btnLoadLocal->set_label(_("Load from local configuration"));
    btnAbout->set_label(_("About"));
    btnSynopsis->set_label(_("Help"));
    btnSaveLocalGlob->set_label(_("Save to global and local configuration"));
    btnSaveGlob->set_label(_("Save to global configuration"));
    btnSaveLocal->set_label(_("Save to local configuration"));
    lblHeadFiltersWindow->set_label(_("Filters"));
}

void MainWindow::view_add_columns(Gtk::TreeView &treeView) {
    treeView.append_column(_("Name"), m_columns.name);
    treeView.append_column_editable(_("Quotas"), m_columns.quotas);
    treeView.append_column(_("Size"), m_columns.size);
    treeView.append_column(_("Soft limit\n(size)"), m_columns.soft_limit_size);
    treeView.append_column(_("Severe\nlimitation\n(size)"), m_columns.hard_limit_size);
    treeView.append_column(_("Deferring\na hard\nlimit\n(size)"), m_columns.hard_limit_size_delay);
    treeView.append_column(_("Hard limit\n"
                            "activation\n"
                            "time (size)"), m_columns.hard_limit_activ_time);
    treeView.append_column(_("Files"), m_columns.files);
    treeView.append_column(_("Soft\nRestriction\n(files)"), m_columns.soft_limit_files);
    treeView.append_column(_("Severe\nlimitation\n(files)"), m_columns.hard_limit_files);
    treeView.append_column(_("Deferring\na hard\nlimit\n(files)"), m_columns.hard_limit_delay);
    treeView.append_column(_("Hard limit\nactivation\ntime (files)"), m_columns.hard_limit_files_activ_time);
}

void MainWindow::filling_device_combo_box_template(Gtk::ComboBoxText *combo_box, map_str_str &map_device) {
    if (map_device.size() != 0) {
        for (const auto &device : map_device) {
            combo_box->append(device.first.c_str());
        }
        combo_box->set_active(0);
    }
}

void MainWindow::entry_combo_box_temp(Gtk::ComboBoxText *combo_box, Gtk::Label *label) {
    string text = combo_box->get_active_text();
    if (map_device.find(text) != map_device.end()){
        label->set_text(map_device[text]);
    }
}

void MainWindow::entry_generalGroupsEnableCheck() {
    boxGeneralGroupsEnableCheck->set_sensitive(generalGroupsEnableCheck->get_active());
}

void MainWindow::entry_generalUsersEnableCheck() {
    boxGeneralUsersEnableCheck->set_sensitive(generalUsersEnableCheck->get_active());
}

void MainWindow::add_CSS() {
    Glib::RefPtr<Gtk::CssProvider> cssProvider = Gtk::CssProvider::create();
    cssProvider->load_from_path(path_css);   
    Glib::RefPtr<Gtk::StyleContext> styleContext = Gtk::StyleContext::create();
    Glib::RefPtr<Gdk::Screen> screen = Gdk::Screen::get_default();//get default screen
    styleContext->add_provider_for_screen(screen, cssProvider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);//add provider for screen in all application
    HeadBackgroundImage->set(path_img_head_background);
    Glib::RefPtr<Gtk::StyleContext> headLabel_css = headLabel->get_style_context();
    Glib::RefPtr<Gtk::StyleContext> boxButton_css = boxButton->get_style_context();
    Glib::RefPtr<Gtk::StyleContext> boxSave_css = boxSave->get_style_context();
    Glib::RefPtr<Gtk::StyleContext> headerBar_css = headerBar->get_style_context();
    if (socket_trd_id_I == 0 && socket_ext_id_I == 0){
        boxButton_css->add_class("bkim_no_plug");
        boxSave_css->add_class("bkim_no_plug");
    }
    headLabel_css->add_class("textHead");
}

/*
void init_treeview_user() {

}

void MainWindow::view_add_data(Gtk::TreeModel::Row &row, Glib::RefPtr<Gtk::ListStore> list_store_m , std::array<std::vector<std::string>, 5> &arr_view , size_t index) {
    row = *(list_store_m->append());
    bool flag_chb = false;
    string name = arr_view[0][index];
    row[m_columns.check_button] = flag_chb;
    row[m_columns.name] = _(name.c_str());
    row[m_columns.description] = _(arr_view[1][index].c_str());
}
*/

void MainWindow::get_builder() {
    builder->set_translation_domain(path_app);
    builder->get_widget("headerTopic", headerTopic);
    builder->get_widget("boxButton", boxButton);
    builder->get_widget("boxSave", boxSave);
    builder->get_widget("aboutWindows", aboutWindows);
    builder->get_widget("HeadOverlay", HeadOverlay);
    builder->get_widget("headerBar", headerBar);
    builder->get_widget("boxFuncs", boxFuncs);
    builder->get_widget("btnLoad", btnLoad);
    builder->get_widget("btnSave", btnSave);
    builder->get_widget("btnBoxAboutDialog", btnBoxAboutDialog);
    builder->get_widget("HeadBackgroundImage", HeadBackgroundImage);
    builder->get_widget("imgInfo", imgInfo);
    builder->get_widget("lblWarning", lblWarning);
    builder->get_widget("boxInfoError", boxInfoError);
    builder->get_widget("imgInfo", imgInfo);
    builder->get_widget("generalTabLabel", generalTabLabel);
    builder->get_widget("GroupsTabLabel", GroupsTabLabel);
    builder->get_widget("UsersTabLabel", UsersTabLabel);
    builder->get_widget("generalDeviceLabel", generalDeviceLabel);
    builder->get_widget("generalGroupsFrameLabel", generalGroupsFrameLabel);
    builder->get_widget("generalGroupsSizeLabel", generalGroupsSizeLabel);
    builder->get_widget("generalGroupsFilesLabel", generalGroupsFilesLabel);
    builder->get_widget("generalUsersFrameLabel", generalUsersFrameLabel);
    builder->get_widget("generalUsersSizeLabel", generalUsersSizeLabel);
    builder->get_widget("generalUsersFilesLabel", generalUsersFilesLabel);
    builder->get_widget("generalGroupsSizeWeeksLabel", generalGroupsSizeWeeksLabel);
    builder->get_widget("generalGroupsFilesWeeksLabel", generalGroupsFilesWeeksLabel);
    builder->get_widget("generalUsersSizeWeeksLabel", generalUsersSizeWeeksLabel);
    builder->get_widget("generalUsersFilesWeeksLabel", generalUsersFilesWeeksLabel);
    builder->get_widget("generalGroupsSizeDaysLabel", generalGroupsSizeDaysLabel);
    builder->get_widget("generalGroupsFilesDaysLabel", generalGroupsFilesDaysLabel);
    builder->get_widget("generalUsersSizeDaysLabel", generalUsersSizeDaysLabel);
    builder->get_widget("generalUsersFilesDaysLabel", generalUsersFilesDaysLabel);
    builder->get_widget("generalGroupsSizeHoursLabel", generalGroupsSizeHoursLabel);
    builder->get_widget("generalGroupsFilesHoursLabel", generalGroupsFilesHoursLabel);
    builder->get_widget("generalUsersSizeHoursLabel", generalUsersSizeHoursLabel);
    builder->get_widget("generalUsersFilesHoursLabel", generalUsersFilesHoursLabel);
    builder->get_widget("generalGroupsSizeMinutesLabel", generalGroupsSizeMinutesLabel);
    builder->get_widget("generalGroupsFilesMinutesLabel", generalGroupsFilesMinutesLabel);
    builder->get_widget("generalUsersSizeMinutesLabel", generalUsersSizeMinutesLabel);
    builder->get_widget("generalUsersFilesMinutesLabel", generalUsersFilesMinutesLabel);
    builder->get_widget("generalFileSystemLabel", generalFileSystemLabel);
    builder->get_widget("generalGroupsEnableCheck", generalGroupsEnableCheck);
    builder->get_widget("generalUsersEnableCheck", generalUsersEnableCheck);
    builder->get_widget("lblLoad", lblLoad);
    builder->get_widget("lblSave", lblSave);
    builder->get_widget("btnSettings", btnSettings);
    builder->get_widget("groupsFileSystemLabel", groupsFileSystemLabel);
    builder->get_widget("groupsFiltersButton", groupsFiltersButton);
    builder->get_widget("btnSettings", btnSettings);
    builder->get_widget("usersFiltersButton", usersFiltersButton);
    builder->get_widget("usersFileSystemLabel", usersFileSystemLabel);
    builder->get_widget("groupsDeviceLabel", groupsDeviceLabel);
    builder->get_widget("usersDeviceLabel", usersDeviceLabel);
    builder->get_widget("headLabel", headLabel);
    builder->get_widget("FiltersWindow", FiltersWindow);
    builder->get_widget("filtersNameFilterCheckbox", filtersNameFilterCheckbox);
    builder->get_widget("filtersQuotasFilterCheckbox", filtersQuotasFilterCheckbox);
    builder->get_widget("filtersSizeFilterCheckbox", filtersSizeFilterCheckbox);
    builder->get_widget("filtersSoftSizeFilterCheckbox", filtersSoftSizeFilterCheckbox);
    builder->get_widget("filtersHardSizeFilterCheckbox", filtersHardSizeFilterCheckbox);
    builder->get_widget("filtersHardSizeDelayFilterCheckbox", filtersHardSizeDelayFilterCheckbox);
    builder->get_widget("filtersHardSizeActivationFilterCheckbox", filtersHardSizeActivationFilterCheckbox);
    builder->get_widget("filtersFilesFilterCheckbox", filtersFilesFilterCheckbox);
    builder->get_widget("filtersSoftFilesFilterCheckbox", filtersSoftFilesFilterCheckbox);
    builder->get_widget("filtersHardFilesFilterCheckbox", filtersHardFilesFilterCheckbox);
    builder->get_widget("filtersHardFilesDelayFilterCheckbox", filtersHardFilesDelayFilterCheckbox);
    builder->get_widget("filtersHardFilesActivationFilterCheckbox", filtersHardFilesActivationFilterCheckbox);
    builder->get_widget("filtersHardFilesActivationFilterCheckbox", filtersHardFilesActivationFilterCheckbox);
    builder->get_widget("btnLoadGlob", btnLoadGlob);
    builder->get_widget("btnLoadLocal", btnLoadLocal);
    builder->get_widget("btnSynopsis", btnSynopsis);
    builder->get_widget("btnAbout", btnAbout);
    builder->get_widget("btnSaveLocalGlob", btnSaveLocalGlob);
    builder->get_widget("btnSaveGlob", btnSaveGlob);
    builder->get_widget("btnSaveLocal", btnSaveLocal);
    builder->get_widget("GroupsTabLabel", GroupsTabLabel);
    builder->get_widget("groupsQuotasTree", groupsQuotasTree);
    builder->get_widget("usersQuotasTree", usersQuotasTree);
    builder->get_widget("quotegroupDeviceLabel", quotegroupDeviceLabel);
    builder->get_widget("quotegroupFileSystemLabel", quotegroupFileSystemLabel);
    builder->get_widget("quotegroupDiskQuotasLabel", quotegroupDiskQuotasLabel);
    builder->get_widget("quotegroupGroupQuotasLabel", quotegroupGroupQuotasLabel);
    builder->get_widget("quotegroupSizeFrameLabel", quotegroupSizeFrameLabel);
    builder->get_widget("quotegroupFilesFrameLabel", quotegroupFilesFrameLabel);
    builder->get_widget("quotegroupSizeCurrentlyLabel", quotegroupSizeCurrentlyLabel);
    builder->get_widget("quotegroupFilesCurrentlyLabel", quotegroupFilesCurrentlyLabel);
    builder->get_widget("quotegroupSizeSoftLimitLabel", quotegroupSizeSoftLimitLabel);
    builder->get_widget("quoteSizeHardLimitLabel", quoteSizeHardLimitLabel);
    builder->get_widget("quotegroupFilesSoftLimitLabel", quotegroupFilesSoftLimitLabel);
    builder->get_widget("quoteFilesHardLimitLabel", quoteFilesHardLimitLabel);
    builder->get_widget("quotegroupFilesHarLimitLabel", quotegroupFilesHarLimitLabel);
    builder->get_widget("quoteuserDeviceLabel", quoteuserDeviceLabel);
    builder->get_widget("quoteuserFileSystemLabel", quoteuserFileSystemLabel);
    builder->get_widget("quoteuserDiskQuotasLabel", quoteuserDiskQuotasLabel);
    builder->get_widget("quoteuserGroupQuotasLabel", quoteuserGroupQuotasLabel);
    builder->get_widget("quoteuserSizeFrameLabel", quoteuserSizeFrameLabel);
    builder->get_widget("quoteuserSizeCurrentlyLabel", quoteuserSizeCurrentlyLabel);
    builder->get_widget("quoteuserSizeSoftLimitLabel", quoteuserSizeSoftLimitLabel);
    builder->get_widget("quoteuserSizeHardLimitLabel1", quoteuserSizeHardLimitLabel1);
    builder->get_widget("quoteuserFilesFrameLabel", quoteuserFilesFrameLabel);
    builder->get_widget("quoteuserFilesCurrentlyLabel", quoteuserFilesCurrentlyLabel);
    builder->get_widget("quoteuserFilesSoftLimitLabel", quoteuserFilesSoftLimitLabel);
    builder->get_widget("quoteFilesHardLimitLabel1", quoteFilesHardLimitLabel1);
    builder->get_widget("quoteuserFilesHarLimitLabel", quoteuserFilesHarLimitLabel);
    builder->get_widget("quoteuserFilesSoftLimitlabel", quoteuserFilesSoftLimitlabel);
    builder->get_widget("QuotasEditWindow", QuotasEditWindow);
    builder->get_widget("QuotasUserEditWindow", QuotasUserEditWindow);
    builder->get_widget("headerAboutTopic", headerAboutTopic);
    builder->get_widget("lblHeadQuotasUserEditWindow", lblHeadQuotasUserEditWindow);
    builder->get_widget("lblHeadQuotasEditWindow", lblHeadQuotasEditWindow);
    builder->get_widget("lblHeadFiltersWindow", lblHeadFiltersWindow);
    builder->get_widget("boxGeneralGroupsEnableCheck", boxGeneralGroupsEnableCheck);
    builder->get_widget("generalGroupsEnableCheck", generalGroupsEnableCheck);
    builder->get_widget("boxGeneralUsersEnableCheck", boxGeneralUsersEnableCheck);
    builder->get_widget("usersDeviceCombo", usersDeviceCombo);
    builder->get_widget("GroupsTabLabel", GroupsTabLabel);
    builder->get_widget("generalTabLabel", generalTabLabel);
    builder->get_widget("generalDeviceCombo", generalDeviceCombo);
    builder->get_widget("groupsDeviceCombo", groupsDeviceCombo);
    builder->get_widget("lblFstypeUsers", lblFstypeUsers);
    builder->get_widget("lblFstypeGroups", lblFstypeGroups);
    builder->get_widget("lblFstypeGeneralSettings", lblFstypeGeneralSettings);
    builder->get_widget("generalGroupsSizeWeeksSpi", generalGroupsSizeWeeksSpi);
    builder->get_widget("generalGroupsFileWeeksSpin", generalGroupsFileWeeksSpin);
    builder->get_widget("generalGroupsSizeDaySpin", generalGroupsSizeDaySpin);
    builder->get_widget("generalGroupsFilesDaySpin", generalGroupsFilesDaySpin);
    builder->get_widget("generalGroupsSizeHourSpin", generalGroupsSizeHourSpin);
    builder->get_widget("generalGroupsFilesHourSpin", generalGroupsFilesHourSpin);
    builder->get_widget("generalGroupsSizeMinuteSpin", generalGroupsSizeMinuteSpin);
    builder->get_widget("generalGroupsFilesMinuteSpin", generalGroupsFilesMinuteSpin);
    builder->get_widget("generalUsersSizWeeksSpin", generalUsersSizWeeksSpin);
    builder->get_widget("generalUsersFileWeeksSpin", generalUsersFileWeeksSpin);
    builder->get_widget("generalUsersSizeDaySpin", generalUsersSizeDaySpin);
    builder->get_widget("generalUsersFilesDaySpin", generalUsersFilesDaySpin);
    builder->get_widget("generalUsersSizeHourSpin", generalUsersSizeHourSpin);
    builder->get_widget("generalUsersFilesHoursSpin", generalUsersFilesHoursSpin);
    builder->get_widget("generalUsersSizeMinuteSpin", generalUsersSizeMinuteSpin);
    builder->get_widget("generalUsersFilesMinutesSpin", generalUsersFilesMinutesSpin);
    builder->get_widget("lblEditWndFsys", lblEditWndFsys);
    builder->get_widget("quotegroupSizeSoftLimitCheck", quotegroupSizeSoftLimitCheck);
    builder->get_widget("quotegroupSizeHardLimitCheck", quotegroupSizeHardLimitCheck);
    builder->get_widget("quotegroupFilesSoftLimitCheck", quotegroupFilesSoftLimitCheck);
    builder->get_widget("quotegroupFilesHardLimitCheck", quotegroupFilesHardLimitCheck);
    builder->get_widget("quotegroupSizeSoftLimitSpin", quotegroupSizeSoftLimitSpin);
    builder->get_widget("quotegroupSizeSoftLimitCombo", quotegroupSizeSoftLimitCombo);
    builder->get_widget("quotegroupSizeHardLimitSpin", quotegroupSizeHardLimitSpin);
    builder->get_widget("quotegroupSizeHardLimitCombo", quotegroupSizeHardLimitCombo);
    builder->get_widget("quotegroupFilesSoftLimitSpin", quotegroupFilesSoftLimitSpin);
    builder->get_widget("quotegroupFilesSoftLimitlabel", quotegroupFilesSoftLimitlabel);
    builder->get_widget("quotegroupFilesHardLimitSpin", quotegroupFilesHardLimitSpin);
    builder->get_widget("quotegroupSaveButton", quotegroupSaveButton);
    builder->get_widget("quotegroupCancelButton", quotegroupCancelButton);
    builder->get_widget("quotegroupDeviceCombo", quotegroupDeviceCombo);
    builder->get_widget("btnDeleteUserQuota", btnDeleteUserQuota);
    builder->get_widget("btnDeleteGroupQuota", btnDeleteGroupQuota);
}

void MainWindow::event() {
    quotegroupSaveButton->signal_clicked().connect([&]() {});
    btnDeleteGroupQuota->signal_clicked().connect([&]() {});
    btnDeleteUserQuota->signal_clicked().connect([&]() {});
    btnLoadGlob->signal_activate().connect([&]() {this->load_global_cfg();});
    btnLoadLocal->signal_activate().connect([&]() {this->load_system_cfg();});
    btnSynopsis->signal_activate().connect([&]() {this->synopsis_show();});
    btnAbout->signal_activate().connect([&]() {aboutWindows->show();});
    btnSaveLocalGlob->signal_activate().connect([&]() {this->wrapper_save_all_cfg();});
    btnSaveGlob->signal_activate().connect([&]() {this->wrapper_save_global_cfg();});
    btnSaveLocal->signal_activate().connect([&]() {this->wrapper_save_system_cfg();});
    groupsFiltersButton->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::groupsFilters_show));
    usersFiltersButton->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::groupsFilters_show));
    generalGroupsEnableCheck->signal_toggled().connect(sigc::mem_fun(*this, &MainWindow::entry_generalGroupsEnableCheck));
    generalUsersEnableCheck->signal_toggled().connect(sigc::mem_fun(*this, &MainWindow::entry_generalUsersEnableCheck));
    generalDeviceCombo->signal_changed().connect([&]() {entry_combo_box_temp(generalDeviceCombo,lblFstypeGeneralSettings);});
    groupsDeviceCombo->signal_changed().connect([&]() {entry_combo_box_temp(groupsDeviceCombo, lblFstypeGroups);});
    usersDeviceCombo->signal_changed().connect([&]() {entry_combo_box_temp(usersDeviceCombo, lblFstypeUsers);});
    quotegroupDeviceCombo->signal_changed().connect([&]() {entry_combo_box_temp(quotegroupDeviceCombo, lblEditWndFsys);});
    quotegroupSizeSoftLimitCheck->signal_toggled().connect([&]() {
        check_limit(quotegroupSizeSoftLimitCheck
        ,quotegroupSizeSoftLimitSpin
        ,quotegroupSizeSoftLimitCombo);
    });
    quotegroupSizeHardLimitCheck->signal_toggled().connect([&]() {
        check_limit(quotegroupSizeHardLimitCheck
        ,quotegroupSizeHardLimitSpin
        ,quotegroupSizeHardLimitCombo);
    });
    quotegroupFilesSoftLimitCheck->signal_toggled().connect([&]() {
        check_limit(quotegroupFilesSoftLimitCheck
        ,quotegroupFilesSoftLimitSpin
        ,quotegroupFilesSoftLimitlabel);
    });
    quotegroupFilesHardLimitCheck->signal_toggled().connect([&]() {
        check_limit(quotegroupFilesHardLimitCheck
        ,quotegroupFilesHardLimitSpin
        ,quotegroupFilesHarLimitLabel);
    });
    quotegroupCancelButton->signal_clicked().connect([&]() {QuotasEditWindow->hide();});
    // QuotasEditWindow->show();
}

void MainWindow::wrapper_settings_quotas_temp(string save_user_or_group) {
    struct partition_cmd _struct_partition_cmd = this->wrapper_settings_quotas();
    string device = _struct_partition_cmd.device;
    string cmd = _struct_partition_cmd.cmd;
    string type_quotas = save_user_or_group;
    string user = "";
    struct struct_quotas _struct_quota;
    _struct_quota.device = device;
    _struct_quota.cmd = cmd;
    _struct_quota.type_quotas = type_quotas;
    _struct_quota.name = user;
    obj_quotas_ubconfig.format_cmd_quotas(_struct_quota);
    
}

void MainWindow::save_quotegroupSaveButton() {
    if (sys_or_ubconfig == "ubconfig") {
        if (save_user_or_group == "usrquota") {
            this->wrapper_settings_quotas_temp(save_user_or_group);
        }
        else {
            this->wrapper_settings_quotas_temp(save_user_or_group);
        }
    }
    else {
        if (save_user_or_group == "usrquota") {
            
        }
        else {

        }
    }
}

struct partition_cmd MainWindow::wrapper_settings_quotas() {
    string str_parted = quotegroupDeviceCombo->get_active_text();
    string value = "";
    if (quotegroupSizeSoftLimitCheck->get_active()) {
        value = Utils::format_str_size(quotegroupSizeSoftLimitSpin->get_value(), quotegroupSizeSoftLimitCombo->get_active_row_number());
        value += ":";
    }
    else {
        value += "0:";
    }
    if (quotegroupSizeHardLimitCheck->get_active()) {
        value += Utils::format_str_size(quotegroupSizeHardLimitSpin->get_value(), quotegroupSizeHardLimitCombo->get_active_row_number());
        value += ":";
    }
    else {
        value += "0:";
    }
    if (quotegroupFilesSoftLimitCheck->get_active()) {
        value += to_string(quotegroupFilesSoftLimitSpin->get_value());
        value += ":";
    }
    else {
        value += "0:";
    }
    if (quotegroupFilesHardLimitCheck->get_active()) {
        value += to_string(quotegroupFilesHardLimitSpin->get_value());
        value += ":";
    }
    else {
        value += "0:";
    }
    struct partition_cmd _struct_partition_cmd;
    _struct_partition_cmd.device = str_parted;
    _struct_partition_cmd.cmd = value;
    return _struct_partition_cmd;
}

void MainWindow::groupsFilters_show() {
    FiltersWindow->show_all();
}

void MainWindow::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box) {
    spin->set_sensitive(check_button->get_active());
    combo_box->set_sensitive(check_button->get_active());
}
void MainWindow::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box) {
    spin->set_sensitive(check_button->get_active());
    combo_box->set_sensitive(check_button->get_active());
}

void MainWindow::info_status_app(string stule) {
    Glib::RefPtr<Gtk::StyleContext> boxInfo = boxInfoError->get_style_context();
    boxInfo->remove_class("boxInfoMessOK");
    boxInfo->remove_class("boxInfoMessError");
    boxInfo->add_class(stule);
}

void MainWindow::init_dict(string flag_load) {
    std::map<std::string, std::string> map_gui_cfg_n;
    map_gui_cfg_n[""] = "";

    map_gui_cfg = map_gui_cfg_n;
    if (flag_load == "global") {
        map_global_cfg = map_gui_cfg_n;
    }
    else if (flag_load == "system") {
        map_system_cfg = map_gui_cfg_n;
    }
}

bool MainWindow::save_template(string section, string flag_save) {
    bool flag_no_save = true;
    obj_save.set_data_local(map_system_cfg);
    obj_save.set_data_global(map_global_cfg);
    obj_save.set_data_gui(map_gui_cfg);
    obj_save.set_vec_params(vec_param_names);
    obj_save.save(section, flag_save);
    vector<string> obj_vec_error = obj_save.get_error();
    flag_no_save = obj_save.get_state_save();
    return flag_no_save;
}

void MainWindow::wrapper_save_all_cfg() {
    this->set_data_cfg();
    bool _flag_save_global = this->save_template("boot", "global");;
    bool _flag_save_local = this->save_template("boot", "system");
    if (_flag_save_global && _flag_save_local) {
        this->info_warning_error(5);
    }
    else {
        info_warning_error(4);
    }
    map_global_cfg = map_gui_cfg;
    map_system_cfg = map_gui_cfg;
    
}

void MainWindow::load_global_cfg() {
    this->load_template(&map_global_cfg, "global");
    info_warning_error(1);
    map_gui_cfg = map_global_cfg;
}

void MainWindow::load_system_cfg() {
    this->load_template(&map_system_cfg, "system");
    info_warning_error(0);
    map_gui_cfg = map_system_cfg;
}

void MainWindow::set_data_cfg() {
    // TODO:
    // Написать функцию
}
void MainWindow::wrapper_save_global_cfg() {
    this->set_data_cfg();
    if (this->save_template("boot", "global")) {
        this->info_warning_error(5);
    }
    else {
        info_warning_error(3);
    }
    map_global_cfg = map_gui_cfg;
    
}

void MainWindow::synopsis_show() {
    string cmd = "xdg-open " + string(_("https://wiki.ublinux.com/ru/Программное_обеспечение/Программы_и_утилиты/Все/")) + app_name;
    if (geteuid() == 0) {
        string response_user = getlogin();
        cmd = "su -l " + response_user + " -c \" DISPLAY=$DISPLAY " + cmd + " \"";
    }
    obj_process_system.call(cmd, "&");
}

void MainWindow::wrapper_save_system_cfg() {
    this->set_data_cfg();
    if (this->save_template("boot", "system")) {
        this->info_warning_error(5);
    }
    else {
        info_warning_error(2);
    }
    map_system_cfg = map_gui_cfg;
}

void MainWindow::load_template(map_str_str* map_temp, string str_load) {
    this->init_dict(str_load);
    string sections;
    sections = "security";
    obj_load.set_sections(sections);
    *map_temp = obj_load.get_load_data(*map_temp, str_load);
}

void MainWindow::info_warning_error(int mess) {
    if (obj_load.get_count_error() > 0 || obj_save.get_count_error() > 0) {
        info_status_app("boxInfoMessError");
        imgInfo->set_from_icon_name("com.ublinux.ubl-settings-diskquota.warning", Gtk::ICON_SIZE_MENU);
        string mess_error = "";
        if (mess == 0) {
            mess_error = string(_("Local configuration reading error")) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 1) {
            mess_error = string(_("Global configuration read error")) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 2) {
            mess_error = string(_("Local configuration write error")) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 3) {
            mess_error = string(_("Global configuration write error")) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 4) {
            mess_error = string(_("Error saved local and global configuration")) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        str_cmd_error = "";
        obj_load.set_count_error(0);
        obj_save.set_count_error(0);
    }
    else {
        info_status_app("boxInfoMessOK");
        imgInfo->set_from_icon_name("com.ublinux.ubl-settings-diskquota.checked", Gtk::ICON_SIZE_MENU);
        if (mess == 0) {
            lblWarning->set_text(_("Local configuration downloaded successfully"));
        }
        else if (mess == 1) {
            lblWarning->set_text(_("Global configuration downloaded successfully"));
        }
        else if (mess == 2) {
            lblWarning->set_text(_("Local configuration successfully written"));
        }
        else if (mess == 3) {
            lblWarning->set_text(_("Global configuration successfully written"));
        }
        else if (mess == 4) {
            lblWarning->set_text(_("Successfully saved local and global configuration"));
        }
        else if (mess == 5) {
            lblWarning->set_text(_("Nothing to save!"));
        }
    }
}

void help() {
    string version = string(_("ubl-settings-diskquota version: ")) + version_application + "\n";
    cout << version.c_str();
    string help;
    help = "GTK settings quotas. for UBLinux\n\n"
           "Usage:  ubl-settings-diskquota [OPTIONS...]\n"
           "Options:\n"
           "  -h, --help	 Show this help\n"
           "  -V, --version	         Show package version\n";
    cout << gettext(help.c_str());

}