#include "model.h"

size_t check_null(size_t num) {
    if (num == 0) {
        return -1;
    }
    return num;
}

char* check_null_to_str(size_t num) {
    if (num == 0) {
        return yon_char_new("-");
    }
    return philos_char_from_size_t(num);
}

void model_clear_cfg(config_u_g_p* _config) {
    free(_config->quota);
    free(_config->size_memory);
    free(_config->device);
    free(_config->UNIX_file);
    free(_config->files);
    model_free_vector_string(&_config->actors);
    vectorFree(&_config->actors);
    free(_config->loaded_keys);
}

void model_clear_cfg_device(disk_status* _config) {
    free(_config->device);
    free(_config->fs);
    free(_config->mount_point);
    free(_config->name);
}

void model_free_vector_string(vector* vec_str) {
    if (vec_str) {
        if (vec_str->vectorList.total> 0) {
            for (int i = 0; i < vec_str->vectorList.total; i++) {
                vectorDelete(vec_str, i);
            }
        }
    }
}

void model_tree_view_add(config_u_g_p* _config) {
    model_null_str_writing(_config);
}

void model_null_str_writing(config_u_g_p* _config) {
    _config->type_arr = yon_char_new(empty_str);
    _config->quota = yon_char_new(empty_str);
    _config->size_memory = yon_char_new(empty_str);
    _config->device = yon_char_new(empty_str);
    _config->UNIX_file = yon_char_new(empty_str);
    _config->files = yon_char_new(empty_str);
    _config->loaded_keys = yon_char_new(empty_str);
    _config->type_arr = yon_char_new(empty_str);
    _config->id = 0;
    _config->soft_restriction_size = 0;
    _config->soft_restriction_file = 0;
    _config->severe_limitation_size = 0;
    _config->severe_limitation_file = 0;
    _config->deferring_size = 0;
    _config->deferring_file = 0;
    _config->size_memory_pow = 0;
    _config->soft_restriction_size_pow = 0;
    _config->severe_limitation_size_pow = 0;
    vector_init(&_config->actors);
}

char* format_actors(vector* vec_actors) {
    char* str_all = yon_char_new("");
    char split_simvol[2] = {0};
    split_simvol[0] = 0;
    split_simvol[1] = 0;
    char* str_actors = NULL;
    if (vec_actors->vectorList.total> 0) {
        for (int i = 0; i < vec_actors->vectorList.total; i++) {
            str_actors = (char*)vec_actors->pfVectorGet(vec_actors, i);
            if (str_actors) {
                str_all = yon_char_unite(str_all,split_simvol, str_actors, NULL);
                split_simvol[0] = ',';
                split_simvol[1] = '\0';
            }
        }
    }
    
    if (strlen(str_all) < 3) {
        return yon_char_new("-");
    }
    return str_all;
}

int fill_tree_view_project(config_all* all_config,hotebook* widget , char* str_fill, int flag_gui_add) {
    GtkTreeModel *model = GTK_TREE_MODEL(widget->liststore);
    if (flag_gui_add == 0) {
        g_object_ref(widget->liststore);
        gtk_list_store_clear(widget->liststore);
    }
    int flag_searhc = 0;
    for (int i = 0; i < all_config->v_project.pfVectorTotal(&all_config->v_project); i++) {
        config_u_g_p* _config = (config_u_g_p*)all_config->v_project.pfVectorGet(&all_config->v_project, i);
        if (strcmp(_config->type_arr, str_fill) == 0) {
            GtkTreeIter iter;
            flag_searhc++;
            gtk_list_store_append(widget->liststore,&iter);
            char* deferring_size = wrapper_str_time(_config->deferring_size);
            char* deferring_file = wrapper_str_time(_config->deferring_file);
            gtk_list_store_set(widget->liststore,&iter,
                    0,fill_tree_view_id(_config->id),
                    1,_config->UNIX_file,
                    2,format_actors(&_config->actors),
                    3,philos_format_cfg_str_size_memory("", check_null(_config->soft_restriction_size),_config->soft_restriction_size_pow),
                    4,philos_format_cfg_str_size_memory("", check_null(_config->severe_limitation_size),_config->severe_limitation_size_pow),
                    5,deferring_size,
                    6,check_null_to_str(_config->soft_restriction_file),
                    7,check_null_to_str(_config->severe_limitation_file),
                    8,deferring_file,
                    -1);
        
        }
    }
    if (flag_gui_add != 0) {
        gtk_tree_view_set_model(GTK_TREE_VIEW(widget->tree_view), model);
    }
    return flag_searhc;
}

int fill_tree_view_user_group(config_all* all_config, hotebook* widget, char* str_fill ,int flag_gui_add) {
    GtkTreeModel *model = GTK_TREE_MODEL(widget->liststore);
    if (flag_gui_add == 0) {
        g_object_ref(widget->liststore);
        gtk_list_store_clear(widget->liststore);
    }
    int flag_searhc = 0;
    vector* vec_temp = NULL;
    if (strcmp(str_fill, "usrquota")==0) {
        vec_temp = &all_config->v_user;
    }
    else {
        vec_temp = &all_config->v_group;
    }
    if (vec_temp->vectorList.total > 0) {
        for (int i = 0; i < vec_temp->vectorList.total; i++) {
            config_u_g_p* _config = (config_u_g_p*)vec_temp->pfVectorGet(vec_temp, i);
            if (strcmp(_config->type_arr, str_fill) == 0) {
                GtkTreeIter iter;
                flag_searhc++;
                gtk_list_store_append(widget->liststore,&iter);
                char* deferring_size = wrapper_str_time(_config->deferring_size);
                char* deferring_file = wrapper_str_time(_config->deferring_file);
                gtk_list_store_set(widget->liststore,&iter,
                                0,format_actors(&_config->actors),
                                1,_config->UNIX_file,
                                2,philos_format_cfg_str_size_memory("", check_null(_config->soft_restriction_size),_config->soft_restriction_size_pow),
                                3,philos_format_cfg_str_size_memory("", check_null(_config->severe_limitation_size),_config->severe_limitation_size_pow),
                                4,deferring_size,
                                5,check_null_to_str(_config->soft_restriction_file),
                                6,check_null_to_str(_config->severe_limitation_file),
                                7,deferring_file,
                                -1);
            }
        }
    }
    if (flag_gui_add != 0) {
        gtk_tree_view_set_model(GTK_TREE_VIEW(widget->tree_view), model);
    }
    return flag_searhc;
}

