/************************************************************************************************/
/* programma che include una libreria creata da utente che gestisce due insiemi di numeri reali */
/************************************************************************************************/

/*****************************/
/* inclusione delle librerie */
/*****************************/

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

/********************************/
/* dichiarazione delle funzioni */
/********************************/

elem_lista_t *crea_insieme(char);
void ordinamento_per_selezione(elem_lista_t *);
void elenco_funzioni();
void stampa_insieme(elem_lista_t *);

/* definizione della funzione principale */
int main(void)
{
    /*dichiarazioni delle variabili locali alla funzione*/
    elem_lista_t         *insieme_A = NULL,     /*lavoro: puntatore all'elemento testa dell'insieme A*/
                 *insieme_B = NULL,     /*lavoro: puntatore all'elemento testa dell'insieme B*/
                 *insieme_C = NULL;     /*lavoro: puntatore all'elemento testa dell'insieme risultante*/
    int           scelta,           /*input:  valore di tipo intero per definire la scelta dell'utente*/
                  esito_uguaglianza,        /*output: valore che definisce l'uguaglianza tra insiemi*/
                  esito_lettura;        /*output: valore che definisce la validazione degli input*/
    char              id_insieme_A = 'a',       /*lavoro: identificazione dell'insieme A*/
                  id_insieme_B = 'b',       /*lavoro: identificazione dell'insieme B*/
                  rimozione_carattere;      /*lavoro: variabile di svuotamento buffer*/

    /*chiamata a funzione: stampa a video dell'elenco delle operazioni*/
    do
    {
        do
        {
            /*chiamata a funzione: stampa menù*/
            elenco_funzioni();
            printf("\nScelta: ");
            esito_lettura = scanf("%d",
                          &scelta);

            /*validazione input: scelta menù*/
            if (esito_lettura != 1)
            {
                printf("\nInput non accettabile, prego reinserire!\n");

                /*pulizia buffer*/
                while ((rimozione_carattere = getchar()) != '\n');
            }
        }
        /*ripeti finché l'esito di scanf sia negativo*/
        while (esito_lettura != 1);

        /*scelta delle funzioni da eseguire*/
        switch (scelta)
        {
            case 1:
                /*chiamata a funzione: creazione dell'insieme A*/
                insieme_A = crea_insieme(id_insieme_A);

                /*chiamata a funzione: creazione dell'insieme B*/
                insieme_B = crea_insieme(id_insieme_B);
                break;
            case 2:
                /*chiamata a funzione: operazione di uguaglianza*/
                esito_uguaglianza = uguaglianza_insiemi(insieme_A,
                                    insieme_B);

                /*stampa a video degli insiemi*/
                printf("\nINSIEMI:\n");
                printf("\nInsieme A = { ");
                stampa_insieme(insieme_A);
                printf("Insieme B = { ");
                stampa_insieme(insieme_B);

                /*verifica di uguaglianza*/
                if (esito_uguaglianza == 1)
                    printf("\nUGUAGLIANZA:\n\nInsieme A = Insieme B\n");
                else
                    printf("\nUGUAGLIANZA:\n\nInsieme A != Insieme B\n");
                break;
            case 3:
                /*stampa a video degli insiemi*/
                printf("\nINSIEMI:\n");
                printf("\nInsieme A = { ");
                stampa_insieme(insieme_A);
                printf("Insieme B = { ");
                stampa_insieme(insieme_B);

                /*chiamata a funzione: operazione d'intersezione*/
                printf("\nINTERSEZIONE:\n\nInsieme C = { ");
                insieme_C = intersezione_insiemi(insieme_A,
                                 insieme_B);

                /*stampa dell'insieme risultante*/
                stampa_insieme(insieme_C);
                break;
            case 4:
                /*stampa a video degli insiemi*/
                printf("\nINSIEMI:\n");
                printf("\nInsieme A = { ");
                stampa_insieme(insieme_A);
                printf("Insieme B = { ");
                stampa_insieme(insieme_B);

                /*chiamata a funzione: operazione di differenza A-B*/
                printf("\nDIFFERENZA (A-B):\n\nInsieme C = { ");
                insieme_C = differenza_insiemi(insieme_A,
                                   insieme_B);

                /*stampa a video dell'insieme risultante*/
                stampa_insieme(insieme_C);

                /*chiamata a funzione: operazione di differenza B-A*/
                printf("\nDIFFERENZA (B-A):\n\nInsieme C = { ");
                insieme_C = differenza_insiemi(insieme_B,
                                   insieme_A);

                /*stampa a video dell'insieme risultante*/
                stampa_insieme(insieme_C);
                break;
            case 5:
                /*stampa a video degli insiemi*/
                printf("\nINSIEMI:\n");
                printf("\nInsieme A = { ");
                stampa_insieme(insieme_A);
                printf("Insieme B = { ");
                stampa_insieme(insieme_B);

                /*chiamata a funzione: operazione di differenza simmetrica*/
                printf("\nDIFFERENZA SIMMETRICA:\n\nInsieme C = { ");
                insieme_C = differenza_simmetrica_insiemi(insieme_A,
                                      insieme_B);

                /*stampa a video dell'insieme risultante*/
                stampa_insieme(insieme_C);
                break;
            case 0:
                /*uscita dal programma*/
                break;
            default:
                printf("\nInput non accettabile, prego reinserire!\n");
                break;
        }
    }

    /*ripeti finchè la scelta sia diversa da zero*/
    while (scelta != 0);

    /*messa a capo della stringa: premere un tasto per continuare...*/
    printf("\n");
    return(0);
}

