#include <stdio.h>
#include <string.h>

int zahl (int z);
int array_Laenge(char* anagramm_liste[]);
char *anagramm (int argc, char *argv[]);
char woerterbuch (const char wort[],const int i);
void duplikatmalloc (const char str[],char satz [],const int z);
void *malloc(size_t size);
void leerzeichen_loeschen(char *str);
void argumente (int argc, char *argv[] );
void sortieren(int argc, char *argv[] , const char satz[],char mallocsatz []);
void rechtschreibung(const char satz[], char mallocsatz [], int i);
char anagram_find (int argc, char *argv[] , const char satz[],char mallocsatz [],char *anagramm_liste [],int i,int r);
void ausgabe (int argc, char *argv[] , const char satz[],char mallocsatz [],char vergleichsatz [],char *anagramm_liste []);
void loesung (char mallocsatz [],char vergleichsatz [],char *anagramm_liste [], int r);
char* recursion_letter(char *anagramm_liste [],char vergleichsatz[], char mallocsatz[], int i);
void smaller_list(char *anagramm_liste []);
char* rekursionListe(char* anagramm_liste[], char vergleichsatz[],char mallocsatz[]);
char loeschen(char vergleichsatz[],int j);                                                  // Sentence muss im Parameter ebenfalls als const deklariert werden , da ansonsten das Programm einen andere Vorm von Variable erwartet.

                                                    // Sentence muss im Parameter ebenfalls als const deklariert werden , da ansonsten das Programm einen andere Vorm von Variable erwartet.



int main( int argc, char *argv[] )
{

        char *ausgabe = anagramm(argc,argv);
        return 0;
}

char *anagramm (int argc, char *argv[]) // ich will adresse char zurückhaben
{
char *anagramm_liste[argc+1];
//char *anagramm_liste2[argc];
int i = 0;
int z = 0;
int r = 0;
int a = 0;
const char *const satz = argv[1];
int elemente = strlen(satz);
char *mallocsatz = malloc(elemente * sizeof(char)+1);
char *vergleichsatz = malloc(elemente * sizeof(char)+1);
duplikatmalloc(satz,mallocsatz,z);
duplikatmalloc(satz,vergleichsatz,z);
rechtschreibung(satz,mallocsatz,i);
rechtschreibung(satz,vergleichsatz,i);
leerzeichen_loeschen(mallocsatz);
leerzeichen_loeschen(vergleichsatz);
for (i = 2; i < argc; i++){
        r = anagram_find(argc,argv,satz,mallocsatz,anagramm_liste,i,r);
        //anagramm_liste <- enthält alle anagramm wörter
}
printf("anagramm_liste lautet: %s\n", anagramm_liste[0]);
argumente(r,anagramm_liste);
//smaller_list(anagramm_liste);
rekursionListe(anagramm_liste,vergleichsatz,mallocsatz);
return 0;
}

/*
char *rekursionListe(char *anagramm_liste [], int i)                                                     // Sentence muss im Parameter ebenfalls als const deklariert werden , da ansonsten das Programm einen andere Vorm von Variable erwartet.
{

for(int i=1;anagramm_liste[i]!='\0';i++)
{
   anagramm_liste2[i-1] = anagramm_liste[i];
}
return rekursionListe(anagramm_liste, anagramm_liste2,i);
}*/


char* rekursionListe(char* anagramm_liste[], char vergleichsatz[],char mallocsatz[])                                                     // Sentence muss im Parameter ebenfalls als const deklariert werden , da ansonsten das Programm einen andere Vorm von Variable erwartet.
{
        if(anagramm_liste[0] != '\0'){
           for(int i = 0; i < array_Laenge(anagramm_liste); i++){
            printf(" %s\n", anagramm_liste[0]);
            recursion_letter(anagramm_liste,vergleichsatz,mallocsatz,i);
            printf("verlgeichsatz nach funktion:  %s\n", vergleichsatz);
            rekursionListe(&anagramm_liste[1],vergleichsatz,mallocsatz);}
        }
        else{
        }
    return 0;

}

/* "Sxzytwqp Klj Yrtd"  Abc And Def Dxz k kx Ljsrt lt pt Ptyywq y Ywjsrq Zd zzx */
int array_Laenge(char* anagramm_liste[])
{
int i = 0;
    for(i = 1; anagramm_liste[i] != '\0'; i++){

    }
    return i;
}

/*
        for(int i = 0; anagramm_liste[i] != 'zzx' ; i++){
            printf("anagramm_liste lautet: %s\n", anagramm_liste[0]);
            //recursion_letter(anagramm_liste[0],i);
            return rekursionListe(&anagramm_liste[1],vergleichsatz);
        }

for int i ; i != '\0'
*/


