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

int socket_ext_id_I = 0;
int socket_trd_id_I = 0;
bool flag_save = false;
bool flag_save_local = false;
bool flag_save_global = false;
bool flag_load_global = false;
bool flag_lock_help = false;
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();
    this->flag_block_gui();
    btnBoxAboutDialog->set_visible(false);
    map_device = obj_device.get_parted();
    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->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);
    #ifdef WEBKIT_FOUND
        one =  WEBKIT_WEB_VIEW( webkit_web_view_new() );
        three = Glib::wrap(GTK_WIDGET(one));
        wndWeb->add(*three);
    #endif
    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(icon_warning, Gtk::ICON_SIZE_MENU);
        info_status_app(info_box_error_css);
        lblWarning->set_text(program_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);
    this->view_add_columns(*ProjectQuotasTree);
    this->init_tree_view_general();
}
void MainWindow::init_tree_view_general() {
    GeneralQuotasTree->append_column_editable(str_status, m_columnsGeneral.status);
    GeneralQuotasTree->append_column(str_quota, m_columnsGeneral.type_quotas);
    GeneralQuotasTree->append_column(str_device_project, m_columnsGeneral.device);
    GeneralQuotasTree->append_column(str_user, m_columnsGeneral.user);
    GeneralQuotasTree->append_column(str_group, m_columnsGeneral.group);
    GeneralQuotasTree->append_column(str_projects, m_columnsGeneral.projects);
    GeneralQuotasTree->append_column(str_tw_soft_limit, m_columnsGeneral.soft_limit_size);
    GeneralQuotasTree->append_column(str_tw_severe_limitation, m_columnsGeneral.hard_limit_size);
    GeneralQuotasTree->append_column(str_tw_soft_limit_files, m_columnsGeneral.soft_limit_files);
    GeneralQuotasTree->append_column(str_tw_severe_limitation_files, m_columnsGeneral.hard_limit_files);
    GeneralQuotasTree->append_column(str_tw_general_deferring_size, m_columnsGeneral.deferring_size);
    GeneralQuotasTree->append_column(str_tw_general_deferring_files, m_columnsGeneral.deferring_files);
}

void MainWindow::view_add_columns(Gtk::TreeView &treeView) {
    treeView.append_column(str_name, m_columns.name);
    treeView.append_column_editable(str_quotas, m_columns.quotas);
    treeView.append_column(str_size, m_columns.size);
    treeView.append_column(str_tw_soft_limit, m_columns.soft_limit_size);
    treeView.append_column(str_tw_severe_limitation, m_columns.hard_limit_size);
    treeView.append_column(str_tw_deferring_size, m_columns.deferring_size);
    treeView.append_column(str_files, m_columns.files);
    treeView.append_column(str_tw_soft_limit_files, m_columns.soft_limit_files);
    treeView.append_column(str_tw_severe_limitation_files, m_columns.hard_limit_delay);
    treeView.append_column(str_tw_deferring_files, m_columns.deferring_files);
}

