#include "ubl-settings-resourcequota.h"

config main_config;
main_window *widgets;
/**on_close_subwindow(GtkWidget *self)
 * [EN]
 * Closes window in which [self] is contained.
 * [RU]
 * Закрывает окно, в котором расположен виджет [self].
*/
void on_close_subwindow(GtkWidget *self){
    gtk_widget_destroy(gtk_widget_get_toplevel(self));
}

/**yon_open_browser(GtkWidget *self, char *link)
 * [EN]
 * Opens browser with [link] link.
 * [RU]
 * Открывает браузер с [link] ссылкой.
*/
void yon_open_browser(GtkWidget *self, char *link){
    yon_ubl_browser_window_open(link,TITLE_LABEL);
}

/**on_open_documentation_confirmation(GtkWidget *self, char *link)
 * [EN]
 * Opens confirmation window for [link] link.
 * [RU]
 * Открывает окно подтверждение перехода по ссылке [link].
*/
void on_open_documentation_confirmation(GtkWidget *self, char *link){
    if (main_config.always_open_documentation==0){
        GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
        documentation_confirmation_window *widgets = malloc(sizeof(documentation_confirmation_window));
        widgets->Window = yon_gtk_builder_get_widget(builder,"helpConfirmationWindow");
        widgets->AcceptButton = yon_gtk_builder_get_widget(builder,"ReadHelpButton");
        widgets->CloseButton = yon_gtk_builder_get_widget(builder,"CancelHelpButton");
        widgets->HatText = yon_gtk_builder_get_widget(builder,"webHeaderNameLabel");
        widgets->HeaderText = yon_gtk_builder_get_widget(builder,"helpHeader");
        widgets->InfoText = yon_gtk_builder_get_widget(builder,"helpText");
        widgets->AlwaysOpenCheck = yon_gtk_builder_get_widget(builder,"AlwaysOpenDocumentationCheckbox");
        gtk_label_set_text(GTK_LABEL(widgets->HatText),TITLE_LABEL);
        gtk_label_set_text(GTK_LABEL(widgets->HeaderText),HELP_TITLE_LABEL);
        gtk_label_set_text(GTK_LABEL(widgets->InfoText),HELP_INFO_LABEL);
        gtk_button_set_label(GTK_BUTTON(widgets->AcceptButton),OPEN_HELP_LABEL);
        gtk_button_set_label(GTK_BUTTON(widgets->AlwaysOpenCheck),HELP_ALWAYS_OPEN_LABEL);
        gtk_button_set_label(GTK_BUTTON(widgets->CloseButton),CANCEL_LABEL);
        gtk_widget_show_all(widgets->Window);
        g_signal_connect(G_OBJECT(widgets->CloseButton),"clicked",G_CALLBACK(on_close_subwindow),NULL);
        g_signal_connect(G_OBJECT(widgets->AcceptButton),"clicked",G_CALLBACK(yon_open_browser),yon_char_new(link));
        g_signal_connect(G_OBJECT(widgets->AcceptButton),"clicked",G_CALLBACK(on_close_subwindow),NULL);
        
        
    } else {
        yon_open_browser(self,link);
    }
}

/**on_link(GtkWidget *self, char* uri, gpointer user_data)
 * [EN]
 * Signal for hadnling AboutDialog links.
 * Connect to "activate-link" signal.
 * [self] is AboutDialog window;
 * [uri] is activated link;
 * [user_data] is pointer for user data, hasn't used in standard handler;
 * [RU]
 * Функция для обработки сигнала нажатия на ссылку окна AboutDialog.
 * Присоединять к сигналу "activate-link".
 * [self] - окно AboutDialog;
 * [uri] - ссылка, по которой совершается переход;
 * [user_data] - указатель на любые другие данные, не используется в стандартном обработчике;
*/
void on_link(GtkWidget *self, char* uri, gpointer user_data){
    gtk_widget_destroy(self);
    on_open_documentation_confirmation(self,uri);
}

/**on_about()
 * [EN]
 * Function for setting up and showing AboutDialog.
 * Connect it to "activate" signal of Documentation MenuItem.
 * [RU]
 * Функиця для настройки и показа окна AboutDialog.
 * Присоединять к сигналу "activate" кнопки справки типа MenuItem.
*/
void on_about(){
    GtkBuilder *builder=gtk_builder_new_from_file(glade_path);
    GtkWidget *window=yon_gtk_builder_get_widget(builder,"AboutWindow");
    GtkWidget *title=yon_gtk_builder_get_widget(builder,"headerAboutTopic");
    GtkWidget *hideButtonBox=yon_gtk_builder_get_widget(builder,"buttonBoxHide");
    gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(window),version_application);
    gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(window),PROJECT_HOME_LABEL);
    // gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(window),TITLE_LABEL);
    gtk_label_set_text(GTK_LABEL(title),TITLE_LABEL);
    g_signal_connect(G_OBJECT(window),"activate-link",G_CALLBACK(on_link),NULL);
    gtk_widget_set_visible(hideButtonBox,0);
    gtk_widget_destroy(hideButtonBox);
    gtk_widget_show(window);
}

