#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include <M5Cardputer.h>

#include <SD.h>

#include <SPI.h>

#include "src/dsp/miniacid_engine.h"

#include "cardputer_display.h"

#include <cstdarg>

#include <cstdio>

#include "src/ui/miniacid_display.h"

#include "src/audio/cardputer_audio_recorder.h"

#include "miniacid_encoder8.h"

#include "scene_storage_cardputer.h"

static constexpr IGfxColor CP_BLACK = IGfxColor::Black();

CardputerDisplay g_display;

MiniAcidDisplay* g_miniDisplay = nullptr;

SceneStorageCardputer g_sceneStorage;

CardputerAudioRecorder* g_audioRecorder = nullptr;

int16_t g_audioBuffer[AUDIO_BUFFER_SAMPLES];

TaskHandle_t g_audioTaskHandle = nullptr;

MiniAcid g_miniAcid(SAMPLE_RATE, &g_sceneStorage);

Encoder8Miniacid g_encoder8(g_miniAcid);

void audioTask(void *param) {

while (true) {

if (!g_miniAcid.isPlaying()) {

vTaskDelay(10 / portTICK_PERIOD_MS);

continue;

}

while (M5Cardputer.Speaker.isPlaying()) {

vTaskDelay(1 / portTICK_PERIOD_MS);

}

g_miniAcid.generateAudioBuffer(g_audioBuffer, AUDIO_BUFFER_SAMPLES);

// Write to recorder if recording

if (g_audioRecorder) {

g_audioRecorder->writeSamples(g_audioBuffer, AUDIO_BUFFER_SAMPLES);

}

M5Cardputer.Speaker.playRaw(g_audioBuffer, AUDIO_BUFFER_SAMPLES,

SAMPLE_RATE, false);

}

}

void drawUI() {

if (g_miniDisplay) g_miniDisplay->update();

}

void setup() {

auto cfg = M5.config();

M5Cardputer.begin(cfg);

Serial.begin(115200);

#if defined(MINIACID_SCENE_DEBUG)

Serial.printf("sizeof(AutomationLane)=%u sizeof(SynthPattern)=%u sizeof(Scene)=%u\n",

static_cast<unsigned>(sizeof(AutomationLane)),

static_cast<unsigned>(sizeof(SynthPattern)),

static_cast<unsigned>(sizeof(Scene)));

Serial.printf("free heap at boot: %u\n", static_cast<unsigned>(ESP.getFreeHeap()));

#endif

g_display.setRotation(1);

g_display.begin();

g_display.clear(CP_BLACK);

M5Cardputer.Speaker.begin();

M5Cardputer.Speaker.setVolume(200); // 0-255

g_miniAcid.init();

#if defined(MINIACID_SCENE_DEBUG)

Serial.printf("free heap after MiniAcid init: %u\n", static_cast<unsigned>(ESP.getFreeHeap()));

#endif

g_miniDisplay = new MiniAcidDisplay(g_display, g_miniAcid);

// Set audio guard to protect audio task from concurrent access

g_miniDisplay->setAudioGuard([](const std::function<void()>& fn) {

// On Cardputer, we need to suspend/resume the audio task or use a mutex

// For now, just call the function directly since FreeRTOS handles this

fn();

});

// Initialize audio recorder (done after other initialization to avoid boot issues)

g_audioRecorder = new CardputerAudioRecorder();

g_miniDisplay->setAudioRecorder(g_audioRecorder);

xTaskCreatePinnedToCore(audioTask, "AudioTask",

4096, // stack

nullptr,

3, // priority

&g_audioTaskHandle,

1 // core

);

g_encoder8.initialize();

drawUI();

}

