#pragma once
#include <JuceHeader.h>
#include <vector>
#include <cmath>
#include <functional>
#include <initializer_list>
#include <limits>
#include <utility>
#include <array>

// ============================== Design =======================================
// - Bank with F frames, each frame is a single-cycle table of N samples.
// - For each frame, we create L mip-levels: level 0 = full bandwidth,
//   level l halves the permitted harmonics (spectral truncation).
// - Runtime chooses level from note frequency and sampleRate, then morphs
//   between adjacent frames and crossfades between the two nearest levels.
// - Table read uses linear interpolation (cheap and good enough with N>=2048).

namespace WT
{
    // Utility: complex array wrapper for JUCE FFT (interleaved real/imag floats)
    struct ComplexBuf
    {
        std::vector<float> data; // size = 2 * N
        explicit ComplexBuf(size_t N = 0) { resize(N); }
        void resize(size_t N) { data.assign(2 * N, 0.0f); }
        juce::dsp::Complex<float>* asComplex() { return reinterpret_cast<juce::dsp::Complex<float>*>(data.data()); }
    };

    // =======================================================================
    // WavetableBank: holds raw frames + mipmapped versions
    // =======================================================================
    class Bank
    {
    public:
        // N = table length (must be power-of-two for FFT), frames = number of morph frames
        // mipLevels = how many spectral levels (>=1). 5 ~ 6 is plenty for synth use.
        Bank(size_t N = 2048, int frames = 16, int mipLevels = 6)
            : tableSize(N), numFrames(frames), numLevels(mipLevels),
              fft((int)std::log2((double)N))
        {
            jassert(juce::isPowerOfTwo((int)N));
            tables.resize((size_t)numLevels);
            for (int l = 0; l < numLevels; ++l)
                tables[(size_t)l].resize((size_t)numFrames, std::vector<float>(tableSize, 0.0f));
        }

        size_t getSize()    const { return tableSize; }
        int    getFrames()  const { return numFrames; }
        int    getLevels()  const { return numLevels; }

        // Provide raw “design” frames (time-domain single-cycle) then call buildMipmaps().
        // framesRaw.size() must equal numFrames, each frame length must equal tableSize.
        void setRawFrames(const std::vector<std::vector<float>>& framesRaw)
        {
            jassert((int)framesRaw.size() == numFrames);
            for (const auto& f : framesRaw) jassert(f.size() == tableSize);
            raw = framesRaw;
        }

        // Convenience: generate 16-frame bank morphing Sine -> Saw -> Square -> Triangle
        void generateDefaultMorph()
        {
            std::vector<std::vector<float>> frames;
            frames.resize((size_t)numFrames, std::vector<float>(tableSize, 0.0f));

            auto fill = [&](int idx, auto func)
            {
                auto& t = frames[(size_t)idx];
                for (size_t n = 0; n < tableSize; ++n)
                {
                    const float ph = (float) (juce::MathConstants<double>::twoPi * (double)n / (double)tableSize);
                    t[n] = func(ph);
                }
                normalise(t);
            };

            // helper waves
            auto sine = [](float ph) { return std::sin(ph); };
            auto saw  = [](float ph) { return (float)(2.0 * (ph / juce::MathConstants<float>::twoPi) - 1.0); };
            auto sq   = [](float ph) { return ph < juce::MathConstants<float>::pi ? 1.0f : -1.0f; };
            auto tri  = [](float ph) {
                float v = (float)(2.0 * std::abs(2.0 * (ph / juce::MathConstants<float>::twoPi) - 1.0) - 1.0);
                return v;
            };

            // 0..5: sine->saw, 6..10: saw->square, 11..15: square->triangle
            const int F = numFrames;
            for (int i = 0; i < F; ++i)
            {
                const float t = (float) i / (float) juce::jmax(1, F - 1);
                std::function<float(float)> a, b;
                float mix = 0.0f;

                if (i <= 5)      { a = sine; b = saw;    mix = (float)i / 5.0f; }
                else if (i <=10) { a = saw;  b = sq;     mix = (float)(i - 6) / 4.0f; }
                else             { a = sq;   b = tri;    mix = (float)(i - 11) / 4.0f; }

                fill(i, [=](float ph){ return (1.0f - mix) * a(ph) + mix * b(ph); });
            }

            setRawFrames(frames);
        }

