#include "ubl-settings-repomanager.h"

config main_config;

void on_repo_signed(){

}

void on_repo_removed(GtkWidget *self,storage_config_window *window){
    GList *list = gtk_container_get_children(GTK_CONTAINER(gtk_widget_get_parent(self)));
    char *repo = (char*)gtk_entry_get_text(GTK_ENTRY(g_list_nth_data(list,0)));
    GtkTreeIter iter, itar;
    char *storage;
    char *id = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
    if (!yon_char_is_empty(id)){
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
        int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(window->storages_copy),&itar,&iter);
        for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->storages_copy),&itar)){
            char *target;
            gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,2,&target,-1);
            if (!strcmp(target,repo)){
                gtk_tree_store_remove(window->storages_copy,&itar);
                break;
            }
        }
    }
    yon_storage_config_update(window);
}

void on_repo_sign_changed(GtkWidget *self, storage_config_window *window){
    GList *list = gtk_container_get_children(GTK_CONTAINER(gtk_widget_get_parent(self)));
    const char *sign = gtk_combo_box_get_active_id(GTK_COMBO_BOX(g_list_nth_data(list,2)));
    char *target_repo = (char*)gtk_entry_get_text(GTK_ENTRY(g_list_nth_data(list,0)));
    const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
    if (!yon_char_is_empty(id)){
        GtkTreeIter iter,itar;
        int size;
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
        char *storage_path;
        gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&iter,3,&storage_path,-1);
        config_str repos = yon_tree_store_get_all_at_level(window->storages_copy,&iter,&size,2,2);
        int found = yon_char_parsed_check_exist(repos,size,target_repo);
        if (found>-1){
            char *child_id = yon_char_unite((char*)id,":",yon_char_from_int(found),NULL);
            if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&itar,child_id)){
                if (!yon_char_is_empty(sign)){
                    gtk_tree_store_set(window->storages_copy,&itar,6,1,5,sign,-1);
                    if (system(yon_sign_repo(storage_path,target_repo,sign))){
                        gtk_combo_box_set_active(GTK_COMBO_BOX((GtkWidget*)g_list_nth_data(list,2)),0);
                        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),REPO_SIGN_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
                    }
                }else
                    gtk_tree_store_set(window->storages_copy,&itar,6,-1,5,NULL,-1);
            }
        }
    }
}

void yon_storage_config_update(storage_config_window *window){  
    GList *children = gtk_container_get_children(GTK_CONTAINER(window->ReposBox));
    for (int i=0;i<g_list_length(children);i++){
        gtk_widget_destroy((GtkWidget*)g_list_nth_data(children,i));
    }
    GtkTreeIter iter,itar;
    const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
    if (id){
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
        if (gtk_tree_model_iter_children(GTK_TREE_MODEL(window->storages_copy),&itar,&iter)){
            int valid = 1;
            for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->storages_copy),&itar)){
                char *repo;
                gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,2,&repo,-1);
                GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_repo_block);
                GtkWidget *box = yon_gtk_builder_get_widget(builder,"MainBox");
                gtk_box_pack_start(GTK_BOX(window->ReposBox),box,0,0,0);
                yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(gtk_builder_get_object(builder,"SignatureCombo")));
                gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_builder_get_object(builder,"SignatureCombo")),0);
                g_signal_connect(gtk_builder_get_object(builder,"SignatureButton"),"clicked",G_CALLBACK(on_repo_signed),window);
                g_signal_connect(gtk_builder_get_object(builder,"RepoRemoveButton"),"clicked",G_CALLBACK(on_repo_removed),window);
                g_signal_connect(gtk_builder_get_object(builder,"SignatureCombo"),"changed",G_CALLBACK(on_repo_sign_changed),window);
                gtk_entry_set_text(GTK_ENTRY(gtk_builder_get_object(builder,"RepoNameEntry")),repo);
            }
        }
    }
}

// filechooser window section

file_chooser_window *yon_file_chooser_window_new(){
    file_chooser_window *window = malloc(sizeof(file_chooser_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_filechooser);
    window->Window = yon_gtk_builder_get_widget(builder,"Window");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->ChooseButton = yon_gtk_builder_get_widget(builder,"ChooseButton");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->NameEntry = yon_gtk_builder_get_widget(builder,"NameEntry");
    window->FileChooserWidget = yon_gtk_builder_get_widget(builder,"FileChooserWidget");
    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);

    return window;
}

// storage-configure window section

void on_storage_open(GtkWidget *self, storage_config_window *window){
    GtkWidget *dialog = gtk_file_chooser_dialog_new(TITLE_LABEL,GTK_WINDOW(window->MainWindow),GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,CLOSE_LABEL,GTK_RESPONSE_CANCEL,OPEN_LABEL,GTK_RESPONSE_ACCEPT,NULL);
    yon_gtk_window_setup(GTK_WINDOW(dialog),GTK_WINDOW(window->MainWindow),TITLE_LABEL,icon_path,"file_chooser");
    int responce = gtk_dialog_run(GTK_DIALOG(dialog));
    if (responce == GTK_RESPONSE_ACCEPT){
        char *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
        if (!yon_char_is_empty(path)){
            GtkTreeIter iter, itar;
            gtk_tree_store_append(window->storages_copy,&iter,NULL);
            char *name = yon_char_new(path);
            free(yon_char_divide(name,yon_char_find_last(name,'/')));
            gtk_tree_store_set(window->storages_copy,&iter,2,name,3,path,-1);
            gtk_entry_set_text(GTK_ENTRY(window->AddEntry),"");
            char *iterpath = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->storages_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StoragePathCombo),iterpath,path);
            char *repos=NULL;
            int repos_size=0;
            yon_window_config_get_parameter("storage_info",path,&repos,YON_TYPE_STRING);
            g_signal_handlers_block_by_func(G_OBJECT(window->StoragePathCombo),on_storage_changed,window);
            yon_gtk_combo_box_text_find(window->StoragePathCombo,path);
            g_signal_handlers_unblock_by_func(G_OBJECT(window->StoragePathCombo),on_storage_changed,window);
            if (!yon_char_is_empty(repos)){
                config_str repos_list = yon_char_parse(repos,&repos_size,",");
                for (int i=0;i<repos_size;i++){
                    char *render_name = yon_char_new(repos_list[i]);
                    free(yon_char_divide(render_name,yon_char_find_last(render_name,'/')));
                    gtk_tree_store_append(window->storages_copy,&itar,&iter);
                    gtk_tree_store_set(window->storages_copy,&itar,2,render_name,3,repos_list[i],-1);
                    free(render_name);
                }
                yon_char_parsed_free(repos_list,repos_size);
            } else {
                yon_window_config_add_instant_parameter(path,"storage_info","",YON_TYPE_STRING);
            }
        }
    }
    yon_storage_config_update(window);
    gtk_widget_destroy(dialog);
}

void on_storage_create(GtkWidget *self, storage_config_window *window){
    GtkWidget *dialog = gtk_file_chooser_dialog_new(TITLE_LABEL,GTK_WINDOW(window->MainWindow),GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,CLOSE_LABEL,GTK_RESPONSE_CANCEL,OPEN_LABEL,GTK_RESPONSE_ACCEPT,NULL);
    yon_gtk_window_setup(GTK_WINDOW(dialog),GTK_WINDOW(window->MainWindow),TITLE_LABEL,icon_path,"file_chooser");
    int responce = gtk_dialog_run(GTK_DIALOG(dialog));
    if (responce == GTK_RESPONSE_ACCEPT){
        char *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
        if (!yon_char_is_empty(path)){
            GtkTreeIter iter;
            gtk_tree_store_append(window->storages_copy,&iter,NULL);
            char *name = yon_char_new(path);
            free(yon_char_divide(name,yon_char_find_last(name,'/')));
            gtk_tree_store_set(window->storages_copy,&iter,2,name,3,path,-1);
            char *iterpath = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->storages_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StoragePathCombo),iterpath,path);
            g_signal_handlers_block_by_func(G_OBJECT(window->StoragePathCombo),on_storage_changed,window);
            yon_gtk_combo_box_text_find(window->StoragePathCombo,path);
            g_signal_handlers_unblock_by_func(G_OBJECT(window->StoragePathCombo),on_storage_changed,window);
            gtk_entry_set_text(GTK_ENTRY(window->AddEntry),"");
            yon_window_config_add_instant_parameter(path,"storage_info","",YON_TYPE_STRING);
        }
    }
    yon_storage_config_update(window);
    gtk_widget_destroy(dialog);
}

