// SoundPatch.c
// Turns a soundThing patch into a table the sound device can be handed.
//
// ---- Why this exists ----
//
// soundThing is where a patch gets DESIGNED, because it has a screen, a keyboard and a pair
// of ears attached to it. Voyager's sound device is the same voice engine with the editor
// taken off, so the sound a patch makes is the same sound - but its settings arrive as bytes
// through a selector, and a byte is not seconds or hertz.
//
// The first sound written for a game here was guessed at in bytes: a cutoff of 40 looked
// small and is 57 Hz, so the bang came out as a low gurgle. That is what this is for. Design
// it where it can be heard, convert it, and the numbers stop being a matter of opinion.
//
// ---- What a byte means ----
//
// Every parameter the device takes is a documented function of a natural value, and all of
// them invert. Times are SQUARED into four seconds, because the difference between five and
// fifty milliseconds is the whole character of a percussive sound and the difference between
// three and four seconds is nothing anybody can hear. Cutoff and LFO rate are EXPONENTIAL,
// because pitch is logarithmic and so is where a filter sounds like it is. Depths and detune
// are CENTRED on 128, so half of nothing is no change and either side of it is a direction.
//
// Written by Anachronaut

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

// How a natural value becomes a byte. The inverse of soundParameter in sound.c, and the
// reason that file and this one have to be read together if either changes.
typedef enum {
    AS_DIRECT,      // already a byte: a waveform, a routing, a filter type
    AS_BOOL,        // nought or one
    AS_RANGE,       // linear from low to high
    AS_SQUARED,     // times, so that the short end has the resolution
    AS_EXPONENTIAL, // cutoff and rate, because hearing is logarithmic
    AS_SIGNED,      // centred on 128, reaching `high` either way
    AS_OCTAVE       // a small signed number, offset by 128
} Shape;

typedef struct {
    const char *field;      // what soundThing calls it
    unsigned char parameter; // what the device calls it
    Shape shape;
    double low, high;
    const char *note;
} Mapping;