        // Build mip-levels by FFT → spectral truncation → IFFT
        void buildMipmaps()
        {
            jassert(!raw.empty());
            ComplexBuf freq(tableSize);
            ComplexBuf time(tableSize);

            for (int f = 0; f < numFrames; ++f)
            {
                // Forward FFT of raw frame
                std::fill(freq.data.begin(), freq.data.end(), 0.0f);
                for (size_t n = 0; n < tableSize; ++n)
                {
                    time.data[2 * n + 0] = raw[(size_t)f][n];
                    time.data[2 * n + 1] = 0.0f;
                }
                fft.performRealOnlyForwardTransform(time.data.data());
                const auto spectrum = time.data; // snapshot packed spectrum for reuse
                // After JUCE real FFT, bins are laid out as: Re[0], Re[N/2], Re[1], Im[1], Re[2], Im[2], ...
                // We'll reconstruct complex bins for easy masking.

                // Helper to zero all harmonics above kMax (inclusive index in [0..N/2])
                auto maskAndIFFT = [&](int level, int kMax)
                {
                    // Restore the original spectrum before masking this mip level
                    for (size_t idx = 0; idx < spectrum.size(); ++idx)
                        time.data[idx] = spectrum[idx];

                    // Copy time.data into working complex bins
                    auto* bins = freq.asComplex();
                    // DC & Nyquist are purely real in real-FFT
                    bins[0].real (time.data[0]);
                    bins[0].imag (0.0f);
                    bins[tableSize/2].real (time.data[1]);
                    bins[tableSize/2].imag (0.0f);

                    // Rebuild the rest (Re[k], Im[k]) packed starting at index 2
                    for (size_t k = 1; k < tableSize/2; ++k)
                    {
                        bins[k].real (time.data[2 * k + 0]);
                        bins[k].imag (time.data[2 * k + 1]);
                    }

                    // Mask
                    for (size_t k = (size_t)kMax + 1; k < tableSize/2; ++k)
                        bins[k] = { 0.0f, 0.0f };

                    // Pack back into real-FFT layout for inverse
                    time.data[0] = bins[0].real();  // DC
                    time.data[1] = bins[tableSize/2].real(); // Nyquist
                    for (size_t k = 1; k < tableSize/2; ++k)
                    {
                        time.data[2 * k + 0] = bins[k].real();
                        time.data[2 * k + 1] = bins[k].imag();
                    }

                    // IFFT
                    fft.performRealOnlyInverseTransform(time.data.data());

                    // Copy, normalise a little (scale JUCE inverse divides by N already)
                    auto& dst = tables[(size_t)level][(size_t)f];
                    for (size_t n = 0; n < tableSize; ++n)
                        dst[n] = time.data[2 * n + 0];

                    normalise(dst);
                };

                // Level 0 → all harmonics available up to N/2 - 1
                for (int l = 0; l < numLevels; ++l)
                {
                    const int maxH = (int)((tableSize / 2) >> l);       // halve per level
                    const int kMax = juce::jmax(1, juce::jmin(maxH, (int)tableSize/2 - 1));
                    maskAndIFFT(l, kMax);
                }
            }
        }

        // sample at (frame, level, phase in [0,1))
        inline float lookup (float frameIdx, int level, float phase) const noexcept
        {
            const int f0 = juce::jlimit(0, numFrames - 1, (int)std::floor(frameIdx));
            const int f1 = juce::jlimit(0, numFrames - 1, f0 + 1);
            const float t = juce::jlimit(0.0f, 1.0f, frameIdx - (float)f0);

            const auto& T0 = tables[(size_t)level][(size_t)f0];
            const auto& T1 = tables[(size_t)level][(size_t)f1];

            const float pos = phase * (float)tableSize;
            const int   i0  = (int) std::floor(pos) & (int)(tableSize - 1);
            const int   i1  = (i0 + 1) & (int)(tableSize - 1);
            const float a   = pos - (float) std::floor(pos);

            const float s0 = juce::jmap(a, T0[(size_t)i0], T0[(size_t)i1]);
            const float s1 = juce::jmap(a, T1[(size_t)i0], T1[(size_t)i1]);
            return juce::jmap(t, s0, s1);
        }

        // choose mip-level for given frequency (Hz) & sampleRate
        inline int chooseLevel (float freq, double sampleRate) const noexcept
        {
            // permitted harmonics at this pitch:
            const float maxH = (float) (0.5 * sampleRate / juce::jmax(1.0f, freq));
            // level so that harmonic budget of level >= maxH, i.e. l = ceil(log2((N/2)/maxH))
            const float base = (float)(tableSize * 0.5);
            const float ratio = base / juce::jmax(1.0f, maxH);
            int l = (int) std::ceil (std::log2 (ratio));
            return juce::jlimit (0, numLevels - 1, l);
        }

