export interface MidiOutputInfo {
	id: string;
	name: string;
}

export interface SynthParams {
	attack: number;
	release: number;
	cutoff: number;
	detune: number;
	polyphony: number;
	chorus: number;
}

export const DEFAULT_SYNTH_PARAMS: SynthParams = {
	attack: 0.6,
	release: 1.4,
	cutoff: 1800,
	detune: 9,
	polyphony: 6,
	chorus: 0.45,
};

export interface NoteOpts {
	attack?: number;
	release?: number;
	bypassRateLimit?: boolean;
}

export interface AudioEngine {
	kind: 'midi' | 'synth';
	noteOn(note: number, velocity: number, durationMs: number, opts?: NoteOpts): void;
	setModulation?(value: number): void;
	setVolume?(v: number): void;
	setSynthParams?(p: Partial<SynthParams>): void;
	listOutputs?(): MidiOutputInfo[];
	selectOutput?(id: string): void;
	currentOutputId?(): string | null;
	dispose(): void;
}

interface PadVoice {
	oscs: OscillatorNode[];
	gain: GainNode;
	filter: BiquadFilterNode;
	end: number;
}

class SynthEngine implements AudioEngine {
	kind = 'synth' as const;
	private ctx: AudioContext;
	private master: GainNode;
	private padBus: GainNode;
	private wetBus: GainNode;
	private morph: BiquadFilterNode;
	private active: PadVoice[] = [];
	private params: SynthParams = { ...DEFAULT_SYNTH_PARAMS };
	private lastNoteAt = 0;
	private minNoteGapMs = 35;

	constructor() {
		this.ctx = new (window.AudioContext ||
			(window as unknown as { webkitAudioContext: typeof AudioContext })
				.webkitAudioContext)();
		this.master = this.ctx.createGain();
		this.master.gain.value = 0.25;
		this.master.connect(this.ctx.destination);

		this.padBus = this.ctx.createGain();
		this.padBus.gain.value = 0.6;

		this.wetBus = this.ctx.createGain();
		this.wetBus.gain.value = this.params.chorus;

		this.morph = this.ctx.createBiquadFilter();
		this.morph.type = 'lowpass';
		this.morph.Q.value = 0.4;
		this.morph.frequency.value = 1200;
		this.morph.connect(this.padBus);

		this.buildChorus(this.padBus, this.wetBus);
		this.padBus.connect(this.master);
		this.wetBus.connect(this.master);
	}

	setModulation(value: number) {
		const v = Math.max(0, Math.min(1, value));
		const target = 350 + v * v * 5500;
		this.morph.frequency.setTargetAtTime(target, this.ctx.currentTime, 0.15);
	}

	setSynthParams(p: Partial<SynthParams>) {
		Object.assign(this.params, p);
		if (p.chorus !== undefined) {
			this.wetBus.gain.setTargetAtTime(
				p.chorus,
				this.ctx.currentTime,
				0.05,
			);
		}
	}

	private buildChorus(input: GainNode, output: GainNode) {
		const ctx = this.ctx;
		const make = (delayMs: number, lfoHz: number, depthMs: number, phase: number) => {
			const delay = ctx.createDelay(0.1);
			delay.delayTime.value = delayMs / 1000;
			const lfo = ctx.createOscillator();
			lfo.frequency.value = lfoHz;
			const lfoGain = ctx.createGain();
			lfoGain.gain.value = depthMs / 1000;
			lfo.connect(lfoGain).connect(delay.delayTime);
			input.connect(delay).connect(output);
			lfo.start(ctx.currentTime + phase);
		};
		make(18, 0.6, 4, 0);
		make(24, 0.83, 5, 0.25);
		make(30, 0.41, 3.5, 0.5);
	}

	async resume() {
		if (this.ctx.state !== 'running') await this.ctx.resume();
	}

	setVolume(v: number) {
		this.master.gain.setTargetAtTime(v, this.ctx.currentTime, 0.02);
	}

