#include <M5StickC.h>
#include "Kernel.h"
#include "EAT.h"
#include "EEPROM.h"

#define VERSION 1
#define MAX_ENTRIES 16
#define EEPROM_SIZE 4096

byte version = 0;
byte options = 0;
byte modules[MAX_ENTRIES];
byte lengths[MAX_ENTRIES];

int EAT_get_offset(byte module);

void EAT_load()
{
  EEPROM.begin(EEPROM_SIZE);
  version = EEPROM.read(0);
  options = EEPROM.read(1);

  if (version != VERSION)
  {
    char msg[255];
    sprintf(msg, "Unsupported version (%d) -- please reinitialize EEPROM.", version);
    Kernel_panic(msg);
    //Kernel_panic("Unsupported EAT version -- please reinitialize EEPROM.");
  }

  for (int i=0; i<MAX_ENTRIES; i++)
  {
    modules[i] = EEPROM.read((i*2)+2);
    lengths[i] = EEPROM.read((i*2)+3);
  }
}

void EAT_commit()
{
  EEPROM.write(0, version);
  EEPROM.write(1, options);

  for (int i=0; i<MAX_ENTRIES; i++)
  {
    EEPROM.write((i*2)+2, modules[i]);
    EEPROM.write((i*2)+3, lengths[i]);
  }
  EEPROM.commit();
}

void EAT_initialize()
{
  EEPROM.begin(EEPROM_SIZE);
  version = VERSION;
  options = 0;
  for (int i=0; i<MAX_ENTRIES; i++)
  {
    modules[i] = 0;
    lengths[i] = 0;
  }
  EAT_commit();
}

int EAT_get_offset(byte module)
{
  int offset = 0;
  for (int i=0; i<MAX_ENTRIES; i++)
  {
    if (modules[i] == module)
    {
      return offset + 2 + (MAX_ENTRIES * 2);  // header + EAT
    }
    else
    {
      offset += lengths[i];
    }
  }
  return -1;
}

int EAT_get_length(byte module)
{
  for (int i=0; i<MAX_ENTRIES; i++)
  {
    if (modules[i] == module)
    {
      return lengths[i];
    }
  }
  return -1;
}

bool EAT_allocate(byte module, byte length)
{
  for (int i=0; i<MAX_ENTRIES; i++)
  {
    if (modules[i] == module)
    {
      return false;
    }
    if (modules[i] == 0)
    {
      modules[i] = module;
      lengths[i] = length;
      EAT_commit();
      return true;
    }
  }
  Kernel_panic("Attempt to allocate EAT module but out of entries");
}

void EAT_write(byte module, byte offset, byte value)
{
  int module_offset = EAT_get_offset(module);
  if (offset == -1)
  {
    Kernel_panic("Attempt to write to uninitialized EAT module");
  }
  if (offset > EAT_get_length(module) - 1)
  {
    Kernel_panic("Attempt to write outside EAT module bounds");
  }
  offset += module_offset;
  EEPROM.write(offset, value);
  EEPROM.commit();
}

byte EAT_read(byte module, byte offset)
{
  int module_offset = EAT_get_offset(module);
  if (offset == -1)
  {
    Kernel_panic("Attempt to write to uninitialized EAT module");
  }
  if (offset > EAT_get_length(module) - 1)
  {
    Kernel_panic("Attempt to write outside EAT module bounds");
  }
  offset += module_offset;
  return EEPROM.read(offset
  );
}