        static void normalise (std::vector<float>& t)
        {
            float mx = 0.0f;
            for (float v : t) mx = juce::jmax(mx, std::abs(v));
            if (mx < 1.0e-6f) return;
            for (float& v : t) v /= mx;
        }

    private:
        size_t tableSize;
        int    numFrames;
        int    numLevels;

        juce::dsp::FFT fft;
        std::vector<std::vector<float>> raw;
        // [level][frame][sample]
        std::vector<std::vector<std::vector<float>>> tables;
    };

    struct Preset
    {
        juce::String category;
        juce::String name;
        std::shared_ptr<Bank> bank;
    };

    class FactoryLibrary
    {
    public:
        static const std::vector<Preset>& get()
        {
            static const std::vector<Preset> presets = buildFactoryLibrary();
            return presets;
        }

    private:
        using WaveFn = std::function<float(float)>;

        static WaveFn additive(const std::initializer_list<std::pair<int, float>>& partials)
        {
            const auto coeffs = std::vector<std::pair<int, float>>(partials);
            return [coeffs](float phase)
            {
                float v = 0.0f;
                for (auto [harm, gain] : coeffs)
                    v += gain * std::sin((float)harm * phase);
                return v;
            };
        }

        static WaveFn pulse(float duty)
        {
            duty = juce::jlimit(0.01f, 0.99f, duty);
            return [duty](float phase)
            {
                const float norm = phase / juce::MathConstants<float>::twoPi;
                return (norm < duty ? 1.0f : -1.0f);
            };
        }

        static WaveFn bendFold(float amount)
        {
            return [amount](float phase)
            {
                float x = std::sin(phase);
                x = juce::jlimit(-1.0f, 1.0f, x + amount * x * x * x);
                return x;
            };
        }

        static std::vector<float> renderWave(size_t tableSize, const WaveFn& fn)
        {
            std::vector<float> table(tableSize, 0.0f);
            for (size_t n = 0; n < tableSize; ++n)
            {
                const float phase = (float)(juce::MathConstants<double>::twoPi * (double)n / (double)tableSize);
                table[n] = fn(phase);
            }
            // Remove any DC component before normalising so waves stay centred.
            float mean = 0.0f;
            for (float v : table)
                mean += v;
            mean /= (float)tableSize;
            for (auto& v : table)
                v -= mean;
            Bank::normalise(table);
            return table;
        }

        static std::vector<std::vector<float>> generateFrames(size_t tableSize,
                                                              const std::vector<WaveFn>& keyWaves,
                                                              int frames)
        {
            std::vector<std::vector<float>> out((size_t)frames, std::vector<float>(tableSize, 0.0f));
            if (keyWaves.empty())
                return out;

            std::vector<std::vector<float>> rendered;
            rendered.reserve(keyWaves.size());
            for (const auto& fn : keyWaves)
                rendered.push_back(renderWave(tableSize, fn));

            if (rendered.size() == 1)
            {
                for (auto& frame : out)
                    frame = rendered.front();
                return out;
            }

            const int segments = (int)rendered.size() - 1;
            for (int f = 0; f < frames; ++f)
            {
                const float globalT = (float) f / (float) juce::jmax(1, frames - 1);
                const float scaled  = globalT * (float) segments;
                const int seg       = juce::jlimit(0, segments - 1, (int) std::floor(scaled));
                const float t       = scaled - (float) seg;

                const auto& A = rendered[(size_t) seg];
                const auto& B = rendered[(size_t) (seg + 1)];
                auto& dst = out[(size_t) f];

                for (size_t i = 0; i < tableSize; ++i)
                    dst[i] = juce::jmap(t, A[i], B[i]);

                Bank::normalise(dst);
            }

            return out;
        }