void on_storage_disable(GtkWidget *self, storage_config_window *window){
    dialog_confirmation_data *data = malloc(sizeof(dialog_confirmation_data));
    data->action_text=DISABLE_CONFIRMATION_LABEL;
    data->function=NULL;
    data->data=NULL;
        GtkTreeIter iter,itar;
    if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(window->StoragePathCombo),&iter)){
        if (yon_confirmation_dialog_call(self,data)){GtkTreeIter itar;
        char *storage;
        const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
        if (id){
            gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&itar,id);
            gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,3,&storage,-1);
            char *repos;
            yon_window_config_get_parameter("storage_info",storage,&repos,YON_TYPE_STRING);
            int repo_size;
            config_str repo_list = yon_char_parse(repos,&repo_size,",");
            for (int i=0;i<repo_size;i++){
                yon_window_config_erase_custom_parameter(repo_list[i],"repo_info");
            }
            if (repo_size)
                yon_char_parsed_free(repo_list,repo_size);
            yon_window_config_erase_custom_parameter(storage,"storage_info");
            gtk_tree_store_remove(window->storages_copy,&itar);
            gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(window->StoragePathCombo),gtk_combo_box_get_active(GTK_COMBO_BOX(window->StoragePathCombo)));
        }
        }
        yon_storage_config_update(window);
    }
}
void on_storage_remove(GtkWidget *self, storage_config_window *window){
    dialog_confirmation_data *data = malloc(sizeof(dialog_confirmation_data));
    data->action_text=REMOVE_CONFIRMATION_LABEL;
    data->function=NULL;
    data->data=NULL;
    if (yon_confirmation_dialog_call(self,data)){
        GtkTreeIter itar;
        char *storage;
        const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
        if (id){
            gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&itar,id);
            gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,3,&storage,-1);
            char *repos;
            yon_window_config_get_parameter("storage_info",storage,&repos,YON_TYPE_STRING);
            int repo_size;
            config_str repo_list = yon_char_parse(repos,&repo_size,",");
            for (int i=0;i<repo_size;i++){
                yon_window_config_erase_custom_parameter(repo_list[i],"repo_info");
            }
            if (repo_size)
                yon_char_parsed_free(repo_list,repo_size);
            yon_window_config_erase_custom_parameter(storage,"storage_info");
            rmdir(storage);
            gtk_tree_store_remove(window->storages_copy,&itar);
            gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(window->StoragePathCombo),gtk_combo_box_get_active(GTK_COMBO_BOX(window->StoragePathCombo)));
        }
    }
    yon_storage_config_update(window);
}

void on_repo_add(GtkWidget *self, storage_config_window *window){
    char *new_repo = yon_char_new((char*)gtk_entry_get_text(GTK_ENTRY(window->AddEntry)));
    gtk_entry_set_text(GTK_ENTRY(window->AddEntry),"");
    if (yon_char_is_empty(new_repo)){
        yon_ubl_status_highlight_incorrect(window->AddEntry);
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_NAME_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        return;
    }
    GtkTreeIter iter,itar, childiter;
    const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
    if (id){
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&itar,id);
        char *path;
        gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,3,&path,-1);
        char *child_path = yon_char_unite(path,"/",new_repo,NULL);
        gtk_tree_store_append(window->storages_copy,&childiter,&itar);
        gtk_tree_store_set(window->storages_copy,&childiter,2,new_repo,3,child_path,-1);
        yon_storage_config_update(window);
        char *old;
        yon_window_config_get_parameter("storage_info",path,&old,YON_TYPE_STRING);
        int old_repos_size;
        config_str old_repos_parsed = yon_char_parse(old,&old_repos_size,",");
        if (yon_char_parsed_check_exist(old_repos_parsed,old_repos_size,child_path)==-1){
            yon_char_parsed_add_or_create_if_exists(old_repos_parsed,&old_repos_size,child_path);
        }
        yon_window_config_add_instant_parameter(path,"storage_info",yon_char_parsed_to_string(old_repos_parsed,old_repos_size,","),YON_TYPE_STRING);
        yon_char_parsed_free(old_repos_parsed,old_repos_size);
            yon_launch(create_storage_command(path, new_repo));
            int size;
            config_str dirs = yon_file_list_dirs(child_path,&size);
            for (int i=0;i<size;i++){
                char *arch_path = yon_char_unite(child_path,"/",dirs[i],NULL);
                gtk_tree_store_append(window->storages_copy,&iter,&childiter);
                gtk_tree_store_set(window->storages_copy,&iter,2,dirs[i],3,arch_path,-1);

                if (!yon_char_is_empty(arch_path)&&!access(arch_path,F_OK)){
                    config_str final = NULL;
                    int final_size=0;
                    DIR *current_dir = opendir(arch_path);
                    struct dirent* cur_dir;
                    while ((cur_dir=readdir(current_dir))){
                        if (strlen(cur_dir->d_name)>8){
                            char *extension = yon_char_new(cur_dir->d_name);
                            free(yon_char_divide(extension,yon_char_find_last(extension,'.')-4));
                            if ((strcmp(cur_dir->d_name, ".") && strcmp(cur_dir->d_name, ".."))&&strstr(extension,"tar.")){
                                yon_char_parsed_add_or_create_if_exists(final,&final_size,cur_dir->d_name);
                            }
                        }
                    }
                    closedir(current_dir);
                    yon_window_config_add_instant_parameter(arch_path,"package_info",yon_char_parsed_to_string(final,size,","),YON_TYPE_STRING);
                }
            }
            yon_char_parsed_free(dirs,size);
    }
    free(new_repo);
}

void on_storage_accept(GtkWidget *self, dictionary *dict){
    main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
    storage_config_window *window = yon_dictionary_get_data(dict->first->next,storage_config_window*);
    gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),NULL);
    gtk_tree_store_clear(main_config.tree_store);
    yon_gtk_tree_store_copy_full(window->storages_copy,main_config.tree_store);
    gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),GTK_TREE_MODEL(main_config.tree_store));
    yon_window_config_save_instant();
    on_subwindow_close(self);
    yon_ubl_status_box_render(STORAGES_SAVED_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
}

gboolean yon_storage_filter_func(GtkTreeModel *model,
              GtkTreeIter  *iter,
              gpointer      data);

void on_storage_changed(GtkWidget *self, storage_config_window *window){
    yon_storage_config_update(window);
}

