/**
 * @license
 * Copyright 2017 Google Inc. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * @file Complete room model with early and late reflections.
 * @author Andrew Allen <bitllama@google.com>
 */
'use strict';
// Internal dependencies.
import LateReflections from './late-reflections.js';
import EarlyReflections from './early-reflections.js';
import Utils from './utils.js';
/**
 * Generate absorption coefficients from material names.
 * @param {Object} materials
 * @return {Object}
 */
function _getCoefficientsFromMaterials(materials) {
    // Initialize coefficients to use defaults.
    let coefficients = {};
    for (let property in Utils.DEFAULT_ROOM_MATERIALS) {
        if (Utils.DEFAULT_ROOM_MATERIALS.hasOwnProperty(property)) {
            coefficients[property] = Utils.ROOM_MATERIAL_COEFFICIENTS[Utils.DEFAULT_ROOM_MATERIALS[property]];
        }
    }
    // Sanitize materials.
    if (materials == undefined) {
        materials = {};
        Object.assign(materials, Utils.DEFAULT_ROOM_MATERIALS);
    }
    // Assign coefficients using provided materials.
    for (let property in Utils.DEFAULT_ROOM_MATERIALS) {
        if (Utils.DEFAULT_ROOM_MATERIALS.hasOwnProperty(property) &&
            materials.hasOwnProperty(property)) {
            if (materials[property] in Utils.ROOM_MATERIAL_COEFFICIENTS) {
                coefficients[property] =
                    Utils.ROOM_MATERIAL_COEFFICIENTS[materials[property]];
            }
            else {
                Utils.log('Material \"' + materials[property] + '\" on wall \"' +
                    property + '\" not found. Using \"' +
                    Utils.DEFAULT_ROOM_MATERIALS[property] + '\".');
            }
        }
        else {
            Utils.log('Wall \"' + property + '\" is not defined. Default used.');
        }
    }
    return coefficients;
}
/**
 * Sanitize coefficients.
 * @param {Object} coefficients
 * @return {Object}
 */
function _sanitizeCoefficients(coefficients) {
    if (coefficients == undefined) {
        coefficients = {};
    }
    for (let property in Utils.DEFAULT_ROOM_MATERIALS) {
        if (!(coefficients.hasOwnProperty(property))) {
            // If element is not present, use default coefficients.
            coefficients[property] = Utils.ROOM_MATERIAL_COEFFICIENTS[Utils.DEFAULT_ROOM_MATERIALS[property]];
        }
    }
    return coefficients;
}
/**
 * Sanitize dimensions.
 * @param {Utils~RoomDimensions} dimensions
 * @return {Utils~RoomDimensions}
 */
function _sanitizeDimensions(dimensions) {
    if (dimensions == undefined) {
        dimensions = {};
    }
    for (let property in Utils.DEFAULT_ROOM_DIMENSIONS) {
        if (!(dimensions.hasOwnProperty(property))) {
            dimensions[property] = Utils.DEFAULT_ROOM_DIMENSIONS[property];
        }
    }
    return dimensions;
}
/**
 * Compute frequency-dependent reverb durations.
 * @param {Utils~RoomDimensions} dimensions
 * @param {Object} coefficients
 * @param {Number} speedOfSound
 * @return {Array}
 */
