#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <limits.h>
#include <ncurses.h>
#include <pthread.h>
#include <regex.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

typedef struct {
  char *path;
  char *lower_path;
  off_t size;
  time_t mtime;
  int is_dir;
  char git_status;
} FileInfo;

typedef enum { SORT_NAME, SORT_SIZE, SORT_DATE } SortMode;
typedef enum { SEARCH_FUZZY, SEARCH_REGEX } SearchMode;

FileInfo *files = NULL;
int file_count = 0;
int file_capacity = 0;

pthread_mutex_t files_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t indexing_thread;
volatile bool indexing_complete = false;
volatile bool indexing_started = false;

#define MAX_INDEXING_THREADS 8
#define DIR_QUEUE_CAPACITY 2048
#define FILE_BATCH_SIZE 128
char *dir_queue[DIR_QUEUE_CAPACITY];
int queue_head = 0;
int queue_tail = 0;
int queue_count = 0;
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t queue_cond = PTHREAD_COND_INITIALIZER;
volatile int active_workers = 0;
volatile bool producer_finished = false;

pthread_mutex_t git_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t git_root_mutex = PTHREAD_MUTEX_INITIALIZER;
int *git_queue = NULL;
volatile int git_queue_count = 0;

#define MAX_HISTORY 10
char search_history[MAX_HISTORY][256];
int history_count = 0;
int history_index = -1;

#define MAX_BOOKMARKS 100
char *bookmarks[MAX_BOOKMARKS];
int bookmark_count = 0;
bool show_bookmarks_only = false;

#define MAX_SELECTED 1000
int selected_indices[MAX_SELECTED];
int selected_count = 0;

bool show_preview = true;
SortMode sort_mode = SORT_NAME;
SearchMode search_mode = SEARCH_FUZZY;

pthread_mutex_t preview_mutex = PTHREAD_MUTEX_INITIALIZER;
char last_preview_path[PATH_MAX] = {0};

void rzf_cleanup_terminal(int sig) {
  (void)sig;
  endwin();
  exit(0);
}

char *rzf_get_file_extension(const char *filename) {
  const char *dot = strrchr(filename, '.');
  if (!dot || dot == filename)
    return "";
  return (char *)(dot + 1);
}

bool rzf_is_text_file(const char *path) {
  const char *ext = rzf_get_file_extension(path);
  
  // Common text file extensions
  const char *text_exts[] = {
    "txt", "c", "h", "cpp", "hpp", "cc", "cxx", "py", "js", "ts", "java",
    "rb", "go", "rs", "sh", "bash", "zsh", "fish", "pl", "php", "html",
    "htm", "css", "xml", "json", "yaml", "yml", "toml", "ini", "conf",
    "cfg", "log", "md", "markdown", "rst", "tex", "vim", "el", "lisp",
    "scm", "clj", "lua", "r", "m", "swift", "kt", "scala", "hs", "ml",
    "fs", "pas", "d", "nim", "cr", "jl", "dart", "ex", "exs", "erl",
    "hrl", "zig", "v", "sql", "cmake", "make", "dockerfile", "gitignore",
    NULL
  };
  
  // Check if it has no extension (often scripts or config files)
  if (strlen(ext) == 0) {
    return true;
  }
  
  // Check against known text extensions
  for (int i = 0; text_exts[i] != NULL; i++) {
    if (strcasecmp(ext, text_exts[i]) == 0) {
      return true;
    }
  }
  
  return false;
}

bool rzf_matches_file_type_filter(const char *path, const char *filter) {
  if (!filter || strlen(filter) < 2 || filter[0] != ':')
    return true;

  const char *ext = rzf_get_file_extension(path);
  const char *filter_ext = filter + 1;

  if (strcmp(filter_ext, "img") == 0) {
    return strcasecmp(ext, "jpg") == 0 || strcasecmp(ext, "jpeg") == 0 ||
           strcasecmp(ext, "png") == 0 || strcasecmp(ext, "gif") == 0 ||
           strcasecmp(ext, "bmp") == 0 || strcasecmp(ext, "svg") == 0;
  } else if (strcmp(filter_ext, "doc") == 0) {
    return strcasecmp(ext, "txt") == 0 || strcasecmp(ext, "md") == 0 ||
           strcasecmp(ext, "pdf") == 0 || strcasecmp(ext, "doc") == 0 ||
           strcasecmp(ext, "docx") == 0;
  }

  return strcasecmp(ext, filter_ext) == 0;
}

bool rzf_regex_match(const char *text, const char *pattern) {
  regex_t regex;
  int ret = regcomp(&regex, pattern, REG_EXTENDED | REG_ICASE);
  if (ret != 0)
    return false;

  ret = regexec(&regex, text, 0, NULL, 0);
  regfree(&regex);

  return ret == 0;
}

char *rzf_to_lower(const char *str) {
  if (!str)
    return NULL;
  char *lower_str = strdup(str);
  if (!lower_str) {
    perror("strdup");
    exit(EXIT_FAILURE);
  }
  for (int i = 0; lower_str[i]; i++) {
    lower_str[i] = tolower((unsigned char)lower_str[i]);
  }
  return lower_str;
}

void rzf_format_size(off_t size, char *buf) {
  const char *units[] = {"B", "KB", "MB", "GB", "TB"};
  int i = 0;
  double d_size = size;

  if (d_size < 1024) {
    sprintf(buf, "%ldB", (long)d_size);
    return;
  }

  while (d_size >= 1024 && i < 4) {
    d_size /= 1024.0;
    i++;
  }
  sprintf(buf, "%.1f%s", d_size, units[i]);
}

char rzf_get_git_status(const char *filepath) {
  static time_t last_check = 0;
  static char git_root[PATH_MAX] = {0};
  time_t now = time(NULL);

  pthread_mutex_lock(&git_root_mutex);
  if (now - last_check > 5 || git_root[0] == 0) {
    last_check = now;
    FILE *fp = popen("git rev-parse --show-toplevel 2>/dev/null", "r");
    if (fp) {
      if (fgets(git_root, sizeof(git_root), fp) != NULL) {
        git_root[strcspn(git_root, "\n")] = 0;
      } else {
        git_root[0] = 0;
      }
      pclose(fp);
    }
  }

  if (git_root[0] == 0) {
    pthread_mutex_unlock(&git_root_mutex);
    return ' ';
  }

  char cmd[PATH_MAX + 100];
  snprintf(cmd, sizeof(cmd),
           "cd '%s' && git status --porcelain '%s' 2>/dev/null", git_root,
           filepath);
  pthread_mutex_unlock(&git_root_mutex);

  FILE *fp = popen(cmd, "r");
  if (!fp)
    return ' ';

  char line[256];
  char status = ' ';
  if (fgets(line, sizeof(line), fp) != NULL) {
    if (line[0] == 'M' || line[1] == 'M')
      status = 'M';
    else if (line[0] == '?' && line[1] == '?')
      status = '?';
    else if (line[0] == 'A')
      status = 'A';
    else if (line[0] == 'D')
      status = 'D';
  }

  pclose(fp);
  return status;
}

