path: root/src/path.c

#include "path.h"

#include "util.h"

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

extern char *realpath(const char *restrict path, char *restrict resolved_path);

int ecex_path_copy(char *out, size_t out_size, const char *text) {
    if (!out || out_size == 0) return -1;
    if (!text) text = "";
    size_t len = strlen(text);
    if (len >= out_size) {
        memcpy(out, text, out_size - 1);
        out[out_size - 1] = '\0';
        return -1;
    }
    memcpy(out, text, len + 1);
    return 0;
}

char *ecex_path_expand_user(const char *path) {
    if (!path) return NULL;
    if (path[0] != '~' || (path[1] != '\0' && path[1] != '/')) {
        return ecex_strdup(path);
    }

    const char *home = getenv("HOME");
    if (!home || !home[0]) {
        return ecex_strdup(path);
    }

    size_t home_len = strlen(home);
    size_t rest_len = strlen(path + 1);
    char *expanded = malloc(home_len + rest_len + 1);
    if (!expanded) return NULL;
    memcpy(expanded, home, home_len);
    memcpy(expanded + home_len, path + 1, rest_len + 1);
    return expanded;
}

char *ecex_path_join(const char *dir, const char *name) {
    if (!name) return NULL;
    if (name[0] == '/') {
        return ecex_strdup(name);
    }
    if (!dir || !dir[0]) dir = ".";

    size_t dl = strlen(dir);
    size_t nl = strlen(name);
    int need_slash = dl > 0 && dir[dl - 1] != '/';
    char *out = malloc(dl + (size_t)need_slash + nl + 1);
    if (!out) return NULL;
    memcpy(out, dir, dl);
    if (need_slash) out[dl++] = '/';
    memcpy(out + dl, name, nl + 1);
    return out;
}

char *ecex_path_dirname(const char *path) {
    if (!path || !path[0]) {
        return ecex_strdup(".");
    }

    char *expanded = ecex_path_expand_user(path);
    if (!expanded) return NULL;

    size_t len = strlen(expanded);
    while (len > 1 && expanded[len - 1] == '/') expanded[--len] = '\0';

    char *slash = strrchr(expanded, '/');
    if (!slash) {
        strcpy(expanded, ".");
    } else if (slash == expanded) {
        expanded[1] = '\0';
    } else {
        *slash = '\0';
    }
    return expanded;
}

char *ecex_path_basename_dup(const char *path) {
    const char *base = "untitled";
    if (path && path[0]) {
        const char *slash = strrchr(path, '/');
        if (slash && slash[1]) base = slash + 1;
        else if (slash && slash == path) base = "/";
        else base = path;
    }
    return ecex_strdup(base);
}

char *ecex_path_normalize(const char *path) {
    char *expanded = ecex_path_expand_user(path);
    if (!expanded) return NULL;

    char *resolved = realpath(expanded, NULL);
    if (resolved) {
        free(expanded);
        return resolved;
    }

    if (expanded[0] == '/') return expanded;

    char cwd[4096];
    if (!getcwd(cwd, sizeof(cwd))) return expanded;
    char *joined = ecex_path_join(cwd, expanded);
    free(expanded);
    return joined;
}

static int ecex_project_root_has_marker(const char *dir) {
    static const char *const markers[] = {
        ".git",
        "compile_commands.json",
        "compile_flags.txt",
        ".ecex-project",
    };

    for (size_t i = 0; i < sizeof(markers) / sizeof(markers[0]); i++) {
        char *path = ecex_path_join(dir, markers[i]);
        if (!path) continue;
        int found = ecex_path_exists(path);
        free(path);
        if (found) return 1;
    }

    return 0;
}

static char *ecex_path_parent_dup(const char *path) {
    if (!path || !path[0]) return NULL;

    char *parent = ecex_strdup(path);
    if (!parent) return NULL;

    size_t len = strlen(parent);
    while (len > 1 && parent[len - 1] == '/') parent[--len] = '\0';
    if (strcmp(parent, "/") == 0) return parent;

    char *slash = strrchr(parent, '/');
    if (!slash) {
        free(parent);
        return NULL;
    }

    if (slash == parent) parent[1] = '\0';
    else *slash = '\0';
    return parent;
}

