/*
    * filesystem.cpp
    * Filesystem enumeration and copy/delete helpers for the embedded desktop file manager
    * Copyright (c) 2026 Daniel Hammer
*/

#include "filemanager_internal.hpp"

namespace filemanager {

static void filemanager_reset_list_state(FileManagerState* fm) {
    fm->selected = -1;
    fm->scroll_offset = 0;
    fm->scrollbar.scroll_offset = 0;
    fm->last_click_item = -1;
    fm->last_click_time = 0;
}

static void filemanager_reset_virtual_entry(FileManagerVirtualEntry* entry) {
    if (!entry) return;
    entry->kind = FM_VIRTUAL_ENTRY_NONE;
    entry->external_app_index = -1;
    montauk::memset(&entry->applet, 0, sizeof(entry->applet));
    entry->applet.kind = DESKTOP_APPLET_NONE;
    entry->applet.builtin_id = DESKTOP_BUILTIN_NONE;
    entry->icon_lg = {};
    entry->icon_sm = {};
}

static void filemanager_add_root_entry(FileManagerState* fm,
                                       const char* name,
                                       FileManagerEntryType type,
                                       int drive_index) {
    if (!fm || fm->entry_count >= 64) return;

    int idx = fm->entry_count++;
    montauk::strncpy(fm->entry_names[idx], name, 63);
    fm->entry_types[idx] = type;
    fm->entry_sizes[idx] = 0;
    fm->is_dir[idx] = true;
    fm->drive_indices[idx] = drive_index;
    fm->drive_kinds[idx] = 0;
    if (type == FM_ENTRY_DRIVE && drive_index >= 0) {
        fm->drive_kinds[idx] = montauk::drivekind(drive_index);
    }
}

static int filemanager_add_virtual_entry(FileManagerState* fm,
                                         const char* name,
                                         const char* icon_path,
                                         FileManagerVirtualEntryKind kind) {
    if (!fm || fm->entry_count >= 64) return -1;

    int idx = fm->entry_count;
    montauk::strncpy(fm->entry_names[idx], name, 63);
    fm->entry_types[idx] = FM_ENTRY_VIRTUAL_APP;
    fm->entry_sizes[idx] = 0;
    fm->is_dir[idx] = false;
    fm->drive_indices[idx] = -1;
    filemanager_reset_virtual_entry(&fm->virtual_entries[idx]);
    fm->virtual_entries[idx].kind = kind;

    if (icon_path && icon_path[0]) {
        Color defColor = colors::ICON_COLOR;
        fm->virtual_entries[idx].icon_lg = svg_load(icon_path, 48, 48, defColor);
        fm->virtual_entries[idx].icon_sm = svg_load(icon_path, 16, 16, defColor);
    }

    fm->entry_count++;
    fm->virtual_entry_count = fm->entry_count;
    return idx;
}

static void filemanager_add_external_app_entry(FileManagerState* fm,
                                               const ExternalApp& app,
                                               int external_index) {
    int idx = filemanager_add_virtual_entry(fm, app.name, app.icon_path,
                                            FM_VIRTUAL_ENTRY_EXTERNAL_APP);
    if (idx >= 0) {
        fm->virtual_entries[idx].external_app_index = external_index;
    }
}

static void filemanager_add_system_configuration_applet_entry(
    FileManagerState* fm,
    const DesktopAppletEntry& applet) {
    int idx = filemanager_add_virtual_entry(fm, applet.label, applet.icon_path,
                                            FM_VIRTUAL_ENTRY_SYSTEM_CONFIGURATION_APPLET);
    if (idx >= 0) {
        fm->virtual_entries[idx].applet = applet;
    }
}

static void filemanager_begin_virtual_view(FileManagerState* fm, FileManagerVirtualViewKind view) {
    filemanager_free_app_icons(fm);
    fm->current_path[0] = '\0';
    fm->virtual_view = view;
    fm->entry_count = 0;
}

void filemanager_read_drives(FileManagerState* fm) {
    filemanager_free_app_icons(fm);
    fm->entry_count = 0;
    fm->virtual_view = FM_VIRTUAL_VIEW_NONE;
    fm->current_path[0] = '\0';

    // Home folder entry (if we have a valid home directory)
    DesktopState* ds = fm->desktop;
    if (ds && ds->home_dir[0] != '\0') {
        filemanager_add_root_entry(fm, "Home", FM_ENTRY_HOME, -1);
    }

    // Apps entry
    filemanager_add_root_entry(fm, "Apps", FM_ENTRY_APPS_ROOT, -1);

    // Special user folders (Documents, Desktop, Music, etc.) - only if they exist
    if (ds && ds->home_dir[0] != '\0') {
        for (int sf = 0; sf < SF_COUNT && fm->entry_count < 64; sf++) {
            char probe_path[256];
            montauk::strcpy(probe_path, ds->home_dir);
            int plen = montauk::slen(probe_path);
            if (plen > 0 && probe_path[plen - 1] != '/')
                str_append(probe_path, "/", 256);
            str_append(probe_path, sf_names[sf], 256);

            // Probe: try open to check if the directory exists
            int probe_fd = montauk::open(probe_path);
            if (probe_fd >= 0) {
                montauk::close(probe_fd);
                filemanager_add_root_entry(fm, sf_names[sf], FM_ENTRY_SPECIAL_DIR, sf);
            }
        }
    }

    // Settings entry
    filemanager_add_root_entry(fm, "Settings", FM_ENTRY_SYSTEM_CONFIGURATION_ROOT, -1);

    // Drive entries
    int drives[FM_MAX_DRIVES];
    int driveCount = montauk::drivelist(drives, FM_MAX_DRIVES);

    for (int di = 0; di < driveCount; di++) {
        int d = drives[di];
        char probe[8];
        if (d < 10) {
            probe[0] = '0' + d;
            probe[1] = ':';
            probe[2] = '/';
            probe[3] = '\0';
        } else {
            probe[0] = '1';
            probe[1] = '0' + (d - 10);
            probe[2] = ':';
            probe[3] = '/';
            probe[4] = '\0';
        }
        char label[64];
        montauk::strcpy(label, "Drive ");
        str_append(label, probe, 64);
        char volume_label[64];
        if (montauk::drivelabel(d, volume_label, 64) > 0 && volume_label[0] != '\0') {
            montauk::strncpy(label, volume_label, 64);
            str_append(label, " (", 64);
            str_append(label, probe, 64);
            str_append(label, ")", 64);
        }
        filemanager_add_root_entry(fm, label, FM_ENTRY_DRIVE, d);
        if (fm->entry_count >= 64) break;
    }

    filemanager_reset_list_state(fm);
}

void filemanager_read_dir(FileManagerState* fm) {
    if (fm->current_path[0] == '\0') {
        filemanager_read_drives(fm);
        return;
    }

    filemanager_free_app_icons(fm);
    fm->virtual_view = FM_VIRTUAL_VIEW_NONE;

    const char* names[64];
    fm->entry_count = montauk::readdir(fm->current_path, names, 64);
    if (fm->entry_count < 0) fm->entry_count = 0;

    // readdir returns full paths from the VFS (e.g. "man/fetch.1" instead
    // of just "fetch.1").  Compute the prefix to strip so we get basenames.
    const char* after_drive = fm->current_path;
    for (int k = 0; after_drive[k]; k++) {
        if (after_drive[k] == ':' && after_drive[k + 1] == '/') {
            after_drive += k + 2;
            break;
        }
    }
    char prefix[256] = {0};
    int prefix_len = 0;
    if (after_drive[0] != '\0') {
        montauk::strcpy(prefix, after_drive);
        prefix_len = montauk::slen(prefix);
        if (prefix_len > 0 && prefix[prefix_len - 1] != '/') {
            prefix[prefix_len++] = '/';
            prefix[prefix_len] = '\0';
        }
    }

    for (int i = 0; i < fm->entry_count; i++) {
        const char* raw = names[i];
        // Strip directory prefix if it matches
        if (prefix_len > 0) {
            bool match = true;
            for (int k = 0; k < prefix_len; k++) {
                if (raw[k] != prefix[k]) { match = false; break; }
            }
            if (match) raw += prefix_len;
        }
        montauk::strncpy(fm->entry_names[i], raw, 128);
        int len = montauk::slen(fm->entry_names[i]);

        // Detect directory
        if (len > 0 && fm->entry_names[i][len - 1] == '/') {
            fm->is_dir[i] = true;
            fm->entry_names[i][len - 1] = '\0';
        } else {
            fm->is_dir[i] = false;
        }

        fm->entry_types[i] = detect_file_type(fm->entry_names[i], fm->is_dir[i]);

        // Get file size
        fm->entry_sizes[i] = 0;
        if (!fm->is_dir[i]) {
            char fullpath[512];
            montauk::strcpy(fullpath, fm->current_path);
            int plen = montauk::slen(fullpath);
            if (plen > 0 && fullpath[plen - 1] != '/') {
                str_append(fullpath, "/", 512);
            }
            str_append(fullpath, fm->entry_names[i], 512);
            int fd = montauk::open(fullpath);
            if (fd >= 0) {
                fm->entry_sizes[i] = (int)montauk::getsize(fd);
                montauk::close(fd);
            }
        }
    }

    // Sort: directories first, then alphabetical (case-insensitive)
    for (int i = 1; i < fm->entry_count; i++) {
        char tmp_name[128];
        int tmp_type = fm->entry_types[i];
        int tmp_size = fm->entry_sizes[i];
        bool tmp_isdir = fm->is_dir[i];
        montauk::strcpy(tmp_name, fm->entry_names[i]);

        int j = i - 1;
        while (j >= 0) {
            bool swap = false;
            if (tmp_isdir && !fm->is_dir[j]) {
                swap = true;
            } else if (tmp_isdir == fm->is_dir[j]) {
                if (str_compare_ci(tmp_name, fm->entry_names[j]) < 0) {
                    swap = true;
                }
            }
            if (!swap) break;

            montauk::strcpy(fm->entry_names[j + 1], fm->entry_names[j]);
            fm->entry_types[j + 1] = fm->entry_types[j];
            fm->entry_sizes[j + 1] = fm->entry_sizes[j];
            fm->is_dir[j + 1] = fm->is_dir[j];
            j--;
        }
        montauk::strcpy(fm->entry_names[j + 1], tmp_name);
        fm->entry_types[j + 1] = tmp_type;
        fm->entry_sizes[j + 1] = tmp_size;
        fm->is_dir[j + 1] = tmp_isdir;
    }

    filemanager_reset_list_state(fm);
}

void filemanager_free_app_icons(FileManagerState* fm) {
    if (!fm) return;

    for (int i = 0; i < fm->virtual_entry_count; i++) {
        if (fm->virtual_entries[i].icon_lg.pixels) {
            montauk::mfree(fm->virtual_entries[i].icon_lg.pixels);
            fm->virtual_entries[i].icon_lg.pixels = nullptr;
        }
        if (fm->virtual_entries[i].icon_sm.pixels) {
            montauk::mfree(fm->virtual_entries[i].icon_sm.pixels);
            fm->virtual_entries[i].icon_sm.pixels = nullptr;
        }
        filemanager_reset_virtual_entry(&fm->virtual_entries[i]);
    }
    fm->virtual_entry_count = 0;
}

void filemanager_read_virtual_view(FileManagerState* fm, FileManagerVirtualViewKind view) {
    switch (view) {
    case FM_VIRTUAL_VIEW_APPS: filemanager_read_apps(fm); break;
    case FM_VIRTUAL_VIEW_SYSTEM_CONFIGURATION:
        filemanager_read_system_configuration(fm);
        break;
    default: filemanager_read_drives(fm); break;
    }
}

void filemanager_read_apps(FileManagerState* fm) {
    filemanager_begin_virtual_view(fm, FM_VIRTUAL_VIEW_APPS);

    DesktopState* ds = fm->desktop;
    if (!ds) return;

    for (int i = 0; i < ds->external_app_count && fm->entry_count < 64; i++) {
        filemanager_add_external_app_entry(fm, ds->external_apps[i], i);
    }

    filemanager_reset_list_state(fm);
}

void filemanager_read_system_configuration(FileManagerState* fm) {
    filemanager_begin_virtual_view(fm, FM_VIRTUAL_VIEW_SYSTEM_CONFIGURATION);

    DesktopAppletEntry applets[32];
    int applet_count = desktop_list_system_configuration_applets(fm->desktop, applets, 32);
    for (int i = 0; i < applet_count && fm->entry_count < 64; i++) {
        filemanager_add_system_configuration_applet_entry(fm, applets[i]);
    }

    filemanager_reset_list_state(fm);
}

bool filemanager_delete_recursive(const char* path) {
    // Try deleting as a file (or empty directory) first
    if (montauk::fdelete(path) == 0) return true;

    // If that failed, it may be a non-empty directory -- enumerate and delete children
    const char* names[64];
    int count = montauk::readdir(path, names, 64);
    if (count < 0) return false;

    // Compute the prefix to strip (readdir returns paths relative to drive root)
    const char* after_drive = path;
    for (int k = 0; after_drive[k]; k++) {
        if (after_drive[k] == ':' && after_drive[k + 1] == '/') {
            after_drive += k + 2;
            break;
        }
    }
    char prefix[256] = {0};
    int prefix_len = 0;
    if (after_drive[0] != '\0') {
        montauk::strcpy(prefix, after_drive);
        prefix_len = montauk::slen(prefix);
        if (prefix_len > 0 && prefix[prefix_len - 1] != '/') {
            prefix[prefix_len++] = '/';
            prefix[prefix_len] = '\0';
        }
    }

    for (int i = 0; i < count; i++) {
        const char* raw = names[i];
        if (prefix_len > 0) {
            bool match = true;
            for (int k = 0; k < prefix_len; k++) {
                if (raw[k] != prefix[k]) { match = false; break; }
            }
            if (match) raw += prefix_len;
        }

        char child[512];
        montauk::strcpy(child, path);
        int plen = montauk::slen(child);
        if (plen > 0 && child[plen - 1] != '/')
            str_append(child, "/", 512);
        str_append(child, raw, 512);

        // Strip trailing slash if present (directory marker)
        int clen = montauk::slen(child);
        if (clen > 0 && child[clen - 1] == '/') child[clen - 1] = '\0';

        filemanager_delete_recursive(child);
    }

    // Now the directory should be empty -- delete it
    return montauk::fdelete(path) == 0;
}

bool filemanager_copy_file(const char* src, const char* dst) {
    if (!src || !dst || montauk::streq(src, dst)) return false;

    int sfd = montauk::open(src);
    if (sfd < 0) return false;
    uint64_t size = montauk::getsize(sfd);

    // Create destination
    int dfd = montauk::fcreate(dst);
    if (dfd < 0) {
        montauk::close(sfd);
        return false;
    }

    bool ok = true;
    if (size > 0) {
        static constexpr uint64_t COPY_CHUNK = 64 * 1024;
        uint64_t buf_size = size < COPY_CHUNK ? size : COPY_CHUNK;
        uint8_t* buf = (uint8_t*)montauk::malloc(buf_size);
        if (!buf) {
            montauk::close(sfd);
            montauk::close(dfd);
            montauk::fdelete(dst);
            return false;
        }

        uint64_t off = 0;
        while (off < size) {
            uint64_t todo64 = size - off;
            if (todo64 > buf_size) todo64 = buf_size;
            int todo = (int)todo64;
            int got = montauk::read(sfd, buf, off, todo64);
            if (got != todo) { ok = false; break; }
            int wrote = montauk::fwrite(dfd, buf, off, todo64);
            if (wrote != todo) { ok = false; break; }
            off += todo64;
        }

        montauk::mfree(buf);
    }

    montauk::close(sfd);
    montauk::close(dfd);
    if (!ok) {
        montauk::fdelete(dst);
        return false;
    }
    return true;
}

// Recursive directory copy
bool filemanager_copy_dir_recursive(const char* src, const char* dst) {
    if (!src || !dst || montauk::streq(src, dst)) return false;

    montauk::fmkdir(dst);

    const char* names[64];
    int count = montauk::readdir(src, names, 64);
    if (count < 0) return false;

    // Compute prefix to strip
    const char* after_drive = src;
    for (int k = 0; after_drive[k]; k++) {
        if (after_drive[k] == ':' && after_drive[k + 1] == '/') {
            after_drive += k + 2;
            break;
        }
    }
    char prefix[256] = {0};
    int prefix_len = 0;
    if (after_drive[0] != '\0') {
        montauk::strcpy(prefix, after_drive);
        prefix_len = montauk::slen(prefix);
        if (prefix_len > 0 && prefix[prefix_len - 1] != '/') {
            prefix[prefix_len++] = '/';
            prefix[prefix_len] = '\0';
        }
    }

    for (int i = 0; i < count; i++) {
        const char* raw = names[i];
        if (prefix_len > 0) {
            bool match = true;
            for (int k = 0; k < prefix_len; k++) {
                if (raw[k] != prefix[k]) { match = false; break; }
            }
            if (match) raw += prefix_len;
        }

        bool child_is_dir = false;
        char basename[64];
        montauk::strncpy(basename, raw, 63);
        int blen = montauk::slen(basename);
        if (blen > 0 && basename[blen - 1] == '/') {
            child_is_dir = true;
            basename[blen - 1] = '\0';
        }

        char src_child[512], dst_child[512];
        filemanager_build_fullpath(src_child, 512, src, basename);
        filemanager_build_fullpath(dst_child, 512, dst, basename);

        if (child_is_dir)
            filemanager_copy_dir_recursive(src_child, dst_child);
        else
            filemanager_copy_file(src_child, dst_child);
    }

    return true;
}

} // namespace filemanager