/**
 * @author      : garhve (dev@garhve.com)
 * @file        : basic
 * @created     : Wednesday Dec 14, 2022 18:36:27 CST
 * @description : basic functions go here
 */

#include "tree.h"

// error and init and empty function
void error(const char * str)
{
    perror(str);
    exit(EXIT_FAILURE);
}

void init(regfile * head)
{
    head->node = NULL;
    head->next = NULL;
}

void empty(regfile * head)
{
    regfile * scan = head->next;

    while (head->next != NULL) {
        head->next = scan->next;
        free(scan->node->text);
        free(scan->node);
        free(scan);
        scan = head->next;
    }
}

bool checkdir(const char * d_name)
{
    struct stat st;
    stat(d_name,&st);

    return S_ISDIR(st.st_mode);
}

void allocText(char ** text, const char * str, size_t len)
{
    if (*text == NULL) {
        *text = (char *) calloc (len, sizeof(char));
        if (!*text)
            error("newly allocation failed");
        memmove(*text,str,len);
    }
}

size_t strsize(const char * str)
{
    size_t new = 0;
    while ( *(str+new) != '\0')
        new++;
    return new;
}

char * concat(const char * first, const char * second)
{
    size_t len1 = strsize(first);
    size_t len2 = strsize(second);
    char * text = (char *) calloc (len1+len2+2, sizeof(char)); // 1 for '\0', 1 for '/'
    memcpy(text,first,len1);
    memcpy(text+len1,"/",1);
    memcpy(text+len1+1,second,len2+1);

    return text;
}

nodes * addnodes(const char * d_name, size_t level)
{
    nodes * new = (nodes *) calloc (1,sizeof(nodes));
    if (!new)
        error("allocation for new node failed");

    new->len    = strsize(d_name);
    new->level  = level;
    new->fod    = checkdir(d_name);

    allocText(&new->text, d_name, new->len+1);

    return new;
}

void addreg(regfile * head, const char * d_name, size_t level)
{
    regfile * new = head;

    while (new->next)
        new = new->next;
    new->next = (regfile *) calloc (1,sizeof(regfile));

    if (!new->next)
        error("allocation for new regfile failed");
    new->next->node = addnodes(d_name, level);
    new->next->next = NULL;
}

void extractContent(regfile * head, const char * parent, size_t level)
{
    DIR * d = opendir(parent);
    struct dirent * dir;

    if (!d)
        error("failed to open directory\n");

    while ((dir = readdir(d))) {
        char * text = concat(parent,dir->d_name);

        if ((dir->d_name[0] == '.' && dir->d_name[1] == '.') || (dir->d_name[0] == '.' && dir->d_name[1] == '\0'))
            continue;
        if (checkdir(text) == false) {
            addreg(head, text, level);
        }   else {
            addreg(head, text, level);
            extractContent(head,text,level+1);
        }
        free(text);
    }
    closedir(d);
}

void getfile(regfile * head, const char * parent)
{
    init(head);
    addreg(head,parent,0);
    extractContent(head, parent, 1);
}