#include "libublsettingsui-gtk3.h"

static char *__yon_config_mode=NULL;

char *yon_ubl_save_mode_get_icon_name(SAVE_MODE_TYPE type){
    switch (type){
        case SAVE_MODE_FULL:
            return "com.ublinux.libublsettingsui-gtk3.config-changes-symbolic";
            break;
        case SAVE_MODE_MODULE:
            return "com.ublinux.libublsettingsui-gtk3.config-module-symbolic";
            break;
        case SAVE_MODE_SANDBOX:
            return "com.ublinux.libublsettingsui-gtk3.config-sandbox-symbolic";
            break;
        case SAVE_MODE_RAM_HOME:
            return "com.ublinux.libublsettingsui-gtk3.config-sandbox-ram-home-symbolic";
            break;
        case SAVE_MODE_HDD:
            return "com.ublinux.libublsettingsui-gtk3.config-sandbox-hdd-symbolic";
            break;
        case SAVE_MODE_HDD_HOME:
            return "com.ublinux.libublsettingsui-gtk3.config-sandbox-hdd-home-symbolic";
            break;
    }
}

SAVE_MODE_TYPE yon_ubl_save_mode_get_type(char *type){
    if (!strcmp(type,"changes")){
        return SAVE_MODE_FULL;
    }
    if (!strcmp(type,"module")){
        return SAVE_MODE_MODULE;
    }
    if (!strcmp(type,"sandbox")){
        return SAVE_MODE_SANDBOX;
    }
    if (!strcmp(type,"sandbox_ram_home")){
        return SAVE_MODE_RAM_HOME;
    }
    if (!strcmp(type,"sandbox_hdd")){
        return SAVE_MODE_HDD;
    }
    if (!strcmp(type,"sandbox_hdd_home")){
        return SAVE_MODE_HDD_HOME;
    }
}

//signal emmit handlers - no header initialization

void on_subwindow_close(GtkWidget *self){
    gtk_widget_destroy(gtk_widget_get_toplevel(self));
}

void yon_open_browser(GtkWidget *self, char *link){
    yon_ubl_browser_window_open(link,template_app_information.app_title);
}

void on_open_documentation_confirmation(GtkWidget *self, char *link){
    if (template_app_information.always_open_documentation==0){
        GtkBuilder *builder = gtk_builder_new_from_resource(ui_glade_path_documentation);
        template_documentation_confirmation_window *window = malloc(sizeof(template_documentation_confirmation_window));
        window->Window = yon_gtk_builder_get_widget(builder,"helpConfirmationWindow");
        window->AcceptButton = yon_gtk_builder_get_widget(builder,"ReadHelpButton");
        window->CloseButton = yon_gtk_builder_get_widget(builder,"CancelHelpButton");
        window->HeaderLabel = yon_gtk_builder_get_widget(builder,"webHeaderNameLabel");
        window->AlwaysOpenCheck = yon_gtk_builder_get_widget(builder,"AlwaysOpenDocumentationCheckbox");
        gtk_label_set_text(GTK_LABEL(window->HeaderLabel),template_app_information.app_title);
        gtk_widget_show_all(window->Window);
        g_signal_connect(G_OBJECT(window->CloseButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
        g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(yon_open_browser),yon_char_new(link));
        g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_subwindow_close),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);
}

void on_about(GtkWidget *self, char *version_application){
    GtkBuilder *builder=gtk_builder_new_from_resource(ui_glade_path_about);
    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_comments(GTK_ABOUT_DIALOG(window),template_app_information.app_title);
    gtk_about_dialog_set_logo_icon_name(GTK_ABOUT_DIALOG(window),yon_char_append("com.ublinux.",template_app_information.app_tech_name));
    gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(window),template_app_information.app_tech_name);
    gtk_label_set_text(GTK_LABEL(title),template_app_information.app_title);
    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);
}

//functions