void config_init(){
    main_config.always_open_documentation=0;
    main_config.win_height=0;
    main_config.win_width=0;
    main_config.win_pos_x=0;
    main_config.win_pos_y=0;
    main_config.socket_id=-1;
    main_config.save_socket_id=-1;
    main_config.load_socket_id=-1;
    main_config.lock_help=0;
    main_config.lock_help=0;
    main_config.lock_load_global=0;
    main_config.lock_save_global=0;
    main_config.lock_save_local=0;
    main_config.size_tree_view = 0;
}

main_window *setup_window(){
    /* Widgets getting | Получение виджетов */
    widgets = malloc(sizeof(main_window));
    GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
    widgets->Window = yon_gtk_builder_get_widget(builder,"MainWindow");

    widgets->btnDelQuotas = yon_gtk_builder_get_widget(builder,"btnDelQuotas");
    widgets->treeViewMain = yon_gtk_builder_get_widget(builder,"treeViewMain");
    widgets->tvc0 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc0"));
    widgets->tvc1 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc1"));
    widgets->tvc2 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc2"));
    widgets->tvc3 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc3"));
    widgets->tvc4 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc4"));
    widgets->tvc5 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc5"));
    widgets->tvc6 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc6"));
    widgets->tvc7 = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"tvc7"));

    widgets->btnMainShowAllEmpty = yon_gtk_builder_get_widget(builder,"btnMainShowAllEmpty");
    widgets->btnMainShowCoreStream = yon_gtk_builder_get_widget(builder,"btnMainShowCoreStream");

    main_config.list = GTK_LIST_STORE(gtk_builder_get_object(builder, "liststore"));
    widgets->vteInformation = yon_gtk_builder_get_widget(builder,"vteInformation");
    widgets->vteDispatcher = yon_gtk_builder_get_widget(builder,"vteDispatcher");
    widgets->vteProcesses = yon_gtk_builder_get_widget(builder,"vteProcesses");
    widgets->cbtMainInfo = yon_gtk_builder_get_widget(builder,"cbtMainInfo");
    widgets->cbtMainInfoLevel2 = yon_gtk_builder_get_widget(builder,"cbtMainInfoLevel2");
    widgets->spinUpdateDispatcher = yon_gtk_builder_get_widget(builder,"spinUpdateDispatcher");
    widgets->btnUpdateDispatcher = yon_gtk_builder_get_widget(builder,"btnUpdateDispatcher");
    widgets->btnSaveCfg = yon_gtk_builder_get_widget(builder,"btnSaveCfg");
    widgets->notebookMain = yon_gtk_builder_get_widget(builder,"notebookMain");

    widgets->btnEdit = yon_gtk_builder_get_widget(builder,"btnEdit");
    widgets->btnAdd = yon_gtk_builder_get_widget(builder,"btnAdd");
    widgets->btnInfo = yon_gtk_builder_get_widget(builder,"btnInfo");
    widgets->HatLabel = yon_gtk_builder_get_widget(builder,"headerTopic");
    widgets->PlugBox = yon_gtk_builder_get_widget(builder,"plugBox");

    widgets->HeadOverlay = yon_gtk_builder_get_widget(builder,"HeadOverlay");
    widgets->HeadImage = yon_gtk_builder_get_widget(builder,"HeadBackgroundImage");
    widgets->HeadBox = yon_gtk_builder_get_widget(builder,"HeaderBox");
    widgets->HeadTitleLabel = yon_gtk_builder_get_widget(builder,"HeaderTitleLabel");
    widgets->HeadInfoLabel = yon_gtk_builder_get_widget(builder,"HeaderInfoLabel");
    
    widgets->StatusBox = yon_gtk_builder_get_widget(builder,"mainStatusBox");
    widgets->StatusIcon = yon_gtk_builder_get_widget(builder,"mainStatusIcon");
    widgets->StatusLabel = yon_gtk_builder_get_widget(builder,"mainStatusLabel");

    widgets->SaveLabel = yon_gtk_builder_get_widget(builder,"headerSaveConfigLabel");
    widgets->SaveMenuItem = yon_gtk_builder_get_widget(builder,"SaveGlobalLocalConfigurationMenuItem");
    widgets->SaveGlobalMenuItem = yon_gtk_builder_get_widget(builder,"SaveGlobalConfigurationMenuItem");
    widgets->SaveLocalMenuItem = yon_gtk_builder_get_widget(builder,"SaveLocalConfigurationMenuItem");
    widgets->RightBox = yon_gtk_builder_get_widget(builder,"HeaderRightBox");

    widgets->LoadLabel = yon_gtk_builder_get_widget(builder,"headerLoadConfigLabel");
    widgets->LoadGlobalMenuItem = yon_gtk_builder_get_widget(builder,"LoadGlobalConfigurationMenuItem");
    widgets->LoadLocalMenuItem = yon_gtk_builder_get_widget(builder,"LoadLocalConfigurationMenuItem");
    widgets->LeftBox = yon_gtk_builder_get_widget(builder,"HeaderLeftBox");

    widgets->DocumentationMenuItem = yon_gtk_builder_get_widget(builder,"DocumentationMenuItem");
    widgets->AboutMenuItem = yon_gtk_builder_get_widget(builder,"AboutMenuItem");
    
    widgets->btnShowFilters = yon_gtk_builder_get_widget(builder,"btnShowFilters");
    if (main_config.lock_load_global == 1){
        gtk_widget_set_sensitive(widgets->LoadGlobalMenuItem,0);
    }
    if (main_config.lock_save_global == 1){
        gtk_widget_set_sensitive(widgets->SaveGlobalMenuItem,0);
        gtk_widget_set_sensitive(widgets->SaveMenuItem,0);
    }
    if (main_config.lock_save_local == 1){
        gtk_widget_set_sensitive(widgets->SaveLocalMenuItem,0);
        gtk_widget_set_sensitive(widgets->SaveMenuItem,0);
    }
    if (main_config.lock_save_global == 1 && main_config.lock_save_local == 1) {
        gtk_widget_set_sensitive(widgets->btnSaveCfg,0);  
    }
    

    gtk_widget_show_all(widgets->Window);
    return widgets;
}

