#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include<signal.h>


struct parseInfo {
 int type;          // niewykorzystywany w programie, potrzebny przy jego rozbudowie
 int redirect;      // przekierowanie >>
 int background;    // proces w tle &
 int flagCount;     // licznik flag
 int piped;         // wskaźnik na |
 char* redirect_file;
 char* command;
 char* restCommand;
 char** flags;
};

void parseInfoInit(struct parseInfo *parseInfo_s);
struct parseInfo *parse(char *cmdline);
struct parseInfo *parseCommand(char* command, struct parseInfo* cmd);
char* readline();
void history(char* line);
void handlerSIGQUIT(int signum);


int main()
{
 signal(SIGQUIT, handlerSIGQUIT);
 struct parseInfo* cmd;
 while(1)
 {
  int childPid;
  char * cmdLine;
  cmdLine = readline();         // sczytywanie linii
  history(cmdLine);             // dodawanie do historii
  cmd = parse(cmdLine);         // rozdział linii
  free(cmdLine);
  if(cmd->type == 1)
  {
  }
  else
  {
    while(1)
    {                   // podział na procesy w zależności od wartości flag piped i background
      if(cmd->piped == 0)
      {

	childPid = fork();
	if(childPid == 0)
	{
	  char* command = cmd->command;
	  char** argv = cmd->flags;
	  int k;
	  int fd = open("temp.txt", O_RDWR | O_CREAT | O_TRUNC, 0666);


	  char l;
	  if(cmd->redirect == 0)
	  {
	    if(k = execvp(command, argv) < 0)
	      fprintf(stderr, "Command Error\n%d\n", k);
	  }
	  else
	  {
	    int fd = open(cmd->redirect_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
	    dup2(fd, 1);
	    if(k = execvp(command, argv) < 0)
	      fprintf(stderr, "Command Error\n%d\n", k);
	    close(fd);
	  }
	}
	break;
      }
      else
      {
	int fd = open("temp.txt", O_RDWR | O_CREAT | O_TRUNC, 0666);
	char* l;
	childPid = fork();
	if(childPid == 0)
	{
	  char* command = cmd->command;
	  char** argv = cmd->flags;
	  int k;

	  close(1);
	  dup(fd);

	  if(k = execvp(command, argv) < 0)
	      fprintf(stderr, "Command Error\n%d\n", k);

	}
	char* vol = cmd->restCommand;
	free(cmd);
	cmd = parse(cmd->restCommand);
	close(fd);
      }

    if(cmd->background == 1);
    else
    {
	waitpid(childPid);
    }

    }

  }

  }

 return 0;
}

void parseInfoInit(struct parseInfo* parseInfo_s)   // inicjalizacja struktury
{
  parseInfo_s->type = 0;
  parseInfo_s->redirect = 0;
  parseInfo_s->flagCount = 0;
  parseInfo_s->background = 0;
  parseInfo_s->piped = 0;
  parseInfo_s->redirect_file = (char*)NULL;
  parseInfo_s->command = (char*)NULL;
  parseInfo_s->restCommand = (char*)NULL;
  parseInfo_s->flags = (char**)NULL;
}

struct parseInfo *parse(char *cmdline)  // parser. Pobiera linie danych i je rozdziela na poszczególne elementy
{                                       // najwazniejszy element programu
  char* tab = (char*)NULL;
  char* help;
  int i = 0, j = 0;
  int size = 0;
  struct parseInfo* cmd = malloc(sizeof(struct parseInfo));
  parseInfoInit(cmd);
  while(cmdline[i] != '\0')
  {
    size = 0;
    tab = (char*) NULL;
    while(cmdline[i] != ' ' && cmdline[i] != '\0')  // wczytuje dane do tablicy do póki nie trafi na spację lub koniec pliku
    {
      help = tab;
      tab = malloc(sizeof(char) * (++size));
      for(j = 0; j < size-1; ++j)
      {
	tab[j] = help[j];
      }
      free(help);
      tab[size-1] = cmdline[i];
      ++i;
    }
    if(cmdline[i] == ' ')
    {
      ++i;
    }
    if(cmdline[i] == '|')   // trafia na potok. Zapisuje komende do zmiennej restCommand
    {
      i += 2; // bo spacja po pipe
      cmd->piped = 1;
      int j = 1;
      int k = 0;
      cmd->restCommand = (char*)NULL;
      char* help1;
      while(cmdline[i] != '\0')
      {
	help1 = cmd->restCommand;
        cmd->restCommand = malloc(sizeof(char)*(j+2));
	for(k = 0; k < (j-1); k++)
	{
	   cmd->restCommand[k] = help1[k];
	}
	cmd->restCommand[j-1] = cmdline[i];
	cmd->restCommand[j] = '\0';
	free(help1);
	i++;
	j++;
      }
       help = cmd->restCommand;
       int temp = strlen(help);
       cmd->restCommand = malloc(sizeof(char)*temp+1);
       strcpy(cmd->restCommand, help);
       cmd->restCommand[temp] = '\0';
       free(help);

       help = tab;
       tab = malloc(sizeof(char) *(++size));
       strcpy(tab, help);
       tab[size-1] = '\0';
       free(help);

       cmd = parseCommand(tab, cmd);
       return cmd;
    }
    help = tab;
    tab = malloc(sizeof(char) *(++size));
    strcpy(tab, help);
    tab[size-1] = '\0';
    free(help);
    cmd = parseCommand(tab, cmd);
  }
  return cmd;
}

struct parseInfo* parseCommand(char* command, struct parseInfo* cmd)    // ustawnianie flag sczytywanych w main()
{
  if(cmd->command == (char*)NULL)
  {
    cmd->command = command;
  }
  if(cmd->flags == (char**)NULL)
  {
    cmd->flagCount++;
    char **flag = malloc(sizeof(char*)*(cmd->flagCount+1));
    flag[0] = command;
    flag[1] = NULL;
    cmd->flags = flag;
  }

  else if(!strcmp(command, "&"))
  {
      cmd->background = 1;
  }
  else if(!strcmp(command, ">>"))
  {
    cmd->redirect = 2;
  }
  else if(cmd->redirect == 2)
  {
    cmd->redirect_file = command;
    cmd->redirect = 1;
  }
  else
  {
    cmd->flagCount++;
    int i = 0;
    char **help = cmd->flags;
    char **flag = malloc(sizeof(char*)*(cmd->flagCount+1));
    for(i = 0; i < cmd->flagCount; ++i)
    {
      flag[i] = help[i];
    }
    free(help);
    flag[cmd->flagCount-1] = command;
    flag[cmd->flagCount] = NULL;
    cmd->flags = flag;
  }

  return cmd;
}

char* readline()    // funkcja sczytująca linię ze standardowego wyjścia
{
  int c, i;
  int size = 0;
  char* help;
  char* line = (char*)NULL;
  while((c = getchar()) != '\n')
  {
    help = line;
    line = (char*)malloc(sizeof(char) * (++size));
    for(i = 0; i < (size-1); i++)
    {
      line[i] = help[i];
    }
    free(help);
    line[size-1] = c;
  }
  help = line;
  line = (char*)malloc(sizeof(char) * (++size));
  for(i = 0; i < (size-1); i++)
  {
    line[i] = help[i];
  }
  line[size-1] = '\0';
  free(help);
  return line;
}

void history(char* line)        // zbiera historie do 20 komend
{
  if(*line == '\0')             // pusta linia, nie zapisywana do historii
    return;
  int fd = open ("history.txt", O_RDWR | O_CREAT, 0666);
  char l;
  int count = 0;
  off_t pos = lseek(fd, 0, SEEK_SET);
  while(1 == read(fd, &l, sizeof(l)))   // licznik od pozycji 0
  {
    if(l == '\n')
    {
      count++;
    }
  }
  if(count > 19)
  {
    pos = lseek(fd, 0, SEEK_SET);       //nadpisanie najstarszej wartości
    count = 0;
    while(1 == read(fd, &l, sizeof(l)))
    {
      count++;
      if(l == '\n')
       break;
    }
    pos = lseek(fd, 0, SEEK_SET);
    char* wr = malloc(sizeof(char)*count);
    memset(wr, '\0', count);
    write(fd, wr, count);
  }

  pos = lseek(fd, 0, SEEK_END);
  size_t len = strlen(line);
  write(fd,line, len);
  write(fd, (char*)"\r\n", 2);
  close(fd);
}

void handlerSIGQUIT(int signum) // wyświetlenie całej historii
{
  int fd = open ("history.txt", O_RDWR | O_CREAT, 0666);
  char buffer[16];
  while(16 <= read(fd, buffer, sizeof(buffer)))
  {
    printf("%s", buffer);
  }
}