void on_save_window_parameter_switched(GtkCellRendererToggle *self, gchar *path, template_saving_window *window){
    GtkTreeIter iter,itar;
    if (path){
        if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->filteredModel),&itar,path)){
            char *seek_name;
            gtk_tree_model_get(window->filteredModel,&itar,1,&seek_name,-1);
            int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
            for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
                char *name;
                gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,1,&name,-1);
                if (!strcmp(seek_name,name)){
                    gboolean is_active;
                    gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,0,&is_active,-1);
                    gtk_list_store_set(window->list,&iter,0,!is_active,-1);
                }
            }
            }
    }
    int once_active=0;
    int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
    for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
        int is_active;
        gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,0,&is_active,-1);
        if (is_active){
            once_active=1;
            break;
        }
    }
    if (!once_active) gtk_widget_set_sensitive(window->SaveButton,0);
    else gtk_widget_set_sensitive(window->SaveButton,1);
    gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(window->filteredModel));

}

void on_save_parameters(GtkWidget *self, template_saving_window *window){
    char *append_command = yon_char_unite("ubconfig --target ",template_config->load_mode==1?"global":"system"," set ",NULL);
    char *remove_command = yon_char_unite("ubconfig --target ",template_config->load_mode==1?"global":"system"," remove ",NULL);
    dictionary *final_append=NULL;
    dictionary *final_remove=NULL;
    GtkTreeIter iter;
    int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
    for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
        gboolean is_active,can_save;
        char *parameter,*old_value,*new_value,*section;
        gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,0,&is_active,1,&parameter,2,&old_value,3,&new_value,5,&can_save,6,&section,-1);
        if (is_active&&can_save){
            if(!yon_char_is_empty(parameter)){
                if (yon_char_is_empty(new_value)){ // empty new value - delete
                    if (yon_dictionary_get(&final_remove,section)){
                        final_remove->data = yon_char_unite((char*)final_remove->data," ",parameter,NULL);
                    } else {
                        yon_dictionary_add_or_create_if_exists_with_data(final_remove,section, parameter);
                    }
                } else { // non-empty new value - add
                    if (yon_dictionary_get(&final_append,section)){
                        final_append->data=yon_char_unite((char*)final_append->data," ",yon_char_unite(parameter,"=\"",new_value,"\"",NULL),NULL);
                    } else {
                        yon_dictionary_add_or_create_if_exists_with_data(final_append,section, yon_char_unite(parameter,"=",new_value[0]!='\"'?"\"":"",new_value,new_value[strlen(new_value)-1]!='\"'?"\"":"",NULL));
                    }
                }
            }
        }
    }
    dictionary *dict = NULL;
    if (final_remove){
        for_dictionaries(dict,final_remove){
            char *final_command = yon_char_unite(remove_command," ",dict->key," ",(char*)dict->data,NULL);
            system(final_command);
            free(final_command);
        }
    }
    if (final_append){
        for_dictionaries(dict,final_append){
            char *final_command = yon_char_unite(append_command," ",dict->key," ",(char*)dict->data,NULL);
            system(final_command);
            free(final_command);
        }
    }
    if (window->type==YON_CONFIG_BOTH) {
            if (template_config->load_mode==1){ 
                yon_config_save_registered("system");
            } else if (template_config->load_mode==0){ 
                yon_config_save_registered("global");
            }
        }
    textdomain(template_ui_LocaleName);
    if (window->type == YON_CONFIG_GLOBAL)
        yon_ubl_status_box_render(GLOBAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    else if (window->type == YON_CONFIG_LOCAL)
        yon_ubl_status_box_render(LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    else if (window->type == YON_CONFIG_BOTH)
        yon_ubl_status_box_render(GLOBAL_LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    textdomain(template_app_information.app_locale);

    yon_window_config_custom_window_set(GTK_WINDOW(window->Window),"SaveWindow");
    on_subwindow_close(self);
}

template_saving_window *yon_save_proceed(char *path,YON_CONFIG_TYPE type, ...){
    if (((type==YON_CONFIG_LOCAL&& template_config->load_mode==1)||(type==YON_CONFIG_GLOBAL&& template_config->load_mode==0))){
        yon_config_save_registered(path);
        textdomain(template_ui_LocaleName);
        if (type == YON_CONFIG_GLOBAL)
            yon_ubl_status_box_render(GLOBAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
        else if (type == YON_CONFIG_LOCAL)
            yon_ubl_status_box_render(LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
        else if (type == YON_CONFIG_BOTH)
            yon_ubl_status_box_render(GLOBAL_LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
        textdomain(template_app_information.app_locale);
        return NULL;
    } else {
        char *config_to_save = NULL;
        if (type==YON_CONFIG_GLOBAL) config_to_save="global";
        else if (type==YON_CONFIG_LOCAL) config_to_save="system";
        else if (type==YON_CONFIG_BOTH) {
            if (template_config->load_mode==1){ 
                config_to_save="global";
            } else if (template_config->load_mode==0){ 
                config_to_save="system";
            }
        }
        config_str config_compare=NULL;
        int compare_size=0;
        va_list args;
        va_start(args,type);
        char *cur_section = NULL;
        dictionary *section_commands=NULL;
        while ((cur_section=va_arg(args,char*))){
            char *cur_parameter = va_arg(args,char*);
            yon_dictionary_add_or_create_if_exists_with_data(section_commands,cur_section,cur_parameter);
        }
        struct loaded_config {
            dictionary *dict;
            char *section;
        };

        struct loaded_config loaded;
        loaded.dict = yon_dictionary_new();
        dictionary *dct;
        for_dictionaries(dct,section_commands){
            char *command = yon_char_unite(ubconfig_load_command," ", config_to_save," get ", dct->key," ", yon_dictionary_get_data(dct,char*),NULL);
            FILE *output = popen(command, "r");
            char **output_strings = NULL;
            output_strings = malloc(sizeof(char*));
            int i = 0;
            char str[4096];
            memset(str, 0, 4096);
            while (fgets(str, 4096, output))
            {
                if (!yon_char_is_empty(str)&& strcmp(str,"(null)\n")!=0)
                {
                    char *final_str = yon_char_new(str);
                    char *key = yon_char_divide_search(final_str,"=",-1);
                    final_str=yon_char_divide_search(final_str,"\n",-1);
                    if ((final_str[0]=='\''&&final_str[strlen(final_str)-1]=='\'')||(final_str[0]=='\"'&&final_str[strlen(final_str)-1]=='\"')){
                        final_str[strlen(final_str)-1] = '\0';
                        free(yon_char_divide(final_str,0));
                    }
                    char *str_copy = yon_char_unite(key,"=",final_str,NULL);
                    dictionary *found=NULL;
                    if (!(found=yon_dictionary_get(&loaded.dict,key))){
                        yon_dictionary_add_or_create_if_exists_with_data(loaded.dict,NULL,yon_char_new(dct->key));
                        yon_dictionary_add_or_create_if_exists_with_data(loaded.dict,key,yon_char_new(final_str));
                        yon_char_parsed_add_or_create_if_exists(config_compare,&compare_size,yon_char_new(str_copy));
                    } else{
                        int element = yon_char_parsed_check_exist(config_compare,compare_size,(char*)loaded.dict->data);
                        if (element>-1){
                            free(config_compare[element]);
                            config_compare[element]=yon_char_new(str_copy);
                            loaded.dict->data = yon_char_new(final_str);
                        }
                    }
                }
            }
        }
        GtkBuilder *builder = gtk_builder_new_from_resource(ui_glade_path_saving);
        template_saving_window *window = malloc(sizeof(template_saving_window));
        window->Window = yon_gtk_builder_get_widget(builder,"Window");
        window->HeaderImage = yon_gtk_builder_get_widget(builder,"HeaderImage");
        window->HeaderTopic = yon_gtk_builder_get_widget(builder,"HeaderTopic");
        window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
        window->ParametersTree = yon_gtk_builder_get_widget(builder,"ParametersTree");
        window->SaveButton = yon_gtk_builder_get_widget(builder,"SaveButton");
        window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
        window->ToggleCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"ToggleCell"));
        window->list = GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore1"));
        window->OldValueColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"OldValueColumn"));
        window->OldValueCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"OldValueCell"));
        window->NewValueColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"NewValueColumn"));
        window->NewValueCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"NewValueCell"));
        textdomain(template_ui_LocaleName);
        if (type==YON_CONFIG_BOTH){
            yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"savingTarget",SAVING_GLOBAL_LOCAL_STATE_LABEL,BACKGROUND_IMAGE_INFO_TYPE);
        } else if (type==YON_CONFIG_GLOBAL){
            yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"savingTarget",SAVING_GLOBAL_STATE_LABEL,BACKGROUND_IMAGE_INFO_TYPE);

        } else if (type==YON_CONFIG_LOCAL){
            yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"savingTarget",SAVING_LOCAL_STATE_LABEL,BACKGROUND_IMAGE_INFO_TYPE);

        }
        textdomain(template_app_information.app_locale);
        window->type=type;
        window->filteredModel = GTK_TREE_MODEL(gtk_builder_get_object(builder,"listfilter1"));
        gtk_tree_model_filter_set_visible_column(GTK_TREE_MODEL_FILTER(window->filteredModel),5);
        yon_window_config_custom_window_setup(GTK_WINDOW(window->Window),"SaveWindow");
        gtk_window_set_icon_name(GTK_WINDOW(window->Window),yon_char_append("com.ublinux.",template_app_information.app_tech_name));
        gtk_window_set_title(GTK_WINDOW(window->Window),template_app_information.app_title);
        gtk_label_set_text(GTK_LABEL(window->HeaderTopic),template_app_information.app_title);
        gtk_image_set_from_pixbuf(GTK_IMAGE(window->HeaderImage),gtk_icon_theme_load_icon_for_scale(gtk_icon_theme_get_default(),yon_char_append("com.ublinux.",template_app_information.app_tech_name),32,1,GTK_ICON_LOOKUP_FORCE_SIZE,NULL));
        // yon_gtk_tree_view_minimal_fixed_size_set_full(GTK_TREE_VIEW(window->ParametersTree));
        g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
        g_signal_connect(G_OBJECT(window->SaveButton),"clicked", G_CALLBACK(on_save_parameters),window);
        g_signal_connect(G_OBJECT(window->ToggleCell),"toggled", G_CALLBACK(on_save_window_parameter_switched),window);
        // g_signal_connect(G_OBJECT(window->OldValueColumn),"notify::width",G_CALLBACK(on_column_resize),window->OldValueCell);
        // g_signal_connect(G_OBJECT(window->NewValueColumn),"notify::width",G_CALLBACK(on_column_resize),window->NewValueCell);
        int config_size=0;
        config_str config_strings = yon_config_get_all(&config_size);
        if (config_strings){
            GtkTreeIter iter;
            gtk_tree_view_set_model(GTK_TREE_VIEW(window->ParametersTree),NULL);
            config_str compare_keys = NULL;
            compare_keys = yon_char_parsed_copy(config_compare,compare_size);
            int compare_keys_size=compare_size;
            yon_char_parsed_divide_search_full(compare_keys,compare_keys_size,"=",-1);
            int config_keys_size=0;
            config_str config_keys = yon_config_get_all_keys(&config_keys_size);
            int final_size=0;
                        GdkRGBA rgba;
                        rgba.alpha=0.8;
                        rgba.red=1;
                        rgba.blue=0.3;
                        rgba.green=0.65;
                        char *rgba_string = gdk_rgba_to_string(&rgba);
            for (int i=0;i<compare_keys_size;i++){
                    gtk_list_store_append(window->list,&iter);
                    gtk_list_store_set(window->list,&iter,0,0,1,compare_keys[i],5,1,-1);
                        for (int j=0;j<compare_size;j++){
                            if(config_compare[j][strlen(config_compare[j])-1]=='\n') config_compare[j][strlen(config_compare[j])-1]='\0';
                            char *compare_value = yon_char_new(config_compare[j]);
                            char *compare_name = yon_char_divide_search(compare_value,"=",-1);
                            if (!strcmp(compare_name,compare_keys[i])){
                                char *cur_section = (char*)yon_dictionary_get(&loaded.dict->first,compare_keys[i])->prev->data;
                                gtk_list_store_set(window->list,&iter,2,compare_value,4,rgba_string,6,cur_section,-1);
                            }
                            free(compare_value);
                            free(compare_name);
                        }
                    if (yon_config_check_ignore(compare_keys[i])){
                        gtk_list_store_set(window->list,&iter,0,0,1,compare_keys[i],4,NULL,5,0,-1);

                    }
                    
            }
                char *name,*value;
                for (int i=0;i<config_keys_size;i++){
                    int found=0;
                    char *compare_value = yon_char_new(config_strings[i]);
                    char *compare_name = yon_char_divide_search(compare_value,"=",-1);
                    char *section = yon_config_get_section_for_key(compare_name);
                    int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
                    for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
                            gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,1,&name,2,&value,-1);
                        if (!yon_char_is_empty(name)&&!strcmp(name,config_keys[i])){
                            if (!yon_config_check_ignore(name)){
                                char *combined = yon_char_unite("<s>",value,"</s>\n",compare_value,NULL);
                                gtk_list_store_set(window->list,&iter,3,compare_value,4,NULL,6,section,7,combined,-1);
                                free(combined);
                                if ((value&&!strcmp(value,compare_value))){ //||yon_char_is_empty(compare_value)
                                    gtk_list_store_set(window->list,&iter,0,0,3,value,5,0,-1);
                                } else {
                                    gtk_list_store_set(window->list,&iter,0,1,5,1,-1);
                                    }
                            }
                            found=1;
                            break;
                        }
                    }
                    if (!found){
                        if (!yon_config_check_ignore(compare_name)&&!yon_char_is_empty(compare_value)){
                            GtkTreeIter itar;
                            gtk_list_store_append(window->list,&itar);
                                char *combined = yon_char_append("\n",compare_value);
                            gtk_list_store_set(window->list,&itar,0,1,1,compare_name,3,compare_value,5,1,6,section,7,combined,-1);
                            free(combined);
                        }
                    }
                    free(compare_value);
                    free(compare_name);
            }
            free(rgba_string);
            if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->filteredModel),&iter)){
                gtk_widget_destroy(window->Window);
                textdomain(template_ui_LocaleName);
                yon_ubl_status_box_render(NOTHING_TO_SAVE_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
                textdomain(template_app_information.app_locale);
                return NULL;
            }
            gtk_tree_view_set_model(GTK_TREE_VIEW(window->ParametersTree),window->filteredModel);
        }
        
        gtk_widget_show(window->Window);
        on_save_window_parameter_switched(NULL,NULL,window);
        return window;

    }

}