void MainWindow::lacalization() {
    time_t now = time(0);
    tm *ltm = localtime(&now);
    unsigned int year = 1900 + ltm->tm_year;
    string str_authors = string(copyright) + to_string(year); 
    aboutWindows->set_copyright(str_authors);
    aboutWindows->set_comments(str_setting_user);
    aboutWindows->set_website(website);
    aboutWindows->set_version(_(version_application.c_str()));
    aboutWindows->set_website_label(project_Home_page);
    generalTabLabel->set_text(str_general_settings);
    GroupsTabLabel->set_text(str_groups);
    headerAboutTopic->set_label(_(app_name));
    headerTopic->set_label(name_app);
    UsersTabLabel->set_text(str_users);
    generalGroupsSizeLabel->set_text(str_excess_size_delay);
    generalGroupsFilesLabel->set_text(str_excess_files_delay);
    generalUsersSizeLabel->set_text(str_excess_size_delay);
    generalUsersFilesLabel->set_text(str_excess_files_delay);
    generalGroupsSizeWeeksLabel->set_text(str_weeks);
    generalGroupsFilesWeeksLabel->set_text(str_weeks);
    generalUsersSizeWeeksLabel->set_text(str_weeks);
    generalUsersFilesWeeksLabel->set_text(str_weeks);
    generalGroupsSizeDaysLabel->set_text(str_days);
    generalGroupsFilesDaysLabel->set_text(str_days);
    generalUsersSizeDaysLabel->set_text(str_days);
    generalUsersFilesDaysLabel->set_text(str_days);
    generalGroupsSizeHoursLabel->set_text(str_hours);
    generalGroupsFilesHoursLabel->set_text(str_hours);
    generalUsersSizeHoursLabel->set_text(str_hours);
    generalUsersFilesHoursLabel->set_text(str_hours);
    generalGroupsSizeMinutesLabel->set_text(str_minutes);
    generalGroupsFilesMinutesLabel->set_text(str_minutes);
    generalUsersSizeMinutesLabel->set_text(str_minutes);
    generalUsersFilesMinutesLabel->set_text(str_minutes);
    lblLoad->set_text(str_load_local);
    lblSave->set_text(str_save_local);
    groupsDeviceLabel->set_label(str_device); 
    usersDeviceLabel->set_label(str_device); 
    headLabel->set_label(str_lb_head);   
    filtersNameFilterCheckbox->set_label(str_name);
    filtersQuotasFilterCheckbox->set_label(str_quotas);
    filtersSizeFilterCheckbox->set_label(str_size);
    filtersSoftSizeFilterCheckbox->set_label(str_soft_limit_size);
    filtersHardSizeFilterCheckbox->set_label(str_hard_limit_size);
    filtersHardSizeDelayFilterCheckbox->set_label(str_deferring_hard_limit_size);
    filtersHardSizeActivationFilterCheckbox->set_label(str_hard_activation_size);
    filtersFilesFilterCheckbox->set_label(str_files);
    filtersSoftFilesFilterCheckbox->set_label(str_soft_restriction_files);
    filtersHardFilesFilterCheckbox->set_label(str_severe_limitation_files);
    filtersHardFilesDelayFilterCheckbox->set_label(str_deferring_limit_files);
    filtersHardFilesActivationFilterCheckbox->set_label(str_hard_limit_time); 
    quotegroupDeviceLabel->set_text(str_device);
    quotegroupDiskQuotasLabel->set_text(str_disk_quotas_device);
    quotegroupGroupQuotasLabel->set_text(str_group_quotas_device);
    quotegroupSizeFrameLabel->set_text(str_size);
    quotegroupFilesFrameLabel->set_text(str_files);
    quotegroupSizeCurrentlyLabel->set_text(str_currently_using);
    quotegroupSizeSoftLimitLabel->set_text(str_soft_limit);
    quoteSizeHardLimitLabel->set_text(str_hard_limit);
    quoteFilesHardLimitLabel->set_text(str_hard_limit);
    quotegroupFilesSoftLimitLabel->set_text(str_soft_limit);
    quotegroupFilesCurrentlyLabel->set_text(str_currently_using);
    quoteuserDiskQuotasLabel->set_text(str_disk_quotas_device);
    quoteuserDeviceLabel->set_text(str_device);
    quoteuserGroupQuotasLabel->set_text(str_user_quotas_device);
    quoteuserSizeFrameLabel->set_text(str_size);
    quoteuserSizeCurrentlyLabel->set_text(str_currently_using);
    quoteuserSizeSoftLimitLabel->set_text(str_soft_limit);
    quoteuserSizeHardLimitLabel1->set_text(str_hard_limit);
    quoteuserFileSystemLabel->set_text(str_file_system);
    quoteuserFilesFrameLabel->set_text(str_files);
    quoteuserFilesCurrentlyLabel->set_text(str_currently_using_space);
    quoteuserFilesSoftLimitLabel->set_text(str_soft_limit);
    quoteFilesHardLimitLabel1->set_text(str_hard_limit);
    quoteuserFilesHarLimitLabel->set_text(str_files);
    quoteuserFilesSoftLimitlabel->set_text(str_files);
    quotegroupFileSystemLabel->set_text(str_file_system);
    btnLoadGlob->set_label(load_global);
    btnLoadLocal->set_label(load_local);
    btnAbout->set_label(str_about_1);
    btnSynopsis->set_label(str_help);
    btnSaveLocalGlob->set_label(save_all);
    btnSaveGlob->set_label(save_global);
    btnSaveLocal->set_label(save_local);
    lblHeadFiltersWindow->set_label(str_filters);
    ProjectTabLabel->set_label(str_projects);
    usersProjectLabel->set_text(str_device);
    lblhelpHeader->set_text(read_documentation_web);
    lblhelpText->set_text(redirected_documentation);
    btnReadHelp->set_label(read_online);
    btnCancelHelp->set_label(cancel);
    chkAlwaysOpenHelp->set_label(always_redirect);
    lblwebHeaderName->set_label(name_app);
    chbMangSystemFile->set_label(str_quotas_mode);
    
}

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::flag_block_gui() {
    if (flag_load_global == true) {
        btnLoadGlob->set_sensitive(false);
    }
    if (flag_save_local == true && flag_save_global == true) {
        btnSave->set_sensitive(false);
    }
    if (flag_save == true) {
        btnSave->set_sensitive(false);
    }
    if (flag_save_local == true) {
        btnSaveLocal->set_sensitive(false);
        btnSaveLocalGlob->set_sensitive(false);
    }
    if (flag_save_global == true) {
        btnSaveGlob->set_sensitive(false);
        btnSaveLocalGlob->set_sensitive(false);
    }
    if (flag_lock_help == true) {
        btnSynopsis->set_sensitive(false);
    }
}

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::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("generalGroupsSizeLabel", generalGroupsSizeLabel);
    builder->get_widget("generalGroupsFilesLabel", generalGroupsFilesLabel);
    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("lblLoad", lblLoad);
    builder->get_widget("lblSave", lblSave);
    builder->get_widget("btnSettings", btnSettings);
    builder->get_widget("btnSettings", btnSettings);
    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("usersDeviceCombo", usersDeviceCombo);
    builder->get_widget("GroupsTabLabel", GroupsTabLabel);
    builder->get_widget("generalTabLabel", generalTabLabel);
    builder->get_widget("groupsDeviceCombo", groupsDeviceCombo);
    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("GeneralQuotasTree", GeneralQuotasTree);
    builder->get_widget("ProjectQuotasTree", ProjectQuotasTree);
    builder->get_widget("ProjectTabLabel", ProjectTabLabel);
    builder->get_widget("usersProjectLabel", usersProjectLabel);
    builder->get_widget("btnFilterProject", btnFilterProject);
    builder->get_widget("btnFilterUsers", btnFilterUsers);
    builder->get_widget("btnFilterGroups", btnFilterGroups);
    #ifdef WEBKIT_FOUND
        builder->get_widget("wndWeb", wndWeb);
    #endif
    builder->get_widget("lblHeadeWndWeb", lblHeadeWndWeb);
    builder->get_widget("lblwebHeaderName", lblwebHeaderName);
    builder->get_widget("lblhelpText", lblhelpText);
    builder->get_widget("lblhelpHeader", lblhelpHeader);
    builder->get_widget("chkAlwaysOpenHelp", chkAlwaysOpenHelp);
    builder->get_widget("btnReadHelp", btnReadHelp);
    builder->get_widget("btnCancelHelp", btnCancelHelp);
    builder->get_widget("wndShowWeb", wndShowWeb);
    builder->get_widget("chbMangSystemFile", chbMangSystemFile);
    builder->get_widget("btnDelGroups", btnDelGroups);
    builder->get_widget("btnDelProject", btnDelProject);
    builder->get_widget("btnDelUsers", btnDelUsers);
    builder->get_widget("btnAddGroups", btnAddGroups);
    builder->get_widget("btnAddUsers", btnAddUsers);
    builder->get_widget("btnAddProject", btnAddProject);
    
}

