wsh.c

#include "wsh.h"
#include "dynamic_array.h"
#include "utils.h"
#include "hash_map.h"

#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <unistd.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>

DynamicArray *history_da = NULL;
char *current_path = NULL;
int rc;
HashMap *alias_hm = NULL;

/***************************************************
 * Helper Functions
 ***************************************************/
//Remove in a bit
void *debug_strdup(const char *s, const char *file, int line) {
    void *result = strdup(s);
    fprintf(stderr, "STRDUP: %p '%s' at %s:%d\n", result, s, file, line);
    return result;
}

/**
 * @Brief Free any allocated global resources
 */
void wsh_free(void)
{
  // Free any allocated resources here
    if (alias_hm != NULL) { 
        hm_free(alias_hm); 
        alias_hm = NULL; 
    }
    if (history_da != NULL) {
        da_free(history_da);
        history_da = NULL;
    }
    if (current_path != NULL) {
        free(current_path);
        current_path = NULL;
    }
}

/**
 * @Brief Cleanly exit the shell after freeing resources
 *
 * @param return_code The exit code to return
 */
void clean_exit(int return_code)
{
  wsh_free();
  exit(return_code);
}

/**
 * @Brief Print a warning message to stderr and set the return code
 *
 * @param msg The warning message format string
 * @param ... Additional arguments for the format string
 */
void wsh_warn(const char *msg, ...)
{
  va_list args;
  va_start(args, msg);

  vfprintf(stderr, msg, args);
  va_end(args);
  rc = EXIT_FAILURE;
}

/**
 * @brief Read a line from a file descriptor
 */
ssize_t read_line(int fd, char *buffer, size_t size)
{
    size_t i = 0;
    char c;
    ssize_t bytes_read = 0;
    
    while (i < size - 1) {
        bytes_read = read(fd, &c, 1);
        if (bytes_read == 0) {
            break;  // EOF
        }
        if (bytes_read < 0) {
            return -1;  // Error
        }
        
        buffer[i++] = c;
        if (c == '\n') {
            break;  // End of line
        }
    }
    
    buffer[i] = '\0';
    return (i > 0 || bytes_read > 0) ? i : 0;
}

/**
 * @Brief Main entry point for the shell
 *
 * @param argc Number of arguments
 * @param argv Array of argument strings
 * @return
 */
int main(int argc, char **argv)
{
  alias_hm = hm_create();
  setenv("PATH", "/bin", 1);
  if (argc > 2)
  {
    wsh_warn(INVALID_WSH_USE);
    return EXIT_FAILURE;
  }
  switch (argc)
  {
    case 1:
      interactive_main();
      break;
    case 2:
      rc = batch_main(argv[1]);
      break;
    default:
      break;
  }
  wsh_free();
  return rc;
}

/**
 * @brief Parse a command line into pipeline segments
 */
int parse_pipeline(const char *cmdline, char ***commands, int *argcs)
{
    char *copy = strdup(cmdline);
    char *segment;
    char *saveptr = NULL;
    int num_commands = 0;
    
    // Split by | to get pipeline segments
    segment = strtok_r(copy, "|", &saveptr);
    while (segment && num_commands < 128) {
        while (*segment == ' ') segment++;
        char *end = segment + strlen(segment) - 1;
        while (end > segment && *end == ' ') end--;
        *(end + 1) = '\0';
        
        // Parse each segment into arguments
        char *argv[MAX_ARGS];
        int argc = 0;
        
        parseline_no_subst(segment, argv, &argc);
        
        // store the segment, even if empty
        commands[num_commands] = malloc(sizeof(char*) * (argc + 1));
        for (int i = 0; i < argc; i++) {
            commands[num_commands][i] = strdup(argv[i]);
        }
        commands[num_commands][argc] = NULL;
        argcs[num_commands] = argc;
        num_commands++;
        
        // Free the parsed arguments
        for (int i = 0; i < argc; i++) free(argv[i]);
        
        segment = strtok_r(NULL, "|", &saveptr);
    }
    
    free(copy);
    copy = NULL;
    segment = NULL;
    saveptr = NULL;
    return num_commands;
}