char *ecex_project_root_for_file(const char *path) {
    char *start = NULL;

    if (path && path[0]) {
        if (ecex_path_is_dir(path)) {
            start = ecex_path_normalize(path);
        } else {
            char *dir = ecex_path_dirname(path);
            if (dir) {
                start = ecex_path_normalize(dir);
                free(dir);
            }
        }
    } else {
        char cwd[4096];
        if (ecex_path_cwd(cwd, sizeof(cwd)) == 0) start = ecex_path_normalize(cwd);
    }

    if (!start) return NULL;
    char *fallback = ecex_strdup(start);
    if (!fallback) {
        free(start);
        return NULL;
    }

    char *dir = start;
    while (dir && dir[0]) {
        if (ecex_project_root_has_marker(dir)) {
            free(fallback);
            return dir;
        }

        char *parent = ecex_path_parent_dup(dir);
        if (!parent || strcmp(parent, dir) == 0) {
            free(parent);
            break;
        }

        free(dir);
        dir = parent;
    }

    free(dir);
    return fallback;
}

int ecex_path_exists(const char *path) {
    if (!path) return 0;
    char *expanded = ecex_path_expand_user(path);
    if (!expanded) return 0;
    struct stat st;
    int ok = stat(expanded, &st) == 0;
    free(expanded);
    return ok;
}

int ecex_path_is_dir(const char *path) {
    if (!path) return 0;
    char *expanded = ecex_path_expand_user(path);
    if (!expanded) return 0;
    struct stat st;
    int ok = stat(expanded, &st) == 0 && S_ISDIR(st.st_mode);
    free(expanded);
    return ok;
}

int ecex_path_is_file(const char *path) {
    if (!path) return 0;
    char *expanded = ecex_path_expand_user(path);
    if (!expanded) return 0;
    struct stat st;
    int ok = stat(expanded, &st) == 0 && S_ISREG(st.st_mode);
    free(expanded);
    return ok;
}

long long ecex_path_file_size(const char *path) {
    if (!path) return -1;
    char *expanded = ecex_path_expand_user(path);
    if (!expanded) return -1;
    struct stat st;
    long long size = (stat(expanded, &st) == 0 && S_ISREG(st.st_mode)) ? (long long)st.st_size : -1;
    free(expanded);
    return size;
}

static int ext_eq(const char *path, const char *ext) {
    if (!path || !ext) return 0;
    size_t pl = strlen(path), el = strlen(ext);
    if (pl < el) return 0;
    const char *p = path + pl - el;
    for (size_t i = 0; i < el; i++) {
        if (tolower((unsigned char)p[i]) != tolower((unsigned char)ext[i])) return 0;
    }
    return 1;
}

int ecex_path_is_image(const char *path) {
    return ext_eq(path, ".png") || ext_eq(path, ".jpg") || ext_eq(path, ".jpeg") ||
           ext_eq(path, ".bmp") || ext_eq(path, ".ppm") || ext_eq(path, ".pnm") ||
           ext_eq(path, ".pgm") || ext_eq(path, ".gif") || ext_eq(path, ".webp") ||
           ext_eq(path, ".tif") || ext_eq(path, ".tiff") || ext_eq(path, ".avif") ||
           ext_eq(path, ".heic") || ext_eq(path, ".heif") || ext_eq(path, ".jxl") ||
           ext_eq(path, ".qoi") || ext_eq(path, ".tga") || ext_eq(path, ".dds") ||
           ext_eq(path, ".exr") || ext_eq(path, ".hdr") || ext_eq(path, ".ico");
}

int ecex_path_is_previewable_image(const char *path) {
    return ecex_path_is_image(path);
}

int ecex_path_is_video(const char *path) {
    return ext_eq(path, ".mp4") || ext_eq(path, ".m4v") || ext_eq(path, ".mov") ||
           ext_eq(path, ".mkv") || ext_eq(path, ".webm") || ext_eq(path, ".avi") ||
           ext_eq(path, ".wmv") || ext_eq(path, ".flv") || ext_eq(path, ".gif") ||
           ext_eq(path, ".ogv") || ext_eq(path, ".mpeg") || ext_eq(path, ".mpg");
}

int ecex_path_is_media(const char *path) {
    return ecex_path_is_image(path) || ecex_path_is_video(path);
}

int ecex_path_cwd(char *out, size_t out_size) {
    if (!out || out_size == 0) return -1;
    if (!getcwd(out, out_size)) {
        ecex_path_copy(out, out_size, ".");
        return -1;
    }
    return 0;
}