/* definizione della funzione per la creazione dell'insieme */
elem_lista_t *crea_insieme(char id_insieme)
{
    /*dichiarazione delle variabili locali alla funzione*/
    elem_lista_t         *p,                /*lavoro: puntatore ausiliario che punterà alla testa dell'insieme */
                 *corr_p,           /*lavoro: puntatore ausiliario che scorrerà l'insieme */
                 *rip_p;            /*lavoro: puntatore ausiliario che controlla la ripetizione dei valori*/
    int               card,             /*input:  variabile contenente la cardinalità dell'insieme */
                  i,                /*lavoro: variabile contatore*/
                  esito_lettura,        /*lavoro: variabile di controllo acquisizione tramite funzione scanf*/
                  ripetuto = 0;         /*lavoro: variabile di controllo di ripetizione dei valori*/
    char              rimozione_carattere;      /*lavoro: variabile di svuotamento buffer*/

    /*inserimento della cardinalità da tastiera*/
    do
    {
        /*printf relativa all'insieme A*/
        if (id_insieme == 'a')
            printf("\nInserire la cardinalita' dell'insieme A\n");


        /*printf relativa all'insieme B*/
        else
            printf("\nInserire la cardinalita' dell'insieme B\n");

        printf("\nCardinalita': ");
        esito_lettura = scanf("%d",
                       &card);

        /*validazione input: cardinalità insieme*/
        if ((esito_lettura != 1 ||
             card < 0))
        {
            printf("\nInput non accettabile!\n");

            /*pulizia buffer*/
            while ((rimozione_carattere = getchar()) != '\n');
        }
    }

    /*ripeti finché l'esito di scanf sia negativo o minore di zero*/
    while ((esito_lettura != 1 ||
        card < 0));

    /*pulizia buffer*/
    while ((rimozione_carattere = getchar()) != '\n');

    /*condizione in cui l'insieme sia vuoto*/
    if (card == 0)
    {
        printf("\nInsieme vuoto!\n");
        p = NULL;
    }

    /*creazione dell'insieme non vuoto*/
    else
    {
        /*allocazione dinamica del primo elemento dell'insieme */
        p = (elem_lista_t *)malloc(sizeof(elem_lista_t));
        printf("\nInserire i valori reali:\n\n");
        do
        {
            printf("1' Valore: ");
            esito_lettura = scanf("%lf",
                           &p->valore);

            /*validazione input: inserimento valore*/
            if (esito_lettura != 1)
            {
                printf("\nInput non accettabile, prego reinserire!\n\n");

                /*pulizia buffer*/
                while ((rimozione_carattere = getchar()) != '\n');
            }
        }

        /*ripeti finché l'esito di scanf sia negativo*/
        while (esito_lettura != 1);

        /*pulizia buffer*/
        while ((rimozione_carattere = getchar()) != '\n');

        /*inizializzazione del puntatore successivo a NULL*/
        p->succ_p = NULL;

        /*assegnazione del puntatore ausiliario alla testa dell'insieme*/
        corr_p = p;

        /*creazione degli elementi successivi dell'insieme*/
        for (i = 2;
            (i <= card);
             i++)
        {
            /*allocazione dinamica degli elementi successivi dell'insieme*/
            corr_p->succ_p = (elem_lista_t *)malloc(sizeof(elem_lista_t));

            /*scorrimento del puntatore ausiliario al valore successivo*/
            corr_p = corr_p->succ_p;
            corr_p->succ_p = NULL;
            do
            {
                /*assegnazione di rip_p alla testa dell'insieme*/
                rip_p = p;

                /*printf condizionale in caso di ripetizione elemento*/
                if (ripetuto == 1)
                    printf("\nValore gia' inserito, prego reinserire!\n");

                /*verifica di ripetizione elementi*/
                do
                {
                    printf("%d' Valore: ", i);
                    esito_lettura = scanf("%lf",
                                   &corr_p->valore);

                    /*validazione input: inserimento valore*/
                    if (esito_lettura != 1)
                    {
                        printf("\nInput non accettabile, prego reinserire!\n\n");

                        /*pulizia buffer*/
                        while ((rimozione_carattere = getchar()) != '\n');
                    }
                }

                /*ripeti finché l'esito di scanf sia negativo*/
                while (esito_lettura != 1);

                /*pulizia buffer*/
                while ((rimozione_carattere = getchar()) != '\n');

                /*scansione insieme creato: controllo ripetizione valore*/
                ripetuto = 0;
                while (rip_p->succ_p != NULL)
                {

                    /*se trovato: ripetizione input*/
                    if (rip_p->valore == corr_p->valore)
                        ripetuto = 1;

                    /*scorrimento dei valori dell'insieme*/
                    rip_p = rip_p->succ_p;
                }
            }

            /*ripeti finché ripetuto sia uguale a uno*/
            while (ripetuto == 1);
        }

        /*chiamata a funzione: algoritmo di ordinamento per selezione*/
        ordinamento_per_selezione(p);
    }

    if (id_insieme == 'a')
        printf("\nInsieme A generato!\n");

    if (id_insieme == 'b')
        printf("\nInsieme B generato!\n");

    /*valore restituito alla funzione: primo elemento dell'insieme*/
    return(p);
}

