/*
   Chassis polysynth framework

   Copyright 2024 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 "peacock.hpp"

void Peacock::initParameter(uint32_t index, Parameter& parameter) {
    switch (index) {
        case pLFORate:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "LFO Rate";
            parameter.symbol = "ch_lforate";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 48.0f;
            parameter.midiCC = 3;
            break;

        case pLFODelay:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "LFO Delay";
            parameter.symbol = "ch_lfodelay";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 9;
            break;

        case pVCORange:
            parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
            parameter.name = "Range";
            parameter.symbol = "ch_vcorange";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 2.0f;
            parameter.ranges.def = 1.0f;
            parameter.midiCC = 12;
            parameter.enumValues.count = 3;
            parameter.enumValues.restrictedMode = true;
            {
                ParameterEnumerationValue* const enumValues = new ParameterEnumerationValue[3];
                enumValues[0].value = 0.0f;
                enumValues[0].label = "16'";
                enumValues[1].value = 1.0f;
                enumValues[1].label = "8'";
                enumValues[2].value = 2.0f;
                enumValues[2].label = "4'";
                parameter.enumValues.values = enumValues;
            }

            break;

        case pLFODepth:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "LFO";
            parameter.symbol = "ch_lfo";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 10.0f;
            parameter.midiCC = 13;
            break;

        case pPWMDepth:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "PWM";
            parameter.symbol = "ch_pwm";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 48.0f;
            parameter.midiCC = 14;
            break;

        case pPWMMode:
            parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
            parameter.name = "PWM Mode";
            parameter.symbol = "ch_pwmmode";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 1.0f;
            parameter.ranges.def = 1.0f;
            parameter.midiCC = 15;
            parameter.enumValues.count = 2;
            parameter.enumValues.restrictedMode = true;
            {
                ParameterEnumerationValue* const enumValues = new ParameterEnumerationValue[2];
                enumValues[0].value = 0.0f;
                enumValues[0].label = "LFO";
                enumValues[1].value = 1.0f;
                enumValues[1].label = "MAN";
                parameter.enumValues.values = enumValues;
            }

            break;

        case pSaw:
            parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
            parameter.name = "Saw";
            parameter.symbol = "ch_saw";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 1.0f;
            parameter.ranges.def = 1.0f;
            parameter.midiCC = 17;
            break;

        case pSqr:
            parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
            parameter.name = "Square";
            parameter.symbol = "ch_sqr";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 1.0f;
            parameter.ranges.def = 1.0f;
            parameter.midiCC = 16;
            break;

        case pSubLevel:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Sub Osc";
            parameter.symbol = "ch_sub";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 18;
            break;

        case pNoiseLevel:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Noise";
            parameter.symbol = "ch_noise";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 19;
            break;

        case pHPF:
            parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
            parameter.name = "HPF";
            parameter.symbol = "ch_hpf";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 3.9f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 20;
            break;

        case pCutoff:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Freq";
            parameter.symbol = "ch_freq";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 60.0f;
            parameter.midiCC = 74;
            break;
        case pRes:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Res";
            parameter.symbol = "ch_reso";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 71;
            break;
        case pVCFPol:
            parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
            parameter.name = "Polarity";
            parameter.symbol = "ch_vcfmode";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 1.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 21;
            parameter.enumValues.count = 2;
            parameter.enumValues.restrictedMode = true;
            {
                ParameterEnumerationValue* const enumValues = new ParameterEnumerationValue[2];
                enumValues[0].value = 0.0f;
                enumValues[0].label = "POS";
                enumValues[1].value = 1.0f;
                enumValues[1].label = "INV";
                parameter.enumValues.values = enumValues;
            }

            break;
        case pEnv:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Env";
            parameter.symbol = "ch_vcfenv";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 46.0f;
            parameter.midiCC = 22;
            break;
        case pLfo:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "LFO";
            parameter.symbol = "ch_vcflfo";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 23;
            break;
        case pKyb:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Kybd";
            parameter.symbol = "ch_vcfkey";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 71.0f;
            parameter.midiCC = 24;
            break;

        case pAttack:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Attack";
            parameter.symbol = "ch_attack";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 27.0f;
            parameter.midiCC = 73;
            break;

        case pDecay:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Decay";
            parameter.symbol = "ch_decay";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 57.0f;
            parameter.midiCC = 75;
            break;

        case pSustain:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Sustain";
            parameter.symbol = "ch_sustain";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 57.0f;
            parameter.midiCC = 27;
            break;

        case pRelease:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "Release";
            parameter.symbol = "ch_release";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 48.0f;
            parameter.midiCC = 72;
            break;

        case pEnvGate:
            parameter.hints = kParameterIsAutomatable | kParameterIsInteger;  // | kParameterIsBoolean;
            parameter.name = "Env-Gate";
            parameter.symbol = "ch_envgate";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 1.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 25;
            parameter.enumValues.count = 2;
            parameter.enumValues.restrictedMode = true;
            {
                ParameterEnumerationValue* const enumValues = new ParameterEnumerationValue[2];
                enumValues[0].value = 0.0f;
                enumValues[0].label = "ENV";
                enumValues[1].value = 1.0f;
                enumValues[1].label = "GATE";
                parameter.enumValues.values = enumValues;
            }
            break;

        case pVCALevel:
            parameter.hints = kParameterIsAutomatable;
            parameter.name = "VCA Level";
            parameter.symbol = "ch_vcalevel";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 40.0f;
            parameter.midiCC = 26;
            break;
/*
        case pModWheel:
            parameter.hints = kParameterIsAutomatable | kParameterIsHidden;
            parameter.name = "Mod wheel";
            parameter.symbol = "ch_modwheel";
            parameter.ranges.min = 0.0f;
            parameter.ranges.max = 127.0f;
            parameter.ranges.def = 0.0f;
            parameter.midiCC = 1;
            break;
            */
    }
    // chorus, porta, bend range, key mode still to do
}

