//**************************************************************************************
//16-Steps Sequencer Module for VCV Rack by Autodafe http://www.autodafe.net
//
//Based on code taken from the Fundamentals plugins by Andrew Belt http://www.vcvrack.com
//**************************************************************************************


#include "plugin.hpp"


struct SEQ16 : Module {
    enum ParamIds {
        CLOCK_PARAM,
        RUN_PARAM,
        RESET_PARAM,
        STEPS_PARAM,
        ROW1_PARAM,
        ROW2_PARAM = ROW1_PARAM + 16,
        ROW3_PARAM = ROW2_PARAM + 16,
        GATE_PARAM = ROW3_PARAM + 16,
        NUM_PARAMS = GATE_PARAM + 16
    };
    enum InputIds {
        CLOCK_INPUT,
        EXT_CLOCK_INPUT,
        START_INPUT,
        STOP_INPUT,
        RESET_INPUT,
        STEPS_INPUT,
        NUM_INPUTS
    };
    enum OutputIds {
        CLOCK_OUT,
        CLOCK_GATE_OUT,
        GATES_OUTPUT,
        ROW1_OUTPUT,
        ROW2_OUTPUT,
        ROW3_OUTPUT,
        GATE_OUTPUT,
        NUM_OUTPUTS = GATE_OUTPUT + 16
    };

enum LightIds {
        RUNNING_LIGHT,
        RESET_LIGHT,
        GATES_LIGHT,
        ROW_LIGHTS,
        GATE_LIGHTS = ROW_LIGHTS + 3,
        NUM_LIGHTS = GATE_LIGHTS + 16
    };


bool running = true;
    SchmittTrigger clockTrigger; // for external clock
    // For buttons
    SchmittTrigger runningTrigger;
    SchmittTrigger resetTrigger;
    SchmittTrigger gateTriggers[16];
    float phase = 0.0;
    int index = 0;
    bool gateState[16] = {};
    float resetLight = 0.0;
    float stepLights[16] = {};



    enum GateMode {
        TRIGGER,
        RETRIGGER,
        CONTINUOUS,
    };
    GateMode gateMode = TRIGGER;
    PulseGenerator gatePulse;


    SEQ16() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}
    void step() override;

    json_t *dataToJson() override {
        json_t *rootJ = json_object();

        // running
        json_object_set_new(rootJ, "running", json_boolean(running));

        // gates
        json_t *gatesJ = json_array();
        for (int i = 0; i < 16; i++) {
            json_t *gateJ = json_integer((int) gateState[i]);
            json_array_append_new(gatesJ, gateJ);
        }
        json_object_set_new(rootJ, "gates", gatesJ);

        // gateMode
        json_t *gateModeJ = json_integer((int) gateMode);
        json_object_set_new(rootJ, "gateMode", gateModeJ);

        return rootJ;
    }

    void dataFromJson(json_t *rootJ) override {
        // running
        json_t *runningJ = json_object_get(rootJ, "running");
        if (runningJ)
            running = json_is_true(runningJ);

        // gates
        json_t *gatesJ = json_object_get(rootJ, "gates");
        if (gatesJ) {
            for (int i = 0; i < 16; i++) {
                json_t *gateJ = json_array_get(gatesJ, i);
                if (gateJ)
                    gateState[i] = !!json_integer_value(gateJ);
            }
        }

        // gateMode
        json_t *gateModeJ = json_object_get(rootJ, "gateMode");
        if (gateModeJ)
            gateMode = (GateMode)json_integer_value(gateModeJ);
    }

    void onReset() override {
        for (int i = 0; i < 16; i++) {
            gateState[i] = false;
        }
    }

    void onRandomize() override {
        for (int i = 0; i < 16; i++) {
            gateState[i] = (random() > 0.5f);
        }
    }
};




