// native_bridge/juce_fx/JuceFxEngine.cpp
// Implementation: AudioProcessorGraph với input/output node — chain rỗng G1.
// G2: nạp VST3 theo fx_chain (path, preset_b64, bypass), chèn node giữa
// input/output; latency thật = graph.getLatencySamples() (PDC nội bộ graph).
#include "JuceFxEngine.h"

#include <juce_audio_processors/juce_audio_processors.h>
#include "sheredom_json.h"

#include <algorithm>
#include <array>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>

namespace {

// --- base64 decode (RFC 4648) — như RenderFxJob.cpp -------------------------
int b64val(unsigned char c) {
    if (c >= 'A' && c <= 'Z') return (int)(c - 'A');
    if (c >= 'a' && c <= 'z') return (int)(c - 'a') + 26;
    if (c >= '0' && c <= '9') return (int)(c - '0') + 52;
    if (c == '+') return 62;
    if (c == '/') return 63;
    return -1;
}

bool base64Decode(const std::string& in, std::vector<uint8_t>& out) {
    out.clear();
    out.reserve((in.size() / 4) * 3);
    uint32_t acc = 0;
    int bits = 0;
    for (unsigned char ch : in) {
        if (ch == '=' || ch == '\n' || ch == '\r' || ch == ' ') continue;
        int v = b64val(ch);
        if (v < 0) return false;
        acc = (acc << 6) | (uint32_t)v;
        bits += 6;
        if (bits >= 8) {
            bits -= 8;
            out.push_back((uint8_t)((acc >> bits) & 0xFF));
        }
    }
    return true;
}

// --- sheredom helpers (giống RenderFxJob.cpp) -------------------------------
const json_object_element_s* jMember(const json_object_s* o, const char* key) {
    for (const json_object_element_s* e = o ? o->start : nullptr; e; e = e->next)
        if (e->name && e->name->string && std::strcmp(e->name->string, key) == 0)
            return e;
    return nullptr;
}

std::string jString(const json_object_s* o, const char* key, const std::string& def) {
    const json_object_element_s* m = jMember(o, key);
    if (m && m->value && m->value->type == json_type_string) {
        const auto* s = static_cast<const json_string_s*>(m->value->payload);
        return std::string(s->string, s->string_size);
    }
    return def;
}

bool jBool(const json_object_s* o, const char* key, bool def) {
    const json_object_element_s* m = jMember(o, key);
    if (m && m->value) {
        if (m->value->type == json_type_true) return true;
        if (m->value->type == json_type_false) return false;
    }
    return def;
}

}  // namespace

struct JuceFxEngine::Slot {
    std::string type;
    std::string path;
    std::string presetB64;
    bool bypass = false;
};

struct JuceFxEngine::Impl {
    juce::AudioProcessorGraph graph;
    juce::AudioBuffer<float> buf;
    uint32_t sampleRate = 0;
    uint32_t blockSize = 0;
    bool prepared = false;
    std::vector<Slot> slots;                 // chain đã parse (thứ tự slot)
    std::vector<juce::AudioProcessorGraph::Node::Ptr> pluginNodes;  // node theo slot (null = bỏ qua)
    std::vector<uint32_t> slotLatencies;     // latency thật từng slot (0 = skip/bypass/fail)
    uint32_t totalLatency = 0;
};

JuceFxEngine::JuceFxEngine() : impl_(std::make_unique<Impl>()) {}

JuceFxEngine::~JuceFxEngine() { shutdown(); }

void JuceFxEngine::shutdown() {
    if (impl_->prepared) {
        impl_->graph.releaseResources();
        impl_->graph.clear();
        impl_->prepared = false;
        impl_->sampleRate = 0;
        impl_->blockSize = 0;
    }
    impl_->pluginNodes.clear();
    impl_->slotLatencies.assign(impl_->slots.size(), 0);
    impl_->totalLatency = 0;
}

void JuceFxEngine::setChain(const std::string& chainJson) {
    // Parse mảng JSON fx_chain: [ {type,path,preset_b64,bypass}, ... ].
    impl_->slots.clear();
    json_value_s* root = json_parse(chainJson.data(), chainJson.size());
    if (root && root->type == json_type_array) {
        const auto* arr = static_cast<const json_array_s*>(root->payload);
        for (const json_array_element_s* el = arr->start; el; el = el->next) {
            const json_value_s* v = el->value;
            if (!v || v->type != json_type_object) continue;
            const auto* o = static_cast<const json_object_s*>(v->payload);
            Slot s;
            s.type = jString(o, "type", "");
            s.path = jString(o, "path", "");
            s.presetB64 = jString(o, "preset_b64", "");
            s.bypass = jBool(o, "bypass", false);
            impl_->slots.push_back(std::move(s));
        }
    }
    if (root) free(root);
}