/**
 * @brief Add command to history
 */
void add_to_history(const char *cmdline)
{
    if (!history_da) {
        history_da = da_create(100);
    }
    
    // Skip empty commands
    if (!cmdline || strlen(cmdline) == 0) return;
    
    // Don't add duplicate consecutive commands
    if (history_da->size > 0) {
        char *last = da_get(history_da, history_da->size - 1);
        if (last && strcmp(last, cmdline) == 0) return;
    }
    
    da_put(history_da, cmdline);
}

/**
 * @Brief Expand aliases in command line (only first token)
 */
char *expand_aliases(const char *cmdline)
{
    if (!cmdline || !alias_hm || strlen(cmdline) == 0) {
        return strdup(cmdline);
    }
    
    // Parse first token only
    char *argv[MAX_ARGS];
    int argc = 0;
    parseline_no_subst(cmdline, argv, &argc);
    
    if (argc == 0) {
        return strdup(cmdline);
    }
    
    // Check if first token is an alias
    char *alias_cmd = hm_get(alias_hm, argv[0]);
    if (!alias_cmd) {
        // Free parsed arguments and return original
        for (int i = 0; i < argc; i++) free(argv[i]);
        return strdup(cmdline);
    }
    
    // Handle empty alias command
    if (strlen(alias_cmd) == 0) {
        // If alias is empty, just use the remaining arguments
        if (argc == 1) {
            // No arguments, return empty string
            for (int i = 0; i < argc; i++) free(argv[i]);
            return strdup("");
        } else {
            // Skip the first token (the alias name)
            char *new_cmd = strdup(argv[1]);
            for (int i = 2; i < argc; i++) {
                new_cmd = append(new_cmd, " ");
                new_cmd = append(new_cmd, argv[i]);
            }
            for (int i = 0; i < argc; i++) free(argv[i]);
            return new_cmd;
        }
    }
    
    // Build new command with alias expansion
    char *new_cmd = strdup(alias_cmd);
    for (int i = 1; i < argc; i++) {
        new_cmd = append(new_cmd, " ");
        new_cmd = append(new_cmd, argv[i]);
    }

    // Free parsed arguments
    for (int i = 0; i < argc; i++) free(argv[i]);
    
    return new_cmd;
}

/**
 * @Brief Find executable in PATH
 */
char *find_executable(const char *cmd)
{
    if (!cmd || strlen(cmd) == 0) return NULL;
    
    // If command starts with . or /, it's a path - check if executable
    if (cmd[0] == '.' || cmd[0] == '/') {
        if (access(cmd, X_OK) == 0) {
            return strdup(cmd);
        }
        return NULL;
    }
    
    // Get PATH
    char *path_env = getenv("PATH");
    if (!path_env || strlen(path_env) == 0) {
        return NULL;
    }
    
    // Search in PATH directories
    char *path_copy = strdup(path_env);
    if (!path_copy) {
        perror("strdup");
        return NULL;
    }
    
    char *dir = strtok(path_copy, ":");
    char *result = NULL;
    
    while (dir) {
        // Build full path: dir/cmd
        size_t full_len = strlen(dir) + strlen(cmd) + 2;
        char *full_path = malloc(full_len);
        if (!full_path) {
            perror("malloc");
            free(path_copy);
            return NULL;
        }
        
        snprintf(full_path, full_len, "%s/%s", dir, cmd);
        
        if (access(full_path, X_OK) == 0) {
            result = full_path;  // Found it
            break;
        }
        
        free(full_path);
        dir = strtok(NULL, ":");
    }
    
    free(path_copy);
    return result;
}

/**
 * @Brief Execute external command
 */
