/*
   Peacock-8 VA polysynth

   Copyright 2025 Gordon JC Pearce <gordonjcp@gjcp.net>

   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
   copyright notice and this permission notice appear in all copies.

   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
   OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
   CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include "module.hpp"

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

#include "tables.hpp"

Module::Module() {
    // cutoff frequencies for various RC networks
    vcaTC = 1 - exp(-6.283 * 159 / sampleRate);  // VCA and VCF 10k/0.1u time constant
    subTC = 1 - exp(-6.283 * 15 / sampleRate);   // Main VCA and Sub Level 1k + 10u time constant
    pwmTC = 1 - exp(-6.283 * 40 / sampleRate);   // integrator with 100k/0.047u time constant

    vcaBuf = new float[bufferSize];
    subBuf = new float[bufferSize];
    pwmBuf = new float[bufferSize];
    noiseBuf = new float[bufferSize];
}

Module::~Module() {
    printf("module destructor\n");
    delete vcaBuf;
    delete subBuf;
    delete pwmBuf;
}

void Module::genNoise() {
    for (uint32_t i = 0; i < bufferSize; i++) {
        noiseRNG *= 0x8088405;
        noiseRNG++;
        noiseBuf[i] = 2 - (noiseRNG & 0xffff) / 16384.0f;
    }
}

void Module::lfoRampOn() {
    lfoDelayState = 1;
    lfoDelayTimer = 0;
    lfoDelay = 0;
}

void Module::runLFO() {
    if (lfoDelayState == 1) {
        lfoDelayTimer += lfoDelayTable[patchRam.lfoDelay >> 4];
        if (lfoDelayTimer & 0xc000) lfoDelayState = 2;
    }
    if ((lfoDelayState == 2)) {
        lfoDelay += attackTable[patchRam.lfoDelay];
    }

    if (lfoDelay & 0xc000) {
        lfoDelayState = 0;
        lfoDelay = 0x3fff;
    }

    lfoRate = lfoRateTable[patchRam.lfoRate];  // FIXME move to parameters

    lfoPhase += (lfoState & 0x01) ? -lfoRate : lfoRate;
    if (lfoPhase > 0x1fff) {
        lfoPhase = 0x1fff;
        lfoState++;
    }
    if (lfoPhase < 0x0000) {
        lfoPhase = 0x0000;
        lfoState++;
    }
    lfo = (lfoState & 0x02) ? -lfoPhase : lfoPhase;

    pw = (lfoState & 0x02) ? lfoPhase + 0x2000 : 0x2000 - lfoPhase; // PW LFO is unipolar
    pw = (patchRam.switch2 & 0x01) ?  0x3fff : pw;  // either LFO or "all on"
    pw =  0x3fff - ((pw * patchRam.pwmLfo) >> 7);   // scaled by PWM pot
    // lfo = (lfo * lfoDelay) >> 14;
}

void Module::run(Voice* voices, uint32_t blockSize) {
    // run updates for module board

    // FIXME break these out to the patch setter
    a = attackTable[patchRam.env_a];  // attack time coeff looked up in table
    d = decayTable[patchRam.env_d];   // decay time coeff looked up in table
    r = decayTable[patchRam.env_r];   // release time coeff looked up in table
    s = patchRam.env_s << 7;          // scale 0x00-0x7f to 0x0000-0x3f80

    master = powf(2, (patchRam.vca / 31.75 - 4.0f)) * 0.1;

    // originally I had 0.28, 0.36, 0.4
    // measurement suggests that saw and square are around 100mV each with sub 160mV

    square = (patchRam.switch1 & 0x08) ? 0.3 : 0;
    saw = (patchRam.switch1 & 0x10) ? .3 : 0;
    sub = (patchRam.sub / 127.0f) * 0.48;

    res = patchRam.vcfReso / 127.0;
    noise = (patchRam.noise / 127.0) * 0.4;

    // FIXME the exp in these is expensive, don't call it all the time
    chorus->setChorus(patchRam.switch1 & 0x60);
    chorus->setHpf(patchRam.switch2 & 0x18);

    runLFO();

    float pwf = pw / 32768.0f;
    for (uint32_t i = 0; i < blockSize; i++) {
        vcaRC = (master - vcaRC) * subTC + vcaRC;
        pwmRC = (pwf - pwmRC) * pwmTC + pwmRC;
        subRC = (sub - subRC) * vcaTC + subRC;

        vcaBuf[i] = vcaRC;
        pwmBuf[i] = pwmRC;
        subBuf[i] = subRC;

        if (bufPtr < bufferSize) bufPtr++;
    }

    int16_t vcf = (patchRam.vcfEnv << 7) * ((patchRam.switch2 & 0x02) ? -1 : 1);

    int16_t pitchBase = 0x1818;
    pitchBase += (lfo * lfoDepthTable[patchRam.vcoLfo]) >> 11;

    for (uint32_t i = 0; i < NUM_VOICES; i++) {
        // maybe move all this into voice.cpp FIXME
        Voice* v = &voices[i];
        switch (v->envPhase) {
            case 0:                           // release phase FIXME use an enum I guess
                v->env = (v->env * r) >> 16;  // "RC" decay to zero
                break;
            case 1:           // attack phase
                v->env += a;  // linear attack to 0x3fff
                break;
            case 2:
                v->env = (((v->env - s) * d) >> 16) + s;
                break;
        }
        if (v->env > 0x3fff) {
            v->env = 0x3fff;
            v->envPhase = 2;  // flip to decay
        }

        // pitch
        // FIXME clean this all up a bit
        int16_t pitch = pitchBase + (v->note << 8);
        int16_t semi = pitch >> 8;
        float frac = (pitch & 0xff) / 256.0;

        float p1 = pitchTable[semi], p2 = pitchTable[semi + 1];
        int16_t px = ((p2 - p1) * frac + p1);

        px *= (patchRam.switch1 & 0x07);

        v->omega = px / (sampleRate * 8.0f);  // fixme use proper scaler

        // per voice we need to calculate the key follow amount and envelope amount
        v->vcfCut = (patchRam.vcfFreq << 7) + ((vcf * v->env) >> 14);
        v->vcfCut += (lfo * patchRam.vcfLfo) >> 9;

        v->vcfCut += (int)((v->note - 36) * (patchRam.vcfKey << 1) * 0.375);

        if (v->vcfCut > 0x3fff) v->vcfCut = 0x3fff;
        if (v->vcfCut < 0) v->vcfCut = 0;

        v->vcaEnv = (patchRam.switch2 & 0x04) ? (v->envPhase ? 0x3fff : 0) : v->env;
    }
}