var Intonation = (function(){
  var Intonation = function(opt){
    opt = this.opt = Object.assign({
      root: 440,
      octave: 0,
      interval: 2,
      tet: 0,
      intervals: null,
    }, opt || {})
    this.generate()
  }
  Intonation.prototype.generate = function(opt){
    opt = Object.assign(this.opt, opt || {})
    if (opt.tet) {
      this.generate_tet()
    }
    else if (opt.intervals) {
      this.generate_intervals()
    }
  }
  Intonation.prototype.generate_intervals = function(){
    var root = this.opt.root
    var interval_list = this.opt.intervals
    if (typeof interval_list == "string") {
      interval_list = interval_list.split(" ")
    }
    this.intervals = interval_list
    this.opt.interval = parseInterval.call(this, interval_list.pop() )
    this.scale = interval_list.map( parseIntervalString.bind(this) ).filter(function(v){
      return !! v
    })
  }
  Intonation.prototype.generate_tet = function(){
    var scale = this.scale = []
    var root = this.opt.root
    var tet = this.opt.tet
    var interval = this.opt.interval
    var ratio = Math.pow( interval, 1/tet )
    var n = root
    scale.push(n)
    for (var i = 0; i < tet; i++) {
      n *= ratio
      scale.push(n)
    }
    this.intervals = null
  }
  Intonation.prototype.index = function(i, octave){
    octave = octave || this.opt.octave
    var f = this.scale[ mod(i, this.scale.length)|0 ]
    var pow = Math.floor(norm(i, 0, this.scale.length)) + octave
    f *= Math.pow(this.opt.interval, pow)
    return f
  }
  Intonation.prototype.range = function(min, max){
    var a = []
    for (var i = min; i < max; i++) {
      a.push( this.index(i) )
    }
    return a
  }
  Intonation.prototype.set_root = function(f){
    this.opt.root = f
    this.generate()
  }
  Intonation.prototype.quantize_frequency = function(f){
    if (f == 0) return 0
    var scale_f = f
    var pow = 0
    var interval = this.opt.interval
    var scale = this.scale
    while (scale_f < root) {
      scale_f *= interval
      pow -= 1
    }
    while (scale_f > root * interval) {
      scale_f /= interval
      pow += 1
    }
    for (var i = 0; i < scale.length; i++) {
      if (scale_f > scale[i]) continue
      scale_f = scale[i]
      break
    }
    scale_f *= Math.pow(2, pow)
    return scale_f
  }
  Intonation.prototype.quantize_index = function(i){
    return mod(index-1, this.scale.length)|0
  }
  var parseInterval = Intonation.prototype.parse_interval = function (s) {
    if (typeof s == "number") return s
    if (! s.indexOf("/") == -1) return parseInt(s)
    var pp = s.split("/")
    var num = parseInt(pp[0])
    var den = parseInt(pp[1])
    if (isNaN(num)) return 1
    if (isNaN(den) || den == 0) return num
    if (num == den) return 1
    return num / den
  }
  var parseIntervalString = Intonation.prototype.parse_interval_string = function(s){
    if (s.indexOf("/") !== -1) return parseInterval(s) * this.opt.root // intervals
    if (s.indexOf("f") !== -1) return parseFloat(s)    // pure frequencies
    return parseFloat(s)
  }
  function norm(n,a,b){ return (n-a) / (b-a) }
  function mod(n,m){ return n-(m * Math.floor(n/m)) }

  return Intonation
})()