// A biquad filter has a z-transform of
// H(z) = (b0 + b1 / z + b2 / z^2) / (1 + a1 / z + a2 / z^2)
//
// The formulas for the various filters were taken from
// http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt.


// Lowpass filter.
function createLowpassFilter(freq, q, gain) {
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;

  if (freq == 1) {
    // The formula below works, except for roundoff.  When freq = 1,
    // the filter is just a wire, so hardwire the coefficients.
    b0 = 1;
    b1 = 0;
    b2 = 0;
    a0 = 1;
    a1 = 0;
    a2 = 0;
  } else {
    let theta = Math.PI * freq;
    let alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
    let cosw = Math.cos(theta);
    let beta = (1 - cosw) / 2;

    b0 = beta;
    b1 = 2 * beta;
    b2 = beta;
    a0 = 1 + alpha;
    a1 = -2 * cosw;
    a2 = 1 - alpha;
  }

  return normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
}

function createHighpassFilter(freq, q, gain) {
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;

  if (freq == 1) {
    // The filter is 0
    b0 = 0;
    b1 = 0;
    b2 = 0;
    a0 = 1;
    a1 = 0;
    a2 = 0;
  } else if (freq == 0) {
    // The filter is 1.  Computation of coefficients below is ok, but
    // there's a pole at 1 and a zero at 1, so round-off could make
    // the filter unstable.
    b0 = 1;
    b1 = 0;
    b2 = 0;
    a0 = 1;
    a1 = 0;
    a2 = 0;
  } else {
    let theta = Math.PI * freq;
    let alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
    let cosw = Math.cos(theta);
    let beta = (1 + cosw) / 2;

    b0 = beta;
    b1 = -2 * beta;
    b2 = beta;
    a0 = 1 + alpha;
    a1 = -2 * cosw;
    a2 = 1 - alpha;
  }

  return normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
}

function normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2) {
  let scale = 1 / a0;

  return {
    b0: b0 * scale,
    b1: b1 * scale,
    b2: b2 * scale,
    a1: a1 * scale,
    a2: a2 * scale
  };
}

function createBandpassFilter(freq, q, gain) {
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;
  let coef;

  if (freq > 0 && freq < 1) {
    let w0 = Math.PI * freq;
    if (q > 0) {
      let alpha = Math.sin(w0) / (2 * q);
      let k = Math.cos(w0);

      b0 = alpha;
      b1 = 0;
      b2 = -alpha;
      a0 = 1 + alpha;
      a1 = -2 * k;
      a2 = 1 - alpha;

      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
    } else {
      // q = 0, and frequency is not 0 or 1.  The above formula has a
      // divide by zero problem.  The limit of the z-transform as q
      // approaches 0 is 1, so set the filter that way.
      coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
    }
  } else {
    // When freq = 0 or 1, the z-transform is identically 0,
    // independent of q.
    coef = { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 }
  }

  return coef;
}

function createLowShelfFilter(freq, q, gain) {
  // q not used
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;
  let coef;

  let S = 1;
  let A = Math.pow(10, gain / 40);

  if (freq == 1) {
    // The filter is just a constant gain
    coef = {b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0};
  } else if (freq == 0) {
    // The filter is 1
    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
  } else {
    let w0 = Math.PI * freq;
    let alpha = 1 / 2 * Math.sin(w0) * Math.sqrt((A + 1 / A) * (1 / S - 1) + 2);
    let k = Math.cos(w0);
    let k2 = 2 * Math.sqrt(A) * alpha;
    let Ap1 = A + 1;
    let Am1 = A - 1;

    b0 = A * (Ap1 - Am1 * k + k2);
    b1 = 2 * A * (Am1 - Ap1 * k);
    b2 = A * (Ap1 - Am1 * k - k2);
    a0 = Ap1 + Am1 * k + k2;
    a1 = -2 * (Am1 + Ap1 * k);
    a2 = Ap1 + Am1 * k - k2;
    coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
  }

  return coef;
}

function createHighShelfFilter(freq, q, gain) {
  // q not used
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;
  let coef;

  let A = Math.pow(10, gain / 40);

  if (freq == 1) {
    // When freq = 1, the z-transform is 1
    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
  } else if (freq > 0) {
    let w0 = Math.PI * freq;
    let S = 1;
    let alpha = 0.5 * Math.sin(w0) * Math.sqrt((A + 1 / A) * (1 / S - 1) + 2);
    let k = Math.cos(w0);
    let k2 = 2 * Math.sqrt(A) * alpha;
    let Ap1 = A + 1;
    let Am1 = A - 1;

    b0 = A * (Ap1 + Am1 * k + k2);
    b1 = -2 * A * (Am1 + Ap1 * k);
    b2 = A * (Ap1 + Am1 * k - k2);
    a0 = Ap1 - Am1 * k + k2;
    a1 = 2 * (Am1 - Ap1 * k);
    a2 = Ap1 - Am1 * k - k2;

    coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
  } else {
    // When freq = 0, the filter is just a gain
    coef = {b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0};
  }

  return coef;
}