        static std::vector<Preset> buildFactoryLibrary()
        {
            const size_t tableSize = 2048;
            const int frames = 16;
            const int levels = 6;

            std::vector<Preset> presets;
            presets.reserve(240);

            const WaveFn sine      = [](float ph){ return std::sin(ph); };
            const WaveFn sawUp     = [](float ph){
                const float norm = (ph / juce::MathConstants<float>::twoPi) - std::floor(ph / juce::MathConstants<float>::twoPi);
                return 2.0f * norm - 1.0f;
            };
            const WaveFn sawDown   = [](float ph){
                const float norm = (ph / juce::MathConstants<float>::twoPi) - std::floor(ph / juce::MathConstants<float>::twoPi);
                return 1.0f - 2.0f * norm;
            };
            const WaveFn triangle  = [](float ph){
                float norm = ph / juce::MathConstants<float>::twoPi;
                norm -= std::floor(norm);
                float tri = norm < 0.25f ? norm * 4.0f :
                             norm < 0.75f ? 2.0f - norm * 4.0f :
                                            norm * 4.0f - 4.0f;
                return juce::jlimit(-1.0f, 1.0f, tri);
            };
            const WaveFn square50  = pulse(0.5f);
            const WaveFn pulse30   = pulse(0.3f);
            const WaveFn pulse10   = pulse(0.1f);
            const WaveFn organ     = additive({ {1, 1.0f}, {2, 0.5f}, {3, 0.35f}, {4, 0.2f} });
            const WaveFn choir     = additive({ {1, 1.0f}, {3, 0.4f}, {5, 0.25f}, {7, 0.18f} });
            const WaveFn bell      = additive({ {1, 1.0f}, {2, 0.7f}, {6, 0.45f}, {8, 0.3f}, {9, 0.2f} });
            const WaveFn hollow    = additive({ {2, 1.0f}, {4, 0.6f}, {6, 0.3f}, {8, 0.15f} });
            const WaveFn airy      = additive({ {1, 1.0f}, {4, 0.6f}, {6, 0.25f}, {9, 0.18f} });
            const WaveFn bendSoft  = bendFold(0.4f);
            const WaveFn bendHard  = bendFold(1.0f);
            const WaveFn clipped   = [](float ph){ return std::tanh(2.5f * std::sin(ph)); };
            const WaveFn evenStack = additive({ {2, 1.0f}, {6, 0.6f}, {10, 0.4f} });
            const WaveFn oddStack  = additive({ {1, 1.0f}, {5, 0.6f}, {9, 0.3f} });

            auto mix = [](std::initializer_list<std::pair<WaveFn, float>> parts)
            {
                std::vector<WaveFn> funcs;
                std::vector<float> weights;
                funcs.reserve(parts.size());
                weights.reserve(parts.size());
                for (const auto& entry : parts)
                {
                    funcs.push_back(entry.first);
                    weights.push_back(entry.second);
                }

                return WaveFn([funcs, weights](float phase) mutable
                {
                    float v = 0.0f;
                    for (size_t i = 0; i < funcs.size(); ++i)
                        v += weights[i] * funcs[i](phase);
                    return v;
                });
            };

            auto makeAdditive = [](const std::vector<std::pair<int, float>>& partials)
            {
                auto coeffs = partials;
                return WaveFn([coeffs](float phase) mutable
                {
                    float v = 0.0f;
                    for (auto [harm, gain] : coeffs)
                        v += gain * std::sin((float) harm * phase);
                    return v;
                });
            };

            auto formatIndex = [](int idx)
            {
                return juce::String(idx + 1).paddedLeft('0', 2);
            };

            auto sanitise = [](const juce::String& source, const juce::String& fallback)
            {
                juce::String cleaned;
                for (int i = 0; i < source.length(); ++i)
                {
                    auto ch = source[i];
                    if (ch >= 32 && ch <= 126)
                        cleaned += ch;
                }
                cleaned = cleaned.trim();
                return cleaned.isEmpty() ? fallback : cleaned;
            };

            auto addPreset = [&](const juce::String& category,
                                 const juce::String& name,
                                 const std::vector<WaveFn>& keys)
            {
                auto bank = std::make_shared<Bank>(tableSize, frames, levels);
                bank->setRawFrames(generateFrames(tableSize, keys, frames));
                bank->buildMipmaps();
                const juce::String safeCategory = sanitise(category, juce::String("Misc"));
                const juce::String fallbackName = juce::String("Preset ") + juce::String(presets.size() + 1);
                const juce::String safeName = sanitise(name, fallbackName);
                presets.push_back({ safeCategory, safeName, bank });
            };

            // Electric Piano
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float brightness = juce::jmap(t, 0.35f, 0.85f);
                const float bellMix    = juce::jmap(t, 0.15f, 0.45f);

                std::vector<std::pair<int, float>> attackCoeffs {
                    { 1, 1.0f },
                    { 2, 0.45f * brightness },
                    { 3, 0.32f * brightness },
                    { 4, 0.18f * brightness },
                    { 5, 0.12f * bellMix },
                    { 6, 0.08f * bellMix },
                    { 8, 0.05f * bellMix }
                };

                std::vector<std::pair<int, float>> bodyCoeffs {
                    { 1, 1.0f },
                    { 2, 0.4f * brightness },
                    { 3, 0.25f * brightness },
                    { 4, 0.16f * bellMix },
                    { 6, 0.10f * bellMix },
                    { 9, 0.06f * bellMix }
                };

                std::vector<std::pair<int, float>> releaseCoeffs {
                    { 1, 1.0f },
                    { 2, 0.30f },
                    { 3, 0.22f },
                    { 5, 0.12f * bellMix },
                    { 7, 0.10f * bellMix }
                };

                auto attack = makeAdditive(attackCoeffs);
                auto body   = makeAdditive(bodyCoeffs);
                auto release= makeAdditive(releaseCoeffs);
                auto shimmer = mix({
                    { airy, 0.35f + 0.20f * t },
                    { bell, 0.30f + 0.20f * t },
                    { oddStack, 0.25f }
                });

                const juce::String name = "EP Tines " + formatIndex(i);
                addPreset("Electric Piano", name, { attack, body, release, shimmer });
            }