void JuceFxEngine::prepare(uint32_t sampleRate, uint32_t blockSize) {
    if (impl_->prepared && impl_->sampleRate == sampleRate &&
        impl_->blockSize == blockSize)
        return;  // không đổi — giữ graph
    shutdown();

    impl_->sampleRate = sampleRate;
    impl_->blockSize = blockSize;
    impl_->graph.setPlayConfigDetails(2, 2, (double)sampleRate, (int)blockSize);

    auto& g = impl_->graph;
    const auto inNode = g.addNode(std::make_unique<
        juce::AudioProcessorGraph::AudioGraphIOProcessor>(
        juce::AudioProcessorGraph::AudioGraphIOProcessor::audioInputNode));
    const auto outNode = g.addNode(std::make_unique<
        juce::AudioProcessorGraph::AudioGraphIOProcessor>(
        juce::AudioProcessorGraph::AudioGraphIOProcessor::audioOutputNode));
    using NCh = juce::AudioProcessorGraph::NodeAndChannel;
    using Conn = juce::AudioProcessorGraph::Connection;

    // G2: nạp VST3 theo chain — nối nối tiếp in -> p0 -> p1 -> ... -> out.
    // Slot bypass / type khác vst3 / load fail → passthrough (latency 0).
    impl_->pluginNodes.assign(impl_->slots.size(), nullptr);
    impl_->slotLatencies.assign(impl_->slots.size(), 0);
    juce::AudioProcessorGraph::Node::Ptr prev = inNode;
    for (size_t i = 0; i < impl_->slots.size(); ++i) {
        const Slot& s = impl_->slots[i];
        if (s.bypass || (s.type != "vst3" && s.type != "vst") || s.path.empty())
            continue;
        juce::VST3PluginFormat fmt;
        juce::OwnedArray<juce::PluginDescription> descs;
        fmt.findAllTypesForFile(descs, juce::File(s.path).getFullPathName());
        if (descs.isEmpty()) {
            std::cerr << "[JuceFxEngine] slot " << i << " no VST3 desc: "
                      << s.path << std::endl;
            continue;
        }
        auto inst = fmt.createInstanceFromDescription(*descs.getFirst(),
                                                      (double)sampleRate,
                                                      (int)blockSize);
        if (!inst) {
            std::cerr << "[JuceFxEngine] slot " << i << " createInstance fail: "
                      << s.path << std::endl;
            continue;
        }
        if (!s.presetB64.empty()) {
            std::vector<uint8_t> bytes;
            if (base64Decode(s.presetB64, bytes) && !bytes.empty()) {
                juce::MemoryBlock mb(bytes.data(), bytes.size());
                if (juce::VST3PluginFormat::setStateFromVSTPresetFile(inst.get(), mb))
                    std::cerr << "[JuceFxEngine] slot " << i << " preset applied" << std::endl;
                else
                    std::cerr << "[JuceFxEngine] slot " << i << " preset FAILED" << std::endl;
            }
        }
        auto node = g.addNode(std::unique_ptr<juce::AudioProcessor>(std::move(inst)));
        impl_->pluginNodes[i] = node;
        for (int ch = 0; ch < 2; ++ch) {
            NCh src; src.nodeID = prev->nodeID; src.channelIndex = ch;
            NCh dst; dst.nodeID = node->nodeID; dst.channelIndex = ch;
            g.addConnection(Conn(src, dst));
        }
        prev = node;
    }
    for (int ch = 0; ch < 2; ++ch) {
        NCh src; src.nodeID = prev->nodeID; src.channelIndex = ch;
        NCh dst; dst.nodeID = outNode->nodeID; dst.channelIndex = ch;
        g.addConnection(Conn(src, dst));
    }

    g.prepareToPlay((double)sampleRate, (int)(blockSize * 4));  // batch tối đa 4 block
    impl_->buf.setSize(2, (int)(blockSize * 4), false, false, true);

    // Latency thật từng slot sau prepareToPlay (plugin set trong prepare).
    for (size_t i = 0; i < impl_->pluginNodes.size(); ++i)
        if (impl_->pluginNodes[i])
            impl_->slotLatencies[i] =
                (uint32_t)impl_->pluginNodes[i]->getProcessor()->getLatencySamples();
    impl_->totalLatency = (uint32_t)g.getLatencySamples();
    impl_->prepared = true;
}

void JuceFxEngine::process(float* inL, float* inR, uint32_t n) {
    if (!impl_->prepared || n == 0) return;
    auto& b = impl_->buf;
    b.setSize(2, (int)n, false, false, true);
    b.copyFrom(0, 0, inL, (int)n);
    b.copyFrom(1, 0, inR, (int)n);
    juce::MidiBuffer midi;
    impl_->graph.processBlock(b, midi);
    // Graph PDC nội bộ: output đã align dry/wet — copy về in-place như contract.
    const auto* outL = b.getReadPointer(0);
    const auto* outR = b.getReadPointer(1);
    std::copy(outL, outL + n, inL);
    std::copy(outR, outR + n, inR);
}

uint32_t JuceFxEngine::latencySamples() const {
    return impl_->prepared ? impl_->totalLatency : 0u;
}

std::vector<uint32_t> JuceFxEngine::entryLatencies() const {
    return impl_->slotLatencies;
}