function createPeakingFilter(freq, q, gain) {
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;
  let coef;

  let A = Math.pow(10, gain / 40);

  if (freq > 0 && freq < 1) {
    if (q > 0) {
      let w0 = Math.PI * freq;
      let alpha = Math.sin(w0) / (2 * q);
      let k = Math.cos(w0);

      b0 = 1 + alpha * A;
      b1 = -2 * k;
      b2 = 1 - alpha * A;
      a0 = 1 + alpha / A;
      a1 = -2 * k;
      a2 = 1 - alpha / A;

      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
    } else {
      // q = 0, we have a divide by zero problem in the formulas
      // above.  But if we look at the z-transform, we see that the
      // limit as q approaches 0 is A^2.
      coef = {b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0};
    }
  } else {
    // freq = 0 or 1, the z-transform is 1
    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
  }

  return coef;
}

function createNotchFilter(freq, q, gain) {
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;
  let coef;

  if (freq > 0 && freq < 1) {
    if (q > 0) {
      let w0 = Math.PI * freq;
      let alpha = Math.sin(w0) / (2 * q);
      let k = Math.cos(w0);

      b0 = 1;
      b1 = -2 * k;
      b2 = 1;
      a0 = 1 + alpha;
      a1 = -2 * k;
      a2 = 1 - alpha;
      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
    } else {
      // When q = 0, we get a divide by zero above.  The limit of the
      // z-transform as q approaches 0 is 0, so set the coefficients
      // appropriately.
      coef = {b0: 0, b1: 0, b2: 0, a1: 0, a2: 0};
    }
  } else {
    // When freq = 0 or 1, the z-transform is 1
    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
  }

  return coef;
}

function createAllpassFilter(freq, q, gain) {
  let b0;
  let b1;
  let b2;
  let a0;
  let a1;
  let a2;
  let coef;

  if (freq > 0 && freq < 1) {
    if (q > 0) {
      let w0 = Math.PI * freq;
      let alpha = Math.sin(w0) / (2 * q);
      let k = Math.cos(w0);

      b0 = 1 - alpha;
      b1 = -2 * k;
      b2 = 1 + alpha;
      a0 = 1 + alpha;
      a1 = -2 * k;
      a2 = 1 - alpha;
      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
    } else {
      // q = 0
      coef = {b0: -1, b1: 0, b2: 0, a1: 0, a2: 0};
    }
  } else {
    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
  }

  return coef;
}

function filterData(filterCoef, signal, len) {
  let y = new Array(len);
  let b0 = filterCoef.b0;
  let b1 = filterCoef.b1;
  let b2 = filterCoef.b2;
  let a1 = filterCoef.a1;
  let a2 = filterCoef.a2;

  // Prime the pump. (Assumes the signal has length >= 2!)
  y[0] = b0 * signal[0];
  y[1] = b0 * signal[1] + b1 * signal[0] - a1 * y[0];

  // Filter all of the signal that we have.
  for (let k = 2; k < Math.min(signal.length, len); ++k) {
    y[k] = b0 * signal[k] + b1 * signal[k - 1] + b2 * signal[k - 2] -
        a1 * y[k - 1] - a2 * y[k - 2];
  }

  // If we need to filter more, but don't have any signal left,
  // assume the signal is zero.
  for (let k = signal.length; k < len; ++k) {
    y[k] = -a1 * y[k - 1] - a2 * y[k - 2];
  }

  return y;
}

// Map the filter type name to a function that computes the filter coefficents
// for the given filter type.
let filterCreatorFunction = {
  'lowpass': createLowpassFilter,
  'highpass': createHighpassFilter,
  'bandpass': createBandpassFilter,
  'lowshelf': createLowShelfFilter,
  'highshelf': createHighShelfFilter,
  'peaking': createPeakingFilter,
  'notch': createNotchFilter,
  'allpass': createAllpassFilter
};

let filterTypeName = {
  'lowpass': 'Lowpass filter',
  'highpass': 'Highpass filter',
  'bandpass': 'Bandpass filter',
  'lowshelf': 'Lowshelf filter',
  'highshelf': 'Highshelf filter',
  'peaking': 'Peaking filter',
  'notch': 'Notch filter',
  'allpass': 'Allpass filter'
};

function createFilter(filterType, freq, q, gain) {
  return filterCreatorFunction[filterType](freq, q, gain);
}