import {
    AbstractInput, CallbackInputConsumer,
    InputConsumer,
    InputConsumerType,
    InputDevice, InputStartResult,
    InputState,
    LevelMeter, NodeInputConsumer
} from "tc-shared/voice/RecorderBase";
import * as log from "tc-shared/log";
import * as loader from "tc-loader";
import {LogCategory} from "tc-shared/log";
import * as aplayer from "./player";
import * as rbase from "tc-shared/voice/RecorderBase";

declare global {
    interface MediaStream {
        stop();
    }
}

let _queried_devices: JavascriptInputDevice[];
let _queried_permissioned: boolean = false;

export interface JavascriptInputDevice extends InputDevice {
    device_id: string;
    group_id: string;
}

function getUserMediaFunctionPromise() : (constraints: MediaStreamConstraints) => Promise<MediaStream> {
    if('mediaDevices' in navigator && 'getUserMedia' in navigator.mediaDevices)
        return constraints => navigator.mediaDevices.getUserMedia(constraints);

    const _callbacked_function = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
    if(!_callbacked_function)
        return undefined;

    return constraints => new Promise<MediaStream>((resolve, reject) => _callbacked_function(constraints, resolve, reject));
}

async function query_devices() {
    const general_supported = !!getUserMediaFunctionPromise();

    try {
        const context = aplayer.context();
        const devices = await navigator.mediaDevices.enumerateDevices();

        _queried_permissioned = false;
        if(devices.filter(e => !!e.label).length > 0)
            _queried_permissioned = true;

        _queried_devices = devices.filter(e => e.kind === "audioinput").map((e: MediaDeviceInfo): JavascriptInputDevice => {
            return {
                channels: context ? context.destination.channelCount : 2,
                sample_rate: context ? context.sampleRate : 44100,

                default_input: e.deviceId == "default",

                driver: "WebAudio",
                name: e.label || "device-id{" + e.deviceId+ "}",

                supported: general_supported,

                device_id: e.deviceId,
                group_id: e.groupId,

                unique_id: e.deviceId
            }
        });
        if(_queried_devices.length > 0 && _queried_devices.filter(e => e.default_input).length == 0)
            _queried_devices[0].default_input = true;
    } catch(error) {
        log.error(LogCategory.AUDIO, tr("Failed to query microphone devices (%o)"), error);
        _queried_devices = [];
    }
}

export function devices() : InputDevice[] {
    if(typeof(_queried_devices) === "undefined")
        query_devices();

    return _queried_devices || [];
}


export function device_refresh_available() : boolean { return true; }
export function refresh_devices() : Promise<void> { return query_devices(); }

export function create_input() : AbstractInput { return new JavascriptInput(); }

export async function create_levelmeter(device: InputDevice) : Promise<LevelMeter> {
    const meter = new JavascriptLevelmeter(device as any);
    await meter.initialize();
    return meter;
}

loader.register_task(loader.Stage.JAVASCRIPT_INITIALIZING, {
    function: async () => { query_devices(); }, /* May wait for it? */
    priority: 10,
    name: "query media devices"
});

export namespace filter {
    export abstract class JAbstractFilter<NodeType extends AudioNode> implements rbase.filter.Filter {
        type;

        source_node: AudioNode;
        audio_node: NodeType;

        context: AudioContext;
        enabled: boolean = false;

        active: boolean = false; /* if true the filter filters! */
        callback_active_change: (new_state: boolean) => any;

        paused: boolean = true;

        abstract initialize(context: AudioContext, source_node: AudioNode);
        abstract finalize();

        /* whatever the input has been paused and we don't expect any input */
        abstract set_pause(flag: boolean);

        is_enabled(): boolean {
            return this.enabled;
        }
    }

    export class JThresholdFilter extends JAbstractFilter<GainNode> implements rbase.filter.ThresholdFilter {
        public static update_task_interval = 20; /* 20ms */

        type = rbase.filter.Type.THRESHOLD;
        callback_level?: (value: number) => any;

        private _threshold = 50;

        private _update_task: any;
        private _analyser: AnalyserNode;
        private _analyse_buffer: Uint8Array;

        private _silence_count = 0;
        private _margin_frames = 5;

        private _current_level = 0;
        private _smooth_release = 0;
        private _smooth_attack = 0;

