#define _POSIX_C_SOURCE 200809L
#include "execution_helpers.h"

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

#include "../expansion/expansion.h"
#include "../utils/ast/ast.h"
#include "../utils/hash_map/hash_map.h"
#include "execution.h"

static char **list_to_argv(struct list *command_list)
{
    size_t len = 0;
    struct list *cur = command_list;
    while (cur)
    {
        len++;
        cur = cur->next;
    }
    char **argv = calloc(len + 1, sizeof(char *));
    if (!argv)
        return NULL;
    cur = command_list;
    for (size_t i = 0; i < len; i++)
    {
        argv[i] = (char *)cur->data;
        cur = cur->next;
    }
    argv[len] = NULL;
    return argv;
}

static int try_builtin(char **argv);

int exec_ast_command(struct ast_command *command, struct hash_map *vars)
{
    (void)vars;
    if (!command || !(command->command))
        return 1;
    char **argv = list_to_argv(command->command);
    if (!argv || !(argv[0]))
    {
        free(argv);
        return 0;
    }
    int builtin_ret = try_builtin(argv);
    if (builtin_ret != -1)
    {
        free(argv);
        return builtin_ret;
    }
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork");
        free(argv);
        return 1;
    }
    if (pid == 0)
    {
        execvp(argv[0], argv);
        perror("execvp");
        _exit(127);
    }
    int status = 0;
    waitpid(pid, &status, 0);
    free(argv);
    if (WIFEXITED(status))
    {
        return WEXITSTATUS(status);
    }
    return 1;
}

int exec_ast_if(struct ast_if *if_node, struct hash_map *vars)
{
    int cond = execution(if_node->condition, vars);
    if (cond == 0)
        return execution(if_node->then_clause, vars);
    else
        return execution(if_node->else_clause, vars);
}

int exec_ast_list(struct ast_list *list_node, struct hash_map *vars)
{
    struct list *cur = list_node->children;
    int ret = 0;
    while (cur)
    {
        struct ast *child = (struct ast *)cur->data;
        if (!ast_is_void(child))
            ret = execution(child, vars);
        cur = cur->next;
    }
    return ret;
}

int exec_ast_and_or(struct ast_and_or *ao_node, struct hash_map *vars)
{
    int left_ret = execution(ao_node->left, vars);
    if (ao_node->type == AST_AND_OR_TYPE_AND)
    {
        if (left_ret == 0)
            return execution(ao_node->right, vars);
        return left_ret;
    }
    else
    {
        if (left_ret != 0)
            return execution(ao_node->right, vars);
        return left_ret;
    }
}

static int get_fd_target(const struct ast_redir *redir)
{
    if (redir->io_number != -1)
        return redir->io_number;
    if (redir->type == AST_REDIR_TYPE_LESS
        || redir->type == AST_REDIR_TYPE_DLESS
        || redir->type == AST_REDIR_TYPE_LESSAND)
        return 0;
    return 1;
}

static int open_redir_file(const struct ast_redir *redir, int *flags, int *mode)
{
    *mode = 0644;
    if (redir->type == AST_REDIR_TYPE_GREAT
        || redir->type == AST_REDIR_TYPE_CLOBBER)
    {
        *flags = O_WRONLY | O_CREAT | O_TRUNC;
        return open(redir->filename, *flags, *mode);
    }
    else if (redir->type == AST_REDIR_TYPE_DGREAT)
    {
        *flags = O_WRONLY | O_CREAT | O_APPEND;
        return open(redir->filename, *flags, *mode);
    }
    else if (redir->type == AST_REDIR_TYPE_LESS)
    {
        *flags = O_RDONLY;
        return open(redir->filename, *flags);
    }
    return -3; // not a file open
}

static int handle_and_restore_fd(int saved_fd, int fd_target)
{
    if (saved_fd != -1)
    {
        dup2(saved_fd, fd_target);
        close(saved_fd);
    }
    else
    {
        close(fd_target);
    }
    return 0;
}

