Es3 Lab02

#include "stdio.h"
#include "string.h"
#include "ctype.h"
#include "time.h"
#include "stdlib.h"
#define MAX_STR 30
typedef struct{
    char codice_tratta[MAX_STR],partenza[MAX_STR],destinazione[MAX_STR];
    struct tm data, ora_partenza,ora_arrivo;
    int ritardo;
} struttura_corsa;

typedef enum {
    ordinamento_data,ordinamento_codice_tratta,ordinamento_partenza,ordinamento_destinazione,nuovo_file,
} type_comando;

void stampaRisultato(struttura_corsa *database_reale,struttura_corsa *database_ordinato[1000],int dimensione)
{
    int i;
    char partenza[MAX_STR],arrivo[MAX_STR];
    printf("Database ordinato: \n");
    for(i=0; i < dimensione;i++)
    {
        //basterebbe MAX_STR al posto di sizeof partenza in quanto 1 byte * MAX_STR = MAX_STR
        strftime(partenza,sizeof partenza,"%H:%M:%S",&database_ordinato[i]->ora_partenza);
        strftime(arrivo,sizeof partenza,"%H:%M:%S",&database_ordinato[i]->ora_arrivo);

        printf("%s %s %s %s %s %d/%d/%d\n",database_ordinato[i]->codice_tratta,database_ordinato[i]->partenza,database_ordinato[i]->destinazione,partenza,arrivo,database_ordinato[i]->data.tm_year +1900 , database_ordinato[i]->data.tm_mon + 1,database_ordinato[i]->data.tm_mday);
    }
    printf("Database reale: \n");
    for(i=0; i < dimensione;i++)
    {
        //basterebbe MAX_STR al posto di sizeof partenza in quanto 1 byte * MAX_STR = MAX_STR
        strftime(partenza,sizeof partenza,"%H:%M:%S",&database_reale[i].ora_partenza);
        strftime(arrivo,sizeof partenza,"%H:%M:%S",&database_reale[i].ora_arrivo);

        printf("%s %s %s %s %s %d/%d/%d\n",database_reale[i].codice_tratta,database_reale[i].partenza,database_reale[i].destinazione,partenza,arrivo,database_reale[i].data.tm_year +1900 , database_reale[i].data.tm_mon + 1,database_reale[i].data.tm_mday);
    }

}
void toLowerStr(char *strToLower)
{
    int i;
    for(i=0; i < strlen(strToLower); i++)
    {
        strToLower[i] = tolower(strToLower[i]);
    }
}

struttura_corsa *ottieni_informazioni(int *dimensione_max,char *nome_file)
{
    int i;
    char data_formato_stringa[MAX_STR],orario_formato_stringa_partenza[MAX_STR],orario_formato_stringa_arrivo[MAX_STR];
    struttura_corsa *database;
    FILE *fp;
    fp = fopen(nome_file,"r");

    if(!fp)
    {
        return NULL;
    }
    fscanf(fp,"%d",dimensione_max);

    database = (struttura_corsa *)malloc(sizeof(struttura_corsa) * (*dimensione_max));

    for(i=0; i < *dimensione_max; i++)
    {
        fscanf(fp,"%s %s %s %s %s %s %d",database[i].codice_tratta,database[i].partenza,database[i].destinazione,data_formato_stringa,orario_formato_stringa_partenza,orario_formato_stringa_arrivo,&database[i].ritardo);
        strptime(data_formato_stringa,"%Y/%m/%d",&database[i].data);
        strptime(orario_formato_stringa_partenza,"%H:%M:%S",&database[i].ora_partenza);
        strptime(orario_formato_stringa_arrivo,"%H:%M:%S",&database[i].ora_arrivo);

        //per evitare incongruenze nei confronti
        toLowerStr(database[i].partenza);
        toLowerStr(database[i].codice_tratta);
        toLowerStr(database[i].destinazione);
    }
    fclose(fp);
    return database;

}
void scambioValori(struttura_corsa *database[1000], int j)
{
    struttura_corsa *tmp;

    tmp = database[j];
    database[j] = database[j+1];
    database[j+1] = tmp;
}
void copiaArray(struttura_corsa *database,struttura_corsa ***database_ordinato,int dimensione)
{
    int i;
    (* database_ordinato) = (struttura_corsa **) malloc(sizeof (struttura_corsa *) * dimensione);
    for(i=0; i < dimensione; i++)
    {
        (*database_ordinato)[i] = database + i;
    }

}
void ordinamento_per_data(struttura_corsa *database,int dimensione_database)
{
    int i,j,l=0, r = dimensione_database - 1;
    struttura_corsa **database_ordinato; //stesse dimensioni massime del vettore database
    copiaArray(database,&database_ordinato,dimensione_database);
    time_t data1 , data2,orario1,orario2;
    for(i=0; i < r; i++)
    {
        for(j=l; j < r - i; j++)
        {
            data1 = mktime(&database_ordinato[j]->data);
            data2 = mktime(&database_ordinato[j+1]->data);
            if(data1 > data2)
            {
                scambioValori(database_ordinato,j);
            }else if( data1 == data2)
            {
                orario1 = mktime(&database_ordinato[j]->ora_partenza);
                orario2 = mktime(&database_ordinato[j+1]->ora_partenza);

                if(orario1 > orario2)
                {
                    scambioValori(database_ordinato,j);
                }

            }


        }
    }
    stampaRisultato(database,database_ordinato,dimensione_database);
    free(database_ordinato);

}
void ordinamento_per_codice_tratta(struttura_corsa *database,int dimensione_database)
{
    int i, j ,l=0, r = dimensione_database - 1;
    struttura_corsa **database_ordinato; //stesse dimensioni massime del vettore database
    copiaArray(database,&database_ordinato,dimensione_database);

    for(i=0; i < r; i++)
    {
        for(j=l; j < r - i; j++)
        {
            if(strcmp(database_ordinato[j]->codice_tratta,database_ordinato[j+1]->codice_tratta) > 0)
            {
                scambioValori(database_ordinato,j);
            }
        }
    }
    stampaRisultato(database,database_ordinato,dimensione_database);
    free(database_ordinato);
}