storage_config_window *yon_storage_config_window_new(){
    storage_config_window *window = malloc(sizeof(storage_config_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_storage_config);
    window->MainWindow = yon_gtk_builder_get_widget(builder,"MainWindow");
    window->HeadLabel = yon_gtk_builder_get_widget(builder,"HeadLabel");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->StoragePathCombo = yon_gtk_builder_get_widget(builder,"StoragePathCombo");
    window->OpenExistingButton = yon_gtk_builder_get_widget(builder,"OpenExistingButton");
    window->CreateNewButton = yon_gtk_builder_get_widget(builder,"CreateNewButton");
    window->DisableButton = yon_gtk_builder_get_widget(builder,"DisableButton");
    window->DeleteButton = yon_gtk_builder_get_widget(builder,"DeleteButton");
    window->ReposBox = yon_gtk_builder_get_widget(builder,"ReposBox");
    window->AddEntry = yon_gtk_builder_get_widget(builder,"AddEntry");
    window->AddRepoButton = yon_gtk_builder_get_widget(builder,"AddRepoButton");
    window->storages_copy = gtk_tree_store_new(7,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_INT);
    yon_gtk_tree_store_copy_full(main_config.tree_store,window->storages_copy);
    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->OpenExistingButton),"clicked",G_CALLBACK(on_storage_open),window);
    g_signal_connect(G_OBJECT(window->CreateNewButton),"clicked",G_CALLBACK(on_storage_create),window);
    g_signal_connect(G_OBJECT(window->DisableButton),"clicked",G_CALLBACK(on_storage_disable),window);
    g_signal_connect(G_OBJECT(window->DeleteButton),"clicked",G_CALLBACK(on_storage_remove),window);
    g_signal_connect(G_OBJECT(window->AddRepoButton),"clicked",G_CALLBACK(on_repo_add),window);
    g_signal_connect(G_OBJECT(window->StoragePathCombo),"changed",G_CALLBACK(on_storage_changed),window);
    

    return window;
}

void on_storage_configure_clicked(GtkWidget *self, main_window *widgets){
    storage_config_window *window = yon_storage_config_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),TITLE_LABEL,icon_path,"storage-configuration-window");
    gtk_window_set_transient_for(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window));
    GtkTreeIter iter,itar;
    for_iter(window->storages_copy,&iter){
        char *storage;
        gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&iter,3,&storage,-1);
        char *id = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->storages_copy),&iter);
        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StoragePathCombo),id,storage);
    }

    dictionary *dict = NULL;
    yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
    yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_storage_accept),dict);
    gtk_widget_show(window->MainWindow);
}

//repo-move window


//repo-add window section
gboolean yon_storage_filter_func(GtkTreeModel *model,GtkTreeIter *iter,gpointer data){
    GtkTreeIter parent;
    if (gtk_tree_model_iter_parent(model, &parent, iter))
        return 0;
    return 1;
  }

config_str yon_tree_store_get_all_at_level(GtkTreeStore *target,GtkTreeIter *parent, int *size, int column, int level){
    (*size)=0;
    config_str final = NULL;
    GtkTreePath *path=NULL, *parent_path=NULL;
    GtkTreeIter iter;
    if (parent){
        parent_path = gtk_tree_model_get_path(GTK_TREE_MODEL(target),parent);
    }
    int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(target),&iter,parent);
    for(;valid;valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(target),&iter)){
        path = gtk_tree_model_get_path(GTK_TREE_MODEL(target),&iter);
        if (path && gtk_tree_path_get_depth(path)==level&&(!parent_path||gtk_tree_path_is_descendant(path,parent_path))){
            char *append=NULL;
            gtk_tree_model_get(GTK_TREE_MODEL(target),&iter,column,&append,-1);
            yon_char_parsed_add_or_create_if_exists(final,size,append);
        }
        gtk_tree_path_free(path);
    }
    return final;
}

void on_add_target_repo_selection_changed(GtkWidget *target,repo_add_window *window){
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->RepositoryCombo));
    char *path_str = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StorageCombo));
    if (!yon_char_is_empty(path_str)){
        GtkTreeIter iter, itar;
        GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
        if (gtk_tree_model_get_iter(GTK_TREE_MODEL(window->tree_copy),&iter,path)){
            
            int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(window->tree_copy),&itar,&iter);
            for(;valid;valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(window->tree_copy),&itar)){
                char *current;
                gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,2,&current,-1);
                if (!yon_char_is_empty(current)){
                    char *path_str = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&itar);
                    gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->RepositoryCombo),path_str,current);
                }
            }
        }

    }
}

void on_add_target_arch_selection_changed(GtkWidget *target,repo_add_window *window){
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->ArchitectureCombo));
    char *path_str = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->RepositoryCombo));
    if (!yon_char_is_empty(path_str)){
        GtkTreeIter iter, itar;
        GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
        if (gtk_tree_model_get_iter(GTK_TREE_MODEL(window->tree_copy),&iter,path)){
            
            int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(window->tree_copy),&itar,&iter);
            for(;valid;valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(window->tree_copy),&itar)){
                char *current, *current_path;
                gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,2,&current,3,&current_path,-1);
                if (!yon_char_is_empty(current)){
                    char *path_str = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&itar);
                    gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->ArchitectureCombo),path_str,current);
                    
                }
            }
        }
        gtk_widget_set_sensitive(window->RepoSignCombo,1);

    } else {
        gtk_widget_set_sensitive(window->RepoSignCombo,0);

    }
}

void on_arch_chosen(GtkWidget *target,repo_add_window *window){
    char *path_str = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->ArchitectureCombo));
    if (!yon_char_is_empty(path_str)){
        gtk_widget_set_sensitive(window->PackageSignCombo,1);
    } else {
        gtk_widget_set_sensitive(window->PackageSignCombo,0);
    }
}

void on_add_target_package_selection_changed(GtkWidget *target,repo_add_window *window){
    gtk_list_store_clear(GTK_LIST_STORE(window->PackagesList));
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ArchitectureCombo))==-1){
        gtk_widget_set_sensitive(window->AddPackageButton,0);
    } else {
        gtk_widget_set_sensitive(window->AddPackageButton,1);
    }
}

void on_move_storage_changed(GtkWidget *self, repo_add_window *window){
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->MoveTargetRepoEntry));
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->MoveSourceRepoEntry));
    GtkTreeIter iter,itar;
    char *id = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(self));
    gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->MoveTargetStorageEntry),id);
    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,id);
    int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(window->tree_copy),&itar,&iter);
    for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->tree_copy),&itar)){
        char *target;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,2,&target,-1);
        char *child_id = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&itar);
        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveTargetRepoEntry),child_id,target);
        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveSourceRepoEntry),child_id,target);
    }
}

void on_move_repo_changed(GtkWidget *self, repo_add_window *window){
    GtkWidget *ArchCombo = NULL;
    ArchCombo = self==window->MoveSourceRepoEntry?window->MoveSourceArchEntry:window->MoveTargetArchEntry;

    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(ArchCombo));
    GtkTreeIter iter,itar;
    char *id = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(self));
    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,id);
    int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(window->tree_copy),&itar,&iter);
    for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->tree_copy),&itar)){
        char *target;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,2,&target,-1);
        char *child_id = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&itar);
        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(ArchCombo),child_id,target);
    }
    
}

void on_move_arch_changed(GtkWidget *self, repo_add_window *window){
    GtkWidget *TargetArchCombo = self==window->MoveTargetArchEntry?window->MoveSourceArchEntry:window->MoveTargetArchEntry;
    GtkWidget *TargetRepoCombo = self==window->MoveTargetArchEntry?window->MoveSourceRepoEntry:window->MoveTargetRepoEntry;
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(self))>-1){
    
        const char *current = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(self));
        const char *repo_id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(TargetRepoCombo));

        if (!yon_char_is_empty(current)&&!yon_char_is_empty(repo_id)){

            GtkTreeIter iter, itar;

            g_signal_handlers_block_by_func(G_OBJECT(TargetArchCombo),on_move_arch_changed,window);
            if (yon_gtk_combo_box_text_find(TargetArchCombo,(char*)current)==-1){
                gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,repo_id);
                gtk_tree_store_append(window->tree_copy,&itar,&iter);
                char *id = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&itar);
                yon_debug_output("%s\n","arch");
                gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(TargetArchCombo),id,current);
            }
            g_signal_handlers_unblock_by_func(G_OBJECT(TargetArchCombo),on_move_arch_changed,window);
            gtk_widget_set_sensitive(window->MoveTargetArchEntry,0);
            gtk_widget_set_sensitive(window->AddPackageButton,1);
        }
    }
}