void main_update_dispatcher() {
    int second = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->spinUpdateDispatcher));
    char* str_second =  yon_char_from_int(second);
    char *cmd = yon_char_get_augumented("systemd-cgtop -d ", str_second);
    yon_terminal_integrated_launch(widgets->vteDispatcher, cmd, NULL, NULL);
    free(str_second);
    free(cmd);
}

void main_update_processes() {
    char* cmd = NULL;
    gboolean active_all_empty = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->btnMainShowAllEmpty));
    gboolean active_core_stream = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->btnMainShowCoreStream));
    if (active_core_stream == 1) {
        cmd = "systemd-cgls --no-page -l";
    }
    else if (active_all_empty == 1) {
        cmd = "systemd-cgls --no-page -k";
    }
    else if (active_all_empty == 1 && active_core_stream == 1) {
        cmd = "systemd-cgls --no-page -l -k";
    }
    else {
        cmd = "systemd-cgls --no-page";
    }
    yon_terminal_integrated_launch(widgets->vteProcesses, cmd, NULL, NULL);
}

void main_update_information() {
    int menu_id = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtMainInfo));
    char* cmd = NULL;
    config_str fill_cmb_2 = NULL;
    int size = 0;
    if (menu_id == 0) {
        fill_cmb_2 = philos_list_user(&size);

    }
    else if (menu_id == 1) {

    }
    else if (menu_id == 2) {

    }
    else if (menu_id == 3) {

    }
    if (menu_id >= 0) {
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->cbtMainInfoLevel2));
        philos_fill_combo_box_text(widgets->cbtMainInfoLevel2, fill_cmb_2, size);
        // yon_terminal_integrated_launch(widgets->vteProcesses, cmd, NULL, NULL);
    }
}

void load_system_cfg() {
    template_cfg(CMD_LOAD_SYSTEM);
}

void load_global_cfg() {
    template_cfg(CMD_LOAD_GLOBAL);
}