void rzf_load_history(void) {
  char history_file[PATH_MAX];
  snprintf(history_file, sizeof(history_file), "%s/.rzf_history",
           getenv("HOME"));

  FILE *fp = fopen(history_file, "r");
  if (!fp)
    return;

  char line[256];
  history_count = 0;
  while (fgets(line, sizeof(line), fp) && history_count < MAX_HISTORY) {
    line[strcspn(line, "\n")] = 0;
    strcpy(search_history[history_count++], line);
  }

  fclose(fp);
}

void rzf_save_history(void) {
  char history_file[PATH_MAX];
  const char *home = getenv("HOME");
  if (!home)
    return;
  snprintf(history_file, sizeof(history_file), "%s/.rzf_history", home);

  FILE *fp = fopen(history_file, "w");
  if (!fp)
    return;

  for (int i = 0; i < history_count; i++) {
    fprintf(fp, "%s\n", search_history[i]);
  }

  fclose(fp);
}

void rzf_add_to_history(const char *query) {
  if (strlen(query) == 0)
    return;

  for (int i = 0; i < history_count; i++) {
    if (strcmp(search_history[i], query) == 0) {
      char temp[256];
      strcpy(temp, search_history[i]);
      for (int j = i; j > 0; j--) {
        strcpy(search_history[j], search_history[j - 1]);
      }
      strcpy(search_history[0], temp);
      return;
    }
  }

  if (history_count == MAX_HISTORY) {
    history_count--;
  }

  for (int i = history_count; i > 0; i--) {
    strcpy(search_history[i], search_history[i - 1]);
  }
  strcpy(search_history[0], query);
  history_count++;
}

void rzf_load_bookmarks(void) {
  char bookmark_file[PATH_MAX];
  const char *home = getenv("HOME");
  if (!home)
    return;
  snprintf(bookmark_file, sizeof(bookmark_file), "%s/.rzf_bookmarks", home);

  FILE *fp = fopen(bookmark_file, "r");
  if (!fp)
    return;

  char line[PATH_MAX];
  bookmark_count = 0;
  while (fgets(line, sizeof(line), fp) && bookmark_count < MAX_BOOKMARKS) {
    line[strcspn(line, "\n")] = 0;
    bookmarks[bookmark_count] = strdup(line);
    if (bookmarks[bookmark_count])
      bookmark_count++;
  }

  fclose(fp);
}

void rzf_save_bookmarks(void) {
  char bookmark_file[PATH_MAX];
  const char *home = getenv("HOME");
  if (!home)
    return;
  snprintf(bookmark_file, sizeof(bookmark_file), "%s/.rzf_bookmarks", home);

  FILE *fp = fopen(bookmark_file, "w");
  if (!fp)
    return;

  for (int i = 0; i < bookmark_count; i++) {
    fprintf(fp, "%s\n", bookmarks[i]);
  }

  fclose(fp);
}

bool rzf_is_bookmarked(const char *path) {
  char abs_path[PATH_MAX];
  if (realpath(path, abs_path) == NULL)
    return false;

  for (int i = 0; i < bookmark_count; i++) {
    if (strcmp(bookmarks[i], abs_path) == 0)
      return true;
  }
  return false;
}

void rzf_add_bookmark(const char *path) {
  if (bookmark_count >= MAX_BOOKMARKS)
    return;

  char abs_path[PATH_MAX];
  if (realpath(path, abs_path) == NULL)
    return;

  if (rzf_is_bookmarked(path))
    return;

  bookmarks[bookmark_count] = strdup(abs_path);
  if (bookmarks[bookmark_count]) {
    bookmark_count++;
    rzf_save_bookmarks();
  }
}

void rzf_remove_bookmark(const char *path) {
  char abs_path[PATH_MAX];
  if (realpath(path, abs_path) == NULL)
    return;

  for (int i = 0; i < bookmark_count; i++) {
    if (strcmp(bookmarks[i], abs_path) == 0) {
      free(bookmarks[i]);
      for (int j = i; j < bookmark_count - 1; j++) {
        bookmarks[j] = bookmarks[j + 1];
      }
      bookmark_count--;
      rzf_save_bookmarks();
      return;
    }
  }
}

bool rzf_is_selected(int index) {
  for (int i = 0; i < selected_count; i++) {
    if (selected_indices[i] == index)
      return true;
  }
  return false;
}

void rzf_toggle_selection(int index) {
  if (rzf_is_selected(index)) {
    for (int i = 0; i < selected_count; i++) {
      if (selected_indices[i] == index) {
        for (int j = i; j < selected_count - 1; j++) {
          selected_indices[j] = selected_indices[j + 1];
        }
        selected_count--;
        return;
      }
    }
  } else {
    if (selected_count < MAX_SELECTED) {
      selected_indices[selected_count++] = index;
    }
  }
}

void rzf_clear_selections(void) { selected_count = 0; }

int rzf_compare_files(const void *a, const void *b) {
  FileInfo *fa = (FileInfo *)a;
  FileInfo *fb = (FileInfo *)b;

  if (fa->is_dir && !fb->is_dir)
    return -1;
  if (!fa->is_dir && fb->is_dir)
    return 1;

  switch (sort_mode) {
  case SORT_SIZE:
    if (fa->size < fb->size)
      return -1;
    if (fa->size > fb->size)
      return 1;
    return strcasecmp(fa->path, fb->path);
  case SORT_DATE:
    if (fa->mtime < fb->mtime)
      return 1;
    if (fa->mtime > fb->mtime)
      return -1;
    return strcasecmp(fa->path, fb->path);
  case SORT_NAME:
  default:
    return strcasecmp(fa->path, fb->path);
  }
}

void rzf_sort_files(void) {
  pthread_mutex_lock(&files_mutex);
  if (file_count > 0) {
    qsort(files, file_count, sizeof(FileInfo), rzf_compare_files);
  }
  pthread_mutex_unlock(&files_mutex);
}