int yon_confirmation_dialog_call(GtkWidget *self,dialog_confirmation_data *data){
    textdomain(template_ui_LocaleName);
    GtkWidget *dialog = gtk_dialog_new_with_buttons(template_app_information.app_title,GTK_WINDOW(gtk_widget_get_toplevel(self)),GTK_DIALOG_USE_HEADER_BAR,CANCEL_LABEL,GTK_RESPONSE_CANCEL,ACCEPT_LABEL,GTK_RESPONSE_ACCEPT,NULL);
    textdomain(template_app_information.app_locale);
    gtk_window_set_modal(GTK_WINDOW(dialog),1);
    gtk_window_set_icon_name(GTK_WINDOW(dialog),yon_char_append("com.ublinux.",template_app_information.app_tech_name));
    gtk_window_set_title(GTK_WINDOW(dialog),template_app_information.app_title);
    gtk_widget_set_size_request(dialog,450,-1);
    GList *list = gtk_container_get_children(GTK_CONTAINER(gtk_dialog_get_header_bar(GTK_DIALOG(dialog))));
    GtkWidget *image_cancel = gtk_image_new_from_icon_name("com.ublinux.libublsettingsui-gtk3.cancel-symbolic",GTK_ICON_SIZE_BUTTON);
    GtkWidget *image_accept = gtk_image_new_from_icon_name("com.ublinux.libublsettingsui-gtk3.accept-symbolic",GTK_ICON_SIZE_BUTTON);
    gtk_button_set_image((GtkButton*)g_list_nth_data(list,0),image_cancel);
    gtk_button_set_image((GtkButton*)g_list_nth_data(list,1),image_accept);
    gtk_style_context_add_class(gtk_widget_get_style_context((GtkWidget*)g_list_nth_data(list,0)),"marginright");
    gtk_style_context_add_class(gtk_widget_get_style_context((GtkWidget*)g_list_nth_data(list,1)),"marginright");

    g_list_free(list);
    GtkWidget *header_label = gtk_label_new(template_app_information.app_title);
    gtk_widget_show(header_label);
    PangoAttrList *attributes = pango_attr_list_new();
    PangoAttribute *boldAttr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
    pango_attr_list_insert(attributes, boldAttr);
    gtk_label_set_attributes(GTK_LABEL(header_label),attributes);

    GtkWidget *header = gtk_dialog_get_header_bar(GTK_DIALOG(dialog));
    gtk_header_bar_set_custom_title(GTK_HEADER_BAR(header),header_label);
    gtk_widget_show(header);

    GtkWidget *image = gtk_image_new_from_icon_name("dialog-question-symbolic",GTK_ICON_SIZE_DIALOG);
    gtk_widget_show(image);
    gtk_widget_set_margin_start(image,20);
    gtk_widget_set_margin_end(image,20);
    gtk_widget_set_margin_bottom(image,20);
    gtk_widget_set_margin_top(image,20);

    GtkWidget *label = gtk_label_new(data->action_text);
    gtk_widget_set_margin_end(label,20);
    gtk_widget_show(label);

    GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
    gtk_widget_show(box);
    gtk_box_pack_start(GTK_BOX(box),image,0,0,5);
    gtk_box_pack_start(GTK_BOX(box),label,0,0,5);
    gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),box,1,1,5);

    int resp = gtk_dialog_run(GTK_DIALOG(dialog));
    if (resp == GTK_RESPONSE_ACCEPT&&data->function){
        data->function(NULL,data->data);
    }
    gtk_widget_destroy(dialog);
    return resp;
}

