/nobber/trunk

#pragma once

/*******
 * utils.h
 * These utility functions and macros can requiers nob.h
 *
 * You may use them as you see fit.
 *
 * This header file uses the standard STB-style inclue stuff:
 * define NOBBER_UTILS_IMPREMENTATION 
 * to in one file, so they get built.
 ******/

#include <stdlib.h>
#include <stdio.h>

#include <alloca.h>
#include <errno.h>
#include <linux/limits.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#include <inttypes.h>
#include <unistd.h>
#include <assert.h>
#if defined(__unix__) || defined(__linux__)
    #include <unistd.h>
#endif
#ifdef __darwin__
    #include <mach-o/dyld.h>
#endif

#include "nob.h"

#define IN /*Does nothing, just a mark.*/
#define OUT /*Does nothing, just a mark.*/
#define INOUT /*Does nothing, just a mark.*/

typedef struct da_strings_t DaStrings;

typedef enum NobberError {
    NOBBER_RETURN_NORMAL,
    NOBBER_RETURN_UNUSED0,
    NOBBER_RETURN_UNUSED1,
    NOBBER_RETURN_UNUSED2,
    NOBBER_RETURN_UNUSED3,
    NOBBER_RETURN_UNKNOWN_COMMAND,
    NOBBER_RETURN_EXEC,
    NOBBER_RETURN_COUNT
} NobberError;

void * malloc0 (size_t size);
char * strip_extention (IN char * file_name);
char * c_to_o_ext (IN char * str);
DaStrings * compile_files (IN char * source_files[], size_t source_files_len, IN char * build_flags[], size_t build_flags_len, INOUT Nob_Cmd * cmd, INOUT Nob_Procs * procs);
void link_files (IN DaStrings * object_files, IN char * exec_name, IN char * link_flags[], size_t link_flags_len, INOUT Nob_Cmd * cmd);
void clean_files (IN char * source_files[], size_t len, char * exec_name, INOUT Nob_Cmd * cmd);
char * construct_string (IN char * str, ...);
NobberError run_excutable (INOUT Nob_Cmd * cmd, IN char * executable);
char * get_path_of_current_executalbe ();
char ** split_string (IN char * str, char delimeter, OUT size_t * out_size);


//#define free0(ptr) \
//    free (ptr); \
//    ptr = NULL;
#define free0(ptr) \
    memset ((void *)ptr, 0, sizeof ((void *) ptr)); \
    free (ptr);

struct da_strings_t {
    char ** items;
    size_t count;
    size_t capacity;
};


/** 
 * free the items in a list propperly!
 * TODO: Need a version that takes a FreeFunc.
 **/
#define da_free_items(Type, da) { \
    for (Type *it = (da)->items; it < (da)->items + (da)->capacity; it++) { \
        if (*it == NULL) break;\
        free (*it);\
    }\
    free ((da)->items);\
}

#ifdef NOBBER_UTILS_IMPLEMENTAITON

/* ----------------- */

void * malloc0 (size_t size) {
    void * out_val = malloc (size);
    memset (out_val, 0, size);
    return out_val;
}


// https://stackoverflow.com/questions/43163677/how-do-i-strip-a-file-extension-from-a-string-in-c
char * strip_extention (IN char * file_name) {
    char * out_str = malloc(strlen(file_name) + 1);
    strcpy (out_str, file_name);
    char *end = out_str + strlen(out_str);

    while (end > out_str && *end != '.' && *end != '\\' && *end != '/') {
        --end;
    }

    if ((end > out_str && *end == '.') &&
            (*(end - 1) != '\\' && *(end - 1) != '/')) {
        *end = '\0';
    }

    return out_str;
}

char * c_to_o_ext (IN char * str) {
    char * out_str = malloc (strlen(str) + 1);
    char * tmp_str = strip_extention (str);
    sprintf (out_str, "%s.o", tmp_str); 
    free (tmp_str);
    return out_str;
}

DaStrings * compile_files (IN char * source_files[], size_t source_files_len,
                           IN char * build_flags[], size_t build_flags_len, 
                           INOUT Nob_Cmd * cmd, INOUT Nob_Procs * procs) {
    DaStrings * object_files = malloc0 (sizeof (DaStrings));
    for (size_t i = 0; i < source_files_len; i++) {
        cmd->count = 0;
        if (source_files[i] == NULL) break;
        nob_cmd_append (cmd, "cc");
        nob_cmd_append (cmd, source_files[i]);
        nob_da_append_many (cmd, build_flags, build_flags_len);
        nob_cmd_append (cmd, "-c");
        char * tmp_str = c_to_o_ext (source_files[i]);
        nob_cmd_append (cmd, "-o", tmp_str);

        char * s = malloc0 (strlen (tmp_str) + 1);
        strcpy (s, tmp_str);
        nob_da_append (object_files, s);

        nob_cmd_run (cmd, .async = procs);
        free0 (tmp_str);
    }
    return object_files;
}