void rzf_draw_file_preview(WINDOW *win, const char *filepath) {
  if (!win)
    return;
  werase(win);
  box(win, 0, 0);

  if (!filepath) {
    mvwprintw(win, 1, 1, "No file selected");
    return;
  }

  struct stat st;
  if (stat(filepath, &st) != 0) {
    mvwprintw(win, 1, 1, "Cannot stat file");
    return;
  }

  if (S_ISDIR(st.st_mode)) {
    mvwprintw(win, 1, 1, "[Directory]");
    DIR *dir = opendir(filepath);
    if (dir) {
      struct dirent *entry;
      int line = 3;
      int max_lines = getmaxy(win) - 2;
      while ((entry = readdir(dir)) != NULL && line < max_lines) {
        if (strcmp(entry->d_name, ".") != 0 &&
            strcmp(entry->d_name, "..") != 0) {
          mvwprintw(win, line++, 2, "%s", entry->d_name);
        }
      }
      closedir(dir);
    }
  } else {
    FILE *fp = fopen(filepath, "rb");
    if (!fp) {
      mvwprintw(win, 1, 1, "Cannot open file");
      return;
    }

    unsigned char buffer[512];
    size_t bytes_read = fread(buffer, 1, sizeof(buffer), fp);
    bool is_binary = false;
    for (size_t i = 0; i < bytes_read; i++) {
      if (buffer[i] == 0 || (buffer[i] < 32 && buffer[i] != '\n' &&
                             buffer[i] != '\r' && buffer[i] != '\t')) {
        is_binary = true;
        break;
      }
    }
    fclose(fp);

    if (is_binary) {
      mvwprintw(win, 1, 1, "[Binary file]");
      char size_str[32];
      rzf_format_size(st.st_size, size_str);
      mvwprintw(win, 3, 2, "Size: %s", size_str);
    } else {
      fp = fopen(filepath, "r");
      if (fp) {
        char line[1024];
        int line_num = 1;
        int max_lines = getmaxy(win) - 2;
        int max_cols = getmaxx(win) - 2;
        while (fgets(line, sizeof(line), fp) && line_num < max_lines) {
          line[strcspn(line, "\n")] = 0;
          mvwprintw(win, line_num, 1, "%.*s", max_cols, line);
          line_num++;
        }
        fclose(fp);
      }
    }
  }
}

void rzf_add_files_batch(FileInfo *batch, int count) {
  if (count == 0)
    return;
  pthread_mutex_lock(&files_mutex);
  if (file_count + count > file_capacity) {
    file_capacity = (file_count + count) * 2;
    if (file_capacity == 0)
      file_capacity = 256;
    FileInfo *new_files = realloc(files, file_capacity * sizeof(FileInfo));
    if (!new_files) {
      pthread_mutex_unlock(&files_mutex);
      perror("realloc failed");
      exit(EXIT_FAILURE);
    }
    files = new_files;
  }
  memcpy(&files[file_count], batch, count * sizeof(FileInfo));
  file_count += count;
  pthread_mutex_unlock(&files_mutex);
}

void rzf_enqueue_dir(const char *path) {
  pthread_mutex_lock(&queue_mutex);
  while (queue_count >= DIR_QUEUE_CAPACITY) {
    pthread_cond_wait(&queue_cond, &queue_mutex);
  }
  dir_queue[queue_tail] = strdup(path);
  if (!dir_queue[queue_tail]) {
    pthread_mutex_unlock(&queue_mutex);
    return;
  }
  queue_tail = (queue_tail + 1) % DIR_QUEUE_CAPACITY;
  queue_count++;
  active_workers++;
  pthread_cond_signal(&queue_cond);
  pthread_mutex_unlock(&queue_mutex);
}

char *rzf_dequeue_dir() {
  pthread_mutex_lock(&queue_mutex);
  while (queue_count == 0 && !producer_finished) {
    pthread_cond_wait(&queue_cond, &queue_mutex);
  }
  if (queue_count == 0) {
    pthread_mutex_unlock(&queue_mutex);
    return NULL;
  }
  char *path = dir_queue[queue_head];
  queue_head = (queue_head + 1) % DIR_QUEUE_CAPACITY;
  queue_count--;
  pthread_cond_signal(&queue_cond);
  pthread_mutex_unlock(&queue_mutex);
  return path;
}

void *rzf_indexing_worker_func(void *arg) {
  (void)arg;
  const char *ignore_list[] = {".git", "node_modules", ".venv",
                               "venv", "env",          NULL};
  FileInfo local_batch[FILE_BATCH_SIZE];
  int local_count = 0;

  while (1) {
    char *base_path = rzf_dequeue_dir();
    if (base_path == NULL)
      break;

    DIR *dir = opendir(base_path);
    if (dir) {
      struct dirent *entry;
      while ((entry = readdir(dir)) != NULL) {
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
          continue;

        bool should_ignore = false;
        for (int i = 0; ignore_list[i] != NULL; i++) {
          if (strcmp(entry->d_name, ignore_list[i]) == 0) {
            should_ignore = true;
            break;
          }
        }
        if (should_ignore)
          continue;

        char path[PATH_MAX];
        snprintf(path, sizeof(path), "%s/%s", base_path, entry->d_name);

        struct stat statbuf;
        if (lstat(path, &statbuf) == 0) {
          int is_dir = S_ISDIR(statbuf.st_mode);
          char real[PATH_MAX];
          if (realpath(path, real) == NULL)
            continue;
          local_batch[local_count].path = strdup(path);
          local_batch[local_count].lower_path = rzf_to_lower(path);
          if (!local_batch[local_count].path ||
              !local_batch[local_count].lower_path) {
            if (local_batch[local_count].path)
              free(local_batch[local_count].path);
            if (local_batch[local_count].lower_path)
              free(local_batch[local_count].lower_path);
            continue;
          }
          local_batch[local_count].size = statbuf.st_size;
          local_batch[local_count].mtime = statbuf.st_mtime;
          local_batch[local_count].is_dir = is_dir;
          local_batch[local_count].git_status = ' ';
          local_count++;

          if (local_count == FILE_BATCH_SIZE) {
            rzf_add_files_batch(local_batch, local_count);
            local_count = 0;
          }
          if (is_dir && !S_ISLNK(statbuf.st_mode)) {
            rzf_enqueue_dir(path);
          }
        }
      }
      closedir(dir);
    }
    free(base_path);

    pthread_mutex_lock(&queue_mutex);
    active_workers--;
    if (active_workers == 0 && producer_finished) {
      pthread_cond_broadcast(&queue_cond);
    }
    pthread_mutex_unlock(&queue_mutex);
  }

  if (local_count > 0) {
    rzf_add_files_batch(local_batch, local_count);
  }
  return NULL;
}