void template_cfg(char* cmd) {
    int size = 0;
    int index_quotas = 0;
    char** cfg = yon_config_load(cmd, &size);
    for (int index = 0; index < size; index++) {
        char* str_key_value = yon_char_new(cfg[index]);
        char* str_key = yon_char_divide_search(str_key_value, "=",-1);
        if (yon_char_find_count(str_key, "CGROUP_QUOTA") != 0) {
            if (str_key_value[0] == '\"') {
                yon_char_divide(str_key_value, 0);
                size_t length = strlen(str_key_value);
                str_key_value = yon_char_divide(str_key_value, length-2);
            }
            str_split_key(str_key, index_quotas);
            str_split_value(str_key_value, index);
            index_quotas++;
        }
    }
    if (index_quotas != 0) {
        fill_tree_view(0, size);
    }
    
    
}
void str_split_key(char* value, int index) {
    yon_char_divide_search(value, "[", -1);
    value = yon_char_divide_search(value, "]", -1);
    if (strstr(value, ".") != NULL) {
        if (strstr(value, ".slice") != NULL) {
            main_config.quota_volume = yon_char_parsed_append(main_config.quota_volume, &index, value); 
            index--;
            main_config.type_quota_size = philos_int_append(main_config.type_quota_size, &index, 4);
            index--;
            main_config.quota_volume = yon_char_parsed_append(main_config.type_quota, &index, STR_PROCESS); 
            index--;
        }
        else if (strstr(value, ".service") != NULL) {
            main_config.quota_volume = yon_char_parsed_append(main_config.quota_volume, &index, value); 
            index--;
            main_config.type_quota_size = philos_int_append(main_config.type_quota_size, &index, 3);
            index--;
            main_config.quota_volume = yon_char_parsed_append(main_config.type_quota, &index, STR_SLICE); 
            index--;
        }
        else {
            main_config.quota_volume = yon_char_parsed_append(main_config.quota_volume, &index, value); 
            index--;
            main_config.type_quota_size = philos_int_append(main_config.type_quota_size, &index, -1);
            index--;
            main_config.quota_volume = yon_char_parsed_append(main_config.type_quota, &index, "-"); 
            index--;
        }
            
    }
    else {
        int user_size = 0;
        char** arr_users = philos_list_user(&user_size);
        for (int user_index = 0; user_index < user_size; user_index++) {
            // Пользователь
            if (strcmp(arr_users[user_index], value) != 0) {
                main_config.type_quota_size = philos_int_append(main_config.type_quota_size, &index, 0);
                index--;
                main_config.quota_volume = yon_char_parsed_append(main_config.quota_volume, &index, value); 
                index--;
                main_config.quota_volume = yon_char_parsed_append(main_config.type_quota, &index, STR_USER); 
                index--;
            }
            // Группа
            else {
                main_config.type_quota_size = philos_int_append(main_config.type_quota_size, &index, 1);
                index--;
                main_config.quota_volume = yon_char_parsed_append(main_config.quota_volume, &index, value); 
                index--;
                main_config.quota_volume = yon_char_parsed_append(main_config.type_quota, &index, STR_GROUP); 
                index--;
            }
        }
    }
    
}
void str_split_value(char* values, int index) {
    char* new_value = yon_char_new(values);
    int size = 0;
    char* key = NULL;
    char* value = NULL;
    char** arr_values = philos_str_split(new_value, &size, ",");
    if (arr_values == NULL) {
        return;
    }
    char* value_i = NULL;
    for (int index_1 = 0; index_1 < size; index_1++) {
        value = arr_values[index_1];
        key = yon_char_divide_search(value, "=", -1);
        if (yon_char_find_count(key, "MemoryHigh") != 0) {
            set_pow_size(value, main_config.soft_raw_limit_size, main_config.soft_raw_limit, index);
        }
        else {
            set_pow_size("-", main_config.soft_raw_limit_size, main_config.soft_raw_limit, index);
        }
        if (yon_char_find_count(key, "MemoryMax") != 0) {
            set_pow_size(value, main_config.hard_raw_limit_size, main_config.hard_raw_limit, index);
        }
        else {
            set_pow_size("-", main_config.hard_raw_limit_size, main_config.hard_raw_limit, index);
        }
        if (yon_char_find_count(key, "MemorySwapMax") != 0) {
            set_pow_size(value, main_config.swap_size, main_config.swap, index); 
        }
        else {
            set_pow_size("-", main_config.swap_size, main_config.swap, index); 
        }
        if (yon_char_find_count(key, "CPUQuota") != 0) {
            set_pow_size(value, main_config.cpu_limit_size, main_config.cpu_limit, index); 
        }
        else {
            set_pow_size("-", main_config.cpu_limit_size, main_config.cpu_limit, index); 
        }
        if (yon_char_find_count(key, "IOReadBandwidthMax") != 0) {
            set_pow_size(value, main_config.i_o_limit_read_size, main_config.i_o_limit_read, index);
        }
        else {
            set_pow_size("-", main_config.i_o_limit_read_size, main_config.i_o_limit_read, index);
        }
        if (yon_char_find_count(key, "IOWriteBandwidthMax") != 0) {
            set_pow_size(value, main_config.i_o_limit_write_size, main_config.i_o_limit_write, index); 
        }
        else {
            set_pow_size("-", main_config.i_o_limit_write_size, main_config.i_o_limit_write, index); 
        }
    }
}

void set_pow_size(char* str_find, int* array_size, char** array_data , int index) {
    if (strstr(str_find,"K") != NULL) {
        array_size = philos_int_append(array_size, &index, 0);
        index--;
    }
    else if (strstr(str_find,"M") != NULL) {
        array_size = philos_int_append(array_size, &index, 1);
        index--;
    }
    else if (strstr(str_find,"G") != NULL) {
        array_size = philos_int_append(array_size, &index, 2);
        index--;
    }
    else if (strstr(str_find,"T") != NULL) {
        array_size = philos_int_append(array_size, &index, 3);
        index--;
    }
    else if (strstr(str_find,"\%") != NULL) {
        array_size = philos_int_append(array_size, &index, -1);
        index--;
    }
    else if (strstr(str_find,"\"") != NULL) {
        
    }
    else if (strstr(str_find,"-") != NULL) {
        array_size = philos_int_append(array_size, &index, -1);
        index--;
    }
    if (strstr(str_find,"-") == NULL) {
        if (str_find[0] == '\"') {
            yon_char_divide(str_find, 0);
            size_t length = strlen(str_find);
            str_find = yon_char_divide(str_find, length-2);
        }
        size_t length = strlen(str_find);
        str_find = yon_char_divide(str_find, length-2);
        array_data = yon_char_parsed_append(array_data, &index, str_find); 
    }
    else {
        array_data = yon_char_parsed_append(array_data, &index, "-"); 
    }
}


