#include "cmd.h"

Command *newCmd() {
    Command *cmd = (Command *)malloc(sizeof(Command));
    cmd->argc = 0;
    cmd->args = NULL;
    cmd->type = CMD_NORMAL;
    cmd->left = NULL;
    cmd->right = NULL;
    for (int i = 0; i < 3; i++) {
        cmd->redirectFile[i] = NULL;
        cmd->redirectFD[i] = i;
    }
    cmd->background = false;
    return cmd;
}

void freeCmd(Command *cmd) {
    if (cmd == NULL) {
        return;
    }
    if (cmd->left != NULL) {
        freeCmd(cmd->left);
    }
    if (cmd->right != NULL) {
        freeCmd(cmd->right);
    }
    int i;
    for (i = 0; i < cmd->argc; i++) {
        free(cmd->args[i]);
    }
    free(cmd->args);
    for (i = 0; i < 3; i++) {
        if (cmd->redirectFile[i] != NULL) {
            free(cmd->redirectFile[i]);
        }
    }
    free(cmd);
}

int runCmd(Command *cmd) {
    int status;
    if (cmd == NULL) {
        fprintf(stderr, "cmd is NULL\n");
        return -1;
    }
    switch (cmd->type) {
    case CMD_NORMAL:
        status = runNormalCmd(cmd);
        break;
    case CMD_PIPE:
        status = runPipeCmd(cmd);
        break;
    case CMD_AND:
    case CMD_OR:
        status = runAndOrCmd(cmd);
        break;
    }

    freeCmd(cmd);
    return status;
}

int runNormalCmd(Command *cmd) {
    pid_t pid;
    int status;
    if (!strcmp(cmd->args[0], "exit")) {
        printf("Good Bye, %s!\n", username);
        exit(0);
    } else if (!strcmp(cmd->args[0], "cd")) {
        if (cmd->argc == 1) {
            chdir(getenv("HOME"));
        } else {
            chdir(cmd->args[1]);
        }
        printf("\r");
        getcwd(pwd, sizeof(pwd));
    } else {
        if ((pid = fork()) == 0) {
            // consider the redirection now
            // it's just a part of normal command
            // but not in other commands
            redirect(cmd);
            exit(execvp(cmd->args[0], cmd->args));
        } else {
            if (!cmd->background) {
                waitpid(pid, &status, 0);
                if (!WIFEXITED(status)) {
                    if (WIFSIGNALED(status)) {
                        fprintf(stderr, "Process %d was killed by signal %d\n",
                                pid, WTERMSIG(status));
                    } else {
                        fprintf(stderr, "Process %d exited with status %d\n",
                                pid, WEXITSTATUS(status));
                    }
                }
            }
        }
        // return the exit status of the child process
        return WEXITSTATUS(status);
    }
}

int runPipeCmd(Command *cmd) {
    int status;
    // create a pipe file and gets two file descriptors
    // fd[0] is the read end, while fd[1] the write end
    int fd[2];
    pid_t left, right;
    pipe(fd);
    if ((left = fork()) == 0) {
        /*
         * close the read end of the pipe, so that the child process
         * can only write to it; then redirect the standard output
         * to the write end of the pipe, and close the write end
         * itself as a file descriptor.
         */
        close(fd[0]);
        dup2(fd[1], 1);
        close(fd[1]);
        exit(runCmd(cmd->left));
    }
    if ((right = fork()) == 0) {
        close(fd[1]);
        dup2(fd[0], 0);
        close(fd[0]);
        exit(runCmd(cmd->right));
    }
    // close the pipe, because the parent process doesn't need it
    // and wait for the two child processes to exit
    close(fd[0]);
    close(fd[1]);
    waitpid(left, NULL, 0);
    waitpid(right, NULL, 0);
}

int runAndOrCmd(Command *cmd) {
    int status;
    if (cmd->type == CMD_AND) {
        if (fork() == 0) {
            exit(runCmd(cmd->left));
        } else {
            waitpid(-1, &status, 0);
            if (WIFEXITED(status) && WEXITSTATUS(status) == 0 && fork() == 0) {
                status = runCmd(cmd->right);
            }
            wait(NULL);
        }
    } else if (cmd->type == CMD_OR) {
        if (fork() == 0) {
            exit(runCmd(cmd->left));
        } else {
            waitpid(-1, &status, 0);
            if (WIFEXITED(status) && WEXITSTATUS(status) != 0 && fork() == 0) {
                status = runCmd(cmd->right);
            }
            wait(NULL);
        }
    }
}

void redirect(Command *cur) {
    int fd;
    char *rfile;
    for (int i = 0; i < 3; i++) {
        fd = cur->redirectFD[i];
        rfile = cur->redirectFile[i];
        if (fd < -1 || fd > 2) {
            fprintf(stderr, "file descriptor %d is invalid\n", fd);
            exit(1);
        }
        if (fd == i && rfile == NULL) {
            continue;
        }
        if (fd == -1) {
            // append
            fd = open(rfile, O_WRONLY | O_CREAT | O_APPEND, 0666);
        } else if (rfile != NULL) {
            // normal redirection
            fd = open(rfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
        } else {
            // file descriptor redirection
            // when here, fd is surely in 0, 1, 2
            ;
        }

        if (fd < 0) {
            fprintf(stderr, "open file %s failed\n", rfile);
            exit(1);
        }
        close(i);
        dup2(fd, i);
        close(fd);
    }
}