void on_add_accept(GtkWidget *self, dictionary *dict){
    repo_add_window *window = yon_dictionary_get_data(dict->first,repo_add_window*);
    file_chooser_window *dialog = yon_dictionary_get_data(dict->first->next,file_chooser_window*);
    char *id = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->ArchitectureCombo));
    char *path,*arch_name;
    GtkTreeIter iter,itar,itor;
    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,id);
    gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,2,&arch_name,3,&path,-1);
    char *packages;
    yon_window_config_get_parameter("package_info",path,&packages,YON_TYPE_STRING);
    int size;
    config_str parsed = yon_char_parse(packages,&size,",");
    GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog->FileChooserWidget));
    for (int i=0;i<g_slist_length(list);i++){
        char *current = g_slist_nth_data(list,i);
        if (yon_char_parsed_check_exist(parsed,size,current)==-1){
            int name_size;
            config_str name = yon_config_load(yon_get_package_name_from_filename(current),&name_size);
            if (name_size<=0){
                yon_ubl_status_box_spawn(GTK_CONTAINER(dialog->StatusBox),PACKAGE_NAME_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
                return;
            }
            yon_char_remove_last_symbol(name[0],'\n');
            if (name_size<=0){
                yon_ubl_status_box_spawn(GTK_CONTAINER(dialog->StatusBox),PACKAGE_NAME_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
                return;
            }
                gtk_list_store_append(window->PackagesList,&itar);
                gtk_list_store_set(window->PackagesList,&itar,1,name[0],2,current,3,1,-1);
                yon_char_parsed_free(name,name_size);
        }
    }
    gtk_widget_destroy(dialog->Window);
    if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->tree_copy),&iter)){
        gtk_widget_set_sensitive(window->StorageCombo,0);
        gtk_widget_set_sensitive(window->RepositoryCombo,0);
        gtk_widget_set_sensitive(window->ArchitectureCombo,0);
    }
}

void on_add_package(GtkWidget *self, repo_add_window *window){
    file_chooser_window *dialog = yon_file_chooser_window_new();
    yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->MainWindow),TITLE_LABEL,icon_path,"filechooserWindow");
    gtk_widget_show(dialog->Window);
    GtkFileFilter *filter = gtk_file_filter_new();
    gtk_file_filter_add_pattern(filter,"*.pkg.tar*[^.sig]");
    gtk_file_filter_set_name(filter,"*.pkg.tar*");
    dictionary *dict = NULL;
    yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
    yon_dictionary_add_or_create_if_exists_with_data(dict,"dialog",dialog);
    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog->FileChooserWidget),filter);
    g_signal_connect(G_OBJECT(dialog->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(dialog->ChooseButton),"clicked",G_CALLBACK(on_add_accept),dict);
}

void on_remove_package(GtkWidget *self, repo_add_window *window){
        char *id = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->RepositoryCombo));
        char *storage = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StorageCombo));
        char *repo;
        char *path;
        GtkTreeModel *model;
        GtkTreeIter iter,itar,itor;
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&itor,storage);
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itor,3,&storage,-1);

        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,id);
        if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->PackagesTree)),&model,&itar)){
            gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,2,&repo,3,&path,-1);
            gtk_list_store_remove(window->PackagesList,&itar);
        }
        if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->tree_copy),&iter)){
            gtk_widget_set_sensitive(window->StorageCombo,1);
            gtk_widget_set_sensitive(window->RepositoryCombo,1);
            gtk_widget_set_sensitive(window->ArchitectureCombo,1);
        }
}

void on_add_window_tree_changed(GtkWidget *self, repo_add_window *window){
    gtk_label_set_text(GTK_LABEL(window->InfoLabel),"");
    GtkTreeModel *model;
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->PackagesTree)),&model,&iter)){
        gtk_widget_set_sensitive(window->RemoveButton,1);
        char *target;
        gtk_tree_model_get(model,&iter,2,&target,-1);
        int size;
        config_str info = yon_config_load(get_package_info_command(target),&size);
        char *result = yon_char_parsed_to_string(info,size,"");
        gtk_label_set_text(GTK_LABEL(window->InfoLabel),result);
        yon_char_parsed_free(info,size);
        free(result);
    } else {
        gtk_widget_set_sensitive(window->RemoveButton,0);
    }
}


void on_add_packages_accept(GtkWidget *self, dictionary *dict){
    main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
    repo_add_window *window = yon_dictionary_get_data(dict->first->next,repo_add_window*);

    GtkTreeIter iter, itar;
    char *storage;
    if (yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->StorageCombo),GTK_TREE_MODEL(window->tree_copy),&itar)){
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,3,&storage,-1);
        const char *repo = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->RepositoryCombo));
        const char *arch = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->ArchitectureCombo));
        GtkTreeModel *model = GTK_TREE_MODEL(window->PackagesList);
        int size=0;
        config_str packages=NULL;
        int valid = gtk_tree_model_get_iter_first(model,&iter);
        for (;valid;valid=gtk_tree_model_iter_next(model,&iter)){
            char *target;
            gtk_tree_model_get(model,&iter,2,&target,-1);
            yon_char_parsed_add_or_create_if_exists(packages,&size,target);
            free(target);
        }
        if (size>0){
            char *command = NULL;
            int repo_sign = gtk_combo_box_get_active(GTK_COMBO_BOX(window->RepoSignCombo));
            int pack_sign = gtk_combo_box_get_active(GTK_COMBO_BOX(window->PackageSignCombo));
            if (repo_sign&&pack_sign){
                command = add_packages_sign_command(storage,arch,repo,gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->RepoSignCombo)),gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->PackageSignCombo)),yon_char_parsed_to_string(packages,size," "));
            } else if (repo_sign){
                command = add_packages_repo_sign_command(storage,arch,repo,gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->RepoSignCombo)),yon_char_parsed_to_string(packages,size," "));
            } else if (pack_sign){
                command = add_packages_package_sign_command(storage,arch,repo,gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->PackageSignCombo)),yon_char_parsed_to_string(packages,size," "));
            } else {
                command = add_packages_command(storage,arch,repo,yon_char_parsed_to_string(packages,size," "));
            }
            yon_debug_output("%s\n",command);
            if (!system(command)){
                gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),NULL);
                gtk_tree_store_clear(widgets->RepoList);
                yon_gtk_tree_store_copy_full(window->tree_copy,widgets->RepoList);
                gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),GTK_TREE_MODEL(widgets->RepoList));
                gtk_widget_destroy(window->MainWindow);
                yon_ubl_status_box_render(PACKAGES_ADD_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
            }
        } else {
            yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_TO_SAVE_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);  
        }
    } else {
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_TO_SAVE_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE); 
    }
}

void on_repo_sign_load(GtkWidget *self, repo_add_window *window){
    GtkTreeIter iter;
    yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(self),GTK_TREE_MODEL(window->tree_copy),&iter);
    char *sign;
    gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,5,&sign,-1);
    if (!yon_char_is_empty(sign))
        gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->RepoSignCombo),sign);
}