void ordinamento_per_stazione_partenza(struttura_corsa *database, int dimensione_database,int stampa)
{
    int i,j,l=0, r = dimensione_database - 1;

    struttura_corsa **database_ordinato; //stesse dimensioni massime del vettore database
    copiaArray(database,&database_ordinato,dimensione_database);

    for(i=0; i < r; i++)
    {
        for(j=l; j < r - i ; j++)
        {
            if(strcmp(database_ordinato[j]->partenza,database_ordinato[j+1]->partenza) > 0)
            {
                scambioValori(database_ordinato,j);
            }
        }
    }
    if(stampa)
    {
        stampaRisultato(database,database_ordinato,dimensione_database);
    }
    free(database_ordinato);

}
void ordinamento_per_stazione_arrivo(struttura_corsa *database, int dimensione_database)
{
    int i,j,l=0, r = dimensione_database - 1;

    struttura_corsa **database_ordinato;
    copiaArray(database,&database_ordinato,dimensione_database);

    for(i=0; i < r; i++)
    {
        for(j=l; j < r - i + l; j++)
        {
            if(strcmp(database_ordinato[j]->destinazione,database_ordinato[j+1]->destinazione) > 0)
            {
                scambioValori(database_ordinato,j);
            }
        }
    }
    stampaRisultato(database,database_ordinato,dimensione_database);
    free(database_ordinato);

}


int handleMenu(struttura_corsa **database,int *dimensione_database,type_comando comando)
{
    char partenza[MAX_STR],nome_file[100];
    switch(comando)
    {
        case ordinamento_data:
            ordinamento_per_data(*database,*dimensione_database);
            break;
        case ordinamento_codice_tratta:
            ordinamento_per_codice_tratta(*database,*dimensione_database);
            break;
        case ordinamento_partenza:
            ordinamento_per_stazione_partenza(*database,*dimensione_database,1);
            break;
        case ordinamento_destinazione:
            ordinamento_per_stazione_arrivo(*database,*dimensione_database);
            break;
        case nuovo_file:
            scanf("%s",nome_file);
            free((*database));

            (*database) = ottieni_informazioni(dimensione_database,nome_file);
            if(!(*database))
            {
                printf("Errore,file non trovato");
                return -1;
            }
            break;
        default:
            printf("Errore, comando inesistente");
            return -1;
    }
    return 1;
}
//l'ordinamento è stata sviluppato con Bubble Sort
int start()
{
    struttura_corsa *database;
    int dimensione_database,result = 1;
    type_comando comando;
    database = ottieni_informazioni(&dimensione_database,"../s293438_1/Lab02/Es3/corse.txt");
    if(!database)
    {
        printf("Errore");
        return -1;
    }
    while(result == 1) {
        printf("Inserisci il comando,successivamente ( se necessario ) manda a capo e inserisci gli eventuali parametri richiesti\n");
        printf("Menu:\n0 --> ordinamento del vettore per data, e a parità di date per ora  \n1 --> ordinamento del vettore per codice di tratta  \n2 --> ordinamento del vettore per stazione di partenza  \n3 --> ordinamento del vettore per stazione di arrivo\n");
        printf("4 --> inserisci nuovo file da cui leggere i dati\nScrivi: ");
        scanf("%d", &comando);

        result = handleMenu(&database, &dimensione_database, comando);
    }
    free(database);
    return 0;
}
int main() {
    start();
    return 0;
}