/***************************************************************************//**

  @file         main.c

  @author       Stephen Brennan; Revised by Evan Niederwerfer

  @date         03/09/25

  @brief        Custom bash shell written in C

*******************************************************************************/

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

int size = 64;	

/*
  Function Declarations for builtin shell commands:
 */

int lsh_cd(char **args);
int lsh_help(char **args);
int lsh_exit(char **args);
int lsh_about(char **args);


char *builtin_str[] = {
  "cd",
  "help",
  "exit",
  "about"
};

int (*builtin_func[]) (char **) = {
  &lsh_cd,
  &lsh_help,
  &lsh_exit,
  &lsh_about
};

int lsh_num_builtins() {
  return sizeof(builtin_str) / sizeof(char *);
}

/*
  Builtin function implementations.
*/

/**
   @brief Bultin command: change directory.
   @param args List of args.  args[0] is "cd".  args[1] is the directory.
   @return Always returns 1, to continue executing.
 */
int lsh_cd(char **args)
{
  if (args[1] == NULL) {
    fprintf(stderr, "lsh: expected argument to \"cd\"\n");
  } else {
    if (chdir(args[1]) != 0) {
      perror("lsh");
    }
  }
  return 1;
}

/**
   @brief Builtin command: print help.
   @param args List of args.  Not examined.
   @return Always returns 1, to continue executing.
 */
int lsh_help(char **args)
{
  int i;
  printf("Stephen Brennan's (revised by Evan Niederwerfer) LSH\n");
  printf("Type program names and arguments, and hit enter.\n");
  printf("The following are built in:\n");

  for (i = 0; i < lsh_num_builtins(); i++) {
    printf("  %s\n", builtin_str[i]);
  }

  printf("Use the man command for information on other programs.\n");
  return 1;
}

/**
   @brief Builtin command: exit.
   @param args List of args.  Not examined.
   @return Always returns 0, to terminate execution.
 */
int lsh_exit(char **args)
{
  return 0;
}

int lsh_about(char **args) {

  printf("Bash shell written in C - Stephen Brennan's shell revised by Evan Niederwerfer \n\n");

  FILE *cmd = popen("bash --version", "r");
  if (cmd == NULL) {
      perror("popen");
      return 1;
  }

  char buffer[128];
  while (fgets(buffer, sizeof(buffer), cmd) != NULL) {
      printf("%s", buffer);
  }

  fclose(cmd);
  
  return 1;
}

/**
  @brief Launch a program and wait for it to terminate.
  @param args Null terminated list of arguments (including program).
  @return Always returns 1, to continue execution.
 */
int lsh_launch(char **args)
{
  pid_t pid;
  int status;

  pid = fork();
  if (pid == 0) {
    // Child process
    if (execvp(args[0], args) == -1) {
      perror("lsh");
    }
    exit(EXIT_FAILURE);
  } else if (pid < 0) {
    // Error forking
    perror("lsh");
  } else {
    // Parent process
    do {
      waitpid(pid, &status, WUNTRACED);
    } while (!WIFEXITED(status) && !WIFSIGNALED(status));
  }

  return 1;
}


 int myPipe(char **args, int j)
{
  pid_t pid, pid2;
  int pipefd[2];

  if (pipe(pipefd) == -1) {
      perror("pipe");
      return -1;
  }

  pid = fork();
  if (pid == 0) { // Child

    close(pipefd[0]);
    dup2(pipefd[1], STDOUT_FILENO); // redirect stdout to the grandchild
    close(pipefd[1]);

    args[j] = NULL;

    execvp(args[0], args); 

  }


  pid2 = fork();
  if (pid2 == 0) {  // Grandchild
    close(pipefd[1]);
    dup2(pipefd[0], STDIN_FILENO); // take in input from the child pipe
    close(pipefd[0]);

    execvp(args[j+1], &args[j+1]);
      

  } 
    
  //parent

  close(pipefd[0]);
  close(pipefd[1]);

  waitpid(pid, NULL, 0);   
  waitpid(pid2, NULL, 0);

  return 1;

} 


	

	 
 int myAmphersand(char **args, int j)
{	

  pid_t pid;
  pid = fork();

  if (pid == -1) {
      perror("Fork Failed");
      return(-1);
  }

  if (pid == 0) {
      args[j] = NULL;
      lsh_launch(args);
  }

  else {
      args = &args[j+1];
      lsh_launch(args);
  }


  waitpid(pid, NULL, 0);
  return 1;
}	

 int mySemicolon(char **args, int j)
{


  args[j] = NULL;

  lsh_launch(args);

  args = &args[j+1];

  lsh_launch(args);

  return 1;
}	