repo_add_window *yon_repo_add_window_new(){
    repo_add_window *window = malloc(sizeof(repo_add_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_repo_add);
    window->MainWindow = yon_gtk_builder_get_widget(builder,"MainWindow");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->StorageCombo = yon_gtk_builder_get_widget(builder,"StorageCombo");
    window->HeadLabel = yon_gtk_builder_get_widget(builder,"HeadLabel");
    window->RepositoryCombo = yon_gtk_builder_get_widget(builder,"RepositoryCombo");
    window->ArchitectureCombo = yon_gtk_builder_get_widget(builder,"ArchitectureCombo");
    window->MoveSourceFrame = yon_gtk_builder_get_widget(builder,"MoveSourceFrame");
    window->MoveSourceStorageEntry = yon_gtk_builder_get_widget(builder,"MoveSourceStorageEntry");
    window->MoveSourceRepoEntry = yon_gtk_builder_get_widget(builder,"MoveSourceRepoEntry");
    window->MoveSourceArchEntry = yon_gtk_builder_get_widget(builder,"MoveSourceArchEntry");
    window->MoveTargetFrame = yon_gtk_builder_get_widget(builder,"MoveTargetFrame");
    window->MoveTargetStorageEntry = yon_gtk_builder_get_widget(builder,"MoveTargetStorageEntry");
    window->MoveTargetRepoEntry = yon_gtk_builder_get_widget(builder,"MoveTargetRepoEntry");
    window->MoveTargetArchEntry = yon_gtk_builder_get_widget(builder,"MoveTargetArchEntry");
    window->PackageSignCombo = yon_gtk_builder_get_widget(builder,"PackageSignCombo");
    window->RepoSignCombo = yon_gtk_builder_get_widget(builder,"RepoSignCombo");
    window->AddPackageButton = yon_gtk_builder_get_widget(builder,"AddPackageButton");
    window->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
    window->PackagesTree = yon_gtk_builder_get_widget(builder,"PackagesTree");
    window->InfoLabel = yon_gtk_builder_get_widget(builder,"InfoLabel");
    window->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->PackagesList = GTK_LIST_STORE(gtk_builder_get_object(builder,"PackagesList"));
    window->tree_copy = gtk_tree_store_new(7,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_INT);
    yon_gtk_tree_store_copy_full(main_config.tree_store,window->tree_copy);

    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->PackagesTree),"cursor-changed",G_CALLBACK(on_add_window_tree_changed),window);
    
    window->added_packages_archs = NULL;
    window->removed_packages_archs = NULL;

    return window;
}

// main window 
void on_add_clicked(GtkWidget *self, main_window *widgets){
    repo_add_window *window = yon_repo_add_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),TITLE_LABEL,icon_path,"add-repo-window");
    GtkTreeIter iter;
    for_iter (window->tree_copy,&iter){
        char *current;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
        if (!yon_char_is_empty(current)){
            char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StorageCombo),path,current);
        }
    }

    yon_sign_list_update();
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));

    gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->PackageSignCombo),0);

    dictionary *dict = NULL;
    yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
    yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);

    g_signal_connect(G_OBJECT(window->StorageCombo),"changed",G_CALLBACK(on_add_target_repo_selection_changed),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_add_target_arch_selection_changed),window);
    g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_arch_chosen),window);
    g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_add_target_package_selection_changed),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_add_packages_accept),dict);
    g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_add_package),window);
    g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_remove_package),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_repo_sign_load),window);
    gtk_widget_show(window->MainWindow);
}

void on_folder_changed(GtkFileChooser *self, file_chooser_window *dialog){
    const char *current = gtk_file_chooser_get_current_folder(self);
    if (!strstr(current,dialog->root_path)){
        gtk_file_chooser_set_current_folder(self,dialog->root_path);
    }
}

void on_move_add_accept(GtkWidget *self, dictionary *dict){
    repo_add_window *window = yon_dictionary_get_data(dict->first,repo_add_window*);
    file_chooser_window *dialog = yon_dictionary_get_data(dict->first->next,file_chooser_window*);
    GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog->FileChooserWidget));
    for (int i=0;i<g_slist_length(list);i++){
        char *path = (char*)g_slist_nth_data(list,i);
        if (yon_file_is_directory(path)){
            int size;
            config_str files = yon_file_ls(path,&size);
            for (int k=0;k<size;k++){
                if (strstr(files[k],".pkg.tar")&&!strstr(files[k],".sig")){
                    GtkTreeIter iter;
                    int temp_size;
                    config_str name = yon_config_load(yon_get_package_name_from_filename(files[k]),&temp_size);
                    yon_char_remove_last_symbol(name[0],'\n');
                    gtk_list_store_append(window->PackagesList,&iter);
                    gtk_list_store_set(window->PackagesList,&iter,1,name[0],2,files[k],-1);
                }
            }
        } else {
            GtkTreeIter iter;
            int temp_size;
            config_str name = yon_config_load(yon_get_package_name_from_filename(path),&temp_size);
            if (temp_size<=0){
                yon_ubl_status_box_spawn(GTK_CONTAINER(dialog->StatusBox),PACKAGE_NAME_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
                return;
            }
            yon_char_remove_last_symbol(name[0],'\n');
            gtk_list_store_append(window->PackagesList,&iter);
            gtk_list_store_set(window->PackagesList,&iter,1,name[0],2,path,-1);

        }
    }
    gtk_widget_destroy(dialog->Window);
    free(dialog);
    GtkTreeIter iter;
    if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->tree_copy),&iter)){
        gtk_widget_set_sensitive(window->MoveSourceStorageEntry,0);
        gtk_widget_set_sensitive(window->MoveSourceRepoEntry,0);
        gtk_widget_set_sensitive(window->MoveSourceArchEntry,0);

        gtk_widget_set_sensitive(window->MoveTargetRepoEntry,0);
        gtk_widget_set_sensitive(window->MoveTargetArchEntry,0);

        if (window->StorageCombo&&window->RepositoryCombo&&window->ArchitectureCombo){
            gtk_widget_set_sensitive(window->StorageCombo,0);
            gtk_widget_set_sensitive(window->RepositoryCombo,0);
            gtk_widget_set_sensitive(window->ArchitectureCombo,0);
        }
    }
}

void on_move_add_package(GtkWidget *self, repo_add_window *window){
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->MoveTargetArchEntry))>-1&&gtk_combo_box_get_active(GTK_COMBO_BOX(window->MoveSourceStorageEntry))>-1){
        file_chooser_window *dialog = yon_file_chooser_window_new();
        yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->MainWindow),TITLE_LABEL,icon_path,"ChooseMoveFileChooserWindow");
        GtkFileFilter *filter = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter,"*.pkg.tar*[^.sig]");
        gtk_file_filter_set_name(filter,"*.pkg.tar.*");
        gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog->FileChooserWidget),filter);
        GtkTreeIter iter,itar;
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveSourceArchEntry),GTK_TREE_MODEL(window->tree_copy),&iter);
        char *target;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&target,3,&dialog->root_path,-1);
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog->FileChooserWidget),target);

        dictionary *dict = NULL;
        yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
        yon_dictionary_add_or_create_if_exists_with_data(dict,"dialog",dialog);

        g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"current-folder-changed",G_CALLBACK(on_folder_changed),dialog);
        g_signal_connect(G_OBJECT(dialog->ChooseButton),"clicked",G_CALLBACK(on_move_add_accept),dict);
        gtk_widget_show(dialog->Window);
    }
}

void on_move_remove_package(GtkWidget *self, repo_add_window *window){
    GtkTreeIter iter;
    GtkTreeModel *model;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->PackagesTree)),&model,&iter)){
        gtk_list_store_remove(window->PackagesList,&iter);
    }
    if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->PackagesList),&iter)){

        gtk_widget_set_sensitive(window->MoveSourceStorageEntry,1);
        gtk_widget_set_sensitive(window->MoveSourceRepoEntry,1);
        gtk_widget_set_sensitive(window->MoveSourceArchEntry,1);

        gtk_widget_set_sensitive(window->MoveTargetRepoEntry,1);
        if (window->StorageCombo&&window->RepositoryCombo&&window->ArchitectureCombo){
            gtk_widget_set_sensitive(window->StorageCombo,1);
            gtk_widget_set_sensitive(window->RepositoryCombo,1);
            gtk_widget_set_sensitive(window->ArchitectureCombo,1);
        }
    }
}

