#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MEMSIZE 100
#define VARIABLES MEMSIZE

struct node_t {
    int start, size;
    struct node_t *next;
};

void printmemory(char memory[], struct node_t* freelist, struct node_t* usedlist){
    printf("memory map\n");
    for (int i = 0; i < MEMSIZE; i++) {
        printf("%c", memory[i]);
    }
    printf("\n");
    printf("free list\n");
    int freebyte = 0;
    int freenumbers_start[100];
    int freenumbers_size[100];
    int counter = 0;
    while (freelist != NULL) {
        freenumbers_start[counter] = freelist->start;
        freenumbers_size[counter] = freelist->size;
        ++counter;
        freebyte += freelist->size;
        freelist = freelist->next;
    }
    --counter;
    for(; counter >= 0; --counter){
        printf("start=%4d, size=%4d\n", freenumbers_start[counter], freenumbers_size[counter]);
    }
    counter = 0;
    printf("used list\n");
    int usedbyte = 0;
    int usednumbers_start[100];
    int usednumbers_size[100];

    while (usedlist != NULL) {
        usednumbers_start[counter] = usedlist->start;
        usednumbers_size[counter] = usedlist->size;
        ++counter;
        usedbyte += usedlist->size;
        usedlist = usedlist->next;
    }
    --counter;
    for(; counter >= 0; --counter){
        printf("start=%4d, size=%4d\n", usednumbers_start[counter], usednumbers_size[counter]);
    }
    printf("%d bytes free, %d bytes used\n", freebyte, usedbyte);
}

int mymalloc(char memory[], struct node_t** freelist, struct node_t** usedlist, int size, char* variables[], int addresses[], char* var, int vars_count){
    struct node_t* previous_free = NULL;
    struct node_t* current_free = *freelist;
    while (current_free != NULL && current_free->size < size) {
        previous_free = current_free;
        current_free = current_free->next;
    }
    if (current_free == NULL){
        return -1;
    }
    struct node_t* new_node = (struct node_t*)malloc(sizeof(struct node_t));
    new_node->start = current_free->start;
    new_node->size = size;
    new_node->next = NULL;
    struct node_t* current_used = *usedlist;
    while (current_used != NULL && current_used->next != NULL) {
        current_used = current_used->next;
    }
    if (current_used != NULL){
        current_used->next = new_node;
    } else {
        *usedlist = new_node;
    }
    for (int i = new_node->start; i < new_node->size + new_node->start; i++) {
        memory[i] = 'X';
    }
    if (size == current_free->size) {
        if (previous_free != NULL){
             previous_free->next = current_free->next;
        } else if (current_free->next != NULL) {
            *freelist = current_free->next;
        } else {
            *freelist = NULL;
        }
        free(current_free);
    } else {
        current_free->start = current_free->start + size;
        current_free->size = current_free->size - size;
    }
    strcpy(variables[vars_count], var);
    addresses = (int*)realloc(addresses, 8);
    addresses[0] = new_node->start;
    printf(" %d\n", sizeof(int)*(vars_count + 1));
    return new_node->start;
}

int main()
{
    char memory[MEMSIZE+1];
    memory[MEMSIZE] = '\0';
    for(int i = 0; i < MEMSIZE; i++){
        memory[i] = '.';
    }
    char cmd;
    char var[128];
    int input_size;
    struct node_t* startfree = (struct node_t*)malloc(sizeof(struct node_t));
    startfree->start = 0;
    startfree->size = MEMSIZE;
    startfree->next = NULL;
    struct node_t* startused = NULL;
    char* variables[VARIABLES] = {};
    int addresses[VARIABLES] = {};
    int vars = 0;
    while (1) {
        printf("Command: ");
        scanf(" %c", &cmd);

        if(cmd == 'q'){
            printf("Bye!\n");
            return 0;
        } else if (cmd == 'm'){
            printf("Variable name? ");
            scanf(" %c", &var);
            printf("Malloc how many bytes? ");
            scanf(" %d", &input_size);
            if(input_size > 0){
                int result = mymalloc(memory, &startfree, &startused, input_size, variables, addresses, var, vars);
                if (result == -1){
                     printf("There is no contiguous memory range that is large enough\n");
                } else {
                    printf("Variable starts at address %d\n", result);
                    ++vars;
                }
            } else {
                printf("The requested number of bytes must be at least 1\n");
            }

        } else if (cmd == 'p'){
            printmemory(memory, startfree, startused);
        } /*else if (cmd = 'v') {

        } else if (cmd = 'f') {

        } else if (cmd = 'g') {

        } else if (cmd = 'e') {

        }*/ else {
            printf("Invalid command '%c'\n", cmd);
        }
    }
}