// package_delivery_system.c
// Pantea Aria
// Implementation file for package delivery system functions
// (TODO)

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

#include "package_delivery_system.h"

// Function prototypes
static struct package *create_package(char sender[], char receiver[],
    double weight, enum priority_type priority, enum status_type status);
static void append_package(struct delivery_centre *centre,
    struct package *new_package);


// Function definitions

// Creates a new empty delivery centre
struct delivery_centre *create_centre(char name[]) {
    struct delivery_centre *new_centre = malloc(sizeof(struct delivery_centre));
    if (new_centre == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }

    strcpy(new_centre->name, name);
    new_centre->packages = NULL;

    return new_centre;
}

// Add a new package to the centre at the head
// Similar to previous lecture code insert_head
void insert_package_at_head(struct delivery_centre *centre, char sender[],
    char receiver[], double weight, enum priority_type priority,
    enum status_type status) {

    struct package *new_package = create_package(sender, receiver, weight,
        priority, status);

    new_package->next = centre->packages;
    centre->packages = new_package;
}

// Given a string, look for package where the receiver is this string
struct package *search_package(struct delivery_centre *centre,
    char receiver[]) {

    struct package *current = centre->packages;

    while (current != NULL) {
        if (strcmp(current->receiver, receiver) == 0) {
            return current;
        }
        current = current->next;
    }

    return NULL;
}

// Removes all packages from a centre
// clears and deletes associated memory of centre and packages in it
void clear_centre(struct delivery_centre *centre) {
    struct package *current = centre->packages;

    while (current != NULL) {
        struct package *temp = current;
        current = current->next;
        free(temp);
    }

    free(centre);
}

// Remove package(s) with certain priority
void delete_package_of_priority(struct delivery_centre *centre,
    enum priority_type priority) {

   struct package *prev = NULL;
   struct package *curr = centre->packages;

    // Find node to delete
    while (curr != NULL) {
        if (curr->priority == priority) {
            if (prev == NULL) {
                centre->packages = centre->packages->next;
                free(curr);
                curr = centre->packages;
            } else {
                prev->next = curr->next;
                free(curr);
                curr = prev->next;
            }
            
        } else {
            prev = curr;
            curr = curr->next;
        }
    }    
}



// Append packages from centre_2 after centre_1 and returns them in one centre
// Assumption made here assumes no same receiver package in centre_1 and centre_2
struct delivery_centre *merge_centres(char merged_centre_name[],
    struct delivery_centre *centre_1, struct delivery_centre *centre_2) {

    struct delivery_centre *merged_centre = create_centre(merged_centre_name);

    if (centre_1->packages == NULL) {
        merged_centre->packages = centre_2->packages;
    } else {
        merged_centre->packages = centre_1->packages;

        struct package *current = centre_1->packages;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = centre_2->packages;
    }

    free(centre_1);
    free(centre_2);

    return merged_centre;
}

// Split packages in a given centre into 3 centres based on package status
// keeping original ordering
// assumption: pending, in_transit and delivered are centres already malloc-ed
// and initialised
void split_centre(struct delivery_centre *given_centre,
    struct delivery_centre *pending,
    struct delivery_centre *in_transit,
    struct delivery_centre *delivered) {

    struct package *current = given_centre->packages;

    pending->packages = NULL;
    in_transit->packages = NULL;
    delivered->packages = NULL;

    while (current != NULL) {
        struct package *next = current->next;
        current->next = NULL;

        if (current->status == PENDING) {
            append_package(pending, current);
        } else if (current->status == IN_TRANSIT) {
            append_package(in_transit, current);
        } else if (current->status == DELIVERED) {
            append_package(delivered, current);
        }

        current = next;
    }

    free(given_centre);
}

// returns number of packages in a given centre
// Improved
int count_packages(struct delivery_centre *centre) {
    if (centre == NULL) {
        return 0;
    }

    int count = 0;
    for (struct package *curr = centre->packages; curr != NULL; curr = curr->next) {
        count++;
    }

    return count;
}

// Your functions here (include function comments):

// Creates and returns a new package node
static struct package *create_package(char sender[], char receiver[],
    double weight, enum priority_type priority, enum status_type status) {

    struct package *new_package = malloc(sizeof(struct package));
    if (new_package == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }

    strcpy(new_package->sender, sender);
    strcpy(new_package->receiver, receiver);
    new_package->weight = weight;
    new_package->priority = priority;
    new_package->status = status;
    new_package->next = NULL;

    return new_package;
}

// Appends a package node to the end of a centre list
static void append_package(struct delivery_centre *centre,
    struct package *new_package) {

    if (centre->packages == NULL) {
        centre->packages = new_package;
        return;
    }

    struct package *current = centre->packages;
    while (current->next != NULL) {
        current = current->next;
    }

    current->next = new_package;
}


////////////////////////////////////////////////////////////////////////////////
//                              Provided Code                                //
////////////////////////////////////////////////////////////////////////////////

// Print/display all packages in centre
// Similar to previous lecture code print_list
void print_packages(struct delivery_centre *centre) {
    printf("Centre Name: %s\n", centre->name);
    struct package *current = centre->packages;

    if (current == NULL) {
        printf("There are no packages in this centre.\n");
    }

    while (current != NULL) {
        printf("---\n");
        print_single_package(current);
        current = current->next;
    }
}

// Prints out details of a single package
void print_single_package(struct package *package) {
    if (package == NULL) {
        printf("Package is NULL.\n");
        return;
    }

    printf("Sender: %s\n", package->sender);
    printf("Receiver: %s\n", package->receiver);
    printf("Weight: %lfkg\n", package->weight);

    printf("Priority: ");
    if (package->priority == STANDARD) {
        printf("STANDARD\n");
    } else if (package->priority == EXPRESS) {
        printf("EXPRESS\n");
    } else if (package->priority == URGENT) {
        printf("URGENT\n");
    } else {
        printf("UNKNOWN\n");
    }

    printf("Status: ");
    if (package->status == PENDING) {
        printf("PENDING\n");
    } else if (package->status == IN_TRANSIT) {
        printf("IN_TRANSIT\n");
    } else if (package->status == DELIVERED) {
        printf("DELIVERED\n");
    } else {
        printf("UNKNOWN\n");
    }
}