void main_cbx_2_event() {
    int menu_id = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtMainInfo));
    char* cmd_text_param = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtMainInfo));
    if (menu_id == 0) {

    }
    else if (menu_id == 1) {

    }
    else if (menu_id == 2) {

    }
    else if (menu_id == 3) {

    }
    if (menu_id >= 0) {

    }
    //char *cmd = yon_char_get_augumented("systemd-cgtop -d ", str_second);
    //yon_terminal_integrated_launch(widgets->vteDispatcher, cmd, NULL, NULL);

}

void tree_view_select(GtkWidget *self, main_window *widgets) {
    GtkTreeIter iter;
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->treeViewMain));
    if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
        gtk_widget_set_sensitive(widgets->btnAdd,1);
        gtk_widget_set_sensitive(widgets->btnDelQuotas,1);
        gtk_widget_set_sensitive(widgets->btnEdit,1);
        gtk_widget_set_sensitive(widgets->btnInfo,1);
    } 
    else {
        gtk_widget_set_sensitive(widgets->btnAdd,1);
        gtk_widget_set_sensitive(widgets->btnDelQuotas,0);
        gtk_widget_set_sensitive(widgets->btnEdit,0);
        gtk_widget_set_sensitive(widgets->btnInfo,0);
    }
    
}

void tree_view_add(int index) {
    main_config.type_quota = yon_char_parsed_append(main_config.type_quota, &main_config.size_tree_view, add_get_quota_object());
    main_config.size_tree_view--;
    main_config.quota_volume = yon_char_parsed_append(main_config.quota_volume, &main_config.size_tree_view, add_get_select_device_to_level_2());
    main_config.size_tree_view--;
    main_config.soft_raw_limit = yon_char_parsed_append(main_config.soft_raw_limit, &main_config.size_tree_view, add_get_soft());
    main_config.size_tree_view--;
    main_config.hard_raw_limit = yon_char_parsed_append(main_config.hard_raw_limit, &main_config.size_tree_view, add_get_hard());
    main_config.size_tree_view--;
    main_config.swap = yon_char_parsed_append(main_config.swap, &main_config.size_tree_view, add_get_limit_swap());
    main_config.size_tree_view--;
    main_config.cpu_limit = yon_char_parsed_append(main_config.cpu_limit, &main_config.size_tree_view, add_get_limit_cpu());
    main_config.size_tree_view--;
    main_config.i_o_limit_read = yon_char_parsed_append(main_config.i_o_limit_read, &main_config.size_tree_view, add_get_read_device());
    main_config.size_tree_view--;
    main_config.i_o_limit_write = yon_char_parsed_append(main_config.i_o_limit_write, &main_config.size_tree_view, add_get_write_device());
    main_config.size_tree_view--;
    
    main_config.type_quota_size = philos_int_append(main_config.type_quota_size, &main_config.size_tree_view, add_get_quota_object_size());
    main_config.size_tree_view--;
    main_config.quota_volume_size = philos_int_append(main_config.quota_volume_size, &main_config.size_tree_view, -1);
    main_config.size_tree_view--;
    main_config.soft_raw_limit_size = philos_int_append(main_config.soft_raw_limit_size, &main_config.size_tree_view, add_get_soft_size());
    main_config.size_tree_view--;
    main_config.hard_raw_limit_size = philos_int_append(main_config.hard_raw_limit_size, &main_config.size_tree_view, add_get_hard_size());
    main_config.size_tree_view--;
    main_config.swap_size = philos_int_append(main_config.swap_size, &main_config.size_tree_view, add_get_limit_swap_size());
    main_config.size_tree_view--;
    main_config.cpu_limit_size = philos_int_append(main_config.cpu_limit_size, &main_config.size_tree_view, add_get_limit_cpu_size());
    main_config.size_tree_view--;
    main_config.i_o_limit_read_size = philos_int_append(main_config.i_o_limit_read_size, &main_config.size_tree_view, add_get_read_device_size());
    main_config.size_tree_view--;
    main_config.i_o_limit_write_size = philos_int_append(main_config.i_o_limit_write_size, &main_config.size_tree_view, add_get_write_device_size());
    fill_tree_view(main_config.size_tree_view-1, main_config.size_tree_view);
}