void *rzf_git_worker_func(void *arg) {
  (void)arg;
  while (1) {
    int i;
    pthread_mutex_lock(&git_queue_mutex);
    if (git_queue_count == 0) {
      pthread_mutex_unlock(&git_queue_mutex);
      break;
    }
    i = git_queue[--git_queue_count];
    pthread_mutex_unlock(&git_queue_mutex);

    char *path_copy;
    pthread_mutex_lock(&files_mutex);
    path_copy = (i < file_count) ? strdup(files[i].path) : NULL;
    pthread_mutex_unlock(&files_mutex);

    if (path_copy) {
      char status = rzf_get_git_status(path_copy);
      free(path_copy);
      pthread_mutex_lock(&files_mutex);
      if (i < file_count)
        files[i].git_status = status;
      pthread_mutex_unlock(&files_mutex);
    }
  }
  return NULL;
}

void *rzf_indexing_thread_func(void *arg) {
  (void)arg;
  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
  pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
  indexing_started = true;

  long num_cores = sysconf(_SC_NPROCESSORS_ONLN);
  int num_threads =
      (num_cores > 1 && num_cores <= MAX_INDEXING_THREADS) ? num_cores : 4;

  pthread_t threads[num_threads];
  for (int i = 0; i < num_threads; i++) {
    pthread_create(&threads[i], NULL, rzf_indexing_worker_func, NULL);
  }

  rzf_enqueue_dir(".");

  pthread_mutex_lock(&queue_mutex);
  producer_finished = true;
  while (active_workers > 0) {
    pthread_cond_broadcast(&queue_cond);
    pthread_cond_wait(&queue_cond, &queue_mutex);
  }
  pthread_mutex_unlock(&queue_mutex);

  for (int i = 0; i < num_threads; i++) {
    pthread_join(threads[i], NULL);
  }

  rzf_sort_files();

  int count = 0;
  pthread_mutex_lock(&files_mutex);
  count = file_count < 1000 ? file_count : 1000;
  pthread_mutex_unlock(&files_mutex);

  if (count > 0) {
    git_queue = malloc(count * sizeof(int));
    if (git_queue) {
      for (int i = 0; i < count; i++)
        git_queue[i] = i;
      git_queue_count = count;

      pthread_t git_threads[num_threads];
      for (int i = 0; i < num_threads; i++) {
        pthread_create(&git_threads[i], NULL, rzf_git_worker_func, NULL);
      }
      for (int i = 0; i < num_threads; i++) {
        pthread_join(git_threads[i], NULL);
      }
      free(git_queue);
      git_queue = NULL;
      git_queue_count = 0;
    }
  }

  indexing_complete = true;
  return NULL;
}

int rzf_recursive_delete(const char *path) {
  struct stat path_stat;
  if (lstat(path, &path_stat) != 0)
    return -1;

  if (!S_ISDIR(path_stat.st_mode)) {
    return remove(path);
  }

  DIR *d = opendir(path);
  if (!d)
    return -1;

  struct dirent *p;
  int ret = 0;
  while (ret == 0 && (p = readdir(d))) {
    if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
      continue;

    char *buf;
    size_t len = strlen(path) + strlen(p->d_name) + 2;
    buf = malloc(len);
    if (!buf) {
      closedir(d);
      return -1;
    }

    snprintf(buf, len, "%s/%s", path, p->d_name);

    struct stat statbuf;
    if (lstat(buf, &statbuf) == 0) {
      if (S_ISDIR(statbuf.st_mode) && !S_ISLNK(statbuf.st_mode)) {
        ret = rzf_recursive_delete(buf);
      } else {
        ret = remove(buf);
      }
    }
    free(buf);
  }
  closedir(d);

  if (ret == 0) {
    ret = rmdir(path);
  }
  return ret;
}

void rzf_draw_help_window(int height, int width) {
  int h = 20, w = 55;
  int start_y = (height - h) / 2;
  int start_x = (width - w) / 2;
  WINDOW *win = newwin(h, w, start_y, start_x);
  if (!win)
    return;
  box(win, 0, 0);
  wattron(win, A_BOLD);
  mvwprintw(win, 1, (w - 10) / 2, "Shortcuts");
  wattroff(win, A_BOLD);

  int line = 3;
  mvwprintw(win, line++, 2, "Up/Down      : Navigate");
  mvwprintw(win, line++, 2, "Enter        : Open file/directory");
  mvwprintw(win, line++, 2, "Ctrl-X       : Copy path to clipboard");
  mvwprintw(win, line++, 2, "Ctrl-Y       : Yank (copy) file contents");
  mvwprintw(win, line++, 2, "Ctrl-B       : Backup file with timestamp");
  mvwprintw(win, line++, 2, "Ctrl-D       : Delete selected item(s)");
  mvwprintw(win, line++, 2, "Ctrl-P       : Toggle preview panel");
  mvwprintw(win, line++, 2, "Ctrl-R       : Search history");
  mvwprintw(win, line++, 2, "Ctrl-S       : Toggle bookmark");
  mvwprintw(win, line++, 2, "Ctrl-F       : Show bookmarks only");
  mvwprintw(win, line++, 2, "Ctrl-Space   : Multi-select");
  mvwprintw(win, line++, 2, "Ctrl-E       : Toggle regex search");
  mvwprintw(win, line++, 2, "Ctrl-V       : Change sort mode");
  mvwprintw(win, line++, 2, "Ctrl-U       : Go to parent directory");
  mvwprintw(win, line++, 2, "Ctrl-K       : Run command on file");
  mvwprintw(win, line++, 2, ":ext         : Filter by extension (e.g. :py)");
  mvwprintw(win, line++, 2, "Ctrl-C/Esc   : Quit");
  mvwprintw(win, line++, 2, "?            : Toggle this help");

  wrefresh(win);
  wgetch(win);
  delwin(win);
}

bool rzf_show_confirmation(int height, int width, const char *message) {
  int h = 3, w = strlen(message) + 8;
  if (w > width - 4)
    w = width - 4;
  int start_y = (height - h) / 2;
  int start_x = (width - w) / 2;
  WINDOW *win = newwin(h, w, start_y, start_x);
  if (!win)
    return false;
  box(win, 0, 0);
  mvwprintw(win, 1, 2, "%.*s (y/n)", w - 8, message);
  wrefresh(win);

  int confirm_ch;
  while (1) {
    confirm_ch = wgetch(win);
    if (confirm_ch == 'y' || confirm_ch == 'Y') {
      delwin(win);
      return true;
    }
    if (confirm_ch == 'n' || confirm_ch == 'N' || confirm_ch == 27) {
      delwin(win);
      return false;
    }
  }
}