int find_and_execute(char **argv, int argc)
{
    if (argc == 0) return EXIT_SUCCESS;
    
    // Check for empty PATH first
    char *path_env = getenv("PATH");
    if (!path_env || strlen(path_env) == 0) {
        wsh_warn(EMPTY_PATH);
        return EXIT_FAILURE;
    }
    
    // Find executable
    char *exec_path = find_executable(argv[0]);
    if (!exec_path) {
        wsh_warn(CMD_NOT_FOUND, argv[0]);
        return EXIT_FAILURE;
    }
    
    // Execute
    pid_t pid = fork();
    if (pid == 0) {
        // Child process
        execv(exec_path, argv);
        // If execv returns, there was an error
        perror("execv");
        free(exec_path);
        exit(EXIT_FAILURE);
    } else if (pid > 0) {
        // Parent process - WAIT for child to complete
        int status;
        waitpid(pid, &status, 0);
        free(exec_path);
        
        if (WIFEXITED(status)) {
            return WEXITSTATUS(status);
        } else {
            return EXIT_FAILURE;
        }
    } else {
        // Fork failed
        perror("fork");
        free(exec_path);
        return EXIT_FAILURE;
    }
}

/**
 * @brief Execute pipeline of commands
 */
int execute_pipeline(char ***commands, int *argcs, int num_commands)
{
    
    if (num_commands == 0) return EXIT_SUCCESS;
    if (num_commands == 1) return execute_command(commands[0], argcs[0]);
    
    int prev_pipe[2] = {-1, -1};
    int next_pipe[2];
    pid_t pids[num_commands];
    int overall_status = EXIT_SUCCESS;
    
    // Create all processes
    for (int i = 0; i < num_commands; i++) {
        
        // Create pipe for all but last command
        if (i < num_commands - 1) {
            if (pipe(next_pipe) == -1) {
                perror("pipe");
                return EXIT_FAILURE;
            }
        }
        
        pids[i] = fork();
        if (pids[i] == 0) {
            // Child process
            if (i > 0) {
                dup2(prev_pipe[0], STDIN_FILENO);
            }
            if (i < num_commands - 1) {
                dup2(next_pipe[1], STDOUT_FILENO);
            }
            
            if (i > 0) {
                close(prev_pipe[0]);
                close(prev_pipe[1]);
            }
            if (i < num_commands - 1) {
                close(next_pipe[0]);
                close(next_pipe[1]);
            }
            
            // Execute command
            execute_command(commands[i], argcs[i]);
            exit(overall_status); // Should never reach here
        } else if (pids[i] < 0) {
            perror("fork");
            return EXIT_FAILURE;
        }
        
        if (i > 0) {
            close(prev_pipe[0]);
            close(prev_pipe[1]);
        }
        
        if (i < num_commands - 1) {
            prev_pipe[0] = next_pipe[0];
            prev_pipe[1] = next_pipe[1];
        }
    }
    
    if (num_commands > 1) {
        close(prev_pipe[0]);
        close(prev_pipe[1]);
    }
    
    // Wait for all children
    for (int i = 0; i < num_commands; i++) {
        int status;
        waitpid(pids[i], &status, 0);
        if (i == num_commands - 1) {
            overall_status = WEXITSTATUS(status);
        }
    }

    return overall_status;
}

/**
 * @Brief Execute a single command (builtin or external)
 */
int execute_command(char **argv, int argc)
{
    if (argc == 0) return EXIT_SUCCESS;
    
    if (strcmp(argv[0], "exit") == 0) {
        int result = wsh_exit(argv, argc);
        return result;
    } else if (strcmp(argv[0], "alias") == 0) {
        int result = wsh_alias(argv, argc);
        return result;
    } else if (strcmp(argv[0], "unalias") == 0) {
        int result = wsh_unalias(argv, argc);
        return result;
    } else if (strcmp(argv[0], "which") == 0) {
        int result = wsh_which(argv, argc);
        return result;
    } else if (strcmp(argv[0], "path") == 0) {
        int result = wsh_path(argv, argc);
        return result;
    } else if (strcmp(argv[0], "cd") == 0) {
        int result = wsh_cd(argv, argc);
        return result;
    } else if (strcmp(argv[0], "history") == 0) {
        int result = wsh_history(argv, argc);
        return result;
    } else {
        // External command
        int result = find_and_execute(argv, argc);
        return result;
    }
}