            // Organ
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float even = juce::jmap(t, 0.30f, 0.65f);
                const float odd  = juce::jmap(t, 0.35f, 0.75f);
                const float perc = juce::jmap(t, 0.10f, 0.35f);

                std::vector<std::pair<int, float>> drawbarCoeffs {
                    { 1, 1.0f },
                    { 2, 0.45f * even },
                    { 3, 0.38f * odd },
                    { 4, 0.28f * even },
                    { 5, 0.24f * odd },
                    { 6, 0.18f * even },
                    { 8, 0.12f * odd }
                };

                auto drawbar = makeAdditive(drawbarCoeffs);
                auto chorusMix = mix({
                    { organ, 0.65f },
                    { choir, 0.35f + 0.15f * t },
                    { airy, 0.25f }
                });
                auto bright = mix({
                    { organ, 0.60f },
                    { sawUp, 0.35f + 0.20f * t },
                    { oddStack, 0.25f + 0.10f * t }
                });
                auto percussion = mix({
                    { bell, 0.30f + 0.25f * perc },
                    { sine, 0.40f },
                    { organ, 0.35f }
                });

                const juce::String name = "Organ Drawbar " + formatIndex(i);
                addPreset("Organ", name, { drawbar, chorusMix, bright, percussion });
            }

            // Bass
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float grit = juce::jmap(t, 0.20f, 0.70f);
                const float hollowAmt = juce::jmap(t, 0.15f, 0.50f);

                std::vector<std::pair<int, float>> subCoeffs {
                    { 1, 1.0f },
                    { 2, 0.35f },
                    { 3, 0.22f * grit },
                    { 4, 0.15f * hollowAmt }
                };

                auto sub = makeAdditive(subCoeffs);
                auto body = mix({
                    { sawDown, 0.70f },
                    { triangle, 0.45f },
                    { bendSoft, 0.35f * grit }
                });
                auto growl = mix({
                    { bendHard, 0.35f * grit },
                    { clipped, 0.30f + 0.20f * t },
                    { pulse30, 0.24f }
                });
                auto snap = mix({
                    { pulse10, 0.28f },
                    { oddStack, 0.26f },
                    { bendSoft, 0.30f }
                });