void loop() {

M5Cardputer.update();

g_encoder8.update();

if (M5Cardputer.BtnA.wasClicked()) {

if (g_miniAcid.isPlaying()) {

g_miniAcid.stop();

} else {

g_miniAcid.start();

}

drawUI();

}

static constexpr unsigned long KEY_REPEAT_DELAY_MS = 350;

static constexpr unsigned long KEY_REPEAT_INTERVAL_MS = 80;

static Keyboard_Class::KeysState lastKeysState{};

static bool hasLastKeys = false;

static unsigned long nextRepeatAt = 0;

auto handleWithFallback = [&](UIEvent evt) {

evt.event_type = MINIACID_KEY_DOWN;

bool handled = g_miniDisplay ? g_miniDisplay->handleEvent(evt) : false;

if (handled) drawUI();

};

auto applyCtrlLetter = [](const Keyboard_Class::KeysState& ks, uint8_t hid, UIEvent& evt) -> bool {

constexpr uint8_t HID_KEY_A = 0x04;

constexpr uint8_t HID_KEY_Z = 0x1D;

if (!ks.ctrl || hid < HID_KEY_A || hid > HID_KEY_Z) return false;

evt.key = static_cast<char>('a' + (hid - HID_KEY_A));

return true;

};

auto applyAltLetter = [](const Keyboard_Class::KeysState& ks, uint8_t hid, UIEvent& evt) -> bool {

constexpr uint8_t HID_KEY_A = 0x04;

constexpr uint8_t HID_KEY_Z = 0x1D;

if (!ks.alt || hid < HID_KEY_A || hid > HID_KEY_Z) return false;

evt.key = static_cast<char>('a' + (hid - HID_KEY_A));

return true;

};

auto processKeys = [&](const Keyboard_Class::KeysState& ks) {

for (auto hid : ks.hid_keys) {

UIEvent evt{};

evt.alt = ks.alt;

evt.ctrl = ks.ctrl;

evt.shift = ks.shift;

bool shouldSend = false;

if (hid == 0x33) {

evt.scancode = MINIACID_UP;

shouldSend = true;

} else if (hid == 0x37) {

evt.scancode = MINIACID_DOWN;

shouldSend = true;

} else if (hid == 0x36) {

evt.scancode = MINIACID_LEFT;

shouldSend = true;

} else if (hid == 0x38) {

evt.scancode = MINIACID_RIGHT;

shouldSend = true;

} else if (hid == 0x28 || hid == 0x58) { // enter

evt.key = '\n';

shouldSend = true;

} else if (hid == KEY_BACKSPACE) {

evt.key = '\b';

shouldSend = true;

} else if (hid == KEY_TAB) {

evt.key = '\t';

shouldSend = true;

} else if (applyCtrlLetter(ks, hid, evt)) {

shouldSend = true;

} else if (applyAltLetter(ks, hid, evt)) {

shouldSend = true;

}

if (shouldSend) {

handleWithFallback(evt);

}

}

// do not send events only for ctlr/alt/shift changes

// so that we don't get double events when those are used as modifiers

if (ks.ctrl || ks.alt || ks.shift) {

return;

}

for (auto inputChar : ks.word) {

UIEvent evt{};

evt.alt = ks.alt;

evt.ctrl = ks.ctrl;

evt.shift = ks.shift;

evt.key = inputChar;

if (evt.key == '`' || evt.key == '~') { // escape

evt.scancode = MINIACID_ESCAPE;

}

handleWithFallback(evt);

}

};

bool keyChanged = M5Cardputer.Keyboard.isChange();

bool keyPressed = M5Cardputer.Keyboard.isPressed();

if (keyChanged && keyPressed) {

if (g_miniDisplay) g_miniDisplay->dismissSplash();

Keyboard_Class::KeysState ks = M5Cardputer.Keyboard.keysState();

processKeys(ks);

lastKeysState = ks;

hasLastKeys = true;

nextRepeatAt = millis() + KEY_REPEAT_DELAY_MS;

} else if (!keyPressed) {

hasLastKeys = false;

} else if (hasLastKeys && millis() >= nextRepeatAt) {

if (g_miniDisplay) g_miniDisplay->dismissSplash();

processKeys(lastKeysState);

nextRepeatAt = millis() + KEY_REPEAT_INTERVAL_MS;

}

static unsigned long lastUIUpdate = 0;

if (millis() - lastUIUpdate > 80) {

lastUIUpdate = millis();

if (g_miniDisplay) g_miniDisplay->update();

}

delay(5);

}