/*

static open_all_redir(const struct ast_list redir_list)
{
    while (redir_list){
        struct ast_redir *redir = (struct ast_redir*)redir_list->data;
        int target_fd;
        if (redir->io_number != -1)
        {
           target_fd = redir->io_number;
        }
           else
           {
                // assign target_fd depending on redir type
           }

        int saved_fd = dup(target_fd);

        // if redir type is not with '&'
        // then we open("filename")
        // else, no need to open, just new_fd = atoi(filename)

        open();

        dup2(target_fd, new_fd);

        close(new_fd);

        // append target_fd and saved_fd to a list
        // in order to be able to restore all the fds
    }

}


*/
/*
int exec_ast_redir(struct ast_redir *redir, struct hash_map *vars)
{
    int fd_target = get_fd_target(redir);
    int saved_fd = dup(fd_target);
    int new_fd = -1, flags = 0, mode = 0644;
    if (redir->type == AST_REDIR_TYPE_GREAT
        || redir->type == AST_REDIR_TYPE_CLOBBER
        || redir->type == AST_REDIR_TYPE_DGREAT
        || redir->type == AST_REDIR_TYPE_LESS)
    {
        new_fd = open_redir_file(redir, &flags, &mode);
        if (new_fd == -1)
        {
            perror("open");
            if (saved_fd != -1)
                close(saved_fd);
            return 1;
        }
        if (dup2(new_fd, fd_target) == -1)
        {
            perror("dup2");
            close(new_fd);
            if (saved_fd != -1)
                close(saved_fd);
            return 1;
        }
        close(new_fd);
    }
    else if (redir->type == AST_REDIR_TYPE_GREATAND
             || redir->type == AST_REDIR_TYPE_LESSAND)
    {
        new_fd = atoi(redir->filename);
        if (dup2(new_fd, fd_target) == -1)
        {
            perror("dup2");
            if (saved_fd != -1)
                close(saved_fd);
            return 1;
        }
    }
    int ret = execution(redir->child, vars);
    handle_and_restore_fd(saved_fd, fd_target);
    return ret;
} */

// --- Builtins ---

static int builtin_echo(char **argv)
{
    bool newline = true;
    int i = 1;

    if (argv[1] && strcmp(argv[1], "-n") == 0)
    {
        newline = false;
        i++;
    }

    for (; argv[i]; i++)
    {
        printf("%s", argv[i]);
        if (argv[i + 1])
            printf(" ");
    }
    if (newline)
        printf("\n");

    fflush(stdout);
    return 0;
}

static int builtin_true(char **argv)
{
    (void)argv;
    return 0;
}

static int builtin_false(char **argv)
{
    (void)argv;
    return 1;
}

static int builtin_exit(char **argv)
{
    int exit_val = 0;
    if (argv[1])
        exit_val = atoi(argv[1]);
    exit(exit_val);
    return exit_val;
}

static int builtin_cd(char **argv)
{
    const char *path = argv[1];
    if (!path)
    {
        path = getenv("HOME");
        if (!path)
        {
            fprintf(stderr, "cd: HOME not set\n");
            return 1;
        }
    }
    if (chdir(path) != 0)
    {
        perror("cd");
        return 1;
    }
    return 0;
}

/**
 * @brief Tries to execute a builtin command if the command matches a builtin
 *
 * @param argv Array of command arguments
 * @return int Exit status of the builtin command, or -1 if not a builtin
 */
static int try_builtin(char **argv)
{
    if (!argv || !argv[0])
        return 0;

    if (strcmp(argv[0], "echo") == 0)
        return builtin_echo(argv);
    if (strcmp(argv[0], "true") == 0)
        return builtin_true(argv);
    if (strcmp(argv[0], "false") == 0)
        return builtin_false(argv);
    if (strcmp(argv[0], "exit") == 0)
        return builtin_exit(argv);
    if (strcmp(argv[0], "cd") == 0)
        return builtin_cd(argv);

    return -1;
}