/**
 * @Brief Exit built-in command
 */
int wsh_exit(char **argv, int argc)
{
    (void)argv; // Mark parameter as unused to avoid warning
    
    if (argc > 1) {
        wsh_warn(INVALID_EXIT_USE);
        return EXIT_FAILURE;
    }
    clean_exit(rc);
    return EXIT_SUCCESS; // Never reached
}

/**
 * @brief Alias built-in command
 */
int wsh_alias(char **argv, int argc)
{
    if (argc == 1) {
        // Print all aliases sorted
        hm_print_sorted(alias_hm);
        return EXIT_SUCCESS;
    }
    if (argc == 4 && strcmp(argv[2], "=") == 0) {
        char *name = argv[1];
        char *command = argv[3];
        
        // Validate name
        if (strlen(name) == 0) {
            wsh_warn(INVALID_ALIAS_USE);
            return EXIT_SUCCESS;
        }
        
        // Remove surrounding single quotes if present
        char *clean_command;
        size_t cmd_len = strlen(command);
        if (cmd_len >= 2 && command[0] == '\'' && command[cmd_len-1] == '\'') {
            clean_command = malloc(cmd_len - 1);
            strncpy(clean_command, command + 1, cmd_len - 2);
            clean_command[cmd_len - 2] = '\0';
        } else {
            clean_command = strdup(command);
        }
        
        hm_put(alias_hm, name, clean_command);
        free(clean_command);
        return EXIT_SUCCESS;
    }
    else if (argc >= 5 && strcmp(argv[2], "=") == 0) {
        wsh_warn(INVALID_ALIAS_USE);
        return EXIT_SUCCESS;
    }
    else if (argc >= 4 && strcmp(argv[2], "=") != 0) {
        wsh_warn(INVALID_ALIAS_USE);
        return EXIT_SUCCESS;
    }
    else if (argc == 4 && strcmp(argv[2], "=") == 0) {
        char *name = argv[1];
        char *command = argv[3];
        
        // Validate name
        if (strlen(name) == 0) {
            wsh_warn(INVALID_ALIAS_USE);
            return EXIT_SUCCESS;
        }
        
        hm_put(alias_hm, name, command);
        return EXIT_SUCCESS;
    }
    else if (argc == 3 && strcmp(argv[2], "=") != 0) {
        char *name = argv[1];
        char *command = argv[2];
        
        // Validate name
        if (strlen(name) == 0) {
            wsh_warn(INVALID_ALIAS_USE);
            return EXIT_SUCCESS;
        }
        
        hm_put(alias_hm, name, command);
        return EXIT_SUCCESS;
    }
    else if (argc == 3 && strcmp(argv[2], "=") == 0) {
        char *name = argv[1];
        
        // Validate name
        if (strlen(name) == 0) {
            wsh_warn(INVALID_ALIAS_USE);
            return EXIT_SUCCESS;
        }
        
        hm_put(alias_hm, name, "");
        return EXIT_SUCCESS;
    }
    else if (argc == 2) {
        char *arg = argv[1];
        char *equals = strchr(arg, '=');
        
        if (!equals) {
            wsh_warn(INVALID_ALIAS_USE);
            return EXIT_SUCCESS;
        }
        
        // Split without modifying original
        size_t name_len = equals - arg;
        char *name = malloc(name_len + 1);
        strncpy(name, arg, name_len);
        name[name_len] = '\0';
        
        char *command = strdup(equals + 1);
        
        // Validate name
        if (strlen(name) == 0) {
            wsh_warn(INVALID_ALIAS_USE);
            free(name);
            free(command);
            return EXIT_SUCCESS;
        }
        
        hm_put(alias_hm, name, command);
        free(name);
        free(command);
        return EXIT_SUCCESS;
    }
    else {
        wsh_warn(INVALID_ALIAS_USE);
        return EXIT_SUCCESS;
    }
}