void on_move_accept(GtkWidget *self, repo_add_window *window){
    int size = 0;
    config_str packages = NULL;
    GtkTreeIter iter,itar;
    for_iter(GTK_TREE_MODEL(window->PackagesList),&iter){
        char *target=NULL;
        gtk_tree_model_get(GTK_TREE_MODEL(window->PackagesList),&iter,2,&target,-1);
        if (!yon_char_is_empty(target)){
            free(yon_char_divide(target,yon_char_find_last(target,'/')));
            yon_char_parsed_add_or_create_if_exists(packages,&size,target);
            free(target);
        }
    }
    if (size){
        char *arch = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->MoveSourceArchEntry));
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveSourceRepoEntry),GTK_TREE_MODEL(window->tree_copy),&iter);
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveTargetRepoEntry),GTK_TREE_MODEL(window->tree_copy),&itar);
        char *source_path, *source_repo, *target_path, *target_repo;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&source_repo,-1);
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,3,&target_repo,-1);
        source_path = yon_char_divide(source_repo,yon_char_find_last(source_repo,'/'));
        target_path = yon_char_divide(target_repo,yon_char_find_last(target_repo,'/'));
        char *command = yon_move_packages_command(source_path,arch,source_repo, target_repo, yon_char_parsed_to_string(packages,size," "));
        yon_debug_output("%s\n",command);
        if (!system(command)){
            yon_ubl_status_box_render(PACKAGES_MOVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
            on_subwindow_close(window->MainWindow);
        }
    } else {
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_TO_SAVE_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE); 
    }
}

void on_move_clicked(GtkWidget *self, main_window *widgets){
    repo_add_window *window = yon_repo_add_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),TITLE_LABEL,icon_path,"move-repo-window");
    gtk_widget_show(window->MoveSourceFrame);
    gtk_widget_show(window->MoveTargetFrame);
    gtk_widget_hide(gtk_widget_get_parent(window->PackageSignCombo));
    GtkTreeIter iter;
    for_iter (window->tree_copy,&iter){
        char *current;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
        if (!yon_char_is_empty(current)){
            char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveSourceStorageEntry),path,current);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveTargetStorageEntry),path,current);
        }
    }

    yon_sign_list_update();
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->PackageSignCombo),0);

    gtk_widget_destroy(gtk_widget_get_parent(window->StorageCombo));
    g_signal_connect(G_OBJECT(window->MoveSourceStorageEntry),"changed",G_CALLBACK(on_move_storage_changed),window);
    g_signal_connect(G_OBJECT(window->MoveSourceRepoEntry),"changed",G_CALLBACK(on_move_repo_changed),window);
    g_signal_connect(G_OBJECT(window->MoveSourceArchEntry),"changed",G_CALLBACK(on_move_arch_changed),window);

    g_signal_connect(G_OBJECT(window->MoveTargetRepoEntry),"changed",G_CALLBACK(on_move_repo_changed),window);
    g_signal_connect(G_OBJECT(window->MoveTargetArchEntry),"changed",G_CALLBACK(on_move_arch_changed),window);

    g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_move_add_package),window);
    g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_move_remove_package),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_move_accept),window);
    g_signal_connect(G_OBJECT(window->MoveSourceRepoEntry),"changed",G_CALLBACK(on_repo_sign_load),window);
    gtk_widget_show(window->MainWindow);
}

void on_remove_add_package(GtkWidget *self, repo_add_window *window){
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ArchitectureCombo))>-1){
        file_chooser_window *dialog = yon_file_chooser_window_new();
        yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->MainWindow),TITLE_LABEL,icon_path,"ChooseMoveFileChooserWindow");
        GtkFileFilter *filter = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter,"*.pkg.tar*[^.sig]");
        gtk_file_filter_set_name(filter,"*.pkg.tar.*");
        gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog->FileChooserWidget),filter);
        GtkTreeIter iter,itar;
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->ArchitectureCombo),GTK_TREE_MODEL(window->tree_copy),&iter);
        char *target;
        int temp_size=0;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&target,-1);
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->ArchitectureCombo),GTK_TREE_MODEL(window->tree_copy),&itar);
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,3,&dialog->root_path,-1);
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog->FileChooserWidget),target);

        dictionary *dict = NULL;
        yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
        yon_dictionary_add_or_create_if_exists_with_data(dict,"dialog",dialog);

        g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"current-folder-changed",G_CALLBACK(on_folder_changed),dialog);
        g_signal_connect(G_OBJECT(dialog->ChooseButton),"clicked",G_CALLBACK(on_move_add_accept),dict);
        gtk_widget_show(dialog->Window);
    }
}

void on_remove_arch_selection_changed(GtkWidget *self, repo_add_window *window){
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ArchitectureCombo))==-1){
        gtk_widget_set_sensitive(window->AddPackageButton,0);
    } else {
        gtk_widget_set_sensitive(window->AddPackageButton,1);
    }
}

void on_remove_accept(GtkWidget *self, repo_add_window *window){
    GtkTreeModel *model;
    GtkTreeIter iter;
    const char *storage_id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StorageCombo));
    char *storage_path;
    char *repo = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->RepositoryCombo));
    char *arch = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->ArchitectureCombo));

    if (!yon_char_is_empty(storage_id)){
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,storage_id);
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&storage_path,-1);
        int size;
        config_str packages=NULL;
        for_iter(GTK_TREE_MODEL(window->PackagesList),&iter){
            char *target;
            gtk_tree_model_get(GTK_TREE_MODEL(window->PackagesList),&iter,1,&target,-1);
            yon_char_parsed_add_or_create_if_exists(packages,&size,target);
        }
        if (size){
            char *sign = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->RepoSignCombo));
            char *command;
            if (yon_char_is_empty(sign)){
                command = yon_delete_packages_command(storage_path,arch,repo,yon_char_parsed_to_string(packages,size," "));
            } else {
                command = yon_delete_packages_sign_command(storage_path,arch,repo,yon_char_parsed_to_string(packages,size," "),sign);
            }
            yon_debug_output("%s\n",command);
            if (!system(command)){
                yon_ubl_status_box_render(PACKAGES_MOVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
            }
        } else {
            yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_TO_SAVE_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE); 
            return;
        }
    }else {
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_TO_SAVE_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        return;
    }
    gtk_widget_destroy(window->MainWindow);
}

void on_remove_clicked(GtkWidget *self, main_window *widgets){
    repo_add_window *window = yon_repo_add_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),TITLE_LABEL,icon_path,"add-repo-window");
    GtkTreeIter iter;
    for_iter (window->tree_copy,&iter){
        char *current;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
        if (!yon_char_is_empty(current)){
            char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StorageCombo),path,current);
        }
    }
    yon_sign_list_update();
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);

    gtk_widget_hide(gtk_widget_get_parent(window->PackageSignCombo));

    gtk_button_set_label(GTK_BUTTON(window->AddButton),REMOVE_PACKAGES_TOOLTIP_LABEL);

    g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_arch_chosen),window);
    g_signal_connect(G_OBJECT(window->StorageCombo),"changed",G_CALLBACK(on_add_target_repo_selection_changed),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_add_target_arch_selection_changed),window);
    g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_remove_arch_selection_changed),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_remove_accept),window);
    g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_remove_add_package),window);
    g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_move_remove_package),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_repo_sign_load),window);
    gtk_widget_show(window->MainWindow);
}

    /*      setup functions     */
void config_init(){
    main_config.tree_store=NULL;
    main_config.always_open_documentation=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.signs=NULL;
    main_config.signs_size=0;
    yon_sign_list_update();
}