void link_files (IN DaStrings * object_files, IN char * exec_name,
        IN char * link_flags[], size_t link_flags_len,
        INOUT Nob_Cmd * cmd) {
    nob_cmd_append (cmd, "cc");
    nob_cmd_append (cmd, "-o", exec_name);
    nob_da_append_many (cmd, (char**) object_files->items, object_files->count);
    nob_da_append_many (cmd, (char**) link_flags, link_flags_len);
    nob_cmd_run (cmd);
}

void clean_files (IN char * source_files[],  size_t len, char * exec_name, INOUT Nob_Cmd * cmd) {
    cmd->count = 0;
    DaStrings tmp_strings = {0};
    for (size_t i = 0; i < len; i++) {
        if (source_files[i] == NULL) break;
        char * tmp_file = strip_extention ((char *)source_files[i]);
        char * tmp_obj_file = c_to_o_ext (tmp_file);
        nob_da_append (&tmp_strings, tmp_obj_file);
        tmp_file = c_to_o_ext (tmp_file);
        free0 (tmp_file);
    }
    nob_cmd_append (cmd, "rm");
    nob_da_append_many (cmd, tmp_strings.items, tmp_strings.count);
    for (size_t i = 0; i < tmp_strings.count; i++) {
        char * s = tmp_strings.items[i];
        if (s == NULL) break;
    }
    nob_cmd_append (cmd, exec_name);
    nob_cmd_run (cmd);
    da_free_items (char *, &tmp_strings);
}

char * construct_string (IN char * str, ...) {
    char * retval = NULL;
    va_list list = {0};
    Nob_String_Builder sb = {0};
    nob_sb_append_cstr (&sb, str);
    va_start (list, str);
    while (*str++) {
        nob_sb_append_cstr (&sb, str);
    }
    va_end (list);
    Nob_String_View sv = nob_sv_from_parts (sb.items, sb.count);
    retval = malloc0 (strlen (sv.data) + 1);
    strcpy (retval, sv.data);
    return retval;
}

NobberError run_excutable (INOUT Nob_Cmd * cmd, IN char * executable) {
    // We assume we are only running from the current directory.
    char * cwd;
    NobberError ret_val = NOBBER_RETURN_NORMAL;
    strcat (cwd, "/");
    strcat (cwd, executable);
    return ret_val;
}

char * get_path_of_current_executalbe () {
    char buf[PATH_MAX];
#if  defined(__DragonFly__) || defined(__NetBSD__) || defined(__linux__)
    #if defined(__linux__)
    #define PROC_EXE_PATH "/proc/self/exe"
    #elif defined(__NetBSD__)
    #define PROC_EXE_PATH "/proc/curproc/exe"
    #elif defined(__DragonFly__)
    #endif
    if (readlink (PROC_EXE_PATH, buf, PATH_MAX) < 0) {
        fprintf (stderr, "[ERROR] Could not readlink /proc/self/exe: %s", strerror (errno));
        return NULL;
    }
#elif defined(__FreeBSD__)
    int mib[4];
    mib[0] = CTL_KERN;
    mib[1] = KERN_PROC;
    mib[2] = KERN_PROC_PATHNAME;
    mib[3] = -1;
    sysctl(mib, 4, buf, PATH_MAX, NULL, 0);
#elif defined(__darwin__)
    if (_NSGetExecutablePath(buf, PATH_MAX) < 0) {
        fprintf (stderr, "[ERROR] Could not get executable path.");
    }
#elif defined(WIN32)
    if (!GetModuleFileNameA (NULL, buf, MAX_PATH)) {
        fprintf (stderr, "[ERROR] Could not readlink /proc/self/exe: %s", strerror (errno));
        return NULL;
    }
#else
    static_assert (false, "get_path_of_current_executalbe () is not implemented for this platform.");
#endif
    char * ret = malloc (strlen (buf));
    strcpy(ret, buf);
    return ret;
}

char ** split_string (IN char * str, char deliminator, OUT size_t * out_size) {
    char * str_cpy = strndup (str, strlen (str));
    char * ptr = str_cpy;
    char delim[2] = {deliminator, 0};
    size_t no_of_tokens = 0;

    // Count the nuber of tokens
    while (*ptr) {
        if (*ptr == deliminator) {
            no_of_tokens++;
        }
        ptr++;
    }
    if (*(--ptr) != deliminator) {
        no_of_tokens++;
    }
    no_of_tokens++; // add empty space.
    
    char ** result = malloc0 (sizeof (char *) * no_of_tokens);
    if (result) {
        size_t idx = 0;
        char * tok_ptr = str_cpy;
  
        char * token = strtok (tok_ptr, delim);
        while (token) {
            result[idx] = strndup (token, strlen (token));
            token = strtok (NULL, delim);
            idx++;
        }
        result[idx] = 0;
    }
    *out_size = no_of_tokens - 1;
    free (str_cpy);
    return result;
}


#endif // NOBBER_UTILS_IMPLEMENTATION