void SEQ16::step()  {
    const float lightLambda = 0.075;


outputs[CLOCK_OUT].value=0;

    outputs[CLOCK_GATE_OUT].value=0;



    // Run
    if (runningTrigger.process(params[RUN_PARAM].value)) {
        running = !running;
    }



if(inputs[START_INPUT].value>0){running=true;}

    if(inputs[STOP_INPUT].value>0){running=false;}



    lights[RUNNING_LIGHT].value = running ? 1.0 : 0.0;

    bool nextStep = false;

    if (running) {
        if (inputs[EXT_CLOCK_INPUT].active) {
            // External clock
            if (clockTrigger.process(inputs[EXT_CLOCK_INPUT].value)) {
                phase = 0.0;
                nextStep = true;
outputs[CLOCK_OUT].value=1;
            }
        }
        else {
            // Internal clock
            float clockTime = powf(2.0, params[CLOCK_PARAM].value + inputs[CLOCK_INPUT].value);
            phase += clockTime / engineGetSampleRate();
            if (phase >= 1.0) {
                phase -= 1.0;
                nextStep = true;
                outputs[CLOCK_OUT].value=1;
            }
        }
    }

    // Reset
    if (resetTrigger.process(params[RESET_PARAM].value + inputs[RESET_INPUT].value)) {
        phase = 0.0;
        index = 16;
        nextStep = true;
        resetLight = 1.0;
    }

    if (nextStep) {
        // Advance step
        int numSteps = clamp(roundf(params[STEPS_PARAM].value + inputs[STEPS_INPUT].value), 1.0f, 16.0f);
        index += 1;
        if (index >= numSteps) {
            index = 0;
        }
        stepLights[index] = 1.0;
        gatePulse.trigger(1e-3);
    }

    resetLight -= resetLight / lightLambda / engineGetSampleRate();

    bool pulse = gatePulse.process(1.0 / engineGetSampleRate());



    // Gate buttons
    for (int i = 0; i < 16; i++) {
        if (gateTriggers[i].process(params[GATE_PARAM + i].value)) {
            gateState[i] = !gateState[i];
        }
        bool gateOn = (running && i == index && gateState[i]);
        if (gateMode == TRIGGER)
            gateOn = gateOn && pulse;
        else if (gateMode == RETRIGGER)
            gateOn = gateOn && !pulse;

        outputs[GATE_OUTPUT + i].value = gateOn ? 10.0 : 0.0;




        if (outputs[GATE_OUTPUT + i].value!=0)
        {
            outputs[CLOCK_GATE_OUT].value=gateOn ? 1.0 : 0.0;
        }


        stepLights[i] -= stepLights[i] / lightLambda / engineGetSampleRate();
        lights[GATE_LIGHTS + i].value = gateState[i] ? 1.0 - stepLights[i] : stepLights[i];
    }

    // Rows
    float row1 = params[ROW1_PARAM + index].value;
    float row2 = params[ROW2_PARAM + index].value;
    float row3 = params[ROW3_PARAM + index].value;

    bool gatesOn = (running && gateState[index]);
    if (gateMode == TRIGGER)
        gatesOn = gatesOn && pulse;
    else if (gateMode == RETRIGGER)
        gatesOn = gatesOn && !pulse;

        outputs[ROW1_OUTPUT].value = row1;
    outputs[ROW2_OUTPUT].value = row2;
    outputs[ROW3_OUTPUT].value = row3;
    outputs[GATES_OUTPUT].value = gatesOn ? 10.0 : 0.0;
    lights[RESET_LIGHT].value = resetLight;
    lights[GATES_LIGHT].value = gatesOn ? 1.0 : 0.0;
    lights[ROW_LIGHTS].value = row1 / 10.0;
    lights[ROW_LIGHTS + 1].value = row2 / 10.0;
    lights[ROW_LIGHTS + 2].value = row3 / 10.0;
}

struct AutodafePurpleLight : ModuleLightWidget {
    AutodafePurpleLight() {
        addBaseColor(nvgRGB(0x89, 0x13, 0xC4));
    }
};




struct SEQ16Widget : ModuleWidget {
    SEQ16Widget(SEQ16 *module);