/**
 * @brief Unalias built-in command
 */
int wsh_unalias(char **argv, int argc)
{
    if (argc != 2) {
        wsh_warn(INVALID_UNALIAS_USE);
        return EXIT_FAILURE;
    }
    
    hm_delete(alias_hm, argv[1]);
    return EXIT_SUCCESS;
}

/**
 * @brief Which built-in command
 */
int wsh_which(char **argv, int argc)
{
    if (argc != 2) {
        wsh_warn(INVALID_WHICH_USE);
        return EXIT_FAILURE;
    }
    
    char *name = argv[1];
    
    // Check if it's an alias
    char *alias_cmd = hm_get(alias_hm, name);
    if (alias_cmd) {
        printf(WHICH_ALIAS, name, alias_cmd);
        return EXIT_SUCCESS;
    }
    
    // Check if it's a built-in
    if (strcmp(name, "exit") == 0 || strcmp(name, "alias") == 0 ||
        strcmp(name, "unalias") == 0 || strcmp(name, "which") == 0 ||
        strcmp(name, "path") == 0 || strcmp(name, "cd") == 0 ||
        strcmp(name, "history") == 0) {
        printf(WHICH_BUILTIN, name);
        return EXIT_SUCCESS;
    }
    
    // Check if it's an executable
    char *exec_path = find_executable(name);
    if (exec_path) {
        printf(WHICH_EXTERNAL, name, exec_path);
        free(exec_path);
        return EXIT_SUCCESS;
    }
    
    // Not found
    printf(WHICH_NOT_FOUND, name);
    return EXIT_FAILURE;
}

/**
 * @brief Path built-in command
 */
int wsh_path(char **argv, int argc)
{
    if (argc == 1) {
        // Print current PATH
        char *path = getenv("PATH");
        if (path) {
            printf("%s\n", path);
        } else {
            printf("\n");  // Print empty line if PATH not set
        }
        return EXIT_SUCCESS;
    }
    
    if (argc > 2) {
        wsh_warn(INVALID_PATH_USE);
        return EXIT_FAILURE;
    }
    
    // Set new PATH
    if (setenv("PATH", argv[1], 1) != 0) {
        perror("setenv");
        return EXIT_FAILURE;
    }
    
    return EXIT_SUCCESS;
}

/**
 * @brief Change directory built-in command
 */
int wsh_cd(char **argv, int argc)
{
    char *target_dir = NULL;
    
    if (argc == 1) {
        // cd with no arguments - go to HOME
        target_dir = getenv("HOME");
        if (!target_dir) {
            wsh_warn(CD_NO_HOME);
            return EXIT_FAILURE;
        }
    } else if (argc == 2) {
        target_dir = argv[1];
    } else {
        wsh_warn(INVALID_CD_USE);
        return EXIT_FAILURE;
    }
    
    if (chdir(target_dir) != 0) {
        perror("cd");
        return EXIT_FAILURE;
    }
    
    return EXIT_SUCCESS;
}

/**
 * @brief History built-in command
 */