        finalize() {
            this.set_pause(true);

            if(this.source_node) {
                try { this.source_node.disconnect(this._analyser) } catch (error) {}
                try { this.source_node.disconnect(this.audio_node) } catch (error) {}
            }

            this._analyser = undefined;
            this.source_node = undefined;
            this.audio_node = undefined;
            this.context = undefined;
        }

        initialize(context: AudioContext, source_node: AudioNode) {
            this.context = context;
            this.source_node = source_node;

            this.audio_node = context.createGain();
            this._analyser = context.createAnalyser();

            const optimal_ftt_size = Math.ceil((source_node.context || context).sampleRate * (JThresholdFilter.update_task_interval / 1000));
            const base2_ftt = Math.pow(2, Math.ceil(Math.log2(optimal_ftt_size)));
            this._analyser.fftSize = base2_ftt;

            if(!this._analyse_buffer || this._analyse_buffer.length < this._analyser.fftSize)
                this._analyse_buffer = new Uint8Array(this._analyser.fftSize);

            this.active = false;
            this.audio_node.gain.value = 1;

            this.source_node.connect(this.audio_node);
            this.source_node.connect(this._analyser);

            /* force update paused state */
            this.set_pause(!(this.paused = !this.paused));
        }

        get_margin_frames(): number { return this._margin_frames; }
        set_margin_frames(value: number) {
            this._margin_frames = value;
        }

        get_attack_smooth(): number {
            return this._smooth_attack;
        }

        get_release_smooth(): number {
            return this._smooth_release;
        }

        set_attack_smooth(value: number) {
            this._smooth_attack = value;
        }

        set_release_smooth(value: number) {
            this._smooth_release = value;
        }

        get_threshold(): number {
            return this._threshold;
        }

        set_threshold(value: number): Promise<void> {
            this._threshold = value;
            return Promise.resolve();
        }

        public static process(buffer: Uint8Array, ftt_size: number, previous: number, smooth: number) {
            let level;
            {
                let total = 0, float, rms;

                for(let index = 0; index < ftt_size; index++) {
                    float = ( buffer[index++] / 0x7f ) - 1;
                    total += (float * float);
                }
                rms = Math.sqrt(total / ftt_size);
                let db  = 20 * ( Math.log(rms) / Math.log(10) );
                // sanity check

                db = Math.max(-192, Math.min(db, 0));
                level = 100 + ( db * 1.92 );
            }

            return previous * smooth + level * (1 - smooth);
        }

        private _analyse() {
            this._analyser.getByteTimeDomainData(this._analyse_buffer);

            let smooth;
            if(this._silence_count == 0)
                smooth = this._smooth_release;
            else
                smooth = this._smooth_attack;

            this._current_level = JThresholdFilter.process(this._analyse_buffer, this._analyser.fftSize, this._current_level, smooth);

            this._update_gain_node();
            if(this.callback_level)
                this.callback_level(this._current_level);
        }

        private _update_gain_node() {
            let state;
            if(this._current_level > this._threshold) {
                this._silence_count = 0;
                state = true;
            } else {
                state = this._silence_count++ < this._margin_frames;
            }
            if(state) {
                this.audio_node.gain.value = 1;
                if(this.active) {
                    this.active = false;
                    this.callback_active_change(false);
                }
            } else {
                this.audio_node.gain.value = 0;
                if(!this.active) {
                    this.active = true;
                    this.callback_active_change(true);
                }
            }
        }

        set_pause(flag: boolean) {
            if(flag === this.paused) return;
            this.paused = flag;

            if(this.paused) {
                clearInterval(this._update_task);
                this._update_task = undefined;

                if(this.active) {
                    this.active = false;
                    this.callback_active_change(false);
                }
            } else {
                if(!this._update_task && this._analyser)
                    this._update_task = setInterval(() => this._analyse(), JThresholdFilter.update_task_interval);
            }
        }
    }

    export class JStateFilter extends JAbstractFilter<GainNode> implements rbase.filter.StateFilter {
        type = rbase.filter.Type.STATE;

        finalize() {
            if(this.source_node) {
                try { this.source_node.disconnect(this.audio_node) } catch (error) {}
            }

            this.source_node = undefined;
            this.audio_node = undefined;
            this.context = undefined;
        }

        initialize(context: AudioContext, source_node: AudioNode) {
            this.context = context;
            this.source_node = source_node;

            this.audio_node = context.createGain();
            this.audio_node.gain.value = this.active ? 0 : 1;

            this.source_node.connect(this.audio_node);
        }