function _getDurationsFromProperties(dimensions, coefficients, speedOfSound) {
    let durations = new Float32Array(Utils.NUMBER_REVERB_FREQUENCY_BANDS);
    // Sanitize inputs.
    dimensions = _sanitizeDimensions(dimensions);
    coefficients = _sanitizeCoefficients(coefficients);
    if (speedOfSound == undefined) {
        speedOfSound = Utils.DEFAULT_SPEED_OF_SOUND;
    }
    // Acoustic constant.
    let k = Utils.TWENTY_FOUR_LOG10 / speedOfSound;
    // Compute volume, skip if room is not present.
    let volume = dimensions.width * dimensions.height * dimensions.depth;
    if (volume < Utils.ROOM_MIN_VOLUME) {
        return durations;
    }
    // Room surface area.
    let leftRightArea = dimensions.width * dimensions.height;
    let floorCeilingArea = dimensions.width * dimensions.depth;
    let frontBackArea = dimensions.depth * dimensions.height;
    let totalArea = 2 * (leftRightArea + floorCeilingArea + frontBackArea);
    for (let i = 0; i < Utils.NUMBER_REVERB_FREQUENCY_BANDS; i++) {
        // Effective absorptive area.
        let absorbtionArea = (coefficients.left[i] + coefficients.right[i]) * leftRightArea +
            (coefficients.down[i] + coefficients.up[i]) * floorCeilingArea +
            (coefficients.front[i] + coefficients.back[i]) * frontBackArea;
        let meanAbsorbtionArea = absorbtionArea / totalArea;
        // Compute reverberation using Eyring equation [1].
        // [1] Beranek, Leo L. "Analysis of Sabine and Eyring equations and their
        //     application to concert hall audience and chair absorption." The
        //     Journal of the Acoustical Society of America, Vol. 120, No. 3.
        //     (2006), pp. 1399-1399.
        durations[i] = Utils.ROOM_EYRING_CORRECTION_COEFFICIENT * k * volume /
            (-totalArea * Math.log(1 - meanAbsorbtionArea) + 4 *
                Utils.ROOM_AIR_ABSORPTION_COEFFICIENTS[i] * volume);
    }
    return durations;
}
/**
 * Compute reflection coefficients from absorption coefficients.
 * @param {Object} absorptionCoefficients
 * @return {Object}
 */
function _computeReflectionCoefficients(absorptionCoefficients) {
    let reflectionCoefficients = [];
    for (let property in Utils.DEFAULT_REFLECTION_COEFFICIENTS) {
        if (Utils.DEFAULT_REFLECTION_COEFFICIENTS
            .hasOwnProperty(property)) {
            // Compute average absorption coefficient (per wall).
            reflectionCoefficients[property] = 0;
            for (let j = 0; j < Utils.NUMBER_REFLECTION_AVERAGING_BANDS; j++) {
                let bandIndex = j + Utils.ROOM_STARTING_AVERAGING_BAND;
                reflectionCoefficients[property] +=
                    absorptionCoefficients[property][bandIndex];
            }
            reflectionCoefficients[property] /=
                Utils.NUMBER_REFLECTION_AVERAGING_BANDS;
            // Convert absorption coefficient to reflection coefficient.
            reflectionCoefficients[property] =
                Math.sqrt(1 - reflectionCoefficients[property]);
        }
    }
    return reflectionCoefficients;
}
/**
 * @class Room
 * @description Model that manages early and late reflections using acoustic
 * properties and listener position relative to a rectangular room.
 * @param {AudioContext} context
 * Associated {@link
https://developer.mozilla.org/en-US/docs/Web/API/AudioContext AudioContext}.
 * @param {Object} options
 * @param {Float32Array} options.listenerPosition
 * The listener's initial position (in meters), where origin is the center of
 * the room. Defaults to {@linkcode Utils.DEFAULT_POSITION DEFAULT_POSITION}.
 * @param {Utils~RoomDimensions} options.dimensions Room dimensions (in meters). Defaults to
 * {@linkcode Utils.DEFAULT_ROOM_DIMENSIONS DEFAULT_ROOM_DIMENSIONS}.
 * @param {Utils~RoomMaterials} options.materials Named acoustic materials per wall.
 * Defaults to {@linkcode Utils.DEFAULT_ROOM_MATERIALS DEFAULT_ROOM_MATERIALS}.
 * @param {Number} options.speedOfSound
 * (in meters/second). Defaults to
 * {@linkcode Utils.DEFAULT_SPEED_OF_SOUND DEFAULT_SPEED_OF_SOUND}.
 */
