main.c

Go to the documentation of this file.

#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "Pool.h"
#include "Product.h"
 
enum MenuOption
{
    MENU_INVALID,
    MENU_MANAGE_STOCK,
    MENU_GENERATE_REPORT,
    MENU_QUIT
};
 
static enum MenuOption get_menu_selection()
{
    enum MenuOption option = MENU_INVALID;
 
    while (option == MENU_INVALID) {
        fputs("1. Manage Stock Levels\n"
              "2. Generate Reports\n"
              "3. Quit the Program\n\n"
              "Please enter your selection: ",
                stdout);
 
        fflush(stdout);
 
        switch (getchar()) {
        case '1':
            option = MENU_MANAGE_STOCK;
            break;
        case '2':
            option = MENU_GENERATE_REPORT;
            break;
        case '3':
            option = MENU_QUIT;
            break;
        default:
            fputs("Invalid option.\n\n", stderr);
        }
 
        // Flush remaining characters from the input stream.
        char ch;
        while ((ch = getchar()) != '\n' && ch != EOF)
            ;
    }
 
    return option;
}
 
static size_t get_input_line(char *const buffer, const size_t buffer_size, FILE *const stream)
{
    errno = 0;
    if (!fgets(buffer, buffer_size - 1, stream))
        return 0;
 
    if (errno != 0) {
        fputs("Could not get line of input: ", stderr);
        fputs(strerror(errno), stderr);
        return 0;
    }
 
    const size_t input_length = strlen(buffer);
    if (input_length < 2)
        return 0;
 
    if (buffer[input_length - 1] != '\n') {
        fputs("Could not get line of input: too long.\n", stderr);
        return buffer_size;
    }
 
    buffer[input_length - 1] = '\0';
    return input_length;
}
 
static unsigned int convert_to_uint(const char *const buffer, bool *error)
{
    errno = 0;
    char *end = NULL;
    const unsigned long value = strtoul(buffer, &end, 10);
 
    if (errno != 0 || value >= UINT_MAX || *end != '\0') {
        *error = true;
        return 0;
    }
 
    *error = false;
    return (unsigned int) value;
}
 
static int convert_to_sint(const char *const buffer, bool *error)
{
    errno = 0;
    char *end = NULL;
    const long value = strtol(buffer, &end, 10);
 
    if (errno != 0 || value <= INT_MIN || value >= INT_MAX || *end != '\0') {
        *error = true;
        return 0;
    }
 
    *error = false;
    return (int) value;
}
 
static void manage_stock(const struct Pool *const pool)
{
    bool valid = false;
    char buffer[MAX_NAME_LENGTH + 1];
    struct Product *product;
    int quantity_modifier;
 
    while (!valid) {
        fputs("Please Enter a Unique Product Number : ", stdout);
        fflush(stdout);
 
        unsigned int product_id;
        bool error_flag = get_input_line(buffer, sizeof(buffer) / sizeof(buffer[0]), stdin) < 1;
 
        if (!error_flag)
            product_id = convert_to_uint(buffer, &error_flag);
 
        if (error_flag) {
            fputs("That is not a valid product ID.\n", stderr);
            continue;
        }
 
        // ReSharper disable once CppLocalVariableMightNotBeInitialized
        if ((product = pool_get_product_by_index(pool, product_id)) == NULL) {
            fputs("A product with that number does not exist!\n", stderr);
            continue;
        }
 
        valid = true;
    }
 
    valid = false;
    while (!valid) {
        fputs("Please Enter A Stock Level Adjustment Value : ", stdout);
        fflush(stdout);
 
        bool error_flag = get_input_line(buffer, sizeof(buffer) / sizeof(buffer[0]), stdin) < 1;
        if (!error_flag)
            quantity_modifier = convert_to_sint(buffer, &error_flag);
 
        if (error_flag) {
            fputs("That is not a valid quantity modifier.\n", stderr);
            continue;
        }
 
        // ReSharper disable CppLocalVariableMightNotBeInitialized
        if (!product_modify_quantity(product, quantity_modifier)) {
            // ReSharper restore CppLocalVariableMightNotBeInitialized
            fputs("There is insufficient stock to allow that.\n", stderr);
            continue;
        }
 
        valid = true;
    }
}
 