void fill_tree_view(int start, int size) {
    for (int index = start; index < size; index++) {
    GtkTreeIter iter;
    gtk_list_store_append(main_config.list,&iter);
    gtk_list_store_set(main_config.list,&iter,0,main_config.type_quota[index],
                                              1,main_config.quota_volume[index],
                                              2,main_config.soft_raw_limit[index],
                                              3,main_config.hard_raw_limit[index],
                                              4,main_config.swap[index],
                                              5,main_config.cpu_limit[index],
                                              6,main_config.i_o_limit_read[index],
                                              7,main_config.i_o_limit_write[index],-1);
    }
}

int tree_view_edit() {
    int index = 0;
    GtkTreeIter iter;
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);

    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->treeViewMain));
    if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
        char* str_iter = gtk_tree_model_get_string_from_iter(model, &iter);
        index = atoi(str_iter);
        main_config.soft_raw_limit[index] = edit_get_soft();
        main_config.hard_raw_limit[index] = edit_get_hard();
        main_config.swap[index] = edit_get_limit_swap();
        main_config.cpu_limit[index] = edit_get_limit_cpu();
        main_config.i_o_limit_read[index] = edit_get_read_device();
        main_config.i_o_limit_write[index] = edit_get_write_device();

        main_config.soft_raw_limit_size[index] = edit_get_soft_size();
        main_config.hard_raw_limit_size[index] = edit_get_hard_size();
        main_config.swap_size[index] = edit_get_limit_swap_size();
        main_config.cpu_limit_size[index] = edit_get_limit_cpu_size();
        main_config.i_o_limit_read_size[index] = edit_get_read_device_size();
        main_config.i_o_limit_write_size[index] = edit_get_write_device_size();
        gtk_list_store_set(main_config.list,&iter,0,main_config.type_quota[index],
                                                1,main_config.quota_volume[index],
                                                2,main_config.soft_raw_limit[index],
                                                3,main_config.hard_raw_limit[index],
                                                4,main_config.swap[index],
                                                5,main_config.cpu_limit[index],
                                                6,main_config.i_o_limit_read[index],
                                                7,main_config.i_o_limit_write[index],-1);
        return 1;
    }
    else {
        return 0;
    }
    
}

void main_visible_columns(GtkWidget *self) {
    gboolean *flags_filters = filters_get_flag();
    gtk_tree_view_column_set_visible(widgets->tvc0, flags_filters[0]);
    gtk_tree_view_column_set_visible(widgets->tvc1, flags_filters[1]);
    gtk_tree_view_column_set_visible(widgets->tvc2, flags_filters[2]);
    gtk_tree_view_column_set_visible(widgets->tvc3, flags_filters[3]);
    gtk_tree_view_column_set_visible(widgets->tvc4, flags_filters[4]);
    gtk_tree_view_column_set_visible(widgets->tvc5, flags_filters[5]);
    gtk_tree_view_column_set_visible(widgets->tvc6, flags_filters[6]);
    gtk_tree_view_column_set_visible(widgets->tvc7, flags_filters[7]);
    filters_on_hide_subwindow(self);
}

void info_show(GtkWidget *self) {
    GtkTreeIter iter;
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->treeViewMain));
    if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
        char* str_iter = gtk_tree_model_get_string_from_iter(model, &iter);
        int index = atoi(str_iter);
        char* t_quota = main_config.type_quota[index];
        if (yon_char_find_count(t_quota, "-")  == 0) {
            // TODO: add code
        }
    }
    gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->notebookMain), 3);
}

void event_all(main_window *widgets) {
    
}