// ---- The whole of the correspondence ----
//
// Oscillator one is oscillator nought's parameters plus 0x10, and the modulation envelope is
// the amplitude one plus 0x10, which is why the parameter numbers are laid out the way they
// are. Written out in full anyway: a table that has to be understood before it can be read is
// worse than a long one.
static const Mapping mappings[] = {
    { "osc0_waveform",        0x00, AS_DIRECT,      0, 0,       "oscillator 0, waveform" },
    { "osc0_gain",            0x01, AS_RANGE,       0, 4.0,     "gain" },
    { "osc0_dutyCycle",       0x02, AS_RANGE,       0.05, 0.95, "duty" },
    { "osc0_detune",          0x03, AS_SIGNED,      0, 1200,    "detune, in cents" },
    { "osc0_octave",          0x04, AS_OCTAVE,      0, 0,       "octave" },
    { "osc0_active",          0x05, AS_BOOL,        0, 0,       "on" },
    { "osc0_modRouting0",     0x06, AS_DIRECT,      0, 0,       "what moves its width" },
    { "osc0_modDepth0",       0x07, AS_SIGNED,      0, 0.5,     "and how far" },
    { "osc0_modRouting1",     0x08, AS_DIRECT,      0, 0,       "what moves its pitch" },
    { "osc0_modDepth1",       0x09, AS_SIGNED,      0, 1200,    "and how far" },
    { "osc0_modRouting2",     0x0A, AS_DIRECT,      0, 0,       "what moves its gain" },
    { "osc0_modDepth2",       0x0B, AS_SIGNED,      0, 4.0,     "and how far" },

    { "osc1_waveform",        0x10, AS_DIRECT,      0, 0,       "oscillator 1, waveform" },
    { "osc1_gain",            0x11, AS_RANGE,       0, 4.0,     "gain" },
    { "osc1_dutyCycle",       0x12, AS_RANGE,       0.05, 0.95, "duty" },
    { "osc1_detune",          0x13, AS_SIGNED,      0, 1200,    "detune, in cents" },
    { "osc1_octave",          0x14, AS_OCTAVE,      0, 0,       "octave" },
    { "osc1_active",          0x15, AS_BOOL,        0, 0,       "on" },
    { "osc1_modRouting0",     0x16, AS_DIRECT,      0, 0,       "what moves its width" },
    { "osc1_modDepth0",       0x17, AS_SIGNED,      0, 0.5,     "and how far" },
    { "osc1_modRouting1",     0x18, AS_DIRECT,      0, 0,       "what moves its pitch" },
    { "osc1_modDepth1",       0x19, AS_SIGNED,      0, 1200,    "and how far" },
    { "osc1_modRouting2",     0x1A, AS_DIRECT,      0, 0,       "what moves its gain" },
    { "osc1_modDepth2",       0x1B, AS_SIGNED,      0, 4.0,     "and how far" },

    { "ampEnv_attack",        0x20, AS_SQUARED,     0, 4.0,     "amplitude envelope, attack" },
    { "ampEnv_decay",         0x21, AS_SQUARED,     0, 4.0,     "decay" },
    { "ampEnv_sustain",       0x22, AS_RANGE,       0, 1.0,     "sustain" },
    { "ampEnv_release",       0x23, AS_SQUARED,     0, 4.0,     "release" },

    { "modEnv_attack",        0x30, AS_SQUARED,     0, 4.0,     "modulation envelope, attack" },
    { "modEnv_decay",         0x31, AS_SQUARED,     0, 4.0,     "decay" },
    { "modEnv_sustain",       0x32, AS_RANGE,       0, 1.0,     "sustain" },
    { "modEnv_release",       0x33, AS_SQUARED,     0, 4.0,     "release" },

    { "filter_active",        0x40, AS_BOOL,        0, 0,       "filter, on" },
    { "filter_type",          0x41, AS_DIRECT,      0, 0,       "type: 0 low, 1 high, 2 band" },
    { "filter_cutoff",        0x42, AS_EXPONENTIAL, 20.0, 20000.0, "cutoff, in hertz" },
    { "filter_resonance",     0x43, AS_RANGE,       0, 0.99,    "resonance" },
    { "filter_modRouting",    0x44, AS_DIRECT,      0, 0,       "what moves the cutoff" },
    { "filter_modDepth",      0x45, AS_SIGNED,      0, 8000.0,  "and how far, in hertz" },
    { "filter_resModRouting", 0x46, AS_DIRECT,      0, 0,       "what moves the resonance" },
    { "filter_resModDepth",   0x47, AS_SIGNED,      0, 0.99,    "and how far" },

    { "lfo0_active",          0x60, AS_BOOL,        0, 0,       "LFO 0, on" },
    { "lfo0_waveform",        0x61, AS_DIRECT,      0, 0,       "waveform" },
    { "lfo0_rate",            0x62, AS_EXPONENTIAL, 0.05, 20.0, "rate, in hertz" },
    { "lfo1_active",          0x70, AS_BOOL,        0, 0,       "LFO 1, on" },
    { "lfo1_waveform",        0x71, AS_DIRECT,      0, 0,       "waveform" },
    { "lfo1_rate",            0x72, AS_EXPONENTIAL, 0.05, 20.0, "rate, in hertz" },
};
#define MAPPING_COUNT ((int)(sizeof(mappings) / sizeof(mappings[0])))

// ---- What soundThing has and the device does not ----
//
// Named rather than ignored, so a field that is simply new shows up as unknown and a field
// that is deliberately dropped does not. Master volume is the editor's own output level and
// the device has one of its own; pitch bend has no wheel to come from.
static const char *ignored[] = { "master_volume", "master_pitchBendRange" };
#define IGNORED_COUNT ((int)(sizeof(ignored) / sizeof(ignored[0])))

static int clampByte(double raw) {
    long v = lround(raw);
    if (v < 0) return 0;
    if (v > 255) return 255;
    return (int)v;
}