	noteOn(note: number, velocity: number, _durationMs: number, opts?: NoteOpts) {
		const nowMs = performance.now();
		if (!opts?.bypassRateLimit) {
			if (nowMs - this.lastNoteAt < this.minNoteGapMs) return;
			this.lastNoteAt = nowMs;
		}

		const { cutoff, detune, polyphony } = this.params;
		const attack = opts?.attack ?? this.params.attack;
		const release = opts?.release ?? this.params.release;

		while (this.active.length >= polyphony) {
			const oldest = this.active.shift()!;
			const t0 = this.ctx.currentTime;
			oldest.gain.gain.cancelScheduledValues(t0);
			oldest.gain.gain.setTargetAtTime(0, t0, 0.08);
			for (const o of oldest.oscs) o.stop(t0 + 0.4);
		}

		const t = this.ctx.currentTime;
		const freq = 440 * Math.pow(2, (note - 69) / 12);

		const hold = 0.15;
		const total = attack + hold + release;

		const polyScale = 1 / Math.sqrt(Math.max(1, polyphony));
		const peak = (velocity / 127) * 0.32 * polyScale;

		const filter = this.ctx.createBiquadFilter();
		filter.type = 'lowpass';
		filter.Q.value = 0.6;
		const cutoffStart = Math.min(freq * 1.8, cutoff * 0.4);
		const cutoffPeak = Math.min(cutoff * 2.2, 8000);
		filter.frequency.setValueAtTime(cutoffStart, t);
		filter.frequency.linearRampToValueAtTime(cutoffPeak, t + attack);
		filter.frequency.setTargetAtTime(
			cutoffStart * 1.2,
			t + attack + hold,
			release / 3,
		);

		const g = this.ctx.createGain();
		g.gain.setValueAtTime(0, t);
		g.gain.linearRampToValueAtTime(peak, t + attack);
		g.gain.setValueAtTime(peak, t + attack + hold);
		g.gain.exponentialRampToValueAtTime(0.0001, t + attack + hold + release);

		const detuneCents = [-detune, 0, detune];
		const oscs: OscillatorNode[] = [];
		for (const cents of detuneCents) {
			const osc = this.ctx.createOscillator();
			osc.type = 'sawtooth';
			osc.frequency.value = freq;
			osc.detune.value = cents;
			osc.connect(filter);
			osc.start(t);
			osc.stop(t + total + 0.1);
			oscs.push(osc);
		}

		const subOsc = this.ctx.createOscillator();
		subOsc.type = 'sine';
		subOsc.frequency.value = freq / 2;
		const subGain = this.ctx.createGain();
		subGain.gain.value = 0.3;
		subOsc.connect(subGain).connect(filter);
		subOsc.start(t);
		subOsc.stop(t + total + 0.1);
		oscs.push(subOsc);

		filter.connect(g).connect(this.morph);

		const entry: PadVoice = { oscs, gain: g, filter, end: t + total };
		this.active.push(entry);
		oscs[0].onended = () => {
			const i = this.active.indexOf(entry);
			if (i >= 0) this.active.splice(i, 1);
		};
	}

	dispose() {
		this.ctx.close();
	}
}

class MidiEngine implements AudioEngine {
	kind = 'midi' as const;
	private access: MIDIAccess;
	private outputId: string | null = null;
	private channel = 0;
	private lastModSendAt = 0;
	private lastModValue = -1;

	constructor(access: MIDIAccess) {
		this.access = access;
		const first = Array.from(access.outputs.values())[0];
		this.outputId = first ? first.id : null;
	}

	listOutputs(): MidiOutputInfo[] {
		return Array.from(this.access.outputs.values()).map((o) => ({
			id: o.id,
			name: o.name ?? o.id,
		}));
	}

	selectOutput(id: string) {
		this.outputId = id;
	}

	currentOutputId() {
		return this.outputId;
	}

	private send(bytes: number[]) {
		if (!this.outputId) return;
		const out = this.access.outputs.get(this.outputId);
		if (out) out.send(bytes);
	}

	noteOn(note: number, velocity: number, durationMs: number) {
		const v = Math.max(1, Math.min(127, Math.round(velocity)));
		const n = Math.max(0, Math.min(127, Math.round(note)));
		this.send([0x90 | this.channel, n, v]);
		setTimeout(() => {
			this.send([0x80 | this.channel, n, 0]);
		}, durationMs);
	}

	setModulation(value: number) {
		const now = performance.now();
		if (now - this.lastModSendAt < 90) return;
		const cc = Math.max(0, Math.min(127, Math.round(value * 127)));
		if (cc === this.lastModValue) return;
		this.lastModValue = cc;
		this.lastModSendAt = now;
		this.send([0xb0 | this.channel, 74, cc]);
	}

	dispose() {}
}

export async function createEngine(
	preferMidi: boolean,
): Promise<AudioEngine> {
	if (preferMidi && 'requestMIDIAccess' in navigator) {
		try {
			const access = await navigator.requestMIDIAccess({ sysex: false });
			if (access.outputs.size > 0) {
				return new MidiEngine(access);
			}
		} catch {
			// fall through to synth
		}
	}
	const synth = new SynthEngine();
	await synth.resume();
	return synth;
}