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


#include "utils.h"
#include "listen.h"
#include "wortspeicher.h"
#include "kommandos.h"
#include "frontend.h"
#include "parser.h"
#include "variablen.h"
#define DATA_SIZE 512

pid_t ids[100];
pid_t gids[100];
char *Codes[100];
char *MaxBef[100];
int counter=0;
int interpretiere(Kommando k, int forkexec);

void do_execvp(int argc, char **args){
    execvp(*args, args);
    perror("exec-Fehler");
    fprintf(stderr, "bei Aufruf von \"%s\"\n", *args);
    exit(1);
}

int interpretiere_pipeline(Kommando k){
    /* NOT IMPLEMENTED */
    fputs("NOT IMPLEMENTEDeeeeeed", stderr);
    return 0;
}

int umlenkungen(Kommando k){
	Liste ul = k->u.einfach.umlenkungen;
        Umlenkung *u;
	char textA[500] = "";
	//fprintf(stderr, "\"%s\" ", *k->u.einfach.worte);
	for(int i=0; i < k->u.einfach.wortanzahl; i++){
                                strcat(textA,(k->u.einfach.worte)[i]);
				strcat(textA, " ");
	}
	//fprintf(stderr, "\"%s\" ", textA);
	FILE *pf;
	char puffer[DATA_SIZE];
	while(ul){
                u = listeKopf(ul);
                //fprintf(stderr, "%d%s %s", u->filedeskriptor, u->modus==READ ? "< " : u->modus==WRITE ? "> " : ">> ", u->pfad);
		if(u->modus==WRITE){
			//fputs("Fehlerhaftes Kommando\n", stderr);
			pf=popen(textA,"r");
			FILE *datei = fopen (u->pfad,"w");
			while(fgets(puffer,DATA_SIZE,pf)){
				fprintf (datei, "%s",puffer);
				//fputs(puffer,stderr);
			}
			//fgets(puffer,DATA_SIZE,pf);
			pclose(pf);
			fclose (datei);
			return 1;
		}
		if(u->modus==READ){
			pf=popen(textA,"w");
			FILE *datei = fopen (u->pfad,"r");
			while(fgets(puffer,DATA_SIZE,datei)){
      				fputs(puffer, pf);
    			}
			pclose(pf);
			fclose (datei);
			return 1;
		}

		if(u->modus==APPEND){
			pf=popen(textA,"r");
			FILE *datei = fopen (u->pfad,"a");
			while(fgets(puffer,DATA_SIZE,pf)){
				fprintf (datei, "%s",puffer);
				//fputs(puffer,stderr);
			}
			//fgets(puffer,DATA_SIZE,pf);
			pclose(pf);
			fclose (datei);
			return 1;
		}
                ul = listeRest(ul);
        }
    return 0;
}

int aufruf(Kommando k, int forkexec){
    //printf("%i",forkexec);
    /* Programmaufruf im aktuellen Prozess (forkexec==0)
       oder Subprozess (forkexec==1)
       */
	//umlenkungen(k);
	int status;
	MaxBef[counter] = *k->u.einfach.worte;
    if(forkexec){
        int pid;
        if ((pid = fork()) == -1){
            perror("Fehler bei fork");
            return(-1);
        } else if (pid == 0) {
            if(umlenkungen(k))
                exit(1);
            do_execvp(k->u.einfach.wortanzahl, k->u.einfach.worte);
            abbruch("interner Fehler 001"); /* sollte nie ausgeführt werden */

        } else {
            if(k->endeabwarten)waitpid(pid, &status, 0);
                /* So einfach geht das hier nicht! */
                //waitpid(pid, &status, WNOHANG);
            return 0;
        }
    }

    /* nur exec, kein fork */
    if(umlenkungen(k))
        exit(1);
    do_execvp(k->u.einfach.wortanzahl, k->u.einfach.worte);
    abbruch("interner Fehler 001"); /* sollte nie ausgeführt werden */
    exit(1);
}


int interpretiere_einfach(Kommando k, int forkexec){
    char **worte = k->u.einfach.worte;
    int anzahl=k->u.einfach.wortanzahl;
    if (strcmp(worte[0], "exit")==0) {
        switch(anzahl){
            case 1:
                exit(0);
            case 2:
                exit(atoi(worte[1]));
            default:
                fputs( "Aufruf: exit [ ZAHL ]\n", stderr);
                return -1;
        }
    }

    if (strcmp(worte[0], "cd")==0) {
        chdir(worte[1]);
        return 0;
    }
    return aufruf(k, forkexec);
}

int interpretiere(Kommando k, int forkexec){
    int status;
    //kommandoZeigen(k);
    switch(k->typ){
        case K_LEER:
            return 0;
        case K_EINFACH:
            return interpretiere_einfach(k, forkexec);
        case K_SEQUENZ:
            {
                Liste l = k->u.sequenz.liste;
                while(!listeIstleer(l)){
                    status=interpretiere ((Kommando)listeKopf(l), forkexec);
                    l=listeRest(l);
                }
            }
            return status;
        default:
            fputs("unbekannter Kommandotyp, Bearbeitung nicht implementiert\n", stderr);
            break;
    }
    return 0;
}