#include "Storage.hpp"

namespace fw
{
    Storage::Storage()
    {
        this->max_rules = 15;
        this->eeprom_amount_of_rules = 0;
        this->eeprom_rules_head = 1;
        this->eeprom_size = this->max_rules * sizeof(firewall_rule_t) + eeprom_rules_head;
        EEPROM.begin(this->eeprom_size);
    }

    Storage::~Storage()
    {
    }

    uint16_t Storage::eeprom_rule_position(uint8_t key)
    {
        return eeprom_rules_head + (key - 1) * sizeof(firewall_rule_t);
    }

    uint8_t Storage::retrieve_amount_of_rules()
    {
        uint8_t amount_of_rules = EEPROM.read(this->eeprom_amount_of_rules);

        if (amount_of_rules > this->max_rules)
            return 0;
        return amount_of_rules;
    }

    void Storage::store_amount_of_rules(const uint8_t new_amount)
    {
        EEPROM.put(this->eeprom_amount_of_rules, new_amount);
        EEPROM.commit();
    }

    firewall_rule_t *Storage::retrieve_firewall_rule(const uint8_t key)
    {
        firewall_rule_t *rule_ptr = (firewall_rule_t *)malloc(sizeof(firewall_rule_t));
        rule_ptr->key = key;
        uint16_t eespom_position = eeprom_rule_position(key);

        EEPROM.get(eespom_position, rule_ptr->ip);
        EEPROM.get(eespom_position += sizeof(rule_ptr->ip), rule_ptr->port_from);
        EEPROM.get(eespom_position += sizeof(rule_ptr->port_from), rule_ptr->port_to);
        EEPROM.get(eespom_position += sizeof(rule_ptr->port_to), rule_ptr->protocol);
        EEPROM.get(eespom_position += sizeof(rule_ptr->protocol), rule_ptr->target);
        return rule_ptr;
    }

    void Storage::store_all_firewall_rules(firewall_rule_t *rule_head)
    {
        firewall_rule_t *temp = rule_head;
        while (temp != NULL)
        {
            store_firewall_rule(temp);
            temp = temp->next;
        }
    }

    void Storage::store_firewall_rule(firewall_rule_t *rule_ptr)
    {
        uint16_t eespom_position = eeprom_rule_position(rule_ptr->key);

        EEPROM.put(eespom_position, rule_ptr->ip);
        EEPROM.put(eespom_position += sizeof(rule_ptr->ip), rule_ptr->port_from);
        EEPROM.put(eespom_position += sizeof(rule_ptr->port_from), rule_ptr->port_to);
        EEPROM.put(eespom_position += sizeof(rule_ptr->port_to), rule_ptr->protocol);
        EEPROM.put(eespom_position += sizeof(rule_ptr->protocol), rule_ptr->target);

        EEPROM.commit();
    }
}