char *rzf_prompt_for_command(int height, int width) {
  int h = 3, w = 60;
  if (w > width - 4)
    w = width - 4;
  int start_y = (height - h) / 2;
  int start_x = (width - w) / 2;
  WINDOW *win = newwin(h, w, start_y, start_x);
  if (!win)
    return NULL;
  box(win, 0, 0);
  mvwprintw(win, 1, 2, "Command: ");
  wrefresh(win);

  echo();
  char *command = malloc(256);
  if (!command) {
    noecho();
    delwin(win);
    return NULL;
  }
  command[0] = '\0';
  mvwgetnstr(win, 1, 11, command, 255);
  noecho();

  delwin(win);
  if (strlen(command) == 0) {
    free(command);
    return NULL;
  }
  return command;
}

char *rzf_run_interface(char **selected_file_path) {
  initscr();
  raw();
  noecho();
  keypad(stdscr, TRUE);
  curs_set(0);
  timeout(100);
  start_color();
  use_default_colors();

  init_pair(1, COLOR_WHITE, COLOR_CYAN);
  init_pair(2, COLOR_BLUE, -1);
  init_pair(3, COLOR_WHITE, COLOR_BLUE);
  init_pair(4, COLOR_YELLOW, -1);
  init_pair(5, COLOR_GREEN, -1);
  init_pair(6, COLOR_RED, -1);
  init_pair(7, COLOR_MAGENTA, -1);
  init_pair(8, COLOR_YELLOW, COLOR_BLACK);

  char search_query[256] = {0};
  int selected_index = 0;
  int scroll_offset = 0;
  char *command = NULL;
  int filtered_capacity = 256;

  rzf_load_history();
  rzf_load_bookmarks();

  int *filtered_indices = malloc(filtered_capacity * sizeof(int));
  if (!filtered_indices) {
    endwin();
    perror("malloc");
    exit(EXIT_FAILURE);
  }

  int ch;
  int current_file_count = 0;
  int filtered_count = 0;
  WINDOW *preview_win = NULL;
  int last_height = 0, last_width = 0;
  WINDOW *file_list_win = NULL;

  while (1) {
    int height, width;
    getmaxyx(stdscr, height, width);

    bool resized = (height != last_height || width != last_width);
    if (resized) {
      if (file_list_win) {
        delwin(file_list_win);
        file_list_win = NULL;
      }
      if (preview_win) {
        delwin(preview_win);
        preview_win = NULL;
      }
      clear();
      last_height = height;
      last_width = width;
    }

    int list_height = height - 2;
    int list_width = show_preview ? (width / 2) : width;
    if (!file_list_win) {
      file_list_win = newwin(list_height, list_width, 1, 0);
    } else {
      wresize(file_list_win, list_height, list_width);
    }

    if (show_preview) {
      int preview_width = width - list_width;
      if (!preview_win) {
        preview_win = newwin(list_height, preview_width, 1, list_width);
      } else {
        wresize(preview_win, list_height, preview_width);
        mvwin(preview_win, 1, list_width);
      }
    } else {
      if (preview_win) {
        delwin(preview_win);
        preview_win = NULL;
      }
    }

    ch = getch();

    switch (ch) {
    case KEY_UP:
      if (selected_index > 0)
        selected_index--;
      if (selected_index < scroll_offset)
        scroll_offset = selected_index;
      break;
    case KEY_DOWN:
      if (selected_index < filtered_count - 1)
        selected_index++;
      if (selected_index >= scroll_offset + list_height)
        scroll_offset++;
      break;
    case 10:
      if (filtered_count > 0) {
        pthread_mutex_lock(&files_mutex);
        int file_idx = filtered_indices[selected_index];
        if (file_idx < file_count) {
          if (files[file_idx].is_dir) {
            // Navigate into directory
            char *dir_path = strdup(files[file_idx].path);
            pthread_mutex_unlock(&files_mutex);
            
            if (dir_path && chdir(dir_path) == 0) {
              // Clear the queue
              pthread_mutex_lock(&queue_mutex);
              for (int i = 0; i < queue_count; i++) {
                int idx = (queue_head + i) % DIR_QUEUE_CAPACITY;
                if (dir_queue[idx]) {
                  free(dir_queue[idx]);
                  dir_queue[idx] = NULL;
                }
              }
              queue_head = 0;
              queue_tail = 0;
              queue_count = 0;
              pthread_mutex_unlock(&queue_mutex);

              // Clear files
              pthread_mutex_lock(&files_mutex);
              if (files) {
                for (int i = 0; i < file_count; i++) {
                  free(files[i].path);
                  free(files[i].lower_path);
                }
                free(files);
              }
              files = NULL;
              file_count = 0;
              file_capacity = 0;
              pthread_mutex_unlock(&files_mutex);

              // Cancel and restart indexing
              if (indexing_started && !indexing_complete) {
                pthread_cancel(indexing_thread);
                pthread_join(indexing_thread, NULL);
              }
              indexing_complete = false;
              indexing_started = false;
              producer_finished = false;
              active_workers = 0;
              pthread_create(&indexing_thread, NULL, rzf_indexing_thread_func, NULL);
              
              search_query[0] = '\0';
              selected_index = 0;
              scroll_offset = 0;
            }
            if (dir_path) free(dir_path);
          } else {
            // Open file
            char abs[PATH_MAX];
            if (realpath(files[file_idx].path, abs))
              *selected_file_path = strdup(abs);
            else
              *selected_file_path = strdup(files[file_idx].path);
            
            // Determine whether to use vim or xdg-open
            if (rzf_is_text_file(*selected_file_path)) {
              command = strdup("vim");
            } else {
              command = strdup("xdg-open");
            }
            pthread_mutex_unlock(&files_mutex);
            goto end_loop;
          }
        } else {
          pthread_mutex_unlock(&files_mutex);
        }
      }
      break;

    case 27:
    case 3:
      goto end_loop;
    case 2:
      if (filtered_count > 0) {
        pthread_mutex_lock(&files_mutex);
        int file_idx = filtered_indices[selected_index];
        char *path = NULL;
        int is_dir = 0;
        if (file_idx < file_count) {
          path = strdup(files[file_idx].path);
          is_dir = files[file_idx].is_dir;
        }
        pthread_mutex_unlock(&files_mutex);

        if (path && !is_dir) {
          time_t t = time(NULL);
          struct tm *tm = localtime(&t);
          char dt[32];
          strftime(dt, sizeof(dt), "_%Y%m%d_%H%M%S", tm);

          /* hidden backup path in the same directory */
          char backup_path[PATH_MAX];
          const char *slash = strrchr(path, '/');
          const char *fname = slash ? slash + 1 : path;
          size_t dir_len = slash ? (size_t)(slash - path) : 0;
          const char *dot = strrchr(fname, '.');

          if (dot) {
            snprintf(backup_path, sizeof(backup_path), "%.*s/.%.*s%s%s.bak",
                     (int)dir_len, path, (int)(dot - fname), fname, dt, dot);
          } else {
            snprintf(backup_path, sizeof(backup_path), "%.*s/.%s%s.bak",
                     (int)dir_len, path, fname, dt);
          }

          char cmd[PATH_MAX * 2 + 10];
          snprintf(cmd, sizeof(cmd), "cp -- '%s' '%s'", path, backup_path);
          system(cmd);
        }
        if (path)
          free(path);
      }
      break;
    case 24:
      if (filtered_count > 0) {
        char copy_command[PATH_MAX * 10 + 100] = {0};
        pthread_mutex_lock(&files_mutex);
        if (selected_count > 0) {
          char all_paths[PATH_MAX * 10] = {0};
          size_t all_paths_used = 0;
          for (int i = 0; i < selected_count && i < 10; i++) {
            if (selected_indices[i] < file_count) {
              char abs_path[PATH_MAX];
              if (realpath(files[selected_indices[i]].path, abs_path)) {
                size_t path_len = strlen(abs_path);
                if (all_paths_used + path_len + 1 < sizeof(all_paths)) {
                  strcat(all_paths, abs_path);
                  strcat(all_paths, "\n");
                  all_paths_used += path_len + 1;
                }
              }
            }
          }
          pthread_mutex_unlock(&files_mutex);
          if (strlen(all_paths) > 0) {
            all_paths[strlen(all_paths) - 1] = '\0';
            snprintf(copy_command, sizeof(copy_command),
                     "echo -n '%s' | xclip -selection clipboard", all_paths);
          }
        } else {
          int file_idx = filtered_indices[selected_index];
          char *path =
              (file_idx < file_count) ? strdup(files[file_idx].path) : NULL;
          pthread_mutex_unlock(&files_mutex);
          if (path) {
            char abs_path[PATH_MAX];
            if (realpath(path, abs_path)) {
              snprintf(copy_command, sizeof(copy_command),
                       "echo -n '%s' | xclip -selection clipboard", abs_path);
            }
            free(path);
          }
        }
        if (strlen(copy_command) > 0) {
          FILE *pipe = popen(copy_command, "w");
          if (pipe)
            pclose(pipe);
        }
      }
      break;
    case 25:
      if (filtered_count > 0) {
        pthread_mutex_lock(&files_mutex);
        int file_idx = filtered_indices[selected_index];
        char *path = (file_idx < file_count && !files[file_idx].is_dir)
                         ? strdup(files[file_idx].path)
                         : NULL;
        pthread_mutex_unlock(&files_mutex);
        if (path) {
          char cmd[2048];
          snprintf(cmd, sizeof(cmd), "cat '%s' | xclip -selection clipboard",
                   path);
          FILE *p = popen(cmd, "w");
          if (p)
            pclose(p);
          free(path);
        }
      }
      break;
    case 4:
      if (selected_count > 0 || filtered_count > 0) {
        char confirm_msg[1024] = {0};
        bool confirmed = false;
        if (selected_count > 0) {
          confirmed =
              rzf_show_confirmation(height, width, "Delete selected files?");
        } else {
          pthread_mutex_lock(&files_mutex);
          int idx = filtered_indices[selected_index];
          if (idx < file_count)
            snprintf(confirm_msg, sizeof(confirm_msg), "Delete '%s'?",
                     files[idx].path);
          pthread_mutex_unlock(&files_mutex);
          if (strlen(confirm_msg) > 0)
            confirmed = rzf_show_confirmation(height, width, confirm_msg);
        }
        if (confirmed) {
          if (selected_count > 0) {
            char **paths_to_delete = malloc(selected_count * sizeof(char *));
            int *is_dir_flags = malloc(selected_count * sizeof(int));
            int delete_count = 0;

            pthread_mutex_lock(&files_mutex);
            for (int i = 0; i < selected_count; i++) {
              if (selected_indices[i] < file_count) {
                paths_to_delete[delete_count] =
                    strdup(files[selected_indices[i]].path);
                is_dir_flags[delete_count] = files[selected_indices[i]].is_dir;
                if (paths_to_delete[delete_count])
                  delete_count++;
              }
            }
            pthread_mutex_unlock(&files_mutex);

            for (int i = 0; i < delete_count; i++) {
              if (is_dir_flags[i])
                rzf_recursive_delete(paths_to_delete[i]);
              else
                remove(paths_to_delete[i]);
              free(paths_to_delete[i]);
            }
            free(paths_to_delete);
            free(is_dir_flags);
            rzf_clear_selections();
          } else {
            pthread_mutex_lock(&files_mutex);
            int idx = filtered_indices[selected_index];
            char *p = (idx < file_count) ? strdup(files[idx].path) : NULL;
            int d = (idx < file_count) ? files[idx].is_dir : 0;
            pthread_mutex_unlock(&files_mutex);
            if (p) {
              if (d)
                rzf_recursive_delete(p);
              else
                remove(p);
              free(p);
            }
          }

          pthread_mutex_lock(&queue_mutex);
          for (int i = 0; i < queue_count; i++) {
            int idx = (queue_head + i) % DIR_QUEUE_CAPACITY;
            if (dir_queue[idx]) {
              free(dir_queue[idx]);
              dir_queue[idx] = NULL;
            }
          }
          queue_head = 0;
          queue_tail = 0;
          queue_count = 0;
          pthread_mutex_unlock(&queue_mutex);

          pthread_mutex_lock(&files_mutex);
          if (files) {
            for (int i = 0; i < file_count; i++) {
              free(files[i].path);
              free(files[i].lower_path);
            }
            free(files);
          }
          files = NULL;
          file_count = 0;
          file_capacity = 0;
          pthread_mutex_unlock(&files_mutex);

          if (indexing_started && !indexing_complete) {
            pthread_cancel(indexing_thread);
            pthread_join(indexing_thread, NULL);
          }
          indexing_complete = false;
          indexing_started = false;
          producer_finished = false;
          active_workers = 0;
          pthread_create(&indexing_thread, NULL, rzf_indexing_thread_func,
                         NULL);
        }
      }
      break;
    case 16:
      show_preview = !show_preview;
      break;
    case 18:
      if (history_count > 0) {
        history_index = (history_index + 1) % history_count;
        strcpy(search_query, search_history[history_index]);
      }
      break;
    case 19:
      if (filtered_count > 0) {
        pthread_mutex_lock(&files_mutex);
        int idx = filtered_indices[selected_index];
        if (idx < file_count) {
          char *p = files[idx].path;
          if (rzf_is_bookmarked(p))
            rzf_remove_bookmark(p);
          else
            rzf_add_bookmark(p);
        }
        pthread_mutex_unlock(&files_mutex);
      }
      break;
    case 6:
      show_bookmarks_only = !show_bookmarks_only;
      break;
    case 0:
      if (filtered_count > 0 && selected_count < MAX_SELECTED) {
        pthread_mutex_lock(&files_mutex);
        int idx = filtered_indices[selected_index];
        pthread_mutex_unlock(&files_mutex);
        rzf_toggle_selection(idx);
      }
      break;
    case 5:
      search_mode = (search_mode == SEARCH_FUZZY) ? SEARCH_REGEX : SEARCH_FUZZY;
      break;
    case 21: {
      char cwd[PATH_MAX];
      if (getcwd(cwd, sizeof(cwd))) {
        if (strcmp(cwd, "/") != 0) {
          if (chdir("..") == 0) {
            pthread_mutex_lock(&queue_mutex);
            for (int i = 0; i < queue_count; i++) {
              int idx = (queue_head + i) % DIR_QUEUE_CAPACITY;
              if (dir_queue[idx]) {
                free(dir_queue[idx]);
                dir_queue[idx] = NULL;
              }
            }
            queue_head = 0;
            queue_tail = 0;
            queue_count = 0;
            pthread_mutex_unlock(&queue_mutex);

            pthread_mutex_lock(&files_mutex);
            if (files) {
              for (int i = 0; i < file_count; i++) {
                free(files[i].path);
                free(files[i].lower_path);
              }
              free(files);
            }
            files = NULL;
            file_count = 0;
            file_capacity = 0;
            pthread_mutex_unlock(&files_mutex);

            if (indexing_started && !indexing_complete) {
              pthread_cancel(indexing_thread);
              pthread_join(indexing_thread, NULL);
            }
            indexing_complete = false;
            indexing_started = false;
            producer_finished = false;
            active_workers = 0;
            pthread_create(&indexing_thread, NULL, rzf_indexing_thread_func,
                           NULL);
            search_query[0] = '\0';
            selected_index = 0;
            scroll_offset = 0;
          }
        }
      }
    } break;
    case 11:
      if (filtered_count > 0) {
        char *cmd = rzf_prompt_for_command(height, width);
        if (cmd && strlen(cmd) > 0) {
          pthread_mutex_lock(&files_mutex);
          int idx = filtered_indices[selected_index];
          char *fp = (idx < file_count) ? strdup(files[idx].path) : NULL;
          pthread_mutex_unlock(&files_mutex);
          if (fp) {
            size_t fc_size = strlen(cmd) + strlen(fp) + 10;
            char *fc = malloc(fc_size);
            if (fc) {
              snprintf(fc, fc_size, "%s '%s'", cmd, fp);
              endwin();
              system(fc);
              printf("\nPress any key to continue...");
              getchar();
              initscr();
              raw();
              noecho();
              keypad(stdscr, TRUE);
              curs_set(0);
              timeout(100);
              free(fc);
            }
            free(fp);
          }
        }
        if (cmd)
          free(cmd);
      }
      break;
    case 22:
      sort_mode = (sort_mode + 1) % 3;
      rzf_sort_files();
      break;
    case '?':
      rzf_draw_help_window(height, width);
      break;
    case KEY_BACKSPACE:
    case 127:
      if (strlen(search_query) > 0) {
        search_query[strlen(search_query) - 1] = '\0';
      }
      break;
    default:
      if (isprint(ch) && strlen(search_query) < sizeof(search_query) - 1) {
        strncat(search_query, (char *)&ch, 1);
      }
      break;
    }

    char *filter_start = strchr(search_query, ':');
    char file_type_filter[32] = {0};
    if (filter_start && strlen(filter_start) < sizeof(file_type_filter)) {
      strcpy(file_type_filter, filter_start);
    }
    pthread_mutex_lock(&files_mutex);
    current_file_count = file_count;
    if (current_file_count > filtered_capacity) {
      filtered_capacity = current_file_count * 2;
      int *new_filtered =
          realloc(filtered_indices, filtered_capacity * sizeof(int));
      if (!new_filtered) {
        pthread_mutex_unlock(&files_mutex);
        continue;
      }
      filtered_indices = new_filtered;
    }
    filtered_count = 0;
    if (current_file_count > 0) {
      char search_pattern[256];
      if (filter_start) {
        size_t len = filter_start - search_query;
        if (len >= sizeof(search_pattern))
          len = sizeof(search_pattern) - 1;
        strncpy(search_pattern, search_query, len);
        search_pattern[len] = '\0';
      } else {
        strncpy(search_pattern, search_query, sizeof(search_pattern) - 1);
        search_pattern[sizeof(search_pattern) - 1] = '\0';
      }
      char *lower_query = rzf_to_lower(search_pattern);
      if (lower_query) {
        for (int i = 0; i < current_file_count; i++) {
          if (show_bookmarks_only && !rzf_is_bookmarked(files[i].path))
            continue;
          if (file_type_filter[0] && !files[i].is_dir &&
              !rzf_matches_file_type_filter(files[i].path, file_type_filter))
            continue;
          bool m = (search_mode == SEARCH_REGEX && strlen(search_pattern) > 0)
                       ? rzf_regex_match(files[i].path, search_pattern)
                       : (strstr(files[i].lower_path, lower_query) != NULL);
          if (m)
            filtered_indices[filtered_count++] = i;
        }
        free(lower_query);
      }
    }
    pthread_mutex_unlock(&files_mutex);
    if (selected_index >= filtered_count) {
      selected_index = filtered_count > 0 ? filtered_count - 1 : 0;
    }

    move(0, 0);
    clrtoeol();
    attron(A_BOLD);
    int prompt_end;
    if (!indexing_complete) {
      prompt_end = mvprintw(0, 0, "%s%sSearch: %s (indexing... %d files)",
                            search_mode == SEARCH_REGEX ? "[REGEX] " : "",
                            show_bookmarks_only ? "[*] " : "", search_query,
                            current_file_count);
    } else {
      const char *sort_str = sort_mode == SORT_SIZE
                                 ? "[SIZE] "
                                 : (sort_mode == SORT_DATE ? "[DATE] " : "");
      prompt_end = mvprintw(0, 0, "%s%s%sSearch: %s", sort_str,
                            search_mode == SEARCH_REGEX ? "[REGEX] " : "",
                            show_bookmarks_only ? "[*] " : "", search_query);
    }
    if (selected_count > 0)
      mvprintw(0, prompt_end + 2, "(%d selected)", selected_count);
    attroff(A_BOLD);

    werase(file_list_win);
    pthread_mutex_lock(&files_mutex);
    for (int i = 0; i < list_height && (i + scroll_offset) < filtered_count;
         ++i) {
      int current_index = i + scroll_offset;
      if (current_index >= filtered_count)
        continue;
      int file_idx = filtered_indices[current_index];
      if (file_idx >= file_count)
        continue;
      FileInfo *file = &files[file_idx];
      char size_buf[10];
      if (!file->is_dir)
        rzf_format_size(file->size, size_buf);
      else
        strcpy(size_buf, "");
      char time_buf[20];
      strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M",
               localtime(&file->mtime));
      char git_char = file->git_status;
      char display_line[list_width + 1];
      snprintf(display_line, sizeof(display_line), "%c%s %s %s",
               git_char != ' ' ? git_char : ' ',
               rzf_is_bookmarked(file->path) ? "*" : " ",
               file->is_dir ? "[D]" : "   ", file->path);
      int path_len = strlen(display_line);
      if (list_width - path_len > 30) {
        snprintf(display_line + path_len, list_width - path_len, "%*s %s",
                 list_width - path_len - 20, size_buf, time_buf);
      }
      if (rzf_is_selected(file_idx))
        wattron(file_list_win, COLOR_PAIR(8));
      else if (current_index == selected_index)
        wattron(file_list_win, COLOR_PAIR(1) | A_BOLD);
      else if (rzf_is_bookmarked(file->path))
        wattron(file_list_win, COLOR_PAIR(7));
      else if (file->git_status == 'M')
        wattron(file_list_win, COLOR_PAIR(5));
      else if (file->git_status == '?')
        wattron(file_list_win, COLOR_PAIR(6));
      else if (file->is_dir)
        wattron(file_list_win, COLOR_PAIR(2) | A_BOLD);
      mvwprintw(file_list_win, i, 0, "%.*s", list_width, display_line);
      wattroff(file_list_win, A_REVERSE | A_BOLD | COLOR_PAIR(1) |
                                  COLOR_PAIR(2) | COLOR_PAIR(5) |
                                  COLOR_PAIR(6) | COLOR_PAIR(7) |
                                  COLOR_PAIR(8));
    }
    pthread_mutex_unlock(&files_mutex);

    char *preview_path = NULL;
    if (show_preview && filtered_count > 0) {
      pthread_mutex_lock(&files_mutex);
      int idx = filtered_indices[selected_index];
      if (idx < file_count)
        preview_path = files[idx].path;
      pthread_mutex_unlock(&files_mutex);
    }
    pthread_mutex_lock(&preview_mutex);
    if (preview_path &&
        (resized || strcmp(preview_path, last_preview_path) != 0)) {
      rzf_draw_file_preview(preview_win, preview_path);
      strncpy(last_preview_path, preview_path, PATH_MAX - 1);
      last_preview_path[PATH_MAX - 1] = '\0';
    }
    if (!show_preview)
      last_preview_path[0] = '\0';
    pthread_mutex_unlock(&preview_mutex);

    move(height - 1, 0);
    clrtoeol();
    char footer_text[256];
    snprintf(footer_text, sizeof(footer_text),
             "^V:Sort %s | ^P:Preview | ^S:Bookmark | ^F:%s | ^E:%s | ?:Help | "
             "^C:Quit",
             sort_mode == SORT_NAME
                 ? "NAME"
                 : (sort_mode == SORT_SIZE ? "SIZE" : "DATE"),
             show_bookmarks_only ? "ALL" : "*ONLY",
             search_mode == SEARCH_FUZZY ? "REGEX" : "FUZZY");
    attron(COLOR_PAIR(3) | A_BOLD);
    mvprintw(height - 1, 0, "%-*s", width, footer_text);
    attroff(COLOR_PAIR(3) | A_BOLD);

    wnoutrefresh(stdscr);
    wnoutrefresh(file_list_win);
    if (preview_win)
      wnoutrefresh(preview_win);
    doupdate();
  }