void yon_config_load_update(main_window *widgets){
    gsize size=0;
    config_str storages = yon_window_config_get_section("storage_info",&size);
    GtkTreeIter iter,itar,childiter;
    for (int i=0;i<size;i++){
        char *name = yon_char_new(storages[i]);
        free(yon_char_divide(name,yon_char_find_last(name,'/')));
        gtk_tree_store_append(widgets->RepoList,&iter,NULL);
        gtk_tree_store_set(widgets->RepoList,&iter,2,name,3,storages[i],-1);
        free(name);
        yon_window_config_get_parameter("storage_info",storages[i],&name,YON_TYPE_STRING);
        if (!yon_char_is_empty(name)){
            int parsed_size;
            config_str name_parsed = yon_char_parse(name,&parsed_size,",");
            for (int j=0;j<parsed_size;j++){
                char *nm = yon_char_new(name_parsed[j]);
                free(yon_char_divide(nm,yon_char_find_last(nm,'/')));
                gtk_tree_store_append(widgets->RepoList,&itar,&iter);
                gtk_tree_store_set(widgets->RepoList,&itar,3,name_parsed[j],2,nm,-1);
                int size;
                config_str dirs = yon_file_list_dirs(name_parsed[j],&size);
                for (int k=0;k<size;k++){
                    if (strcmp(dirs[k],"pool")&&strcmp(dirs[k],nm)){
                        char *arch_path = yon_char_unite(name_parsed[j],"/",dirs[k],NULL);
                        gtk_tree_store_append(widgets->RepoList,&childiter,&itar);
                        gtk_tree_store_set(widgets->RepoList,&childiter,2,dirs[k],3,arch_path,-1);
                    }
                }
                free(nm);
            }
            yon_char_parsed_free(name_parsed,parsed_size);
        }
        
    }
    if (size)
    yon_char_parsed_free(storages,size);
}

void on_main_tree_selection_changed(GtkWidget *self, main_window *widgets){
    gtk_list_store_clear(widgets->RepoFileList);
    GtkTreeIter iter,itar;
    GtkTreeModel *model=NULL;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter)){
        GtkTreePath *path = gtk_tree_model_get_path(model,&iter);
        int depth = gtk_tree_path_get_depth(path);
        char *target;
        gtk_tree_model_get(model, &iter,3,&target,-1);
        switch (depth){
            case 1:{
                int lvlsize;
                config_str level = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&lvlsize,2,2);
                for (int i=0;i<lvlsize;i++){
                    gtk_list_store_append(widgets->RepoFileList,&itar);
                    gtk_list_store_set(widgets->RepoFileList,&itar,1,level[i],-1);
                }

            }
                break;
            case 2:{
                int lvlsize;
                config_str level = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&lvlsize,2,3);
                for (int i=0;i<lvlsize;i++){
                    gtk_list_store_append(widgets->RepoFileList,&itar);
                    gtk_list_store_set(widgets->RepoFileList,&itar,1,level[i],-1);
                }

            }
                break;
            case 3:{
                char *packages;
                int size;
                config_str parsed = yon_file_ls(target,&size);
                    for (int i=0;i<size;i++){
                        if (strstr(parsed[i],".tar.")&&!strstr(parsed[i],".files.")&&!strstr(parsed[i],".db.")&&!strstr(parsed[i],".sig")){
                        int load_size;
                        char *name = yon_char_unite(target,"/",parsed[i],NULL);
                        config_str load = yon_config_load(yon_get_package_name_from_filename(name),&load_size);
                        if (load_size>0){
                            gtk_list_store_append(widgets->RepoFileList,&itar);
                            yon_char_remove_last_symbol(load[0],'\n');
                            char *temp = load[0];
                            free(name);
                            name=temp;
                            gtk_list_store_set(widgets->RepoFileList,&itar,1,name,3,parsed[i],-1);
                            yon_char_parsed_free(load,load_size);
                            }
                        }
                    }
                }
            break;
        }
    }
}

void on_package_selection_changed(GtkWidget *self, main_window *widgets){
    gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),"");
    GtkTreeIter iter,itar;
    GtkTreeModel *model, *model2;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model,&iter)){
        gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model2,&itar);
        switch (gtk_tree_store_iter_depth(widgets->RepoList,&itar)){
            case 0:
                break;
            case 1:
                break;
            case 2:
                char *path, *filename;
                gtk_tree_model_get(model,&iter,3,&filename,-1);
                gtk_tree_model_get(model2,&itar,3,&path,-1);
                int size;
                config_str parsed = yon_config_load(get_package_info_command(yon_char_unite(path,"/",filename,NULL)),&size);
                char *full = yon_char_parsed_to_string(parsed,size,"");
                gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),full);
                yon_char_parsed_free(parsed,size);
                free(full);
            break;
        }
    }
}

void yon_combo_box_text_set_signs(GtkComboBoxText *target){
    g_return_if_fail(GTK_IS_COMBO_BOX_TEXT(target));
    gtk_combo_box_text_remove_all(target);
    gtk_combo_box_text_append_text(target,DO_NOT_SIGN_LABEL);
    for (int i=0;i<main_config.signs_size;i++){
        char *temp = yon_char_new(main_config.signs[i]);
        free(yon_char_divide_search(temp,"<",-1));
        yon_char_remove_last_symbol(temp,'>');
        gtk_combo_box_text_append(target,temp,main_config.signs[i]);
        free(temp);
    }
}

void yon_sign_list_update(){
    if (main_config.signs&&main_config.signs_size) yon_char_parsed_free(main_config.signs,main_config.signs_size);
    main_config.signs = yon_config_load(get_gpg_keys_command,&main_config.signs_size);
    for (int i=0;i<main_config.signs_size;i++){
        yon_char_remove_last_symbol(main_config.signs[i],'\n');
    }
}

void on_ubl_settings_update_launch(){
    yon_launch_app_with_arguments("ubl-settings-update",NULL);
}

void on_calendar_open(GtkWidget *self,key_creation_window *window){
    yon_calendar_popover_open(GTK_ENTRY(window->ExpireEntry),self);
}

