#include "assert.h"
#include "commandline/parameters.h"
#include "errors/errors.h"
#include "errors/exceptions.h"
#include "files/devices/devices.h"
#include "files/devices/parameters.h"
#include "interpreter/parameters/actions.h"
#include "interpreter/parameters/parameters.h"
#include "memory/virtualmemory.h"
#include "object.h"
#include "stacks.h"
#include "types/attributes.h"
#include "types/boolean.h"
#include "types/composites/composites.h"
#include "types/composites/dictionary.h"
#include "types/equality.h"
#include "types/numbers/integer.h"
#include "types/numbers/representations.h"
#include "unix/operatingsystem.h"
#include "unix/time.h"

object interpreterparameters;

static object userparameters(const configure interpreter)
{
    return readonly(compiled(array(((object []){
        cvn(string("JobName")), action(JobName, string("")),
        cvn(string("MaxDictStack")), action(MaxStack, interpreter.MaxDictStack),
        cvn(string("MaxExecStack")), action(MaxStack, interpreter.MaxExecStack),
        cvn(string("MaxLocalVM")), action(Readonly, interpreter.MaxLocalVM),
        cvn(string("MaxOpStack")), action(MaxStack, interpreter.MaxOpStack),
        cvn(string("VMReclaim")), action(VMReclaim, null),
        cvn(string("VMThreshold")), action(VMThreshold, null)
    }))));
}

static object systemparameters(const configure interpreter)
{
    return readonly(compiled(array(((object []){
        cvn(string("ByteOrder")), action(Readonly, boolean(nativebyteorder() == low)),
        cvn(string("BuildTime")), action(Readonly, integer(buildtime())),
        cvn(string("GenericResourceDir")), string(""),
        cvn(string("GenericResourcePathSep")), string(""),
        cvn(string("FactoryDefaults")), boolean(false),
        cvn(string("PrinterName")), action(PrinterName, string("")),
        cvn(string("RealFormat")), action(Readonly, realformat() == IEEE ? string("IEEE") : string("native")),
        cvn(string("Revision")), action(Readonly, query().release),
        cvn(string("StartJobPassword")), action(Writeonly, interpreter.StartJobPassword),
        cvn(string("SystemParamsPassword")), action(Writeonly, interpreter.SystemParamsPassword)
    }))));
}

static object deviceparameters(const configure interpreter)
{
    object deviceparameters = array((object [allstoragedevices * pair]){null});
    deviceparameters.length = 0;
    for (enum storagedevice device = 0; device < allstoragedevices; ++device) {
        if (storagedeviceparameters[device]) {
            object parameters = storagedeviceparameters[device](interpreter);
            parameters.dict = readvm(parameters.dict);
            static_assert(allstoragedevices <= largestinteger, "");
            define((object[pair]){
                [key] = cvn(string("SearchOrder")),
                [value] = action(Readonly, integer((integer)device))
            }, parameters);
            deviceparameters.array[deviceparameters.length++] = cvn(storagedevicestring(device));
            deviceparameters.array[deviceparameters.length++] = parameters;
        }
    }
    return readonly(compiled(deviceparameters));
}

object setinterpreterparameters(const configure interpreter)
{
    const boolean previous = vm.allocationmode;
    vm.allocationmode = true;
    const object interpreterparameters = create[arraytype](allinterpreterparametercategories);
    interpreterparameters.array[System] = systemparameters(interpreter);
    interpreterparameters.array[Dev] = deviceparameters(interpreter);
    vm.allocationmode = false;
    interpreterparameters.array[User] = userparameters(interpreter);
    vm.allocationmode = previous;
    return noaccess(interpreterparameters);
}