        is_active(): boolean {
            return this.active;
        }

        set_state(state: boolean): Promise<void> {
            if(this.active === state)
                return Promise.resolve();

            this.active = state;
            if(this.audio_node)
                this.audio_node.gain.value = state ? 0 : 1;
            this.callback_active_change(state);
            return Promise.resolve();
        }

        set_pause(flag: boolean) {
            this.paused = flag;
        }
    }
}

class JavascriptInput implements AbstractInput {
    private _state: InputState = InputState.PAUSED;
    private _current_device: JavascriptInputDevice | undefined;
    private _current_consumer: InputConsumer;

    private _current_stream: MediaStream;
    private _current_audio_stream: MediaStreamAudioSourceNode;

    private _audio_context: AudioContext;
    private _source_node: AudioNode; /* last node which could be connected to the target; target might be the _consumer_node */
    private _consumer_callback_node: ScriptProcessorNode;
    private readonly _consumer_audio_callback;
    private _volume_node: GainNode;
    private _mute_node: GainNode;

    private _filters: rbase.filter.Filter[] = [];
    private _filter_active: boolean = false;

    private _volume: number = 1;

    callback_begin: () => any = undefined;
    callback_end: () => any = undefined;

    constructor() {
        aplayer.on_ready(() => this._audio_initialized());
        this._consumer_audio_callback = this._audio_callback.bind(this);
    }

    private _audio_initialized() {
        this._audio_context = aplayer.context();
        if(!this._audio_context)
            return;

        this._mute_node = this._audio_context.createGain();
        this._mute_node.gain.value = 0;
        this._mute_node.connect(this._audio_context.destination);

        this._consumer_callback_node = this._audio_context.createScriptProcessor(1024 * 4);
        this._consumer_callback_node.connect(this._mute_node);

        this._volume_node = this._audio_context.createGain();
        this._volume_node.gain.value = this._volume;

        this._initialize_filters();
        if(this._state === InputState.INITIALIZING)
            this.start();
    }

    private _initialize_filters() {
        const filters = this._filters as any as filter.JAbstractFilter<AudioNode>[];
        for(const filter of filters) {
            if(filter.is_enabled())
                filter.finalize();
        }

        if(this._audio_context && this._volume_node) {
            const active_filter = filters.filter(e => e.is_enabled());
            let stream: AudioNode = this._volume_node;
            for(const f of active_filter) {
                f.initialize(this._audio_context, stream);
                stream = f.audio_node;
            }
            this._switch_source_node(stream);
        }
    }

    private _audio_callback(event: AudioProcessingEvent) {
        if(!this._current_consumer || this._current_consumer.type !== InputConsumerType.CALLBACK)
            return;

        const callback = this._current_consumer as CallbackInputConsumer;
        if(callback.callback_audio)
            callback.callback_audio(event.inputBuffer);

        if(callback.callback_buffer) {
            log.warn(LogCategory.AUDIO, tr("AudioInput has callback buffer, but this isn't supported yet!"));
        }
    }

    current_state() : InputState { return this._state; };

    private _start_promise: Promise<InputStartResult>;
    async start() : Promise<InputStartResult> {
        if(this._start_promise) {
            try {
                await this._start_promise;
                if(this._state != InputState.PAUSED)
                    return;
            } catch(error) {
                log.debug(LogCategory.AUDIO, tr("JavascriptInput:start() Start promise await resulted in an error: %o"), error);
            }
        }

        return await (this._start_promise = this._start());
    }

    /* request permission for devices only one per time! */
    private static _running_request: Promise<MediaStream | InputStartResult>;
    static async request_media_stream(device_id: string, group_id: string) : Promise<MediaStream | InputStartResult> {
        while(this._running_request) {
            try {
                await this._running_request;
            } catch(error) { }
        }
        const promise = (this._running_request = this.request_media_stream0(device_id, group_id));
        try {
            return await this._running_request;
        } finally {
            if(this._running_request === promise)
                this._running_request = undefined;
        }
    }