int wsh_history(char **argv, int argc)
{
    if (!history_da || history_da->size == 0) {
        return EXIT_SUCCESS;
    }
    
    if (argc == 1) {
        // Print all history WITHOUT line numbers
        for (size_t i = 0; i < history_da->size; i++) {
            printf("%s\n", da_get(history_da, i));
        }
        return EXIT_SUCCESS;
    }
    
    if (argc == 2) {
        // Print specific history entry: history n
        char *endptr;
        long n = strtol(argv[1], &endptr, 10);
        
        // Validate argument - must be a number
        if (*endptr != '\0' || n < 1) {
            wsh_warn(HISTORY_INVALID_ARG);
            return EXIT_FAILURE;
        }
        
        // If n > history size, print the last command
        if ((size_t)n > history_da->size) {
            n = history_da->size;
        }
        
        // Print the nth command (1-based index)
        printf("%s\n", da_get(history_da, n - 1));
        return EXIT_SUCCESS;
    }
    
    wsh_warn(INVALID_HISTORY_USE);
    return EXIT_FAILURE;
}

/***************************************************
 * Modes of Execution
 ***************************************************/

/**
 * @Brief Interactive mode: print prompt and wait for user input
 * execute the given input and repeat
 */
void interactive_main(void)
{
    char line[MAX_LINE];
    
    while (1) {
        printf(PROMPT);
        fflush(stdout);
        
        if (fgets(line, sizeof(line), stdin) == NULL) {
            if (feof(stdin)) {
                printf("\n");
                break;
            } else {
                wsh_warn("fgets error\n");
                continue;
            }
        }
        
        line[strcspn(line, "\n")] = 0;
        if (strlen(line) == 0) continue;
        
        char *expanded = expand_aliases(line);
        
        // Check if this is a pipeline
        if (strchr(expanded, '|') != NULL) {
            // Handle as pipeline
            char **commands[128];  // Array of command arrays (char**)
            int argcs[128];        // Array of argument counts
            int num_commands = parse_pipeline(expanded, commands, argcs);

            if (num_commands > 0) {
                // Check for empty segments
                int has_empty_segment = 0;
                for (int i = 0; i < num_commands; i++) {
                    if (argcs[i] == 0) {
                        wsh_warn(EMPTY_PIPE_SEGMENT);
                        has_empty_segment = 1;
                        break;
                    }
                }
                
                if (!has_empty_segment) {
                    rc = execute_pipeline(commands, argcs, num_commands);
                    for (int i = 0; i < num_commands; i++) {
                        for (int j = 0; j < argcs[i]; j++) {
                            free(commands[i][j]);
                        }
                        free(commands[i]);
                    }
                } else {
                    rc = EXIT_FAILURE;
                    for (int i = 0; i < num_commands; i++) {
                        for (int j = 0; j < argcs[i]; j++) {
                            free(commands[i][j]);
                        }
                        free(commands[i]);
                    }
                }
            }
        } else {
            // Handle as single command
            char *argv[MAX_ARGS];
            int argc = 0;
            parseline_no_subst(expanded, argv, &argc);
            
            if (argc > 0) {
                rc = execute_command(argv, argc);
            }
            
            for (int i = 0; i < argc; i++) {
                free(argv[i]);
            }
        }

        add_to_history(line);
        
        free(expanded);
    }

    wsh_free();
    clean_exit(EXIT_SUCCESS); // Clean exit
}

/**
 * @brief Batch mode: read commands from script file line by line
 */