char* wrapper_str_time(size_t seconds) {
    me_time t;
    if (seconds>0) {
        t = time_convert(seconds);
        t.str_time =  yon_char_unite(yon_char_from_int(t.weeks),WEEKS, 
                yon_char_from_int(t.days), DAYS,
                yon_char_from_int(t.hours), HOURS,
                yon_char_from_int(t.minutes), MINUTES, NULL);
    }
    else {
        t.str_time = yon_char_new("-");
    }
    
    return t.str_time;
}

char* quota_type(char* str_quota) {
    if (strcmp(str_quota, "usrquota")==0) {
        return STR_USER;
    }
    else if (strcmp(str_quota, "grpquota")==0) {
        return STR_GROUP;
    }
    else if (strcmp(str_quota, "prjquota")==0) {
        return STR_PROJECT;
    }
}
char quota_fill_generate(char* str_quota, config_u_g_p* _config, GtkListStore* list_store, GtkTreeIter* iter) {
    int index = -1;
    if (strcmp(str_quota, "usrquota")==0) {
        index = 4;
    }
    else if (strcmp(str_quota, "grpquota")==0) {
        index = 5;
    }
    else if (strcmp(str_quota, "prjquota")==0) {
        index = 6;
    }
    if (index != -1) {
        gtk_list_store_set(list_store,iter,index,format_actors(&_config->actors), -1);
    }
    
}

int pars_status_generate(vector* vec_status, char* disk) {
    int flag = -1;
    if (vec_status->vectorList.total > 0) {
        for (int i = 0; i < vec_status->vectorList.total; i++) {
            disk_status* _config = (disk_status*)vec_status->pfVectorGet(vec_status, i);
            if (strstr(_config->device, disk)) {
                flag=1;
            }
        }
    }
    if (flag<0) {
        return 1;
    }
    return flag;
}

int fill_tree_view_generate(vector* vec_fill, vector* vec_status_disk, char* str_fill, GtkWidget* tree_view, GtkListStore* liststoreGeneral) {
    GtkTreeModel *model = GTK_TREE_MODEL(liststoreGeneral);
    if (vec_fill->vectorList.total > 0) {
        for (int i = 0; i < vec_fill->vectorList.total; i++) {
            config_u_g_p* _config = (config_u_g_p*)vec_fill->pfVectorGet(vec_fill, i);
            GtkTreeIter iter;
            gtk_list_store_append(liststoreGeneral,&iter);
            char* deferring_size = wrapper_str_time(_config->deferring_size);
            char* deferring_file = wrapper_str_time(_config->deferring_file);
            quota_fill_generate(str_fill, _config,liststoreGeneral,&iter);
            gtk_list_store_set(liststoreGeneral,&iter,
                    0,pars_status_generate(vec_status_disk,_config->UNIX_file),
                    1,_config->quota,
                    2,quota_type(str_fill),
                    3,_config->UNIX_file,
                    7,philos_format_cfg_str_size_memory("", check_null(_config->soft_restriction_size),_config->soft_restriction_size_pow),
                    8,philos_format_cfg_str_size_memory("", check_null(_config->severe_limitation_size),_config->severe_limitation_size_pow),
                    9,deferring_size,
                    10,check_null_to_str(_config->soft_restriction_file),
                    11,check_null_to_str(_config->severe_limitation_file),
                    12,deferring_file,
                    -1);
        }
    }
    gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), model);
    return 1;
}

int pars_status_device(disk_status* _config) {
    if (_config->status == 2) {
        return 1;
    }
    return 0;
}

int fill_tree_view_device(vector* vec_device, hotebook* widget, int flag_gui_add) {
    GtkTreeModel *model = GTK_TREE_MODEL(widget->liststore);
    if (flag_gui_add == 0) {
        g_object_ref(widget->liststore);
        gtk_list_store_clear(widget->liststore);
    }
    int flag_searhc = 0;
    if (vec_device->vectorList.total > 0) {
        for (int i = 0; i < vec_device->vectorList.total; i++) {
            disk_status* _config = (disk_status*)vec_device->pfVectorGet(vec_device, i);
            GtkTreeIter iter;
            flag_searhc++;
            gtk_list_store_append(widget->liststore,&iter);
            char* deferring_size = wrapper_str_time(_config->deferring_size);
            char* deferring_file = wrapper_str_time(_config->deferring_file);
            gtk_list_store_set(widget->liststore,&iter,
                            0,pars_status_device(_config),
                            1,_config->device,
                            2,_config->mount_point,
                            3,_config->fs,
                            4,_config->name,
                            5,deferring_size,
                            6,deferring_file,
                            -1);
        }
    }
    if (flag_gui_add != 0) {
        gtk_tree_view_set_model(GTK_TREE_VIEW(widget->tree_view), model);
    }
    return flag_searhc;
}