    static async request_media_stream0(device_id: string, group_id: string) : Promise<MediaStream | InputStartResult> {
        const media_function = getUserMediaFunctionPromise();
        if(!media_function) return InputStartResult.ENOTSUPPORTED;

        try {
            log.info(LogCategory.AUDIO, tr("Requesting a microphone stream for device %s in group %s"), device_id, group_id);

            const audio_constrains: MediaTrackConstraints = {};
            audio_constrains.deviceId = device_id;
            audio_constrains.groupId = group_id;

            audio_constrains.echoCancellation = true;
            audio_constrains.autoGainControl = true;
            audio_constrains.noiseSuppression = true;
            /* disabled because most the time we get a OverconstrainedError */ //audio_constrains.sampleSize = {min: 420, max: 960 * 10, ideal: 960};

            const stream = await media_function({
                audio: audio_constrains,
                video: undefined
            });
            if(!_queried_permissioned) query_devices(); /* we now got permissions, requery devices */
            return stream;
        } catch(error) {
            if('name' in error) {
                if(error.name === "NotAllowedError") {
                    //createErrorModal(tr("Failed to create microphone"), tr("Microphone recording failed. Please allow TeaWeb access to your microphone")).open();
                    //FIXME: Move this to somewhere else!

                    log.warn(LogCategory.AUDIO, tr("Microphone request failed (No permissions). Browser message: %o"), error.message);
                    return InputStartResult.ENOTALLOWED;
                } else {
                    log.warn(LogCategory.AUDIO, tr("Microphone request failed. Request resulted in error: %o: %o"), error.name, error);
                }
            } else {
                log.warn(LogCategory.AUDIO, tr("Failed to initialize recording stream (%o)"), error);
            }
            return InputStartResult.EUNKNOWN;
        }
    }

    private async _start() : Promise<InputStartResult> {
        try {
            if(this._state != InputState.PAUSED)
                throw tr("recorder already started");

            this._state = InputState.INITIALIZING;
            if(!this._current_device)
                throw tr("invalid device");

            if(!this._audio_context) {
                debugger;
                throw tr("missing audio context");
            }

            const _result = await JavascriptInput.request_media_stream(this._current_device.device_id, this._current_device.group_id);
            if(!(_result instanceof MediaStream)) {
                this._state = InputState.PAUSED;
                return _result;
            }
            this._current_stream = _result;

            for(const f of this._filters)
                if(f.is_enabled() && f instanceof filter.JAbstractFilter)
                    f.set_pause(false);
            this._consumer_callback_node.addEventListener('audioprocess', this._consumer_audio_callback);

            this._current_audio_stream = this._audio_context.createMediaStreamSource(this._current_stream);
            this._current_audio_stream.connect(this._volume_node);
            this._state = InputState.RECORDING;
            return InputStartResult.EOK;
        } catch(error) {
            if(this._state == InputState.INITIALIZING) {
                this._state = InputState.PAUSED;
            }
            throw error;
        } finally {
            this._start_promise = undefined;
        }
    }

    async stop() {
        /* await all starts */
        try {
            if(this._start_promise)
                await this._start_promise;
        } catch(error) {}

        this._state = InputState.PAUSED;
        if(this._current_audio_stream)
            this._current_audio_stream.disconnect();

        if(this._current_stream) {
            if(this._current_stream.stop)
                this._current_stream.stop();
            else
                this._current_stream.getTracks().forEach(value => {
                    value.stop();
                });
        }

        this._current_stream = undefined;
        this._current_audio_stream = undefined;
        for(const f of this._filters)
            if(f.is_enabled() && f instanceof filter.JAbstractFilter)
                f.set_pause(true);
        if(this._consumer_callback_node)
            this._consumer_callback_node.removeEventListener('audioprocess', this._consumer_audio_callback);
        return undefined;
    }


    current_device(): InputDevice | undefined {
        return this._current_device;
    }

    async set_device(device: InputDevice | undefined) {
        if(this._current_device === device)
            return;


        const saved_state = this._state;
        try {
            await this.stop();
        } catch(error) {
            log.warn(LogCategory.AUDIO, tr("Failed to stop previous record session (%o)"), error);
        }

        this._current_device = device as any; /* TODO: Test for device_id and device_group */
        if(!device) {
            this._state = saved_state === InputState.PAUSED ? InputState.PAUSED : InputState.DRY;
            return;
        }

        if(saved_state !== InputState.PAUSED) {
            try {
                await this.start()
            } catch(error) {
                log.warn(LogCategory.AUDIO, tr("Failed to start new recording stream (%o)"), error);
                throw "failed to start record";
            }
        }
        return;
    }