end_loop:
  if (strlen(search_query) > 0) {
    rzf_add_to_history(search_query);
    rzf_save_history();
  }
  if (preview_win)
    delwin(preview_win);
  if (file_list_win)
    delwin(file_list_win);
  endwin();
  free(filtered_indices);
  return command;
}

void rzf_free_files() {
  pthread_mutex_lock(&files_mutex);
  if (files) {
    for (int i = 0; i < file_count; i++) {
      free(files[i].path);
      free(files[i].lower_path);
    }
    free(files);
    files = NULL;
  }
  pthread_mutex_unlock(&files_mutex);
}

void rzf_free_bookmarks() {
  for (int i = 0; i < bookmark_count; i++) {
    free(bookmarks[i]);
  }
}

int main() {
  signal(SIGINT, rzf_cleanup_terminal);
  signal(SIGTERM, rzf_cleanup_terminal);
  signal(SIGHUP, rzf_cleanup_terminal);

  pthread_create(&indexing_thread, NULL, rzf_indexing_thread_func, NULL);
  
  char *file_to_open = NULL;
  char *command = rzf_run_interface(&file_to_open);
  if (command && file_to_open) {
    // Fork and execute
    pid_t pid = fork();
    if (pid == 0) {
      // Child process
      if (strcmp(command, "xdg-open") == 0) {
        // For xdg-open, we need to detach from the terminal
        setsid();
        // Redirect stdout/stderr to /dev/null to avoid terminal corruption
        freopen("/dev/null", "w", stdout);
        freopen("/dev/null", "w", stderr);
      }
      
      execlp(command, command, file_to_open, (char *)NULL);
      perror("execlp failed");
      exit(EXIT_FAILURE);
    } else if (pid > 0) {
      // Parent process
      if (strcmp(command, "vim") == 0) {
        // Wait for vim to finish
        wait(NULL);
      }
      // For xdg-open, don't wait - let it run in background
    } else {
      perror("fork failed");
    }
  }
    return 0;
  // Clean up indexing thread
  if (indexing_started && !indexing_complete) {
    pthread_cancel(indexing_thread);
  }
  pthread_join(indexing_thread, NULL);

  // Clean up queue
  pthread_mutex_lock(&queue_mutex);
  for (int i = 0; i < queue_count; i++) {
    int idx = (queue_head + i) % DIR_QUEUE_CAPACITY;
    if (dir_queue[idx]) {
      free(dir_queue[idx]);
      dir_queue[idx] = NULL;
    }
  }
  pthread_mutex_unlock(&queue_mutex);

  // Execute the command if we have one
    
  // Clean up memory
  if (file_to_open)
    free(file_to_open);
  if (command)
    free(command);

  rzf_free_files();
  rzf_free_bookmarks();
  
  // Destroy mutexes
  pthread_mutex_destroy(&files_mutex);
  pthread_mutex_destroy(&queue_mutex);
  pthread_mutex_destroy(&git_queue_mutex);
  pthread_mutex_destroy(&git_root_mutex);
  pthread_mutex_destroy(&preview_mutex);
  pthread_cond_destroy(&queue_cond);
  
  return 0;
}