void MainWindow::event() {
    btnCancelHelp->signal_clicked().connect([&]() {wndShowWeb->hide();});
    chkAlwaysOpenHelp->signal_toggled().connect([&]() {flag_open_browser = true;});
    btnReadHelp->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::open_browser));
    btnFilterGroups->signal_clicked().connect([&]() {this->groupsFilters_show();});
    btnFilterUsers->signal_clicked().connect([&]() {this->groupsFilters_show();});
    btnFilterProject->signal_clicked().connect([&]() {this->groupsFilters_show();});
    quotegroupSaveButton->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();});
    chbMangSystemFile->signal_toggled().connect([&]() {this->mode_switch_quota();});
    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();
    btnDelGroups->signal_clicked().connect( 
        sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this, 
        &MainWindow::remove_template), &list_store_groups, &iter_groups, flag_validate_del_groups));
    btnDelUsers->signal_clicked().connect( 
        sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this, 
        &MainWindow::remove_template), &list_store_users, &iter_users, flag_validate_del_users));
    btnDelProject->signal_clicked().connect( 
        sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this, 
        &MainWindow::remove_template), &list_store_project, &iter_project, flag_validate_del_project));
    btnAddProject->signal_clicked().connect( 
        sigc::bind<Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>,  struct tv_g_u_p> (sigc::mem_fun( *this, 
        &MainWindow::set_add_tv_g_u_p), row, list_store_project, obj_tv_g_u_p));
    btnAddUsers->signal_clicked().connect( 
        sigc::bind<Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>,  struct tv_g_u_p> (sigc::mem_fun( *this, 
        &MainWindow::set_add_tv_g_u_p), row, list_store_users, obj_tv_g_u_p));
    btnAddGroups->signal_clicked().connect( 
        sigc::bind<Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>,  struct tv_g_u_p> (sigc::mem_fun( *this, 
        &MainWindow::set_add_tv_g_u_p), row, list_store_groups, obj_tv_g_u_p));
    
    
}

