/*
 * 
 */

#include "command.h"
#include "config.h"
#include "lexer.h"
#include <stdio.h>
#include <unistd.h>

command *create_command() {
  command *cmd = malloc(sizeof(command));
  if (!cmd) {
    return NULL;
  }

  cmd->command = NULL;
  memset(cmd->args, 0, sizeof(char*));
  cmd->pipe[0] = -1;
  cmd->pipe[1] = -1;
  cmd->read_pipe = NULL;
  cmd->infile = NULL;
  cmd->outfile = NULL;
  cmd->next = NULL;
  cmd->pid = 0;

  return cmd;
}

command *commands_from_tokens(token *parsed_cmdstr, size_t *cnt) {

  command *cmd_head = create_command();
  command *cmd = cmd_head;
  size_t arg_cnt = 1;

  *cnt = 0;

  token *prev_tkn = NULL;

  for (token *tkn = parsed_cmdstr; tkn; prev_tkn = tkn, tkn = tkn->next) {
    if (tkn->type == TKN_COMMAND) {
      cmd->command = tkn->text;
      cmd->args[0] = tkn->text;
      arg_cnt = 1;
      (*cnt)++;
    } else if (tkn->type == TKN_ARG) {
      cmd->args[arg_cnt++] = tkn->text;
    } else if (tkn->type == TKN_FILENAME) {
      if (prev_tkn->type == TKN_IN_REDIR) {
        cmd->infile = tkn->text;
      } else {
        cmd->outfile = tkn->text;
      }
    } else if (tkn->type == TKN_PIPE) {
      cmd->next = create_command();
      cmd->next->read_pipe = cmd->pipe;
      cmd = cmd->next;
    }
    
  }

  return cmd_head;
}

void print_commands(FILE *file, command *cmds) {
  for (command *cmd=cmds; cmd; cmd = cmd->next) {
    fprintf(file, "Command: %s\n", cmd->command);
    fprintf(file, "\t");
    for (size_t i=0; i<MAX_ARGUMENT_CNT; i++) {
      fprintf(file, "%s ", cmd->args[i]);
    }
    fprintf(file, "\n\tInfile: %s\n\tOutfile: %s\n\tInput Pipe: %p\n\tPid:%d\n", cmd->infile, cmd->outfile, cmd->read_pipe, cmd->pid);
    if (cmd->read_pipe) {
      fprintf(file, "\tInput Pipe: %d\n", *cmd->read_pipe);
    }
  }
}

void destroy_commands(command *cmds) {
  command **cmd_ptr = &cmds->next;
  while (*cmd_ptr) {
    free(cmds);
    cmds = *cmd_ptr;
    cmd_ptr = &cmds->next;
  }
}

pid_t execute_command(command *cmd) {
  if (cmd->next) {
    pipe(cmd->pipe);
  }

  pid_t res = fork();
  if (res == 0) {
    int fdi = -1, fdo = -1;

    if (cmd->infile) {
      if (!freopen(cmd->infile, "r", stdin)) {
        perror("Could not open input file");
        exit(EXIT_FAILURE);
      }
    } else if (cmd->read_pipe && *cmd->read_pipe >= 0) {
      fdi = dup2(*(cmd->read_pipe), STDIN_FILENO);
      close(*(cmd->read_pipe));
    }

    if (cmd->outfile) {
      if (!freopen(cmd->outfile, "w", stdout)) {
        perror("Could not open output file");
        exit(EXIT_FAILURE);
      }
    } else if (cmd->next) {
      fdo = dup2(cmd->pipe[1], STDOUT_FILENO);
    }

    fprintf(stderr, "In command:\n");
    fprintf(stderr, "STDIN: %d\tSTDOUT: %d\n", fdi, fdo);

    
    if (cmd->pipe[0] >= 0) {
      close(cmd->pipe[0]);
      cmd->pipe[0] = -1;
    }

    if (cmd->pipe[1] >= 0) {
      close(cmd->pipe[1]);
      cmd->pipe[1] = -1;
    }

    
    execvp(cmd->command, cmd->args);
    perror("Could not run command");
    exit(EXIT_FAILURE);
  }  else if (res < 0) {
    perror("Could not run command");
    return -1;
  }

  cmd->pid = res;
  return res;
}