                const juce::String name = "Bass Sculpt " + formatIndex(i);
                addPreset("Bass", name, { sub, body, growl, snap });
            }

            // Drums (GM mapped)
            static const std::array<std::pair<int, const char*>, 20> gmDrumOrder = {{
                {35, "Acoustic Bass Drum"}, {36, "Bass Drum 1"},
                {37, "Side Stick"},         {38, "Acoustic Snare"},
                {39, "Hand Clap"},          {40, "Electric Snare"},
                {41, "Low Floor Tom"},      {42, "Closed Hi-Hat"},
                {43, "High Floor Tom"},     {44, "Pedal Hi-Hat"},
                {45, "Low Tom"},            {46, "Open Hi-Hat"},
                {47, "Low-Mid Tom"},        {48, "Hi-Mid Tom"},
                {49, "Crash Cymbal 1"},     {50, "High Tom"},
                {51, "Ride Cymbal 1"},      {52, "Chinese Cymbal"},
                {53, "Ride Bell"},          {54, "Tambourine"}
            }};

            for (int i = 0; i < 20; ++i)
            {
                const auto& gm = gmDrumOrder[(size_t) i];
                const int gmNumber = gm.first;
                const juce::String label (gm.second);
                const float accent = (float) ((i % 4) + 1) / 4.0f;

                std::vector<WaveFn> waves;

                if (gmNumber == 35 || gmNumber == 36)
                {
                    const float clickAmt = juce::jmap(accent, 0.18f, 0.35f);
                    const float bodyAmt  = juce::jmap(accent, 0.75f, 0.95f);

                    std::vector<std::pair<int, float>> lowCoeffs {
                        { 1, bodyAmt },
                        { 2, 0.32f },
                        { 3, 0.20f * accent },
                        { 4, 0.15f * accent }
                    };

                    auto low = makeAdditive(lowCoeffs);
                    auto punch = mix({
                        { sine, 0.70f },
                        { bendSoft, 0.40f + 0.15f * accent },
                        { hollow, 0.25f * accent }
                    });
                    auto click = mix({
                        { pulse10, clickAmt },
                        { oddStack, 0.25f },
                        { bell, 0.20f + 0.10f * accent }
                    });
                    auto tail = mix({
                        { sine, 0.70f },
                        { triangle, 0.30f },
                        { airy, 0.22f }
                    });
                    waves = { low, punch, click, tail };
                }
                else if (gmNumber == 37 || gmNumber == 38 || gmNumber == 39 || gmNumber == 40)
                {
                    const float snap = juce::jmap(accent, 0.30f, 0.65f);
                    auto strike = mix({
                        { pulse30, 0.40f + 0.20f * snap },
                        { oddStack, 0.30f },
                        { bendHard, 0.25f + 0.10f * snap }
                    });
                    auto noise = mix({
                        { sawUp, 0.50f },
                        { evenStack, 0.40f },
                        { bell, 0.20f + 0.10f * snap }
                    });
                    std::vector<std::pair<int, float>> bodyCoeffs {
                        { 1, 1.0f },
                        { 2, 0.35f },
                        { 3, 0.24f },
                        { 5, 0.15f * snap }
                    };
                    auto body = makeAdditive(bodyCoeffs);
                    auto tail = mix({
                        { airy, 0.50f },
                        { choir, 0.30f },
                        { bell, 0.25f }
                    });
                    waves = { strike, noise, body, tail };
                }
                else if (gmNumber == 41 || gmNumber == 43 || gmNumber == 45
                      || gmNumber == 47 || gmNumber == 48 || gmNumber == 50)
                {
                    const float tone = juce::jmap(accent, 0.40f, 0.80f);
                    std::vector<std::pair<int, float>> bodyCoeffs {
                        { 1, 1.0f },
                        { 2, 0.40f * tone },
                        { 3, 0.28f * tone },
                        { 4, 0.18f }
                    };
                    auto body = makeAdditive(bodyCoeffs);
                    auto strike = mix({
                        { pulse30, 0.30f + 0.15f * tone },
                        { bendSoft, 0.35f },
                        { oddStack, 0.25f }
                    });
                    auto ring = mix({
                        { evenStack, 0.40f },
                        { airy, 0.25f + 0.12f * tone },
                        { bell, 0.20f }
                    });
                    auto tail = mix({
                        { sine, 0.60f },
                        { triangle, 0.30f },
                        { airy, 0.25f }
                    });
                    waves = { strike, body, ring, tail };
                }
                else if (gmNumber == 42 || gmNumber == 44 || gmNumber == 46)
                {
                    const float metallicAmt = juce::jmap(accent, 0.50f, 0.90f);
                    auto metallic = mix({
                        { oddStack, 0.60f },
                        { evenStack, 0.50f },
                        { bell, 0.35f + 0.15f * accent }
                    });
                    auto closed = mix({
                        { metallic, 0.80f },
                        { pulse10, 0.25f },
                        { sawUp, 0.25f }
                    });
                    auto open = mix({
                        { evenStack, 0.45f },
                        { bell, 0.40f + 0.15f * accent },
                        { airy, 0.35f }
                    });
                    auto shimmer = mix({
                        { bell, 0.45f },
                        { oddStack, 0.30f },
                        { choir, 0.25f }
                    });
                    waves = { closed, metallic, open, shimmer };
                }
                else
                {
                    const float spread = juce::jmap(accent, 0.40f, 0.85f);
                    auto strike = mix({
                        { sawUp, 0.50f },
                        { bendHard, 0.40f },
                        { pulse10, 0.30f }
                    });
                    auto wash = mix({
                        { evenStack, 0.50f + 0.20f * spread },
                        { oddStack, 0.45f },
                        { bell, 0.40f + 0.15f * spread }
                    });
                    auto bellLayer = mix({
                        { bell, 0.55f + 0.15f * spread },
                        { choir, 0.30f },
                        { sine, 0.25f }
                    });
                    auto tail = mix({
                        { airy, 0.50f },
                        { bell, 0.35f },
                        { evenStack, 0.30f }
                    });
                    waves = { strike, wash, bellLayer, tail };
                }

                const juce::String name = "GM " + juce::String(gmNumber) + " " + label;
                addPreset("Drums", name, waves);
            }

            // Strings
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float sheen = juce::jmap(t, 0.25f, 0.60f);
                const float warmth = juce::jmap(t, 0.30f, 0.70f);

                auto ensemble = mix({
                    { sine, 0.60f },
                    { triangle, 0.50f },
                    { choir, 0.35f + 0.15f * warmth },
                    { airy, 0.25f + 0.10f * sheen }
                });
                auto bowMotion = mix({
                    { sawUp, 0.40f },
                    { sawDown, 0.35f },
                    { airy, 0.30f },
                    { bendSoft, 0.20f }
                });
                auto shimmer = mix({
                    { choir, 0.40f },
                    { airy, 0.35f + 0.15f * sheen },
                    { bell, 0.20f }
                });
                auto sustain = mix({
                    { sine, 0.55f },
                    { triangle, 0.35f },
                    { organ, 0.25f }
                });

                const juce::String name = "Strings Ensemble " + formatIndex(i);
                addPreset("Strings", name, { ensemble, bowMotion, shimmer, sustain });
            }

            // Brass
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float edge = juce::jmap(t, 0.30f, 0.75f);

                auto section = mix({
                    { sawUp, 0.60f },
                    { sawDown, 0.35f },
                    { organ, 0.30f },
                    { bendSoft, 0.20f * edge }
                });
                auto growl = mix({
                    { bendHard, 0.35f + 0.20f * edge },
                    { clipped, 0.30f },
                    { pulse30, 0.20f }
                });
                auto brassPad = mix({
                    { organ, 0.45f },
                    { choir, 0.30f },
                    { airy, 0.30f }
                });
                auto fanfare = mix({
                    { evenStack, 0.35f + 0.20f * edge },
                    { oddStack, 0.30f },
                    { bell, 0.20f }
                });

                const juce::String name = "Brass Section " + formatIndex(i);
                addPreset("Brass", name, { section, growl, brassPad, fanfare });
            }

            // Choir
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float breath = juce::jmap(t, 0.20f, 0.60f);

                auto vowels = mix({
                    { choir, 0.65f },
                    { airy, 0.40f },
                    { sine, 0.20f }
                });
                auto ahFormant = mix({
                    { choir, 0.50f + 0.20f * breath },
                    { organ, 0.30f },
                    { airy, 0.25f }
                });
                auto shimmer = mix({
                    { airy, 0.40f + 0.20f * breath },
                    { bell, 0.25f },
                    { sine, 0.20f }
                });
                auto pad = mix({
                    { choir, 0.45f },
                    { sine, 0.30f },
                    { triangle, 0.25f }
                });

                const juce::String name = "Choir Aura " + formatIndex(i);
                addPreset("Choir", name, { vowels, ahFormant, shimmer, pad });
            }

            // Pad
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float motion = juce::jmap(t, 0.30f, 0.75f);

                auto warm = mix({
                    { sine, 0.55f },
                    { organ, 0.40f },
                    { airy, 0.30f }
                });
                auto evolving = mix({
                    { choir, 0.35f + 0.20f * motion },
                    { bendSoft, 0.30f },
                    { airy, 0.35f + 0.15f * motion }
                });
                auto shimmer = mix({
                    { bell, 0.30f },
                    { airy, 0.35f + 0.20f * motion },
                    { evenStack, 0.25f }
                });
                auto sub = mix({
                    { sine, 0.50f },
                    { triangle, 0.35f },
                    { hollow, 0.25f }
                });

                const juce::String name = "Pad Horizon " + formatIndex(i);
                addPreset("Pad", name, { warm, evolving, shimmer, sub });
            }

            // SFX
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float chaos = juce::jmap(t, 0.40f, 0.90f);

                auto motionFx = mix({
                    { bendSoft, 0.40f + 0.20f * chaos },
                    { bendHard, 0.35f + 0.20f * chaos },
                    { sawUp, 0.30f }
                });
                auto shimmerFx = mix({
                    { bell, 0.30f + 0.25f * chaos },
                    { airy, 0.30f },
                    { evenStack, 0.25f }
                });
                auto glitch = mix({
                    { clipped, 0.40f },
                    { pulse30, 0.30f },
                    { oddStack, 0.30f }
                });
                auto atmosphere = mix({
                    { airy, 0.45f + 0.20f * chaos },
                    { choir, 0.30f },
                    { organ, 0.20f }
                });

                const juce::String name = "SFX Motion " + formatIndex(i);
                addPreset("SFX", name, { motionFx, shimmerFx, glitch, atmosphere });
            }

            // Lead
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float bite = juce::jmap(t, 0.30f, 0.85f);

                auto classic = mix({
                    { sawUp, 0.60f },
                    { sawDown, 0.35f },
                    { pulse30, 0.25f }
                });
                auto sharp = mix({
                    { pulse10, 0.35f + 0.20f * bite },
                    { bendSoft, 0.30f },
                    { oddStack, 0.25f }
                });
                auto silky = mix({
                    { triangle, 0.40f },
                    { sine, 0.35f },
                    { airy, 0.25f }
                });
                auto grit = mix({
                    { bendHard, 0.35f + 0.20f * bite },
                    { clipped, 0.30f },
                    { pulse30, 0.20f }
                });

                const juce::String name = "Lead Vector " + formatIndex(i);
                addPreset("Lead", name, { classic, sharp, silky, grit });
            }

            // Pluck
            for (int i = 0; i < 20; ++i)
            {
                const float t = (float) i / 19.0f;
                const float sparkle = juce::jmap(t, 0.25f, 0.70f);

                auto transient = mix({
                    { pulse10, 0.35f + 0.20f * sparkle },
                    { oddStack, 0.30f },
                    { bell, 0.25f }
                });
                auto body = mix({
                    { sawDown, 0.50f },
                    { triangle, 0.40f },
                    { sine, 0.30f }
                });
                auto shimmer = mix({
                    { bell, 0.30f + 0.20f * sparkle },
                    { airy, 0.30f },
                    { evenStack, 0.25f }
                });
                auto decay = mix({
                    { sine, 0.50f },
                    { hollow, 0.25f },
                    { airy, 0.30f }
                });

                const juce::String name = "Pluck Spark " + formatIndex(i);
                addPreset("Pluck", name, { transient, body, shimmer, decay });
            }

            return presets;
        }
    };

    // =======================================================================
    // Wavetable Oscillator
    // =======================================================================
    class Osc
    {
    public:
        void prepare (double sr)
        {
            sampleRate = juce::jmax (1.0, sr);
            setFrequency (freq);
        }
        void setBank (std::shared_ptr<Bank> b)
        {
            bank = std::move(b);
            if (bank)
                morph = juce::jlimit (0.0f, (float) (bank->getFrames() - 1), morph);
        }
        void setFrequency (float f)
        {
            const float nyquist = 0.5f * (float) sampleRate;
            freq = juce::jlimit (0.0f, juce::jmax (0.0f, nyquist), f);
            phaseInc = freq / (float) sampleRate;
        }
        void setMorph (float m)
        {
            morph = clampMorph (m);
        }      // 0..frames-1 (continuous)
        void resetPhase (float p = 0.0f) { phase = juce::jlimit(0.0f, 1.0f, p); }
        [[nodiscard]] int getFrameCount() const noexcept { return bank ? bank->getFrames() : 0; }
        [[nodiscard]] float getMaxMorph() const noexcept { return bank ? (float)(bank->getFrames() - 1) : 0.0f; }

        float process(float morphOverride = std::numeric_limits<float>::quiet_NaN())
        {
            if (!bank) return 0.0f;

            const int l0 = bank->chooseLevel(freq, sampleRate);
            const int l1 = juce::jmin(l0 + 1, bank->getLevels() - 1);
            const float preferL0 = 1.0f - juce::jlimit(0.0f, 1.0f,
                                   (float)l0 - (float)bank->chooseLevel(freq * 0.99f, sampleRate));

            const float morphValue = std::isnan(morphOverride) ? morph : clampMorph (morphOverride);

            const float s0 = bank->lookup(morphValue, l0, phase);
            const float s1 = bank->lookup(morphValue, l1, phase);
            const float out = juce::jmap(preferL0, s1, s0); // simple crossfade

            phase += phaseInc;
            while (phase >= 1.0f) phase -= 1.0f;
            return out;
        }

    private:
        float clampMorph (float m) const noexcept
        {
            if (!bank) return juce::jmax (0.0f, m);
            const float maxMorph = (float) (bank->getFrames() - 1);
            return juce::jlimit (0.0f, maxMorph, m);
        }

        std::shared_ptr<Bank> bank;
        double sampleRate { 44100.0 };
        float  freq { 0.0f };
        float  morph { 0.0f };     // 0..frames-1
        float  phase { 0.0f };
        float  phaseInc { 0.0f };
    };
} // namespace WT