#ifndef INTERPRETER_PARAMETERS_ACTIONS_H
#define INTERPRETER_PARAMETERS_ACTIONS_H

#include "assert.h"
#include "object.h"
#include "types/attributes.h"
#include "types/composites/composites.h"
#include "types/numbers/integer.h"

enum action {Array, FileAccess, JobName, MaxStack, PrinterName, Readonly, VMReclaim, VMThreshold, Writeonly, allactions};
enum {actionlength = 2};

static inline object action(enum action action, const object value) {
    assert(action < allactions);
    static_assert(allactions <= largestinteger, "");
    return noaccess(copy[arraytype]((object){
        .type = arraytype,
        .length = actionlength,
        .array = (object [actionlength]){[0] = integer((integer)action), [1] = value},
    }, create[arraytype](actionlength)));
}

static inline enum action actionfrom(const object parameter[const pair])
{
    assert(parameter);
    assert(parameter[value].type == arraytype);
    assert(parameter[value].access == none);
    assert(parameter[value].length == actionlength);
    assert(parameter[value].array);
    assert(parameter[value].array[0].type == integertype);
    assert(parameter[value].array[0].integer >= 0);
    assert(parameter[value].array[0].integer < allactions);
    return (enum action)parameter[value].array[0].integer;
}

static inline object *valuefrom(const object parameter[const pair])
{
    assert(parameter);
    assert(parameter[value].type == arraytype);
    assert(parameter[value].access == none);
    assert(parameter[value].length == actionlength);
    assert(parameter[value].array);
    return &parameter[value].array[1];
}

#define readaction(ENTRY) readaction_(ENTRY)
static inline object readaction_(const object parameter[const pair])
{
    const enum action action = actionfrom(parameter);
    extern object (* const readaction[allactions])(const object[static pair]);
    assert(readaction[action]);
    return readaction[action](parameter);
}

#define writeaction(THING, ENTRY) writeaction_((THING), (ENTRY))
static inline void writeaction_(const object thing, object parameter[const pair])
{
    const enum action action = actionfrom(parameter);
    extern void (* const writeaction[allactions])(object, object parameter[static pair]);
    assert(writeaction[action]);
    writeaction[action](thing, parameter);
}

#endif