    Menu *createContextMenu() override;
};

    SEQ16Widget::SEQ16Widget(SEQ16 *module) : ModuleWidget(module) {
    box.size = Vec(15*42, 380);

    {
        SVGPanel *panel = new SVGPanel();
        panel->box.size = box.size;


        panel->setBackground(SVG::load(assetPlugin(pluginInstance, "res/SEQ16.svg")));
        addChild(panel);
    }

    addChild(createWidget<ScrewSilver>(Vec(5, 0)));
    addChild(createWidget<ScrewSilver>(Vec(box.size.x-20, 0)));
    addChild(createWidget<ScrewSilver>(Vec(5, 365)));
    addChild(createWidget<ScrewSilver>(Vec(box.size.x-20, 365)));

    addParam(createParam<AutodafeKnobPurpleSmall>(Vec(18, 56), module, SEQ16::CLOCK_PARAM, -2.0, 6.0, 2.0));
    addParam(createParam<LEDButton>(Vec(60, 61-1), module, SEQ16::RUN_PARAM, 0.0, 1.0, 0.0));

    addChild(createLight<MediumLight<AutodafePurpleLight>>(Vec(64.4, 64.4), module, SEQ16::RUNNING_LIGHT));
    addParam(createParam<LEDButton>(Vec(98, 61-1), module, SEQ16::RESET_PARAM, 0.0, 1.0, 0.0));



    addOutput(createPort<PJ301MPort>(Vec(403, 98), PortWidget::OUTPUT, module, SEQ16::CLOCK_OUT));
    addOutput(createPort<PJ301MPort>(Vec(442, 98), PortWidget::OUTPUT, module, SEQ16::CLOCK_GATE_OUT));


    addInput(createPort<PJ301MPort>(Vec(327, 98), PortWidget::INPUT, module, SEQ16::START_INPUT));
    addInput(createPort<PJ301MPort>(Vec(365, 98), PortWidget::INPUT, module, SEQ16::STOP_INPUT));




    addChild(createLight<MediumLight<AutodafePurpleLight>>(Vec(103.4, 64.4), module, SEQ16::RESET_LIGHT));

    addParam(createParam<AutodafeKnobPurple>(Vec(128, 52), module, SEQ16::STEPS_PARAM, 1.0, 16.0, 16.0));

    addChild(createLight<MediumLight<AutodafePurpleLight>>(Vec(179.4, 64.4), module, SEQ16::GATES_LIGHT));
    addChild(createLight<MediumLight<AutodafePurpleLight>>(Vec(218.4, 64.4), module, SEQ16::ROW_LIGHTS));
    addChild(createLight<MediumLight<AutodafePurpleLight>>(Vec(256.4, 64.4), module, SEQ16::ROW_LIGHTS + 1));
    addChild(createLight<MediumLight<AutodafePurpleLight>>(Vec(295.4, 64.4), module, SEQ16::ROW_LIGHTS + 2));

    static const float portX[16] = {19,57,96,134,173,211,250,288,326,364,402,440,478,516,554,592};
    addInput(createPort<PJ301MPort>(Vec(portX[0]-1, 99-1), PortWidget::INPUT, module, SEQ16::CLOCK_INPUT));
    addInput(createPort<PJ301MPort>(Vec(portX[1]-1, 99-1), PortWidget::INPUT, module, SEQ16::EXT_CLOCK_INPUT));
    addInput(createPort<PJ301MPort>(Vec(portX[2]-1, 99-1), PortWidget::INPUT, module, SEQ16::RESET_INPUT));
    addInput(createPort<PJ301MPort>(Vec(portX[3]-1, 99-1), PortWidget::INPUT, module, SEQ16::STEPS_INPUT));
    addOutput(createPort<PJ301MPort>(Vec(portX[4]-1, 99-1), PortWidget::OUTPUT, module, SEQ16::GATES_OUTPUT));
    addOutput(createPort<PJ301MPort>(Vec(portX[5]-1, 99-1), PortWidget::OUTPUT, module, SEQ16::ROW1_OUTPUT));
    addOutput(createPort<PJ301MPort>(Vec(portX[6]-1, 99-1), PortWidget::OUTPUT, module, SEQ16::ROW2_OUTPUT));
    addOutput(createPort<PJ301MPort>(Vec(portX[7]-1, 99-1), PortWidget::OUTPUT, module, SEQ16::ROW3_OUTPUT));


    for (int i = 0; i < 16; i++) {
        addParam(createParam<AutodafeKnobPurpleSmall>(Vec(portX[i] - 2, 157), module, SEQ16::ROW1_PARAM + i, 0.0, 6.0, 0.0));
        addParam(createParam<AutodafeKnobPurpleSmall>(Vec(portX[i] - 2, 198), module, SEQ16::ROW2_PARAM + i, 0.0, 6.0, 0.0));
        addParam(createParam<AutodafeKnobPurpleSmall>(Vec(portX[i] - 2, 240), module, SEQ16::ROW3_PARAM + i, 0.0, 6.0, 0.0));
        addParam(createParam<LEDButton>(Vec(portX[i] + 2, 278 - 1), module, SEQ16::GATE_PARAM + i, 0.0, 1.0, 0.0));


        addChild(createLight<MediumLight<AutodafePurpleLight>>(Vec(portX[i]+6.4, 281.4), module, SEQ16::GATE_LIGHTS + i));
        addOutput(createPort<PJ301MPort>(Vec(portX[i] - 1, 308 - 1), PortWidget::OUTPUT, module, SEQ16::GATE_OUTPUT + i));
    }

}




struct SEQ16GateModeItem : MenuItem {
    SEQ16 *SEQ16;
    SEQ16::GateMode gateMode;
    void Action()  {
        SEQ16->gateMode = gateMode;
    }
    void step() override {
        rightText = (SEQ16->gateMode == gateMode) ? "✔" : "";
    }
};

Menu *SEQ16createWidgetContextMenu() {
    Menu *menu = SEQ16createWidgetContextMenu();

    MenuLabel *spacerLabel = new MenuLabel();
    menu->addChild(spacerLabel);

    SEQ16 *SEQ16 = dynamic_cast<struct SEQ16*>(APP->engine->getModule(id));

    //MyModule *module = dynamic_cast<MyModule*>(APP->engine->getModule(moduleId));
    assert(SEQ16);

    MenuLabel *modeLabel = new MenuLabel();
    modeLabel->text = "Gate Mode";
    menu->addChild(modeLabel);

    SEQ16GateModeItem *triggerItem = new SEQ16GateModeItem();
    triggerItem->text = "Trigger";
    triggerItem->SEQ16 = SEQ16;
    triggerItem->gateMode = SEQ16::TRIGGER;
    menu->addChild(triggerItem);

    SEQ16GateModeItem *retriggerItem = new SEQ16GateModeItem();
    retriggerItem->text = "Retrigger";
    retriggerItem->SEQ16 = SEQ16;
    retriggerItem->gateMode = SEQ16::RETRIGGER;
    menu->addChild(retriggerItem);

    SEQ16GateModeItem *continuousItem = new SEQ16GateModeItem();
    continuousItem->text = "Continuous";
    continuousItem->SEQ16 = SEQ16;
    continuousItem->gateMode = SEQ16::CONTINUOUS;
    menu->addChild(continuousItem);

    return menu;
}



Model *modelSEQ16 = createModel<SEQ16, SEQ16Widget>("16-Step Sequencer");