void main_event(main_window *widgets) {
    /* Signal connection | Присоединение сигналов */
    g_signal_connect(G_OBJECT(widgets->Window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(widgets->DocumentationMenuItem),"activate",G_CALLBACK(on_open_documentation_confirmation),WIKI_LINK);
    g_signal_connect(G_OBJECT(widgets->AboutMenuItem),"activate",G_CALLBACK(on_about),NULL);
    
    g_signal_connect(G_OBJECT(widgets->btnShowFilters),"clicked",G_CALLBACK(wrapper_filters_show), NULL);
    g_signal_connect(G_OBJECT(widgets->btnAdd),"clicked",G_CALLBACK(wrapper_add_show), glade_path);
    g_signal_connect(G_OBJECT(widgets->btnEdit),"clicked",G_CALLBACK(wrapper_edit_show), glade_path);
    g_signal_connect(G_OBJECT(widgets->btnInfo),"clicked",G_CALLBACK(info_show), glade_path);
    g_signal_connect(G_OBJECT(widgets->btnUpdateDispatcher),"clicked",G_CALLBACK(main_update_dispatcher), NULL);
    g_signal_connect(G_OBJECT(widgets->btnMainShowAllEmpty), "toggled", G_CALLBACK(main_update_processes), NULL);
    g_signal_connect(G_OBJECT(widgets->btnMainShowCoreStream), "toggled", G_CALLBACK(main_update_processes), NULL);
    g_signal_connect(G_OBJECT(widgets->cbtMainInfo),"changed",G_CALLBACK(main_update_information), NULL);
    g_signal_connect(G_OBJECT(widgets->cbtMainInfoLevel2),"changed",G_CALLBACK(main_cbx_2_event), NULL);
    g_signal_connect(G_OBJECT(widgets->btnDelQuotas), "clicked", G_CALLBACK(tree_view_del_line), widgets);
    g_signal_connect(G_OBJECT(widgets->treeViewMain), "cursor-changed", G_CALLBACK(tree_view_select), widgets);
    g_signal_connect(G_OBJECT(widgets->LoadGlobalMenuItem), "activate", G_CALLBACK(load_global_cfg), widgets);
    g_signal_connect(G_OBJECT(widgets->LoadLocalMenuItem), "activate", G_CALLBACK(load_system_cfg), widgets);
/*
    g_signal_connect(G_OBJECT(widgets->LoadGlobalMenuItem),"activate",G_CALLBACK(),NULL);
    g_signal_connect(G_OBJECT(widgets->LoadLocalMenuItem),"activate",G_CALLBACK(),NULL);
    g_signal_connect(G_OBJECT(widgets->SaveMenuItem),"activate",G_CALLBACK(),NULL);

    g_signal_connect(G_OBJECT(widgets->SaveGlobalMenuItem),"activate",G_CALLBACK(),NULL);
    g_signal_connect(G_OBJECT(widgets->SaveLocalMenuItem),"activate",G_CALLBACK(),NULL);
*/
}
void wrapper_add_show(GtkWidget *self) {
    add_show(NULL, glade_path);
    g_signal_connect(G_OBJECT(get_widget_add()->btnSaveAddSave), "clicked", G_CALLBACK(main_add_btn_save), NULL);
}
void main_add_btn_save() {
    tree_view_add(main_config.size_tree_view);
    add_on_destroy_subwindow(get_widget_add()->Window);
}

void wrapper_filters_show(GtkWidget *self) {
    filters_show(self, glade_path);
    g_signal_connect(G_OBJECT(get_widget_filters()->btnFiltersSave),"clicked",G_CALLBACK(main_visible_columns), NULL);
}

void wrapper_edit_show() {
    GtkTreeIter iter;
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->treeViewMain));
    if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
        char* str_iter = gtk_tree_model_get_string_from_iter(model, &iter);
        int index = atoi(str_iter);
        edit_show(NULL, glade_path);
        edit_set_hard(main_config.hard_raw_limit[index], main_config.hard_raw_limit_size[index]);
        edit_set_limit_cpu(main_config.cpu_limit[index], main_config.cpu_limit_size[index]);
        edit_set_soft(main_config.soft_raw_limit[index], main_config.soft_raw_limit_size[index]);
        edit_set_write_device(main_config.i_o_limit_write[index], main_config.i_o_limit_write_size[index]);
        edit_set_read_device(main_config.i_o_limit_read[index], main_config.i_o_limit_read_size[index]);
        edit_set_limit_swap(main_config.swap[index], main_config.swap_size[index]);
        // edit_set_select_device(main_config.cpu_limit[index]);
        g_signal_connect(G_OBJECT(get_widget_edit()->btnSaveEditSave), "clicked", G_CALLBACK(main_edit_btn_save), NULL);
    }
}

void main_edit_btn_save() {
    if (tree_view_edit(main_config.size_tree_view)) {
        add_on_destroy_subwindow(get_widget_edit()->Window);
    }
    else {

    }
    
}