// standard functions

int yon_ubl_connect_config(_template_config *config){
    int replaces;
    if(!template_config)
        replaces=0;
    else
        replaces=1;
    template_config = config;
    return replaces;
}

template_main_window *setup_window(){
    /* Widgets getting | Получение виджетов */
    template_main_window *widgets = malloc(sizeof(template_main_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(ui_glade_path);
    widgets->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
    widgets->HeadLabel = 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->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->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->InterfaceBox = yon_gtk_builder_get_widget(builder,"InterfaceBox");
    GtkWidget *HatIcon = yon_gtk_builder_get_widget(builder,"HatIcon");
    GtkWidget *HeadImage = yon_gtk_builder_get_widget(builder,"HeadImage");
    GtkWidget *ModeStatusImage = yon_gtk_builder_get_widget(builder,"ModeStatusImage");

    widgets->DocumentationMenuItem = yon_ubl_menu_item_documentation_new(DOCUMENTATION_LABEL);
    widgets->AboutMenuItem = yon_ubl_menu_item_about_new(ABOUT_LABEL);


    if (template_config->lock_load_global == 1){
        gtk_widget_set_sensitive(widgets->LoadGlobalMenuItem,0);
    }
    if (template_config->lock_save_global == 1){
        gtk_widget_set_sensitive(widgets->SaveGlobalMenuItem,0);
        gtk_widget_set_sensitive(widgets->SaveMenuItem,0);
    }
    if (template_config->lock_save_local == 1){
        gtk_widget_set_sensitive(widgets->SaveLocalMenuItem,0);
        gtk_widget_set_sensitive(widgets->SaveMenuItem,0);
    }
    if (template_config->lock_load_system == 1){
        gtk_widget_set_sensitive(widgets->LoadLocalMenuItem,0);
    }
    
    gtk_window_set_icon_name(GTK_WINDOW(widgets->Window),yon_char_append("com.ublinux.",template_app_information.app_tech_name));
    gtk_image_set_from_pixbuf(GTK_IMAGE(HeadImage),gtk_icon_theme_load_icon_for_scale(gtk_icon_theme_get_default(),yon_char_append("com.ublinux.",template_app_information.app_tech_name),32,1,GTK_ICON_LOOKUP_FORCE_SIZE,NULL));
    gtk_image_set_from_pixbuf(GTK_IMAGE(HatIcon),gtk_icon_theme_load_icon_for_scale(gtk_icon_theme_get_default(),yon_char_append("com.ublinux.",template_app_information.app_tech_name),64,1,GTK_ICON_LOOKUP_FORCE_SIZE,NULL));
    gtk_window_set_title(GTK_WINDOW(widgets->Window),template_app_information.app_title);
    gtk_label_set_text(GTK_LABEL(widgets->HeadLabel),template_app_information.app_title);
    gtk_label_set_text(GTK_LABEL(widgets->HeadTitleLabel),template_app_information.app_title);
    gtk_label_set_text(GTK_LABEL(widgets->HeadInfoLabel),template_app_information.app_description);
    
    GtkWidget *menu = yon_gtk_builder_get_widget(builder,"menu2");
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),widgets->DocumentationMenuItem);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),widgets->AboutMenuItem);

    /* Widget registration for config monitoring | Регистрация виджетов для мониторинга конфига */
    // yon_window_config_add_listener(widgets->HeadInfoLabel,"head-text","label",YON_TYPE_STRING); 

    /* 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),template_app_information.wiki_link);
    g_signal_connect(G_OBJECT(widgets->AboutMenuItem),"activate",G_CALLBACK(on_about),template_app_information.app_version);
    
    if (yon_char_is_empty(__yon_config_mode)){
        int size;
        config_str cnf = yon_config_load(SAVE_MODE_GET_COMMAND,&size);
        __yon_config_mode=yon_char_new(cnf[0]);
        if (__yon_config_mode[strlen(__yon_config_mode)-1]=='\n') __yon_config_mode[strlen(__yon_config_mode)-1]='\0';
        yon_char_parsed_free(cnf,size);
        if (!yon_char_is_empty(__yon_config_mode)&&strcmp(__yon_config_mode,"(null)")){
            gtk_image_set_from_pixbuf(GTK_IMAGE(ModeStatusImage),gtk_icon_theme_load_icon_for_scale(gtk_icon_theme_get_default(),yon_ubl_save_mode_get_icon_name(yon_ubl_save_mode_get_type(__yon_config_mode)),25,1,GTK_ICON_LOOKUP_FORCE_SIZE,NULL));
            char *tooltip_text=NULL;
            switch (yon_ubl_save_mode_get_type(__yon_config_mode)){
                case SAVE_MODE_FULL: tooltip_text = SAVE_MODE_FULL_LABEL;
                    break;
                case SAVE_MODE_MODULE: tooltip_text = SAVE_MODE_MODULE_LABEL;
                    break;
                case SAVE_MODE_SANDBOX: tooltip_text = SAVE_MODE_SANDBOX_LABEL;
                    break;
                case SAVE_MODE_RAM_HOME: tooltip_text = SAVE_MODE_RAM_HOME_LABEL;
                    break;
                case SAVE_MODE_HDD: tooltip_text = SAVE_MODE_HDD_LABEL;
                    break;
                case SAVE_MODE_HDD_HOME: tooltip_text = SAVE_MODE_HDD_HOME_LABEL;
                    break;
            }
            gtk_widget_set_tooltip_text(ModeStatusImage,tooltip_text);
        } else {
            free(__yon_config_mode);
            __yon_config_mode=NULL;
            gtk_widget_hide(ModeStatusImage);
        }
    }
    gtk_widget_show(widgets->Window);
    return widgets;
}

int yon_ubl_window_init(char *app_title, char *app_description, char *locale, char *css, char *tech_name, char *version, char *wiki){
    template_app_information.app_title=app_title;
    template_app_information.css_path=css;
    template_app_information.app_tech_name=tech_name;
    template_app_information.app_version=version;
    template_app_information.wiki_link=wiki;
    template_app_information.app_description=app_description;
    
    template_app_information.app_locale=locale;
}

int yon_ubl_setup_arguments(int argc, char *argv[],config_str *unfound_arguments, int *arguments_size, char *additional_options_output){
    (*arguments_size)=0;
    int option_index=0; 
    int show_help=0; 
    int debug_mode=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}, 
                {"lock-load-local", 0,0, 6}, 
                {"socket-id", 1, 0, 's'}, 
                {"socket-ext-id", 1,0, 'e'}, 
                {"socket-trd-id", 1,0, 't'}, 
                {"clear-config", 0,0, 'c'}, 
                { NULL, 0, NULL, 0 } 
        };
        config_str unregistered_arguments=NULL;
        for (int i=1;i<argc;i++){ 
            int argument=getopt_long(argc,argv,"hVvs:e:t:c",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) 
                        template_config->socket_id=atoi(optarg); 
                    break; 
                case 'e': 
                    if(optarg) 
                        template_config->save_socket_id=atoi(optarg); 
                    break; 
                case 't': 
                    if(optarg) 
                        template_config->load_socket_id=atoi(optarg); 
                    break; 
                case 'c': if (system(remove_config_dir_command)){}; 
                    break; 
                case 1: 
                    template_config->lock_help=1; 
                    break; 
                case 2: 
                    template_config->lock_save_local=1; 
                    template_config->lock_save_global=1; 
                    break; 
                case 3: 
                    template_config->lock_save_local=1; 
                    break; 
                case 4: 
                    template_config->lock_save_global=1; 
                    break; 
                case 5: 
                    template_config->lock_load_global=1; 
                    break; 
                case 6: 
                    template_config->lock_load_system=1; 
                    break; 
                default:
                char *unfound = optarg;
                    yon_char_parsed_add_or_create_if_exists(unregistered_arguments,arguments_size,yon_char_unite(argv[i],!yon_char_is_empty(unfound)?"=":"",!yon_char_is_empty(unfound)?unfound:"",NULL));
            } 
        } 
        (*unfound_arguments)=unregistered_arguments;
        if (show_help&&!template_config->lock_help){ 
            printf("%s\n",HELP_LABEL(additional_options_output)); 
            exit(0); 
            } 
    } 
 
    if (getuid()!=0){ 
        template_config->lock_load_global=1; 
        template_config->lock_save_global=1; 
        template_config->lock_save_local=1; 
    } 
}

template_main_window *yon_ubl_window_setup(){
    textdomain (template_ui_LocaleName);
    setlocale(LC_ALL,"");

    template_main_window *widgets = setup_window();
    yon_ubl_header_setup_resource(widgets->HeadOverlay,widgets->HeadBox,widgets->HeadImage,ui_banner_path);
    textdomain(template_ui_LocaleName);
    if (yon_ubl_status_box_setup(widgets->StatusIcon,widgets->StatusBox,widgets->StatusLabel)){
        if (getuid()!=0)
            yon_ubl_status_box_render(ROOT_WARNING_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
        else
            yon_ubl_status_box_render(LOCAL_LOAD_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    }
    textdomain(template_app_information.app_locale);
    template_config->load_mode=1;
    if(template_config)
        yon_ubl_setup_sockets(widgets->PlugBox,widgets->LeftBox,widgets->RightBox,template_config->socket_id,template_config->load_socket_id,template_config->save_socket_id);
    yon_window_config_setup(GTK_WINDOW(widgets->Window));
    yon_window_config_load(ui_config_path);
    GtkCssProvider *css=gtk_css_provider_new();
    gtk_css_provider_load_from_resource(css,template_app_information.css_path);
    gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
                            GTK_STYLE_PROVIDER(css),
                            -1);

    return widgets;
}