#include <stdio.h>
#include <stdlib.h>


typedef struct
{
    int sigla;
    int Na;
    char* antecedenti;
    char conseguente;
}regola;

void stampa(regola**,int,int,char*);
void deduzione (regola**,int,char*,int*,int*,int*,char*,int*,int*,int*,int*,int*,int,int,int*,int);




int main()
{
    int Nr,i,j,Nc,Nco;
    int a = 0, b = 0, c = 1,d = 0, e = 0;
    int  *usate=NULL,*ind_reg=NULL,*rit=NULL,*eseguibile;
    char antecedente,pulizia;
    char *arrivo,*conosciuti;
    regola **regole;
    eseguibile = &a;
    *eseguibile = 1;
    fflush(stdin);

    printf("Inserirci il numero di regole: ");
    scanf("%d",&Nr);
    arrivo = (char*) malloc(sizeof(char));
    regole = (regola**) malloc(Nr*sizeof(regola*));
    for(i=0;i<Nr;i++)
        regole[i] = (regola*) malloc(sizeof(regola));
        //Input
    printf("\n\nInserisci le regole\n");
    for(i=0;i<Nr;i++)
    {
        printf("\tRegola %d\n",i+1);
        regole[i]->sigla = i+1;
        printf("Inserisci il numero di antecedenti: ");
        scanf("%d",&regole[i]->Na);
        for(j=0;j<regole[i]->Na;j++)
            regole[i]->antecedenti = (char*) malloc(regole[i]->Na*sizeof(char));
        printf("Inserisci gli antecedenti:\n");
        for(j=0;j<regole[i]->Na;j++)
        {
           do
           {
            pulizia=getchar();
           }while(pulizia!='\n' && pulizia!=EOF);
           printf("Antecedente %d: ",j+1);
           scanf("%c",&regole[i]->antecedenti[j]);

        }
        do
        {
            pulizia=getchar();
        }while(pulizia!='\n' && pulizia!=EOF);
        printf("Inserisci il conseguente: ");
        scanf("%c",&regole[i]->conseguente);


    }
    printf("Inserisci il numero di elementi conosciuti: ");
    scanf("%d",&Nc);
    Nco = Nc;
    conosciuti = (char*) malloc(Nc*sizeof(char));
    for(i=0;i<Nc;i++)
    {
        printf("Elemento %d:",i+1);
        do
        {
            pulizia=getchar();
        }while(pulizia!='\n' && pulizia!=EOF);
        scanf("%c",&conosciuti[i]);

    }
    //stampa(regole,Nr,Nc,conosciuti);
    printf("Inserisci l'elemento da cercare:");
        do
        {
            pulizia=getchar();
        }while(pulizia!='\n' && pulizia!=EOF);
    scanf("%c",&arrivo[0]);
    deduzione (regole, Nr,arrivo,usate,ind_reg,rit,conosciuti, &d, &b, &c, &Nc, &e, 0, 0,eseguibile,Nco);
    printf("Hello World");

    for(i=0;i<Nr;i++)
    {
        free(regole[i]->antecedenti);
        free(regole[i]);
    }
    free(regole);
    free(arrivo);
    free(conosciuti);
    free(usate);
    free(rit);
    free(ind_reg);

    return 0;
}

void stampa(regola** regole,int Nr,int Nc,char*conosciuti)
{
    int i,j;
    for(i=0;i<Nr;i++)
    {
        printf("\n\nRegola:%d\n",regole[i]->sigla);
        printf("Antecedenti: ");
        for(j=0;j<regole[i]->Na;j++)
            printf("%c ",regole[i]->antecedenti[j]);
            printf("\nConseguente: %c\n",regole[i]->conseguente);


    }

    printf("\n\nElementi conosciuti:");
    for(i=0;i<Nc;i++)
        printf("%c ",conosciuti[i]);



}