    get_filter(type: rbase.filter.Type): rbase.filter.Filter | undefined {
        for(const filter of this._filters)
            if(filter.type == type)
                return filter;

        let new_filter: filter.JAbstractFilter<AudioNode>;
        switch (type) {
            case rbase.filter.Type.STATE:
                new_filter = new filter.JStateFilter();
                break;
            case rbase.filter.Type.VOICE_LEVEL:
                throw "voice filter isn't supported!";
            case rbase.filter.Type.THRESHOLD:
                new_filter = new filter.JThresholdFilter();
                break;
            default:
                throw "invalid filter type, or type isn't implemented! (" + type + ")";
        }

        new_filter.callback_active_change = () => this._recalculate_filter_status();
        this._filters.push(new_filter as any);
        this.enable_filter(type);
        return new_filter as any;
    }

    supports_filter(type: rbase.filter.Type) : boolean {
        switch (type) {
            case rbase.filter.Type.THRESHOLD:
            case rbase.filter.Type.STATE:
                return true;
            default:
                return false;
        }
    }

    private find_filter(type: rbase.filter.Type) : filter.JAbstractFilter<AudioNode> | undefined {
        for(const filter of this._filters)
            if(filter.type == type)
                return filter as any;
        return undefined;
    }

    clear_filter() {
        for(const _filter of this._filters) {
            if(!_filter.is_enabled())
                continue;

            const c_filter = _filter as any as filter.JAbstractFilter<AudioNode>;
            c_filter.finalize();
            c_filter.enabled = false;
        }

        this._initialize_filters();
        this._recalculate_filter_status();
    }

    disable_filter(type: rbase.filter.Type) {
        const filter = this.find_filter(type);
        if(!filter) return;

        /* test if the filter is active */
        if(!filter.is_enabled())
            return;

        filter.enabled = false;
        filter.set_pause(true);
        filter.finalize();
        this._initialize_filters();
        this._recalculate_filter_status();
    }

    enable_filter(type: rbase.filter.Type) {
        const filter = this.get_filter(type) as any as filter.JAbstractFilter<AudioNode>;
        if(filter.is_enabled())
            return;

        filter.enabled = true;
        filter.set_pause(typeof this._current_audio_stream !== "object");
        this._initialize_filters();
        this._recalculate_filter_status();
    }

    private _recalculate_filter_status() {
        let filtered = this._filters.filter(e => e.is_enabled()).filter(e => (e as any as filter.JAbstractFilter<AudioNode>).active).length > 0;
        if(filtered === this._filter_active)
            return;

        this._filter_active = filtered;
        if(filtered) {
            if(this.callback_end)
                this.callback_end();
        } else {
            if(this.callback_begin)
                this.callback_begin();
        }
    }

    current_consumer(): InputConsumer | undefined {
        return this._current_consumer;
    }

    async set_consumer(consumer: InputConsumer) {
        if(this._current_consumer) {
            if(this._current_consumer.type == InputConsumerType.NODE) {
                if(this._source_node)
                    (this._current_consumer as NodeInputConsumer).callback_disconnect(this._source_node)
            } else if(this._current_consumer.type === InputConsumerType.CALLBACK) {
                if(this._source_node)
                    this._source_node.disconnect(this._consumer_callback_node);
            }
        }

        if(consumer) {
            if(consumer.type == InputConsumerType.CALLBACK) {
                if(this._source_node)
                    this._source_node.connect(this._consumer_callback_node);
            } else if(consumer.type == InputConsumerType.NODE) {
                if(this._source_node)
                    (consumer as NodeInputConsumer).callback_node(this._source_node);
            } else {
                throw "native callback consumers are not supported!";
            }
        }
        this._current_consumer = consumer;
    }

    private _switch_source_node(new_node: AudioNode) {
        if(this._current_consumer) {
            if(this._current_consumer.type == InputConsumerType.NODE) {
                const node_consumer = this._current_consumer as NodeInputConsumer;
                if(this._source_node)
                    node_consumer.callback_disconnect(this._source_node);
                if(new_node)
                    node_consumer.callback_node(new_node);
            } else if(this._current_consumer.type == InputConsumerType.CALLBACK) {
                this._source_node.disconnect(this._consumer_callback_node);
                if(new_node)
                    new_node.connect(this._consumer_callback_node);
            }
        }
        this._source_node = new_node;
    }

