#include "mm.h"

/*
The following is 'mm.h':
#include <unistd.h>
typedef struct metadata_block* p_block;

typedef struct metadata_block
{
    size_t size;
    p_block next;
    int free;
}metadata_block;

void* malloc(size_t size);
void free(void* ptr);
void* realloc(void* ptr, size_t size);
*/
//THE MAIN CODE IS AT THE BOTTOM//
#include <stdio.h>

static p_block head = NULL;

void* malloc(size_t size)
{
    void* ptr;
    int isOk = 1;
    int temp = 0;
    p_block curr = head;
    if(size <= 0)
    {
        return NULL;
    }
    if(curr)
    {
        while(curr->next && isOk)
        {
            if(curr->free && size <= curr->size)
            {
                isOk = 0;
            }

            if(isOk)
            {
                curr = curr->next;
            }
        }

        if(isOk) //what will happen if there isn't one free and big enough
        {
            ptr = sbrk(size + sizeof(metadata_block));
            if((int)ptr <= 0)
                return NULL;
            ((p_block)(ptr))->size = size;
            ((p_block)(ptr))->next = NULL; //next run it's the real next.
            ((p_block)(ptr))->free = 0;

            return (ptr + sizeof(metadata_block));
        }
        else
        {
            if(curr->next)
            {
                ptr = curr;
                if(curr->size == size || size > (curr->size - sizeof(metadata_block) - 1)) //not enough room for another block of memory
                {
                    ((p_block)(ptr))->free = 0;
                    return (ptr + sizeof(metadata_block));
                }

                temp = curr->size;
                ((p_block)(ptr))->size = size;
                ((p_block)(ptr))->free = 0;
                ((p_block)(ptr + sizeof(metadata_block) + size))->next = curr->next;
                ((p_block)(ptr))->next = ptr + sizeof(metadata_block) + size;
                ((p_block)(ptr + sizeof(metadata_block) + size))->size = temp - size;
                ((p_block)(ptr + sizeof(metadata_block) + size))->free = 1;

                return (ptr + sizeof(metadata_block));
            }
            else
            {
                ptr = curr;
                if((int)sbrk(size - curr->size) > 0)
                {
                    ((p_block)(ptr))->size = size;
                    ((p_block)(ptr))->next = NULL; //next run it's the real next.
                    ((p_block)(ptr))->free = 0;

                    return (ptr + sizeof(metadata_block));
                }
                return NULL;
            }
        }
    }
    else
    {
        ptr = sbrk(size + sizeof(metadata_block));
        if((int)ptr <= 0)
            return NULL;
        head = ptr;
        ((p_block)(ptr))->size = size;
        ((p_block)(ptr))->next = NULL;
        ((p_block)(ptr))->free = 0;
    }


    return ptr;
}

void free(void* ptr)
{
    void* curr = head;
    void* before = NULL;
    int isLegal = 0;
    printf("curr is %p and ptr is %p\n", curr, ptr);
    if(curr == ptr)
    {
        printf("aaa");
    }
    else
    {
        printf("bbb");
    }
    if(curr && ptr)
    {
        while(curr && !isLegal)
        {
            if(((p_block)(ptr)) == ((p_block)(curr))->next)
            {
                before = curr;
                isLegal = 1;
                curr = ((p_block)(curr))->next;
            }
            else
            {
                curr = ((p_block)(curr))->next;
            }
        }

        if(isLegal)
        {
            curr = curr - sizeof(metadata_block);

            if(((p_block)(curr))->next)
            {
                ((p_block)(curr))->free = 1;
            }
            else
            {
                sbrk(0-(((p_block)(curr))->size + sizeof(metadata_block)));
                ((p_block)(before))->next = NULL;
            }
        }
    }
}

void* realloc(void* ptr, size_t size)
{
    void* ptr2 = malloc(size);
    int i;
    for(i = 0 ; i < size ; i++)
    {
        *((char*)(ptr2 + i)) = *((char*)(ptr + i));
    }

    free(ptr);

    return ptr2;
}

/*
int main()
{
    printf("I'm in.\n");
    char * str = malloc(10);
    printf("After Malloc()\n");
    void * ptr = (void *) str;
    void * ptr2;
    if(!str)
    {
        printf("Fail.\n");
    }
    strcpy(str,"TEST!\0");
    printf("About to free\n");
    free(str);
    printf("free: OK!\n");
}
//OUTPUT IS:
//I'm in.
//After Malloc()
//About to free
//curr is X and ptr is X [both always come out equal - this is the text printed in the free()]
//Segmentation fault (core dumped)
*/