void MainWindow::remove_template(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate_del) {
    if (flag_validate_del && (*list_store)->iter_is_valid(*(iter))) {
        Gtk::TreeModel::Row row = *(*iter);
        if(row) {
            string name = row[m_columns.name] + "";
            // TODO:
            string key = "GRUB_PASSWORD[" + name + "]";
            map_gui_cfg[key] = "";
        }
        (*list_store)->erase((*iter));
        flag_validate_del = false;
        info_status_app(info_box_ok_css);
        imgInfo->set_from_icon_name(icon_checked, Gtk::ICON_SIZE_MENU);
        lblWarning->set_text("");
    }
    flag_validate_del = false;
}

void MainWindow::set_add_tv_g_u_p(Gtk::TreeModel::Row &row, Glib::RefPtr<Gtk::ListStore> list_store, struct tv_g_u_p obj_tv_g_u_p) {
    row = *(list_store->append());
    row[m_columns.name] = obj_tv_g_u_p.name;
    row[m_columns.quotas] = obj_tv_g_u_p.quotas;
    row[m_columns.size] = obj_tv_g_u_p.size;
    row[m_columns.soft_limit_size] = obj_tv_g_u_p.soft_limit_size; 
    row[m_columns.hard_limit_size] = obj_tv_g_u_p.hard_limit_size; 
    row[m_columns.deferring_size] = obj_tv_g_u_p.deferring_size; 
    row[m_columns.files] = obj_tv_g_u_p.files; 
    row[m_columns.soft_limit_files] = obj_tv_g_u_p.soft_limit_files; 
    row[m_columns.hard_limit_delay] = obj_tv_g_u_p.hard_limit_delay; 
    row[m_columns.deferring_files] = obj_tv_g_u_p.deferring_files; 
}

void MainWindow::mode_switch_quota() {
    if (chbMangSystemFile->get_active()) {
        mode_quota = "filesystem";
    }
    else {
        mode_quota = "ubconfig";
    }
}

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(info_box_ok_css);
    boxInfo->remove_class(info_box_error_css);
    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() {
    if (flag_open_browser == true) {
        this->open_browser();
    }
    else {
        wndShowWeb->show_all(); 
    }
    
}