    get_volume(): number {
        return this._volume;
    }

    set_volume(volume: number) {
        if(volume === this._volume)
            return;
        this._volume = volume;
        this._volume_node.gain.value = volume;
    }
}

class JavascriptLevelmeter implements LevelMeter {
    private static _instances: JavascriptLevelmeter[] = [];
    private static _update_task: number;

    readonly _device: JavascriptInputDevice;

    private _callback: (num: number) => any;

    private _context: AudioContext;
    private _gain_node: GainNode;
    private _source_node: MediaStreamAudioSourceNode;
    private _analyser_node: AnalyserNode;

    private _media_stream: MediaStream;

    private _analyse_buffer: Uint8Array;

    private _current_level = 0;

    constructor(device: JavascriptInputDevice) {
        this._device = device;
    }

    async initialize() {
        try {
            await new Promise((resolve, reject) => {
                const timeout = setTimeout(reject, 5000);
                aplayer.on_ready(() => {
                    clearTimeout(timeout);
                    resolve();
                });
            });
        } catch(error) {
            throw tr("audio context timeout");
        }
        this._context = aplayer.context();
        if(!this._context) throw tr("invalid context");

        this._gain_node = this._context.createGain();
        this._gain_node.gain.setValueAtTime(0, 0);

        /* analyser node */
        this._analyser_node = this._context.createAnalyser();

        const optimal_ftt_size = Math.ceil(this._context.sampleRate * (filter.JThresholdFilter.update_task_interval / 1000));
        this._analyser_node.fftSize = Math.pow(2, Math.ceil(Math.log2(optimal_ftt_size)));

        if(!this._analyse_buffer || this._analyse_buffer.length < this._analyser_node.fftSize)
            this._analyse_buffer = new Uint8Array(this._analyser_node.fftSize);

        /* starting stream */
        const _result = await JavascriptInput.request_media_stream(this._device.device_id, this._device.group_id);
        if(!(_result instanceof MediaStream)){
            if(_result === InputStartResult.ENOTALLOWED)
                throw tr("No permissions");
            if(_result === InputStartResult.ENOTSUPPORTED)
                throw tr("Not supported");
            if(_result === InputStartResult.EBUSY)
                throw tr("Device busy");
            if(_result === InputStartResult.EUNKNOWN)
                throw tr("an error occurred");
            throw _result;
        }
        this._media_stream = _result;

        this._source_node = this._context.createMediaStreamSource(this._media_stream);
        this._source_node.connect(this._analyser_node);
        this._analyser_node.connect(this._gain_node);
        this._gain_node.connect(this._context.destination);

        JavascriptLevelmeter._instances.push(this);
        if(JavascriptLevelmeter._instances.length == 1) {
            clearInterval(JavascriptLevelmeter._update_task);
            JavascriptLevelmeter._update_task = setInterval(() => JavascriptLevelmeter._analyse_all(), filter.JThresholdFilter.update_task_interval) as any;
        }
    }

    destory() {
        JavascriptLevelmeter._instances.remove(this);
        if(JavascriptLevelmeter._instances.length == 0) {
            clearInterval(JavascriptLevelmeter._update_task);
            JavascriptLevelmeter._update_task = 0;
        }

        if(this._source_node) {
            this._source_node.disconnect();
            this._source_node = undefined;
        }
        if(this._media_stream) {
            if(this._media_stream.stop)
                this._media_stream.stop();
            else
                this._media_stream.getTracks().forEach(value => {
                    value.stop();
                });
            this._media_stream = undefined;
        }
        if(this._gain_node) {
            this._gain_node.disconnect();
            this._gain_node = undefined;
        }
        if(this._analyser_node) {
            this._analyser_node.disconnect();
            this._analyser_node = undefined;
        }
    }

    device(): InputDevice {
        return this._device;
    }

    set_observer(callback: (value: number) => any) {
        this._callback = callback;
    }

    private static _analyse_all() {
        for(const instance of [...this._instances])
            instance._analyse();
    }

    private _analyse() {
        this._analyser_node.getByteTimeDomainData(this._analyse_buffer);

        this._current_level = filter.JThresholdFilter.process(this._analyse_buffer, this._analyser_node.fftSize, this._current_level, .75);
        if(this._callback)
            this._callback(this._current_level);
    }
}