// carsList.c : Questo file contiene la funzione 'main', in cui inizia e termina l'esecuzione del programma.
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_NAME 21
#define MAX_PLATE 11
#define MAX_ROW 81

struct carRegister
{
    char carName[MAX_NAME + 1];
    char carPlate[MAX_PLATE + 1];
    int regYear;
    int power;
    struct carRegister* next;
};

struct carRegister* createNode(char* carName, char* carPlate, int regYear, int power)
{
    struct carRegister *newNode = (struct carRegister*) malloc(sizeof(struct carRegister));
    if (newNode != NULL)
    {
        strcpy(newNode->carName, carName);
        strcpy(newNode->carPlate, carPlate);
        newNode->regYear = regYear;
        newNode->power = power;
        newNode->next = NULL;
    }
    return(newNode);
        
}

void printList(struct carRegister* head) {
    struct carRegister* current = head;
    while (current != NULL) {
        printf("%s ", current->carName);
        printf("%s ", current->carPlate);
        printf("%d ", current->regYear);
        printf("%d\n", current->power);
        current = current->next;
    }
    printf("\n");
}

void head_insert(struct carRegister** ptr, struct carRegister* newNode)
{
    struct carRegister* tmp = NULL;

    tmp = *ptr;
    *ptr = newNode;
    (*ptr)->next = tmp;
}

void tail_insert(struct carRegister** ptr, struct carRegister* newNode)
{
    struct carRegister* tmp = NULL;

    if (*ptr == NULL)
    {
        *ptr = newNode;
        (*ptr)->next = NULL;
    }
    else
    {
        tmp = *ptr;
        while (tmp->next != NULL)
            tmp = tmp->next;
        tmp->next = newNode;
    }

}

void insert_x_power(struct carRegister** ptr, struct carRegister* newNode)
{
    struct carRegister* tmp = NULL;

    if (*ptr == NULL)
    {
        *ptr = newNode;
        (*ptr)->next = NULL;
    }
    else
    {
        if ((*ptr)->power > newNode->power)
        {
            newNode->next = *ptr;
            *ptr = newNode;
        }
        else
        {
            tmp = *ptr;
            while (tmp->next != NULL)
            {
                if ((tmp->power < newNode->power) && (tmp->next->power > newNode->power))
                {
                    newNode->next = tmp->next;
                    tmp->next = newNode;
                    break;
                }
                else
                {
                    tmp = tmp->next;
                }
            }
            if (tmp->next == NULL)
            {
                tmp->next = newNode;
            }
        }
    }
}

int swap(const char* carName1, const char* carName2, struct carRegister** head)
{
    struct carRegister* current = *head;
    struct carRegister* car1 = NULL;
    struct carRegister* prev1 = NULL;
    struct carRegister* car2 = NULL;
    struct carRegister* prev2 = NULL;
    bool isCar1Head = false, isCar2Head = false, isCar1Found = false, isCar2Found = false;
    
    if (strcmp(carName1, carName2) == 0)
    {
        printf("Coincident car names cannot be swapped\n");
        return(1);
    }

    if (current == NULL)
    {
        printf("Empty list\n");
        return(2);
    }
    if (strcmp(current->carName, carName1) == 0)
    {
        isCar1Head = true;
        isCar1Found = true;
        car1 = *head;
    }
    else
        prev1 = current;
    if (strcmp(current->carName, carName2) == 0)
    {
        isCar2Head = true;
        isCar2Found = true;
        car2 = *head;
    }
    else
        prev2 = current;
    current = current->next;
    while ((current != NULL) && ((car1 == NULL) || (car2 == NULL)))
    {
        if (!isCar1Found)
        {
            if (strcmp(current->carName, carName1) == 0)
            {
                isCar1Found = true;
                car1 = current;
            }
            else
                prev1 = current;
        }
        if (!isCar2Found)
        {
            if (strcmp(current->carName, carName2) == 0)
            {
                isCar2Found = true;
                car2 = current;
            }
            else
                prev2 = current;

        }
        if (isCar1Found && isCar2Found)
        {
            break;
        }
        else
            current = current->next;
    }
    if (isCar1Found && isCar2Found)
    {
        if (isCar1Head)
        {
            *head = car2;
            struct carRegister* tmp = car2->next;
            car2->next = car1->next;
            prev2->next = car1;
            car1->next = tmp;
        }
        else if (isCar2Head)
        {
            *head = car1;
            struct carRegister* tmp = car1->next;
            car1->next = car2->next;
            prev1->next = car2;
            car2->next = tmp;

        }
        else
        {
            struct carRegister* tmp = car2->next;
            prev1->next = car2;
            car2->next = car1->next;
            prev2->next = car1;
            car1->next = tmp;
        }
        return(0);
    }
    else if (!isCar1Found && !isCar2Found)
    {
        printf("Car names %s and %s not found\n", carName1, carName2);
        return(3);
    }
    else if (!isCar1Found)
    {
        printf("Car name %s not found\n", carName1);
        return(4);
    }
    else //(!isCar2Found)
    {
        printf("Car name %s not found\n", carName2);
        return(5);
    }
 }

 // A version of Bubble Sort
 int bubbleSort(struct carRegister** ptr)
 {
    struct carRegister* prev;
    struct carRegister* current;
    struct carRegister* tmp;
    bool swapped = true;

    if (*ptr == NULL || (*ptr)->next == NULL)
        return(0);
    while (swapped)
    {
        swapped = false;
        current = (*ptr)->next;
        if ((*ptr)->power > current->power)
        {
            swapped = true;
            prev = *ptr;
            *ptr = current;
            prev->next = current->next;
            current->next = prev;
        }
        prev = *ptr;
        current = prev->next->next;
        while (current != NULL)
        {
            if (prev->next->power > current->power)
            {
                swapped = true;
                tmp = prev->next;
                prev->next = current;
                tmp->next = current->next;
                current->next = tmp;
            }
            prev = prev->next;
            current = current->next;
        }
        if (!swapped)
            break;
    }
    return(0);
 }

