(function () {
    'use strict';

    const activeOscillators = {};

    let __gainNode = null;
    const getCtx = () => {
        if (typeof getAudioContext === 'function') {
            const ctx = getAudioContext();
            if (!__gainNode) {
                __gainNode = ctx.createGain();
                __gainNode.gain.value = 0.3;
                __gainNode.connect(ctx.destination);
            }
            return ctx;
        }
        if (!window.__sharedAudioCtx) {
            window.__sharedAudioCtx = new (window.AudioContext || window.webkitAudioContext)();
        }
        if (window.__sharedAudioCtx.state === 'suspended') {
            window.__sharedAudioCtx.resume();
        }
        if (!__gainNode) {
            __gainNode = window.__sharedAudioCtx.createGain();
            __gainNode.gain.value = 0.3;
            __gainNode.connect(window.__sharedAudioCtx.destination);
        }
        return window.__sharedAudioCtx;
    };

    const _channels = Array.from({ length: 16 }, () => ({ bank: 0, program: 0, isPercussion: false }));
    let _nextMelodicChannel = 0;

    let _synthInstance = null;
    let _initialized = false;
    let _currentSfId = null;
    let _bankLoadedCount = 0;

    // ── addSoundBank with timeout (SpessaSynth hangs on parse error) ──
    async function _addBankWithTimeout(synth, buffer, sfId, timeoutMs) {
        return new Promise((resolve) => {
            const timer = setTimeout(() => {
                console.warn("[SonicSF] addSoundBank timeout after", timeoutMs, "ms");
                resolve(false);
            }, timeoutMs);

            synth.soundBankManager.addSoundBank(buffer.slice(0), sfId).then(() => {
                clearTimeout(timer);
                resolve(true);
            }).catch((err) => {
                clearTimeout(timer);
                console.error("[SonicSF] addSoundBank rejected:", err);
                resolve(false);
            });
        });
    }

    const SonicSF = {
        loadedFonts: {},

        // ══════════════════════════════════════════════════
        // PHASE 1: Init SpessaSynth Engine (FlowClient.md 1.1)
        // ══════════════════════════════════════════════════
        init: async function (audioContext) {
            if (!window.SpessaSynthClass || !window.__SpessaSynthCDN) {
                console.warn("[SonicSF] SpessaSynth CDN not available. Using oscillator.");
                return;
            }
            try {
                const procUrl = window.__SpessaSynthCDN + "spessasynth_processor.min.js";
                await audioContext.audioWorklet.addModule(procUrl);
                _synthInstance = new window.SpessaSynthClass(audioContext);
                _synthInstance.connect(audioContext.destination);
                await _synthInstance.isReady;
                _initialized = true;
                console.log("[SonicSF] SpessaSynth engine ready.");
            } catch (e) {
                console.warn("[SonicSF] AudioWorklet failed:", e);
                try {
                    const mod = await import("https://cdn.jsdelivr.net/npm/spessasynth_lib@4.3.1/dist/index.js");
                    _synthInstance = new mod.WorkerSynthesizer(audioContext);
                    _synthInstance.connect(audioContext.destination);
                    await _synthInstance.isReady;
                    _initialized = true;
                    console.log("[SonicSF] WorkerSynthesizer ready.");
                } catch (e2) {
                    console.error("[SonicSF] All SpessaSynth paths failed:", e2);
                }
            }
        },

        // ══════════════════════════════════════════════════
        // PHASE 2: Load SF3/SF2 → IndexedDB → SpessaSynth (FlowClient.md 2.)
        // ══════════════════════════════════════════════════
        loadSoundFont: async function (sfId) {
            if (!_initialized || !_synthInstance) return false;
            if (_currentSfId === sfId) return true;
            console.log("[SonicSF] Loading SoundFont:", sfId);

            let buffer = null;
            if (window.SonicSFStorage) {
                buffer = await window.SonicSFStorage.getBuffer(sfId);
                if (buffer) console.log("[SonicSF] Cache HIT for", sfId, buffer.byteLength, "bytes");
            }
            if (!buffer) {
                try {
                    const url = "/api/v1/plugins/soundfonts/download/" + encodeURIComponent(sfId) + "?t=" + Date.now();
                    const resp = await fetch(url);
                    if (!resp.ok) throw new Error("HTTP " + resp.status);
                    buffer = await resp.arrayBuffer();
                    console.log("[SonicSF] Downloaded", sfId, buffer.byteLength, "bytes");
                    if (window.SonicSFStorage) {
                        await window.SonicSFStorage.saveBuffer(sfId, buffer);
                    }
                } catch (e) {
                    console.error("[SonicSF] Download failed:", sfId, e);
                    return false;
                }
            }
            // Load into SpessaSynth with 15s timeout
            const ok = await _addBankWithTimeout(_synthInstance, buffer, sfId, 15000);
            if (ok) {
                _currentSfId = sfId;
                _bankLoadedCount = _synthInstance.soundBankManager?.soundBankList?.length ?? 0;
                console.log("[SonicSF] SoundFont loaded:", sfId, "- banks:", _bankLoadedCount);
                return true;
            } else {
                console.warn("[SonicSF] SoundFont load FAILED:", sfId, "- using oscillator fallback");
                if (window.SonicSFStorage) {
                    try {
                        const db = await window.SonicSFStorage.openDB();
                        const tx = db.transaction(window.SonicSFStorage.storeName, "readwrite");
                        tx.objectStore(window.SonicSFStorage.storeName).delete(sfId);
                    } catch (ce) {}
                }
                _currentSfId = null;
                return false;
            }
        },

        // ══════════════════════════════════════════════════
        // PHASE 3: Set up MIDI Channel (FlowClient.md 3.)
        // ══════════════════════════════════════════════════
        selectInstrument: async function (channel, bank, program, sfId) {
            if (!_initialized || !_synthInstance) return;
            // Phase 2: ensure SoundFont is loaded
            if (sfId) {
                const loaded = await this.loadSoundFont(sfId);
                if (!loaded) {
                    console.warn("[SonicSF] selectInstrument: no SoundFont loaded, ch", channel);
                    return;
                }
            }
            // Phase 3a: controllerChange(CC0) → bank MSB
            try { _synthInstance.controllerChange(channel, 0, bank); } catch (e) {}
            // Phase 3b: controllerChange(CC32) → bank LSB
            try { _synthInstance.controllerChange(channel, 32, 0); } catch (e) {}
            // Phase 3c: programChange
            try { _synthInstance.programChange(channel, program); } catch (e) {}
            // Phase 3d: update SonicSF internal state
            this.controllerChange(channel, 0, bank);
            this.programChange(channel, program);
            console.log("[SonicSF] Switched Channel", channel, "-> Bank:", bank, ", Program:", program, ", SF:", sfId);
        },

        // ══════════════════════════════════════════════════
        // PHASE 4: Play MIDI Note (FlowClient.md 3.)
        // ══════════════════════════════════════════════════
        controllerChange: function (channel, controller, value) {
            if (channel < 0 || channel > 15) return;
            if (_initialized && _synthInstance) {
                try { _synthInstance.controllerChange(channel, controller, value); } catch (e) {}
            }
            if (controller === 0) {
                _channels[channel].bank = value;
                _channels[channel].isPercussion = (value === 128);
            }
        },

        programChange: function (channel, program) {
            if (channel < 0 || channel > 15) return;
            if (_initialized && _synthInstance) {
                try { _synthInstance.programChange(channel, program); } catch (e) {}
            }
            _channels[channel].program = program;
        },

        allocateChannel: function (bank) {
            if (bank === 128) return 9;
            const ch = _nextMelodicChannel % 9;
            _nextMelodicChannel = (_nextMelodicChannel + 1) % 9;
            return ch;
        },

        applyAITrackInstrument: function (bank, program, synthEngine) {
            if (synthEngine) {
                bank = bank !== undefined ? bank : (synthEngine.soundfont_bank || 0);
                program = program !== undefined ? program : (synthEngine.soundfont_program || 0);
            }
            const channel = this.allocateChannel(bank);
            this.selectInstrument(channel, bank, program, synthEngine?.soundfont_id);
            return channel;
        },

        getChannelState: function (channel) {
            if (channel < 0 || channel > 15) return null;
            return { ..._channels[channel] };
        },

        playNote: function (note, velocity, durationMs, startTime, program, destinationNode, channel, synthEngine) {
            // TEMP: always use oscillator for reliable preview
            // SpessaSynth path: only when bank is confirmed loaded
            if (_initialized && _synthInstance && _currentSfId) {
                if (synthEngine) {
                    const ch = channel !== undefined ? channel : (synthEngine.soundfont_bank === 128 ? 9 : 0);
                    try { _synthInstance.controllerChange(ch, 0, synthEngine.soundfont_bank || 0); } catch (e) {}
                    try { _synthInstance.controllerChange(ch, 32, 0); } catch (e) {}
                    try { _synthInstance.programChange(ch, synthEngine.soundfont_program || 0); } catch (e) {}
                    if (channel === undefined) channel = ch;
                }
                if (channel === undefined) channel = 0;
                // Try SpessaSynth, fallback to oscillator on error
                try {
                    this._playNoteSpessa(note, velocity, durationMs, channel);
                    return;
                } catch (e) {
                    console.warn("[SonicSF] SpessaSynth play failed, fallback:", e);
                }
            }
            this._playNoteOsc(note, velocity, durationMs, startTime, program, destinationNode, channel, synthEngine);
        },

        _playNoteSpessa: function (note, velocity, durationMs, channel) {
            const ctx = getCtx();
            const midiPitch = Math.min(127, Math.max(0, parseInt(note) || 60));
            const midiVel = Math.min(127, Math.max(1, Math.floor(
                typeof velocity === 'number' ? (velocity > 1 ? velocity : velocity * 127) : 100
            )));
            const durSec = durationMs / 1000;
            const doNoteOn = () => {
                try {
                    const bl = _synthInstance.soundBankManager?.soundBankList?.length ?? 0;
                    console.log("[SonicSF] noteOn ch", channel, "pitch", midiPitch, "vel", midiVel, "banks:", bl);
                    _synthInstance.noteOn(channel, midiPitch, midiVel);
                    setTimeout(() => { try { _synthInstance.noteOff(channel, midiPitch); } catch (e) {} }, durSec * 1000);
                } catch (e) {
                    console.warn("[SonicSF] noteOn failed:", e);
                }
            };
            doNoteOn();
        },

        _playNoteOsc: function (note, velocity, durationMs, startTime, program, destinationNode, channel, synthEngine) {
            const ctx = getCtx();
            const freq = 440 * Math.pow(2, (note - 69) / 12);
            if (freq <= 0 || isNaN(freq)) return null;

            if (synthEngine) {
                const ch = channel !== undefined ? channel : (synthEngine.soundfont_bank === 128 ? 9 : 0);
                this.controllerChange(ch, 0, synthEngine.soundfont_bank || 0);
                this.programChange(ch, synthEngine.soundfont_program || 0);
                if (channel === undefined) channel = ch;
                if (program === undefined) program = synthEngine.soundfont_program;
            }

            const osc = ctx.createOscillator();
            const noteGain = ctx.createGain();
            let oscType = 'triangle';
            let attackTime = 0.03, decayTime = 0.1, sustainLevel = 0.5, releaseTime = 0.2, volFactor = 0.25;

            let prog = program !== undefined ? parseInt(program) : 0;
            if (channel !== undefined && channel >= 0 && channel < 16) {
                const chState = _channels[channel];
                prog = chState.program || prog;
            }
            if (prog >= 0 && prog <= 7) {
                oscType = 'sine';
                decayTime = 0.3; sustainLevel = 0.1; releaseTime = 0.2;
            } else if (prog >= 8 && prog <= 15) {
                oscType = 'sine';
                decayTime = 0.1; sustainLevel = 0.0; releaseTime = 0.1;
            } else if (prog >= 16 && prog <= 23) {
                oscType = 'sine';
                attackTime = 0.05; sustainLevel = 0.8; releaseTime = 0.1;
            } else if (prog >= 24 && prog <= 31) {
                oscType = 'triangle';
                decayTime = 0.4; sustainLevel = 0.2; releaseTime = 0.3;
            } else if (prog >= 32 && prog <= 39) {
                oscType = 'triangle';
                attackTime = 0.02; decayTime = 0.2; sustainLevel = 0.6; releaseTime = 0.2;
            } else if (prog >= 40 && prog <= 47) {
                oscType = 'sawtooth';
                attackTime = 0.15; sustainLevel = 0.8; releaseTime = 0.5; volFactor = 0.15;
            } else if (prog >= 48 && prog <= 55) {
                oscType = 'sawtooth';
                attackTime = 0.2; sustainLevel = 0.8; releaseTime = 0.6; volFactor = 0.12;
            } else if (prog >= 56 && prog <= 63) {
                oscType = 'sawtooth';
                attackTime = 0.08; sustainLevel = 0.7; releaseTime = 0.3; volFactor = 0.15;
            } else if (prog >= 64 && prog <= 71) {
                oscType = 'square';
                attackTime = 0.05; sustainLevel = 0.6; releaseTime = 0.2; volFactor = 0.15;
            } else if (prog >= 72 && prog <= 79) {
                oscType = 'sine';
                attackTime = 0.1; sustainLevel = 0.7; releaseTime = 0.3; volFactor = 0.2;
            } else if (prog >= 80 && prog <= 119) {
                oscType = 'sawtooth';
                attackTime = 0.05; sustainLevel = 0.6; releaseTime = 0.4; volFactor = 0.15;
            }

            osc.type = oscType;
            osc.frequency.setValueAtTime(freq, 0);
            const startAt = startTime !== undefined ? startTime : ctx.currentTime;
            const durSec = durationMs / 1000;
            const vel = typeof velocity === 'number' ? (velocity > 1 ? velocity / 127 : velocity) : 0.8;
            const targetGain = vel * volFactor;

            noteGain.gain.setValueAtTime(0, startAt);
            noteGain.gain.linearRampToValueAtTime(targetGain, startAt + attackTime);
            noteGain.gain.linearRampToValueAtTime(targetGain * sustainLevel, startAt + attackTime + decayTime);
            const releaseStart = startAt + Math.max(attackTime + decayTime, durSec);
            noteGain.gain.linearRampToValueAtTime(targetGain * sustainLevel, releaseStart);
            noteGain.gain.linearRampToValueAtTime(0, releaseStart + releaseTime);

            osc.connect(noteGain);
            noteGain.connect(destinationNode || __gainNode || ctx.destination);
            osc.start(startAt);
            const stopAt = releaseStart + releaseTime + 0.02;
            osc.stop(stopAt);

            const oscId = `${note}_${Date.now()}_${Math.random()}`;
            activeOscillators[oscId] = { osc, gain: noteGain };
            setTimeout(() => { delete activeOscillators[oscId]; }, (stopAt - ctx.currentTime) * 1000 + 100);
            return osc;
        },

        stopAll: function () {
            if (_initialized && _synthInstance) {
                try { for (let ch = 0; ch < 16; ch++) _synthInstance.allNotesOff(ch); } catch (e) {}
            }
            const ctx = getCtx();
            const now = ctx.currentTime;
            Object.values(activeOscillators).forEach(entry => {
                try {
                    if (entry.gain) { entry.gain.gain.cancelScheduledValues(now); entry.gain.gain.setValueAtTime(0, now); }
                    if (entry.osc) try { entry.osc.stop(now); } catch (e) { }
                } catch (e) { }
            });
            Object.keys(activeOscillators).forEach(k => delete activeOscillators[k]);
        },

        saveToIndexedDB: async function (name, arrayBuffer) {
            if (window.SonicStorage && window.SonicStorage.saveToIndexedDB) {
                await window.SonicStorage.saveToIndexedDB('soundfont_' + name, arrayBuffer);
            }
        },

        loadFromIndexedDB: async function (name) {
            if (window.SonicStorage && window.SonicStorage.loadFromIndexedDB) {
                return await window.SonicStorage.loadFromIndexedDB('soundfont_' + name);
            }
            return null;
        }
    };

    window.SonicSF = SonicSF;
})();