class Room {
    constructor(context, options) {
        // Public variables.
        /**
         * EarlyReflections {@link EarlyReflections EarlyReflections} submodule.
         * @member {AudioNode} early
         * @memberof Room
         * @instance
         */
        /**
         * LateReflections {@link LateReflections LateReflections} submodule.
         * @member {AudioNode} late
         * @memberof Room
         * @instance
         */
        /**
         * Ambisonic (multichannel) output {@link
         * https://developer.mozilla.org/en-US/docs/Web/API/AudioNode AudioNode}.
         * @member {AudioNode} output
         * @memberof Room
         * @instance
         */
        // Use defaults for undefined arguments.
        if (options == undefined) {
            options = {};
        }
        if (options.listenerPosition == undefined) {
            options.listenerPosition = Utils.DEFAULT_POSITION.slice();
        }
        if (options.dimensions == undefined) {
            options.dimensions = {};
            Object.assign(options.dimensions, Utils.DEFAULT_ROOM_DIMENSIONS);
        }
        if (options.materials == undefined) {
            options.materials = {};
            Object.assign(options.materials, Utils.DEFAULT_ROOM_MATERIALS);
        }
        if (options.speedOfSound == undefined) {
            options.speedOfSound = Utils.DEFAULT_SPEED_OF_SOUND;
        }
        // Sanitize room-properties-related arguments.
        options.dimensions = _sanitizeDimensions(options.dimensions);
        let absorptionCoefficients = _getCoefficientsFromMaterials(options.materials);
        let reflectionCoefficients = _computeReflectionCoefficients(absorptionCoefficients);
        let durations = _getDurationsFromProperties(options.dimensions, absorptionCoefficients, options.speedOfSound);
        // Construct submodules for early and late reflections.
        this.early = new EarlyReflections(context, {
            dimensions: options.dimensions,
            coefficients: reflectionCoefficients,
            speedOfSound: options.speedOfSound,
            listenerPosition: options.listenerPosition,
        });
        this.late = new LateReflections(context, {
            durations: durations,
        });
        this.speedOfSound = options.speedOfSound;
        // Construct auxillary audio nodes.
        this.output = context.createGain();
        this.early.output.connect(this.output);
        this._merger = context.createChannelMerger(4);
        this.late.output.connect(this._merger, 0, 0);
        this._merger.connect(this.output);
    }
    /**
     * Set the room's dimensions and wall materials.
     * @param {Utils~RoomDimensions} dimensions Room dimensions (in meters). Defaults to
     * {@linkcode Utils.DEFAULT_ROOM_DIMENSIONS DEFAULT_ROOM_DIMENSIONS}.
     * @param {Utils~RoomMaterials} materials Named acoustic materials per wall. Defaults to
     * {@linkcode Utils.DEFAULT_ROOM_MATERIALS DEFAULT_ROOM_MATERIALS}.
     */
    setProperties(dimensions, materials) {
        // Compute late response.
        let absorptionCoefficients = _getCoefficientsFromMaterials(materials);
        let durations = _getDurationsFromProperties(dimensions, absorptionCoefficients, this.speedOfSound);
        this.late.setDurations(durations);
        // Compute early response.
        this.early.speedOfSound = this.speedOfSound;
        let reflectionCoefficients = _computeReflectionCoefficients(absorptionCoefficients);
        this.early.setRoomProperties(dimensions, reflectionCoefficients);
    }
    /**
     * Set the listener's position (in meters), where origin is the center of
     * the room.
     * @param {Number} x
     * @param {Number} y
     * @param {Number} z
     */
    setListenerPosition(x, y, z) {
        this.early.speedOfSound = this.speedOfSound;
        this.early.setListenerPosition(x, y, z);
        // Disable room effects if the listener is outside the room boundaries.
        let distance = this.getDistanceOutsideRoom(x, y, z);
        let gain = 1;
        if (distance > Utils.EPSILON_FLOAT) {
            gain = 1 - distance / Utils.LISTENER_MAX_OUTSIDE_ROOM_DISTANCE;
            // Clamp gain between 0 and 1.
            gain = Math.max(0, Math.min(1, gain));
        }
        this.output.gain.value = gain;
    }
    /**
     * Compute distance outside room of provided position (in meters).
     * @param {Number} x
     * @param {Number} y
     * @param {Number} z
     * @return {Number}
     * Distance outside room (in meters). Returns 0 if inside room.
     */
    getDistanceOutsideRoom(x, y, z) {
        let dx = Math.max(0, -this.early._halfDimensions.width - x, x - this.early._halfDimensions.width);
        let dy = Math.max(0, -this.early._halfDimensions.height - y, y - this.early._halfDimensions.height);
        let dz = Math.max(0, -this.early._halfDimensions.depth - z, z - this.early._halfDimensions.depth);
        return Math.sqrt(dx * dx + dy * dy + dz * dz);
    }
}
export default Room;