void Peacock::setParameterValue(uint32_t index, float value) {
    // should be trapped by host, but let's be safe
    if (value < 0.0f) value = 0.0f;
    if (value > 127.0f) value = 127.0f;

    switch (index) {
        case pLFORate:
            m->patchRam.lfoRate = value;
            break;
        case pLFODelay:
            m->patchRam.lfoDelay = value;
            break;

        case pLFODepth:
            m->patchRam.vcoLfo = value;
            break;
        case pPWMDepth:
            m->patchRam.pwmLfo = value / 1.27;
            break;
        case pSubLevel:
            m->patchRam.sub = value;
            break;
        case pNoiseLevel:
            m->patchRam.noise = value;
            break;

        case pCutoff:
            m->patchRam.vcfFreq = value;
            break;
        case pRes:
            m->patchRam.vcfReso = value;
            break;
        case pEnv:
            m->patchRam.vcfEnv = value;
            break;
        case pLfo:
            m->patchRam.vcfLfo = value;
            break;
        case pKyb:
            m->patchRam.vcfKey = value;
            break;

        case pVCALevel:
            m->patchRam.vca = value;
            break;

        case pAttack:
            m->patchRam.env_a = value;
            break;
        case pDecay:
            m->patchRam.env_d = value;
            break;
        case pSustain:
            m->patchRam.env_s = value;
            break;
        case pRelease:
            m->patchRam.env_r = value;
            break;

        // switch 1 params
        case pVCORange:  // bits 0-2 of switch 1
            // doesn't look great in Carla because of odd behaviour with small integer knobs
            m->patchRam.switch1 &= 0xf8;
            m->patchRam.switch1 |= (1 << (int)(value));
            break;
        case pSqr:  // bit 3 of switch 1
            m->patchRam.switch1 &= 0xf7;
            m->patchRam.switch1 |= (value >= 0.5) << 3;
            break;

        case pSaw:  // bit 4 of switch 1
            m->patchRam.switch1 &= 0xef;
            m->patchRam.switch1 |= (value >= 0.5) << 4;
            break;

            // missing chorus switch

            // switch 2 params
        case pPWMMode:  // bit 0 of switch 2
            m->patchRam.switch2 &= 0xfe;
            m->patchRam.switch2 |= (value >= 0.5);
            break;

        case pVCFPol:  // bit 1 of switch 2
            m->patchRam.switch2 &= 0xfd;
            m->patchRam.switch2 |= (value >= 0.5) << 1;
            break;
        case pEnvGate:
            m->patchRam.switch2 &= 0xfb;
            m->patchRam.switch2 |= (value >= 0.5) << 2;
            break;

        case pHPF:  // bits 3-4 of switch 2
            // doesn't look great in Carla because of odd behaviour with small integer knobs
            if (value > 3) value = 3;
            m->patchRam.switch2 &= 0xe7;
            m->patchRam.switch2 |= (3-(int)value )<< 3;
            break;
/*
        case pModWheel:
            //s.ff64 = (int)value << 1;
            break;*/
    }
}

float Peacock::getParameterValue(uint32_t index) const {
    switch (index) {
        case pLFORate:
            return m->patchRam.lfoRate;
            break;
        case pLFODelay:
            return m->patchRam.lfoDelay;
            break;
        case pVCORange:
            // FIXME this needs to be better generally
            switch (m->patchRam.switch1 & 0x07) {
                case 1:
                    return 0;
                    break;
                case 4:
                    return 2;
                    break;
                default:
                    return 1;
            }
            break;
        case pLFODepth:
            return m->patchRam.vcoLfo;
            break;
        case pPWMDepth:
            return m->patchRam.pwmLfo * 1.27f;
            break;

        case pPWMMode:
            return (m->patchRam.switch2 & 0x01) != 0;
            break;
        case pSaw:
            return (m->patchRam.switch1 & 0x10) != 0;
            break;
        case pSqr:
            return (m->patchRam.switch1 & 0x08) != 0;

        case pSubLevel:
            return m->patchRam.sub;
            break;
        case pNoiseLevel:
            return m->patchRam.noise;
            break;
        case pHPF:
            return 3-((m->patchRam.switch2 & 0x18) >> 3);
            break;
        case pCutoff:
            return m->patchRam.vcfFreq;
            break;
        case pRes:
            return m->patchRam.vcfReso;
            break;
        case pEnv:
            return m->patchRam.vcfEnv;
            break;
        case pLfo:
            return m->patchRam.vcfLfo;
            break;
        case pKyb:
            return m->patchRam.vcfKey;
            break;
        case pVCFPol:
            return (m->patchRam.switch2 & 0x02) != 0;
            break;

        case pAttack:
            return m->patchRam.env_a;
            break;
        case pDecay:
            return m->patchRam.env_d;
            break;
        case pSustain:
            return m->patchRam.env_s;
            break;
        case pRelease:
            return m->patchRam.env_r;
            break;

        case pEnvGate:
            return (m->patchRam.switch2 & 0x04) != 0;

        case pVCALevel:
            return m->patchRam.vca;
            break;
    }
    return 0;
}