int main()
{
    const char* carsList[] = {
        "Toyota ABC4123 2005 1800",
        "Ford XYZ1789 1992 2700",
        "Honda USA2456 2018 1400",
        "Chevrolet LIBERTY 1986 3600",
        "Volkswagen 4EVERUSA 2008 1100",
        "Nissan NYC5555 1997 4900",
        "BMW LA1DREAM 2010 2100",
        "Mercedes-Benz 1STPLACE 1985 3000",
        "Audi TEXAS123 2015 4200",
        "Tesla MIAMI305 1990 1500",
        "Hyundai LV2LUCKY 2002 2300",
        "Subaru CHI3TOWN 2016 4000",
        "Kia ATLANTA1 1988 1000",
        "Lexus DC2CAPITL 2000 2900",
        "Porsche FL6SUNNY 1995 4600",
        "Jaguar GOTHAM 2019 1300",
        "Land-Rover HOLLYWD 1998 4400",
        "Volvo BEACHFUN 2007 3200",
        "Mazda WDC555 1982 2500",
        "Fiat GR8LAKES 2020 1900"
    };

    struct carRegister* headList = NULL;
    struct carRegister* headListTail = NULL;
    struct carRegister* headListPower = NULL;


    for (int i = 0; i < sizeof(carsList) / sizeof(carsList[0]); i++)
    {
        char carName[MAX_NAME + 1];
        char carPlate[MAX_PLATE + 1];
        char row[MAX_ROW];
        int regYear;
        int power;

        char* t;
        strcpy(row, carsList[i]);
        if ((t = strtok(row, " ")) != NULL)
        {
            strcpy(carName, t);
            if ((t = strtok(NULL, " ")) != NULL)
            {
                strcpy(carPlate, t);
            }
            if ((t = strtok(NULL, " ")) != NULL)
            {
                regYear = atoi(t);
            }
            if ((t = strtok(NULL, " ")) != NULL)
            {
                power = atoi(t);
            }
        }
        else
        {
            printf("Error reading tokens from row");
            return(1);
        }

        struct carRegister* newNode = createNode(carName, carPlate, regYear, power);
        if (newNode != NULL)
        {
            head_insert(&headList, newNode);
            //tail_insert(&headListTail, newNode);
            //insert_x_power(&headListPower, newNode);
        }
        else
        {
            printf("Error creating newNode");
            return(2);
        }
    }
    printList(headList);
    //printList(headListTail);
    //printList(headListPower);
    /*
    if (swap("Audi", "Honda", &headListPower) == 0)
    {
        printList(headListPower);
    }*/
    if (bubbleSort(&headList) == 0)
    {
        printList(headList);
    }
    return(0);
}