/**
   @brief Execute shell built-in or launch program.
   @param args Null terminated list of arguments.
   @return 1 if the shell should continue running, 0 if it should terminate
 */
int lsh_execute(char **args)
{
  int i;

  if (args[0] == NULL) {
    // An empty command was entered.
    return 1;
  }
  
  for(int j = 0; args[j] != NULL; j++)
  {

	// compare "|", "&", ";" with args[j]
	// and go to coorresponding functions.

  for (int j = 0; args[j] != NULL; j++) {
    if (strcmp(args[j], "|") == 0) {
      return myPipe(args, j); // j is the index where the pipe symbol is found
    }
  }

  for (int j = 0; args[j] != NULL; j++) {
    if (strcmp(args[j], ";") == 0) {
      return mySemicolon(args, j); 
    }
  }

  for (int j = 0; args[j] != NULL; j++) {
    if (strcmp(args[j], "&") == 0) {
      return myAmphersand(args, j); 
    }
  }

  }
  
  for (i = 0; i < lsh_num_builtins(); i++) {
    if (strcmp(args[0], builtin_str[i]) == 0) {
      return (*builtin_func[i])(args);
    }
  }



  return lsh_launch(args);
}

#define LSH_RL_BUFSIZE 1024
/**
   @brief Read a line of input from stdin.
   @return The line from stdin.
 */
char *lsh_read_line(void)
{
  int bufsize = LSH_RL_BUFSIZE;
  int position = 0;
  char *buffer = malloc(sizeof(char) * bufsize);
  int c;

  if (!buffer) {
    fprintf(stderr, "lsh: allocation error\n");
    exit(EXIT_FAILURE);
  }

  while (1) {
    // Read a character
    c = getchar();

    if (c == EOF) {
      exit(EXIT_SUCCESS);
    } else if (c == '\n') {
      buffer[position] = '\0';
      return buffer;
    } else {
      buffer[position] = c;
    }
    position++;

    // If we have exceeded the buffer, reallocate.
    if (position >= bufsize) {
      bufsize += LSH_RL_BUFSIZE;
      buffer = realloc(buffer, bufsize);
      if (!buffer) {
        fprintf(stderr, "lsh: allocation error\n");
        exit(EXIT_FAILURE);
      }
    }
  }
}

char* process_line(char *oline)
{

  int length = strlen(oline);

  if (length > 100) {
    oline[100] = '\0';
  }

  for (int i = 0; oline[i] != '\0'; i++) {
        if (oline[i] < 0 || oline[i] > 127) { // ASCII Range
            printf("Error: Invalid character detected. Only ASCII characters (A–Z, a–z, 0–9, dash, dot, forward slash) are allowed.\n");
            exit(EXIT_FAILURE);
        }

    }

	return oline;
}

#define LSH_TOK_BUFSIZE 64
#define LSH_TOK_DELIM " \t\r\n\a"
/**
   @brief Split a line into tokens (very naively).
   @param line The line.
   @return Null-terminated array of tokens.
 */
char **lsh_split_line(char *line)
{
  int bufsize = LSH_TOK_BUFSIZE, position = 0;
  char **tokens = malloc(bufsize * sizeof(char*));
  char *token, **tokens_backup;

  if (!tokens) {
    fprintf(stderr, "lsh: allocation error\n");
    exit(EXIT_FAILURE);
  }

  token = strtok(line, LSH_TOK_DELIM);
  while (token != NULL) {
    tokens[position] = token;
    position++;

    if (position >= bufsize) {
      bufsize += LSH_TOK_BUFSIZE;
      tokens_backup = tokens;
      tokens = realloc(tokens, bufsize * sizeof(char*));
      if (!tokens) {
		free(tokens_backup);
        fprintf(stderr, "lsh: allocation error\n");
        exit(EXIT_FAILURE);
      }
    }

    token = strtok(NULL, LSH_TOK_DELIM);
  }
  tokens[position] = NULL;
  return tokens;
}

/**
   @brief Loop getting input and executing it.
 */
void lsh_loop(void)
{
  char *line, *oline;
  char **args;
  int status;

  do {
    
	printf("CS3230-Evan>> ");

    oline = lsh_read_line();
    
	  line = process_line(oline); // process the input
    args = lsh_split_line(line);
    status = lsh_execute(args);

    free(line);
    free(args);
  } while (status);
}

/**
   @brief Main entry point.
   @param argc Argument count.
   @param argv Argument vector.
   @return status code
 */
int main(int argc, char **argv)
{
  // Load config files, if any.

  // Run command loop.
  lsh_loop();

  // Perform any shutdown/cleanup.

  return EXIT_SUCCESS;
}