/*definizione della funzione di ordinamento per selezione di un insieme*/
void ordinamento_per_selezione(elem_lista_t *insieme)
{
    elem_lista_t         *inizio,   /*lavoro: variabile puntatore che punterà alla testa dell'insieme*/
                 *tmp,      /*lavoro: variabile puntatore ausiliario per il confronto dei valori*/
                 *min;      /*lavoro: variabile puntatore che punterà al valore minimo*/
    double            max;      /*lavoro: variabile in cui verrà salvato il valore massimo*/

    /*inizializzazione del primo valore*/
    inizio = insieme;

    /*scansione dell'insieme*/
    while (inizio->succ_p != NULL)
    {
        min = inizio;
        tmp = inizio->succ_p;

        /*scambia finché tmp è diverso da NULL*/
        while (tmp != NULL)
        {
            /*trova il valore minimo dell'insieme*/
            if (min->valore > tmp->valore)
                min = tmp;


            /*scorrimento al successivo valore*/
            tmp = tmp->succ_p;
        }

        /*operazione di scambio dei valori*/
        max = inizio->valore;
        inizio->valore = min->valore;
        min->valore = max;

        /*impostazione del nuovo valore iniziale all'elemento successivo*/
        inizio = inizio->succ_p;
    }
    return;
}

/*definizione della funzione dell'elenco delle operazioni tra insiemi*/
void elenco_funzioni()
{
    printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
    printf("\n* (Digitare: 1) Generazione insiemi A e B                           *");
    printf("\n* (Digitare: 2) Stabilire se due insiemi sono uguali                *");
    printf("\n* (Digitare: 3) Stabilire l'intersezione tra due insiemi            *");
    printf("\n* (Digitare: 4) Stabilire la differenza tra due insiemi             *");
    printf("\n* (Digitare: 5) Stabilire la differenza simmetrica tra due insiemi  *");
    printf("\n* (Digitare: 0) Termina il programma                                *\n");
    printf("*                                                                   *\n");
    printf("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");
    return;
}

/* definizione della funzione per la stampa a video di un insieme */
void stampa_insieme(elem_lista_t *insieme)
{
    elem_lista_t *p;    /*lavoro: puntatore ausiliario che punterà alla testa dell'insieme*/

    /*scansione e stampa dei valori dell'insieme*/
    p = insieme;
    while (p != NULL)
    {
        if (p->succ_p != NULL)
            printf("%3.3lf, ",
                p->valore);
        else
            printf("%3.3lf ",
                p->valore);
        /*scorrimento al valore successivo*/
        p = p->succ_p;
    }
    printf("}\n");
    return;
}