int batch_main(const char *script_file)
{
    int fd = open(script_file, O_RDONLY);
    if (fd == -1) {
        // File doesn't exist - print the expected error message
        perror("fopen");
        return EXIT_FAILURE;
    }
    
    char line[MAX_LINE];
    int line_num = 0;
    int last_status = EXIT_SUCCESS;
    
    while (1) {
        ssize_t bytes_read = read_line(fd, line, sizeof(line));
        
        if (bytes_read < 0) {
            perror("read");
            break;
        }
        
        if (bytes_read == 0) {
            break;
        }
        
        line_num++;
        
        // Remove trailing newline if present
        if (bytes_read > 0 && line[bytes_read - 1] == '\n') {
            line[bytes_read - 1] = '\0';
        }
        
        // Skip empty lines and comments
        if (strlen(line) == 0 || line[0] == '#') {
            continue;
        }
        
        // Expand aliases
        char *expanded = expand_aliases(line);
        
        // Check if this is a pipeline
        if (strchr(expanded, '|') != NULL) {
            // Handle as pipeline
            char **commands[128];
            int argcs[128];
            int num_commands = parse_pipeline(expanded, commands, argcs);
            
            if (num_commands > 0) {
                // Check for empty segments
                int has_empty_segment = 0;
                for (int i = 0; i < num_commands; i++) {
                    if (argcs[i] == 0) {
                        wsh_warn(EMPTY_PIPE_SEGMENT);
                        has_empty_segment = 1;
                        break;
                    }
                }
                
                if (!has_empty_segment) {
                    last_status = execute_pipeline(commands, argcs, num_commands);
                } else {
                    last_status = EXIT_FAILURE;
                }
            }
            
            for (int i = 0; i < num_commands; i++) {
                for (int j = 0; j < argcs[i]; j++) {
                    free(commands[i][j]);
                }
                free(commands[i]);
            }
        } else {
            // Handle as single command
            char *argv[MAX_ARGS];
            int argc = 0;
            parseline_no_subst(expanded, argv, &argc);
            
            if (argc > 0) {
                last_status = execute_command(argv, argc);
            }
            
            for (int i = 0; i < argc; i++) {
                free(argv[i]);
            }
        }

        // Add to history
        add_to_history(line);

        free(expanded);
        
        // Flush output
        fflush(stdout);
        fflush(stderr);
    }
    

    close(fd);
    return last_status;
}

/***************************************************
 * Parsing
 ***************************************************/

/**
 * @Brief Parse a command line into arguments without doing
 * any alias substitutions.
 * Handles single quotes to allow spaces within arguments.
 *
 * @param cmdline The command line to parse
 * @param argv Array to store the parsed arguments (must be preallocated)
 * @param argc Pointer to store the number of parsed arguments
 */
void parseline_no_subst(const char *cmdline, char **argv, int *argc)
{
  if (!cmdline)
  {
    *argc = 0;
    argv[0] = NULL;
    return;
  }
  char *buf = strdup(cmdline);
  if (!buf)
  {
    perror("strdup");
    clean_exit(EXIT_FAILURE);
  }
  /* Replace trailing newline with space */
  const size_t len = strlen(buf);
  if (len > 0 && buf[len - 1] == '\n')
    buf[len - 1] = ' ';
  else
  {
    char *new_buf = realloc(buf, len + 2);
    if (!new_buf)
    {
      perror("realloc");
      free(buf);
      clean_exit(EXIT_FAILURE);
    }
    buf = new_buf;
    strcat(buf, " ");
  }

  int count = 0;
  char *p = buf;
  while (*p && *p == ' ')
    p++; /* skip leading spaces */

  while (*p)
  {
    char *token_start = p;
    char *token = NULL;
    if (*p == '\'')
    {
      token_start = ++p;
      token = strchr(p, '\'');
      if (!token)
      {
        /* Handle missing closing quote - Print `Missing closing quote` to stderr */
        wsh_warn(MISSING_CLOSING_QUOTE);
        free(buf);
        for (int i = 0; i < count; i++) free(argv[i]);
        *argc = 0;
        argv[0] = NULL;
        return;
      }
      *token = '\0';
      p = token + 1;
    }
    else
    {
      token = strchr(p, ' ');
      if (!token)
        break;
      *token = '\0';
      p = token + 1;
    }
    argv[count] = strdup(token_start);
    if (!argv[count]) {
      perror("strdup");
      for (int i = 0; i < count; i++) free(argv[i]);
      free(buf);
      clean_exit(EXIT_FAILURE);
    }
    count++;
    while (*p && (*p == ' '))
      p++;
  }
  argv[count] = NULL;
  *argc = count;
  free(buf);
}