static int toByte(const Mapping *m, double value) {
    switch (m->shape) {
        case AS_DIRECT:  return clampByte(value);
        case AS_BOOL:    return value != 0.0 ? 1 : 0;
        case AS_RANGE:   return clampByte(255.0 * (value - m->low) / (m->high - m->low));
        // The inverse of part*part*high, so the root comes back out.
        case AS_SQUARED: return clampByte(255.0 * sqrt(value / m->high));
        // And of low * (high/low)^part.
        case AS_EXPONENTIAL:
            if (value < m->low) value = m->low;
            return clampByte(255.0 * log(value / m->low) / log(m->high / m->low));
        case AS_SIGNED:  return clampByte(128.0 + 128.0 * value / m->high);
        case AS_OCTAVE:  return clampByte(128.0 + value);
    }
    return 0;
}

int main(int argc, char **argv) {
    if (argc < 3) {
        fprintf(stderr,
            "Usage: %s <patch.json> <label> [output.asm]\n\n"
            "Turns a soundThing patch into a table for the sound device: a count, then that\n"
            "many parameter and value pairs. Hand the label to playPatch.\n", argv[0]);
        return 2;
    }
    const char *path = argv[1];
    const char *label = argv[2];

    FILE *in = fopen(path, "r");
    if (!in) { fprintf(stderr, "SoundPatch: cannot read %s\n", path); return 1; }

    int values[MAPPING_COUNT];
    int seen[MAPPING_COUNT];
    memset(seen, 0, sizeof(seen));

    char line[512];
    int unknown = 0;
    while (fgets(line, sizeof(line), in)) {
        char field[128];
        double value;
        // Every line of one of these is `"name": number`, with or without a trailing comma.
        if (sscanf(line, " \"%127[^\"]\" : %lf", field, &value) != 2) continue;
        int found = 0;
        for (int i = 0; i < MAPPING_COUNT; i++) {
            if (strcmp(field, mappings[i].field) == 0) {
                values[i] = toByte(&mappings[i], value);
                seen[i] = 1;
                found = 1;
                break;
            }
        }
        if (found) continue;
        for (int i = 0; i < IGNORED_COUNT; i++) {
            if (strcmp(field, ignored[i]) == 0) { found = 1; break; }
        }
        if (!found) {
            fprintf(stderr, "SoundPatch: %s has a field this does not know: %s\n", path, field);
            unknown++;
        }
    }
    fclose(in);

    // A field this does not know is a patch format that has moved on, and writing a table
    // that quietly leaves it out would make a sound nobody could account for.
    if (unknown) {
        fprintf(stderr, "SoundPatch: %d unknown field%s, so nothing was written.\n",
                unknown, unknown == 1 ? "" : "s");
        return 1;
    }

    int count = 0;
    for (int i = 0; i < MAPPING_COUNT; i++) if (seen[i]) count++;
    // The level routing is soundThing's one blind spot: it has no field for it because there
    // it is always the amplitude envelope. Said out loud here so a channel that was left set
    // some other way by a previous patch does not carry it into this one.
    count++;

    FILE *out = stdout;
    if (argc > 3) {
        out = fopen(argv[3], "w");
        if (!out) { fprintf(stderr, "SoundPatch: cannot write %s\n", argv[3]); return 1; }
    }

    fprintf(out, "; %s, converted from %s by SoundPatch.\n", label, path);
    fprintf(out, "; Designed in soundThing, where it can be heard. Do not edit the numbers\n");
    fprintf(out, "; here: change the patch and convert it again.\n\n");
    // Data, and no base: a table of bytes belongs wherever the program including it has got
    // to, the way every other included table does.
    fprintf(out, "#Data\n\n");
    fprintf(out, "%s:\n", label);
    fprintf(out, "  0d%-24d; how many pairs follow\n", count);
    fprintf(out, "  0x50 0x01                 ; the level is the amplitude envelope\n");
    for (int i = 0; i < MAPPING_COUNT; i++) {
        if (!seen[i]) continue;
        fprintf(out, "  0x%02X 0d%-3d              ; %s\n",
                mappings[i].parameter, values[i], mappings[i].note);
    }
    if (out != stdout) fclose(out);
    return 0;
}