static void generate_reports(const struct Pool *const pool)
{
    char path_buffer[PATH_MAX + 1];
 
    fputs("Enter a destination filename for the report : ", stdout);
    fflush(stdout);
 
    FILE *const destination = get_input_line(path_buffer, sizeof(path_buffer) / sizeof(path_buffer[0]), stdin)
            ? fopen(path_buffer, "w+")
            : stdout;
 
    if (pool_serialise_report(pool, destination) < 0)
        fprintf(stderr, "Error writing to report file: file error %d.\n", ferror(destination));
 
    if (destination != stdout)
        fclose(destination);
}
 
static int load_inventory(FILE *const stock_file, struct Pool *const pool)
{
    char name_buffer[MAX_NAME_LENGTH + 1];
    char quantity_buffer[MAX_NAME_LENGTH + 1];
    unsigned int product_id = 0;
 
    while (get_input_line(name_buffer, sizeof(name_buffer) / sizeof(name_buffer[0]), stock_file)) {
        if (!get_input_line(quantity_buffer, sizeof(name_buffer) / sizeof(name_buffer[0]), stock_file)) {
            fprintf(stderr, "Missing quantity for product \"%s\"\n", name_buffer);
            break;
        }
 
        bool error_flag;
        const unsigned int quantity = convert_to_uint(quantity_buffer, &error_flag);
 
        if (error_flag) {
            fprintf(stderr, "Quantity for product \"%s\" is invalid.\n", name_buffer);
            return -1;
        }
 
        struct Product *new_product = product_create(product_id++, name_buffer, quantity);
        if (new_product == NULL) {
            fprintf(stderr, "Could not create new product \"%s\": %s\n", name_buffer, strerror(errno));
            return -1;
        }
 
        if (!pool_insert_element(pool, new_product)) {
            product_delete(&new_product);
            fprintf(stderr, "Could not create new product \"%s\": %s\n", name_buffer, strerror(errno));
            return -1;
        }
    }
 
    return 0;
}
 
static FILE *open_stock_file(const char *const filename)
{
    errno = 0;
    FILE *const fp = fopen(filename, "r+");
 
    if (fp == NULL) {
        if (errno == 0) {
            fputs("could not open stock data file : ", stdout);
            puts(filename);
        } else {
            fputs(strerror(errno), stdout);
            fputs(" : ", stdout);
            puts(filename);
        }
    } else {
        fputs("using stock data file : ", stdout);
        puts(filename);
        putchar('\n');
    }
 
    return fp;
}
 
static void save_inventory(FILE *const datafile, const struct Pool *const pool)
{
    if (pool_serialise_stock_file(pool, datafile) < 0)
        fprintf(stderr, "Error writing to stock data file: file error %d.\n", ferror(datafile));
}
 
int main(const int argc, const char **const argv)
{
    fputs("Stock Control Program Started - ", stdout);
    FILE *stock_file = open_stock_file(argc > 1 ? argv[1] : "stock_data.txt");
    if (stock_file == NULL)
        return EXIT_FAILURE;
 
    struct Pool *pool = pool_create(16, 2.0f);
    if (load_inventory(stock_file, pool) != 0) {
        pool_delete(&pool);
        fclose(stock_file);
        return EXIT_FAILURE;
    }
 
    bool continue_running = true;
    while (continue_running) {
        switch (get_menu_selection()) {
        case MENU_MANAGE_STOCK:
            manage_stock(pool);
            break;
        case MENU_GENERATE_REPORT:
            generate_reports(pool);
            break;
        default:
            save_inventory(stock_file, pool);
            continue_running = false;
            break;
        }
    }
 
    pool_delete(&pool);
    fclose(stock_file);
    return EXIT_SUCCESS;
}