void on_key_generate_accept(GtkWidget *self, key_creation_window* window){
    const char *name = gtk_entry_get_text(GTK_ENTRY(window->NameEntry));
    const char *type = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->EncryptionCombo));
    const char *email = gtk_entry_get_text(GTK_ENTRY(window->EmailEntry));
    char *strength = yon_char_from_long(gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->KeyStrengthSpin)));
    const char *comment = gtk_entry_get_text(GTK_ENTRY(window->CommentsEntry));
    GtkWidget *highlight_target=NULL;
    if (yon_char_is_empty(name)){
        highlight_target=window->NameEntry;
    } else if (yon_char_is_empty(type)){
        highlight_target=window->EncryptionCombo;
    } else if (yon_char_is_empty(email)){
        highlight_target=window->EmailEntry;
    } else if (yon_char_is_empty(strength)){
        highlight_target=window->KeyStrengthSpin;
    } else if (yon_char_is_empty(comment)){
        highlight_target=window->CommentsEntry;
    }
    if (highlight_target){
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        yon_ubl_status_highlight_incorrect(highlight_target);
        return;
    }
    char *expire = NULL;
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ExpireCombo))==1){
        expire = yon_char_from_int(yon_calendar_get_last_date());
    }
    const char *password = gtk_entry_get_text(GTK_ENTRY(window->PasswordEntry));
    const char *password_confirm = gtk_entry_get_text(GTK_ENTRY(window->PasswordConfirmationEntry));
    int ex_status=0;
    if (yon_char_is_empty(password)&&yon_char_is_empty(password_confirm)){
        ex_status = system(yon_generate_key_no_password_command(type,name,email,strength,comment,expire,password));
    } else if (!strcmp(password,password_confirm)){
        ex_status = system(yon_generate_key_command(type,name,email,strength,comment,expire,password));
    } else {
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),PASSWORD_INCORRECT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        return;
    }
    if (!ex_status)
        yon_ubl_status_box_render(KEY_CREATION_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    else 
        yon_ubl_status_box_render(KEY_CREATION_FAILURE_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    gtk_widget_destroy(window->Window);
    yon_sign_list_update();
}

key_creation_window *yon_key_creation_window_new(){
    key_creation_window *window = malloc(sizeof(key_creation_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_key);
    window->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->HeadLabel = yon_gtk_builder_get_widget(builder,"HeadLabel");
    window->NameEntry = yon_gtk_builder_get_widget(builder,"NameEntry");
    window->EmailEntry = yon_gtk_builder_get_widget(builder,"EmailEntry");
    window->CommentsEntry = yon_gtk_builder_get_widget(builder,"CommentsEntry");
    window->EncryptionCombo = yon_gtk_builder_get_widget(builder,"EncryptionCombo");
    window->KeyStrengthSpin = yon_gtk_builder_get_widget(builder,"KeyStrengthSpin");
    window->ExpireCombo = yon_gtk_builder_get_widget(builder,"ExpireCombo");
    window->ExpireEntry = yon_gtk_builder_get_widget(builder,"ExpireEntry");
    window->ExpireButton = yon_gtk_builder_get_widget(builder,"ExpireButton");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
    window->PasswordEntry = yon_gtk_builder_get_widget(builder,"PasswordEntry");
    window->PasswordConfirmationEntry = yon_gtk_builder_get_widget(builder,"PasswordConfirmationEntry");

    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->ExpireButton),"clicked",G_CALLBACK(on_calendar_open),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_key_generate_accept),window);

    int size;
    config_str encription_keys = yon_file_open(key_encription_path,&size);
    window->expire_time=0;

    for (int i=1;i<size;i++){
        yon_char_remove_last_symbol(encription_keys[i],'\n');
        int parsed_size;
        config_str parsed = yon_char_parse(encription_keys[i],&parsed_size,";");
        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->EncryptionCombo),parsed[2],parsed[0]);
        yon_char_parsed_free(parsed,parsed_size);
    }
    return window;
}

void on_key_clicked(GtkWidget *self, main_window *widgets){
    key_creation_window *window = yon_key_creation_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window),TITLE_LABEL,icon_path,"key-create-window");
    gtk_widget_show(window->Window);
}

main_window *yon_main_window_complete(main_window *widgets){ 
    widgets = yon_remalloc(widgets,sizeof(main_window)); 
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path); 
    gtk_box_pack_start(GTK_BOX(widgets->InterfaceBox),yon_gtk_builder_get_widget(builder,"BoxMain"),1,1,0); 
    // Custom widgets configuration 
    {
        widgets->UpdateButton = yon_gtk_builder_get_widget(builder,"UpdateButton");
        widgets->DBConfigurationButton = yon_gtk_builder_get_widget(builder,"DBConfigurationButton");
        widgets->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
        widgets->MoveButton = yon_gtk_builder_get_widget(builder,"MoveButton");
        widgets->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
        widgets->CloudButton = yon_gtk_builder_get_widget(builder,"CloudButton");

        widgets->ReposTree = yon_gtk_builder_get_widget(builder,"ReposTree");
        widgets->SearchEntry = yon_gtk_builder_get_widget(builder,"SearchEntry");
        widgets->RepoFileTree = yon_gtk_builder_get_widget(builder,"RepoFileTree");
        widgets->RepoPackagesTree = yon_gtk_builder_get_widget(builder,"RepoPackagesTree");
        widgets->InformationLabel = yon_gtk_builder_get_widget(builder,"InformationLabel");

        widgets->RepoList = GTK_TREE_STORE(gtk_builder_get_object(builder,"RepoStore"));
        widgets->RepoFileList = GTK_LIST_STORE(gtk_builder_get_object(builder,"RepoFileList"));
        widgets->RepoPackagesTre = GTK_LIST_STORE(gtk_builder_get_object(builder,"RepoPackagesTre"));
        {
            widgets->KeyMenuItem = gtk_menu_item_new();
            gtk_menu_shell_prepend(GTK_MENU_SHELL(gtk_widget_get_parent(widgets->AboutMenuItem)),widgets->KeyMenuItem);
            GtkWidget *icon = gtk_image_new_from_icon_name(key_icon_name,GTK_ICON_SIZE_BUTTON);
            GtkWidget *label = gtk_label_new(KEY_LABEL);
            GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
            gtk_box_pack_start(GTK_BOX(box),icon,0,0,5);
            gtk_box_pack_start(GTK_BOX(box),label,0,0,5);
            gtk_container_add(GTK_CONTAINER(widgets->KeyMenuItem),box);
            gtk_widget_show_all(widgets->KeyMenuItem);
            gtk_style_context_add_class(gtk_widget_get_style_context(widgets->KeyMenuItem),"menuitemtop");
            gtk_style_context_remove_class(gtk_widget_get_style_context(widgets->DocumentationMenuItem),"menuitemtop");
            gtk_style_context_add_class(gtk_widget_get_style_context(widgets->DocumentationMenuItem),"menuitemmiddle");
            g_signal_connect(G_OBJECT(widgets->KeyMenuItem),"activate",G_CALLBACK(on_key_clicked),widgets);
        }
        main_config.tree_store = widgets->RepoList;

        g_signal_connect(G_OBJECT(widgets->DBConfigurationButton),"clicked",G_CALLBACK(on_storage_configure_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->AddButton),"clicked",G_CALLBACK(on_add_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->MoveButton),"clicked",G_CALLBACK(on_move_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->RemoveButton),"clicked",G_CALLBACK(on_remove_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->ReposTree),"cursor-changed",G_CALLBACK(on_main_tree_selection_changed),widgets);
        g_signal_connect(G_OBJECT(widgets->CloudButton),"clicked",G_CALLBACK(on_ubl_settings_update_launch),widgets);
        g_signal_connect(G_OBJECT(widgets->RepoFileTree),"cursor-changed",G_CALLBACK(on_package_selection_changed),widgets);
        yon_calendar_set_date_orientation(1);
        gtk_window_set_title(GTK_WINDOW(widgets->Window),TITLE_LABEL);

        gtk_tree_view_set_search_entry(GTK_TREE_VIEW(widgets->RepoFileTree),GTK_ENTRY(widgets->SearchEntry));

        /* Widget registration for config monitoring | Регистрация виджетов для мониторинга конфига */
        /* Localisation | Локализация */
        gtk_widget_show(widgets->Window);
        return widgets;
    }
}

int main(int argc, char *argv[]){ 
    local=setlocale(LC_ALL, "");
    textdomain (LocaleName);
    config_init();
    
    yon_ubl_connect_config((_template_config*)&main_config); 
    yon_ubl_window_init(TITLE_LABEL,TITLE_INFO_LABEL,LocaleName,CssPath,LocaleName,version_application,WIKI_LINK);
	config_str unfound = NULL;
	int size=0;
	yon_ubl_setup_arguments(argc,argv,&unfound,&size,NULL);
    gtk_init(&argc,&argv);
    template_main_window *widgets = yon_ubl_window_setup(); 
    gtk_widget_hide(gtk_menu_get_attach_widget(GTK_MENU(gtk_widget_get_parent(widgets->SaveMenuItem))));
    gtk_widget_hide(gtk_menu_get_attach_widget(GTK_MENU(gtk_widget_get_parent(widgets->LoadGlobalMenuItem))));
    widgets = (template_main_window*)yon_main_window_complete((main_window*)widgets);
    char *path = yon_char_unite(yon_ubl_user_get_home_directory(),"/.config/",LocaleName,"/",LocaleName,".conf",NULL);
    yon_window_config_load(path);
    yon_config_load_update((main_window*)widgets);
        yon_ubl_status_box_render(DATA_LOADED_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    gtk_main();
    return 0;
}