void tree_view_del_line() {
    int index = 0;
    GtkTreeIter iter;
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->treeViewMain));
    if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
        char* str_iter = gtk_tree_model_get_string_from_iter(model, &iter);
        index = atoi(str_iter);
        main_config.type_quota = yon_char_parsed_shrink(main_config.type_quota, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.quota_volume = yon_char_parsed_shrink(main_config.quota_volume, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.soft_raw_limit = yon_char_parsed_shrink(main_config.soft_raw_limit, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.hard_raw_limit = yon_char_parsed_shrink(main_config.hard_raw_limit, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.swap = yon_char_parsed_shrink(main_config.swap, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.cpu_limit = yon_char_parsed_shrink(main_config.cpu_limit, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.i_o_limit_read = yon_char_parsed_shrink(main_config.i_o_limit_read, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.i_o_limit_write = yon_char_parsed_shrink(main_config.i_o_limit_write, &main_config.size_tree_view,index);
        main_config.size_tree_view++;

        main_config.type_quota_size = remove_element_int_array(main_config.type_quota_size, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.quota_volume_size = remove_element_int_array(main_config.quota_volume_size, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.soft_raw_limit_size = remove_element_int_array(main_config.soft_raw_limit_size, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.hard_raw_limit_size = remove_element_int_array(main_config.hard_raw_limit_size, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.swap_size = remove_element_int_array(main_config.swap_size, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.cpu_limit_size = remove_element_int_array(main_config.cpu_limit_size, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.i_o_limit_read_size = remove_element_int_array(main_config.i_o_limit_read_size, &main_config.size_tree_view,index);
        main_config.size_tree_view++;
        main_config.i_o_limit_write_size = remove_element_int_array(main_config.i_o_limit_write_size, &main_config.size_tree_view,index);
        g_object_ref(main_config.list);
        gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->treeViewMain), NULL);
        gtk_list_store_clear(main_config.list);
        main_fill_tree_view_after_remove();
        gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->treeViewMain), model);
    }
    else {

    }
}

void main_fill_tree_view_after_remove() {
    for (int index= 0; index < main_config.size_tree_view; index++) {
        GtkTreeIter iter;
        gtk_list_store_append(main_config.list,&iter);
        gtk_list_store_set(main_config.list,&iter,0,main_config.type_quota[index],
                                                1,main_config.quota_volume[index],
                                                2,main_config.soft_raw_limit[index],
                                                3,main_config.hard_raw_limit[index],
                                                4,main_config.swap[index],
                                                5,main_config.cpu_limit[index],
                                                6,main_config.i_o_limit_read[index],
                                                7,main_config.i_o_limit_write[index],-1);
    }
}

void main_localization(main_window *widgets) {
    /* Localisation | Локализация */
    gtk_label_set_text(GTK_LABEL(widgets->HatLabel),TITLE_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->SaveLabel),SAVE_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->SaveMenuItem),SAVE_CONFIGURATION_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->SaveGlobalMenuItem),SAVE_GLOBAL_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->SaveLocalMenuItem),SAVE_LOCAL_LABEL);

    gtk_label_set_text(GTK_LABEL(widgets->LoadLabel),LOAD_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->LoadGlobalMenuItem),LOAD_GLOBAL_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->LoadLocalMenuItem),LOAD_LOCAL_LABEL);

    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->DocumentationMenuItem),DOCUMENTATION_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->AboutMenuItem),ABOUT_LABEL);
}

int main(int argc, char *argv[]){
    local=setlocale(LC_ALL, "");
    textdomain (LocaleName);
    config_init();
    int option_index=0;
        int show_help=0;
    {
        struct option long_options[] = {
                {"help", 0, 0, 'h'},
                {"version", 0, 0, 'V'},
                {"lock-help", 0,0, 1},
                {"lock-save", 0,0, 2},
                {"lock-save-local", 0,0, 3},
                {"lock-save-global", 0,0, 4},
                {"lock-load-global", 0,0, 5},
                {"socket-id", 1, 0, 's'},
                {"socket-ext-id", 1,0, 'e'},
                {"socket-trd-id", 1,0, 't'},
                { NULL, 0, NULL, 0 }
        };
        
        for (int i=0;i<argc;i++){
            int argument=getopt_long(argc,argv,"hVvs:e:t:",long_options,&option_index);
            switch(argument){
                case 'h':
                    show_help=1;
                    break;
                case 'v':
                case 'V':
                    printf("%s\n",VERSION_LABEL);
                    exit(0);
                    break;
                case 's':
                    if(optarg)
                        main_config.socket_id=atoi(optarg);
                    break;
                case 'e':
                    if(optarg)
                        main_config.load_socket_id=atoi(optarg);
                    break;
                case 't':
                    if(optarg)
                        main_config.save_socket_id=atoi(optarg);
                    break;
                case 1:
                    main_config.lock_help=1;
                    break;
                case 2:
                    main_config.lock_save_local=1;
                    main_config.lock_save_global=1;
                    break;
                case 3:
                    main_config.lock_save_local=1;
                    break;
                case 4:
                    main_config.lock_save_global=1;
                    break;
                case 5:
                    main_config.lock_load_global=1;
                    break;
            }
        }
        if (show_help==1&&main_config.lock_help!=1){
            printf("%s\n",HELP_LABEL);
            exit(0);
            }
    }
    gtk_init(&argc,&argv);
    device_disk_parsed();
    main_window *widgets = setup_window();
    main_update_information();
    filters_init_flag();
    filters_setup_window(glade_path);
    add_setup_window(glade_path);
    main_localization(widgets);
    tree_view_select(NULL, widgets);
    event_all(widgets);
    main_event(widgets);
    
    
    yon_ubl_header_setup(widgets->HeadOverlay,widgets->HeadBox,widgets->HeadImage,banner_path);
    
    if (yon_ubl_status_box_setup(widgets->StatusIcon,widgets->StatusBox,widgets->StatusLabel))
    yon_ubl_status_box_render(GLOBAL_LOAD_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
    yon_ubl_setup_sockets(widgets->PlugBox,widgets->LeftBox,widgets->RightBox,main_config.socket_id,main_config.load_socket_id,main_config.save_socket_id);

    GtkCssProvider *css=gtk_css_provider_new();
    gtk_css_provider_load_from_path(css,CssPath,NULL);
    gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
                               GTK_STYLE_PROVIDER(css),
                               -1);
    gtk_main();
}