#include "memory/MemoryMap.h"

extern const BOOTBOOT bootboot;

MemoryMapEntry::MemoryMapEntry(u64 address, usize size, bool is_free)
    : m_address(address), m_size(size), m_is_free(is_free)
{
}

MemoryMapEntry& MemoryMapEntry::operator=(const MemoryMapEntry& other)
{
    if (&other == this) return *this;

    m_address = other.address();
    m_size = other.size();
    m_is_free = other.is_free();

    return *this;
}

static MemoryMapEntry memory_map_entry_from_mmapent(const MMapEnt* ent)
{
    return {MMapEnt_Ptr(ent), MMapEnt_Size(ent), MMapEnt_IsFree(ent)};
}

MemoryMapIterator::MemoryMapIterator() : m_mmap_entries((bootboot.size - 128) / 16), m_base_ent(&bootboot.mmap)
{
    rewind();
}

void MemoryMapIterator::rewind()
{
    m_cur_ent = 0;
}

Result<MemoryMapEntry> MemoryMapIterator::at(usize index) const
{
    if (index >= m_mmap_entries) return err(ERANGE);
    return memory_map_entry_from_mmapent(m_base_ent + index);
}

Result<MemoryMapEntry> MemoryMapIterator::next()
{
    return at(m_cur_ent++);
}

MemoryMapEntry MemoryMapIterator::largest_free()
{
    usize largest_size = 0;
    usize largest_index = 0;

    rewind();

    MemoryMapEntry entry;
    while (next().try_set_value(entry))
    {
        if (entry.is_free() && entry.size() > largest_size)
        {
            largest_size = entry.size();
            largest_index = m_cur_ent - 1;
        }
    }

    return at(largest_index).release_value();
}

MemoryMapEntry MemoryMapIterator::highest()
{
    usize highest_address = 0;
    usize highest_index = 0;

    rewind();

    MemoryMapEntry entry;
    while (next().try_set_value(entry))
    {
        if (entry.address() > highest_address)
        {
            highest_address = entry.address();
            highest_index = m_cur_ent - 1;
        }
    }

    return at(highest_index).release_value();
}