void MainWindow::open_browser() {
    #ifdef WEBKIT_FOUND
        webkit_web_view_load_uri(one, link_doc);
        wndWeb->show_all();
    #else
        this->template_open_browser();
    #endif
}

void MainWindow::template_open_browser() {
    string cmd = cmd_xdg + string(_(link_doc)) + " &";
    string buf = "";
    if (geteuid() == 0) {
        string response_user = getlogin();
        int size_s = std::snprintf(nullptr, 0, cmd_execute, response_user.c_str(), cmd.c_str()) + 1;
        auto size = static_cast<size_t>(size_s);
        std::unique_ptr<char[]> buf(new char[ size ]);
        std::snprintf( buf.get(), size, cmd_execute, response_user.c_str(), cmd.c_str() );
        cmd = std::string( buf.get(), buf.get() + size - 1 );
    }
    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::init_work_tv_g_u_p() {
    groupsQuotasTree->remove_all_columns();
    ProjectQuotasTree->remove_all_columns();
    usersQuotasTree->remove_all_columns();
    list_store_groups = Gtk::ListStore::create(m_columns);
    list_store_project = Gtk::ListStore::create(m_columns);
    list_store_users = Gtk::ListStore::create(m_columns);
    groupsQuotasTree->set_model(list_store_groups);
    ProjectQuotasTree->set_model(list_store_project);
    usersQuotasTree->set_model(list_store_users);
    Glib::RefPtr<Gtk::TreeModel> groupsQuotasTreeModel = groupsQuotasTree->get_model();
    groupsQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&> 
    (sigc::mem_fun(*this, &MainWindow::remove_line_template), iter_groups, flag_validate_del_groups));
    Glib::RefPtr<Gtk::TreeModel> ProjectQuotasTreeModel = ProjectQuotasTree->get_model();
    ProjectQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&> 
    (sigc::mem_fun(*this, &MainWindow::remove_line_template), iter_project, flag_validate_del_project));
    Glib::RefPtr<Gtk::TreeModel> usersQuotasTreeModel = usersQuotasTree->get_model();
    usersQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&> 
    (sigc::mem_fun(*this, &MainWindow::remove_line_template),iter_users, flag_validate_del_users));
    this->view_add_columns(*groupsQuotasTree);
    this->view_add_columns(*ProjectQuotasTree);
    this->view_add_columns(*usersQuotasTree);
}

void MainWindow::load_template(map_str_str* map_temp, string str_load) {
    this->init_work_tv_g_u_p();
    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::remove_line_template(const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter, Gtk::TreeModel::iterator& iter_del, bool& flag_del) {
    iter_del = iter;
    flag_del = true;
}

void MainWindow::info_warning_error(int mess) {
    if (obj_load.get_count_error() > 0 || obj_save.get_count_error() > 0) {
        info_status_app(info_box_error_css);
        imgInfo->set_from_icon_name(icon_warning, Gtk::ICON_SIZE_MENU);
        string mess_error = "";
        if (mess == 0) {
            mess_error = string(local_read_error) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 1) {
            mess_error = string(global_read_error) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 2) {
            mess_error = string(local_write_error) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 3) {
            mess_error = string(global_write_error) + str_cmd_error;
            lblWarning->set_text(mess_error);
        }
        else if (mess == 4) {
            mess_error = string(error_save_all) + 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(info_box_ok_css);
        imgInfo->set_from_icon_name(icon_checked, Gtk::ICON_SIZE_MENU);
        if (mess == 0) {
            lblWarning->set_text(local_load_ok);
        }
        else if (mess == 1) {
            lblWarning->set_text(global_load_ok);
        }
        else if (mess == 2) {
            lblWarning->set_text(local_ok_written);
        }
        else if (mess == 3) {
            lblWarning->set_text(global_ok_written);
        }
        else if (mess == 4) {
            lblWarning->set_text(successfully_save_all);
        }
        else if (mess == 5) {
            lblWarning->set_text(nothing_save);
        }
    }
}

MainWindow::~MainWindow() {}

void help() {
    string version = string(str_version) + version_application + "\n";
    cout << version.c_str();
    cout << str_help_h;

}