void deduzione(regola **regole,int Nr,char*arrivo,int*usate,int*ind_reg,int*rit,char*conosciuti,int *dim_usate,int *dim_ind_reg,int* dim_arrivo,int* dim_conosciuti,int *dim_rit,int x,int y,int *eseguibile,int Nco)
{
    int i,j,k;
    if(!*dim_arrivo)
     return;
    printf("Sto cercando:%c\n",arrivo[*dim_arrivo-1]);
    printf("Sono su:%d\n",x);
    printf("Dim_arrivo:%d\n",*dim_arrivo);
    printf("Dim_ritorno:%d\n",*dim_rit);
    printf("Dim_ind_reg:%d\n",*dim_ind_reg);
    printf("Dim_usate:%d\n",*dim_usate);
    *eseguibile = 1;
    if(!*dim_arrivo)
        return;
    if(x>=Nr)
    {
        if(*dim_ind_reg)
        {
            arrivo = (char*) realloc(arrivo,--*dim_arrivo*sizeof(char));
            *dim_ind_reg -=1;
            if(*dim_ind_reg == 0)
            ind_reg = NULL;
            else
            ind_reg = (int*) realloc(ind_reg,*dim_ind_reg*sizeof(int));
            *eseguibile = 0;
            return;

        }
        arrivo = (char*) realloc(arrivo,--*dim_arrivo*sizeof(char));
        *dim_rit -= 1;
        if(*dim_rit == 0)
        rit = NULL;
        else
        rit = (int*) realloc(rit,*dim_rit*sizeof(int));
        if(*dim_rit>0)
        x = 1+rit[*dim_rit-1];

    }
    else
    {
    if(!*dim_arrivo)
        return;
    if(regole[x]->conseguente != arrivo[*dim_arrivo-1])
    x++;
    else
    {
    rit = (int*) realloc(rit,++*dim_rit*sizeof(int));
    rit[*dim_rit-1] = x;
    for(j = 0; j<regole[x]->Na; j++)
    {
        for(i = 0; i<*dim_conosciuti; i++)
            if(regole[x]->antecedenti[j] == conosciuti[i])
                break;
        if(i == *dim_conosciuti)
        {
            ind_reg = (int*) realloc(ind_reg,++*dim_ind_reg*sizeof(int));
            ind_reg[*dim_ind_reg-1] = j;
            arrivo = (char*) realloc(arrivo,++*dim_arrivo*sizeof(char));
            arrivo[*dim_arrivo-1] = regole[x]->antecedenti[j];
            deduzione(regole,Nr,arrivo,usate,ind_reg,rit,conosciuti,dim_usate,dim_ind_reg,dim_arrivo,dim_conosciuti,dim_rit,0,0,eseguibile,Nco);
            if(!*eseguibile)
            {
                x += 1;
                *dim_rit -= 1;
                if(*dim_rit == 0)
                rit = NULL;
                else
                rit = (int*) realloc(rit,*dim_rit*sizeof(int));
                break;
            }
            else
            {
                j = ind_reg[*dim_ind_reg-1];
                *dim_ind_reg -=1;
                if(*dim_ind_reg == 0)
                ind_reg = NULL;
                else
                ind_reg = (int*) realloc(ind_reg,*dim_ind_reg*sizeof(int));

            }

        }

    }
    if (*eseguibile)
    {
        if(regole[x]->conseguente != arrivo[0])
        {
        conosciuti = (char*) realloc(conosciuti, ++*dim_conosciuti*sizeof(char));
        conosciuti[*dim_conosciuti-1] = regole[x]->conseguente;
        }
        usate = (int*) realloc(usate, ++*dim_usate*sizeof(int));
        printf("Regole sigla:%d\n",regole[x]->sigla);
        usate[*dim_usate-1] = regole[x]->sigla;
        if(*dim_ind_reg)
            return;
        if(! *dim_ind_reg)
        {
            printf("Dim_usate prima della stampa:%d\n",*dim_usate);
            printf("Elenco regole:");
            for(i = 0; i < *dim_usate; i++)
                printf("%d ",usate[i]);
            if(Nco < *dim_conosciuti)
            conosciuti = (char*) realloc(conosciuti,--*dim_conosciuti*sizeof(char));
            x = 1+rit[*dim_rit-1];
            *dim_rit -= 1;
            if(*dim_rit == 0)
            rit = NULL;
            else
            rit = (int*) realloc(rit,*dim_rit*sizeof(int));
            *dim_usate -= 1;
            if(*dim_usate == 0)
            usate = NULL;
            else
            usate = (int*) realloc(usate,*dim_usate*sizeof(int));
            printf("\n\n:");

        }


      }

     }
    }

    deduzione (regole,Nr,arrivo,usate,ind_reg,rit,conosciuti,dim_usate,dim_ind_reg,dim_arrivo,dim_conosciuti,dim_rit,x,y,eseguibile,Nco);
}