char* recursion_letter(char *anagramm_liste [],char vergleichsatz[], char mallocsatz[], int i)
{
    int t = 0;
    int z = 0;
    int j = 0;
    duplikatmalloc(mallocsatz,vergleichsatz,z);
        for (z = 0; z < strlen(anagramm_liste[i]); z++){ // buchstbaen
       // printf("Der Buchstabe: %c\n",argv[i][z]);
            for(j = 0; j < strlen(vergleichsatz); j++){
            if (anagramm_liste[i][z] == vergleichsatz[j] || anagramm_liste[i][z] +32 == vergleichsatz[j]) {
              for(; vergleichsatz[j] != '\0'; j++){
                vergleichsatz[j] =  vergleichsatz[j+1];}
            //printf("Die Buchstaben sind gleich und j ist:  %d\n", j);
                t = t+1;
                if(t == strlen(anagramm_liste[i])){
               //printf("r lautet  :  %d\n", r);
                    printf("Anagramm wurde gefunden bei :  %s\n", anagramm_liste[i]);
                    printf("vergleichsatz vor funktion :  %s\n", vergleichsatz);
                    return ;         }
             }else{

                        //printf("Die Buchstaben sind ungleich und j ist: %d\n", j);
                }
            }
  }
  return ;
}
/*
char loeschen(char vergleichsatz[],int j)
{
  for(; vergleichsatz[j] != '\0'; j++)
  vergleichsatz[j] =  vergleichsatz[j+1];
    return vergleichsatz;
}*/


void smaller_list(char *anagramm_liste [])
{
    for(int i = 0;anagramm_liste[i] != 0; i++){
        anagramm_liste[i]=anagramm_liste[i+1];
    }
}


char anagram_find(int argc, char *argv[] , const char satz[],char mallocsatz [],char *anagramm_liste [],int i,int r)
{
    int t = 0;
    int j = 0;
        for (int z = 0; z < strlen(argv[i]); z++){ // buchstbaen
       // printf("Der Buchstabe: %c\n",argv[i][z]);
            for(j = 0; j < strlen(satz); j++){
            if (argv[i][z] == mallocsatz[j] || argv[i][z] +32 == mallocsatz[j]) {
            //printf("Die Buchstaben sind gleich und j ist:  %d\n", j);
            t = t+1;
            if(t == strlen(argv[i])){
               //printf("r lautet  :  %d\n", r);
               // printf("Anagramm wurde gefunden bei :  %s\n", argv[i]);
                anagramm_liste[r] = argv[i];// Anagramm übergeben an liste/ausgabe/array
                r = r+1;
               // printf("Anagramm wurde ubergeben an :  %s\n", anagramm_liste[r]);
                }
                break;
                }else
                {
                        //printf("Die Buchstaben sind ungleich und j ist: %d\n", j);


                }
            }
  }
  anagramm_liste[r] = '\0';
  return r;
}

void leerzeichen_loeschen(char *satz)
{
    int zaehler = 0;
    for (int i = 0; satz[i]; i++) // str [i]== 0 is dass dasselbe wie str [i] == /0
        if (satz[i] != ' ')
            satz[zaehler++] = satz[i];
    satz[zaehler] = '\0';
}


void rechtschreibung(const char satz[], char mallocsatz [], int i)                                // Diese Funktion korrigiert die Größe des ersten Buchstabes wenn nötig und vergrößert den Buchstaben des zweiten Wortes.
{
    for (i = 0; satz[i] != '\0'; i++){
    if (satz[i] < 90 && satz[i] != ' ')
    {
        mallocsatz[i] = mallocsatz[i]+ 32;
    }else {
        }
    }
}


void duplikatmalloc(const char satz[],char mallocsatz [],const int z)
{

    if (satz[z] == '\0')
    {
        mallocsatz [z] = '\0';
    }
    else
    {
     mallocsatz [z] = satz [z];
     duplikatmalloc(satz,mallocsatz, z+1);
    }

}

void argumente(int argc, char *argv[] )
{
        //int i = 0;
        printf( "argc_Anzahl der Arguemente lautet: %d\n", argc );
    //    printf( "argv_Das erste Elemente lautet:  %s\n", argv[0] );
        if ( argc == 1 ) {
                printf( "No arguments were passed.\n" );
        } else {
                printf( "Woerterbuch:\n" );

                for ( int i = 0; i < argc; i++ ) {  // alternativ i++ statt i = i+1;
                        printf( "  %d. %s\n", i, argv[i] );
                }
        }
}


/* "Sxzytwqp Klj Yrtd"  Abc And Def Dxz k kx Ljsrt lt pt Ptyywq y Ywjsrq Zd zzx */