sclass PianoSampler {
  macro dprint { if (debug) printVars } bool debug;
    
  int channels = 1;
  double sampleRate = 48000;
  double currentSample;
  IQuerySound sound;
  IAudioSample audio;
  SlidingWindow window;
  
  long haarFeaturesChecked;

  persistable class Oscillator extends HasKey<Frequency> {
    double currentPeriodStart;
    // all recorded intensities
    new TreeMap<DoubleRange, Channels<Complex>> intensities;
    double interval; // in samples
    
    *(Frequency f) {
      super(f);
      interval = frequency().interval()*sampleRate;
    }
    
    Frequency frequency() { ret key(); }
    double interval() { ret interval; }
    
    void record_impl(DoubleRange r, Channels<Complex> c) {
      intensities.put(r, c);
    }
    
    void advancePeriodToRange(DoubleRange timeRange) {
      double end = currentPeriodStart + interval;
      int phaseShifts = ifloor((timeRange.start-end)/interval);
      if (phaseShifts = 0) ret;
      setStart(currentPeriodStart + phaseShifts*interval);
    }
    
    // we span a total range of interval*1.25 because of the sin/cos thing
    void measure(DoubleRange timeRange) {
      DoubleRange p1 = doubleRangeWithLength(phaseMinus90(), interval);
      p1 = intersectDoubleRanges(p1, timeRange);
      double re = 0;
      if (!isEmpty(p1)) {
        AudioHaarFeature haar = new(audio, p1);
        re = haar!;
      }
      
      DoubleRange p2 = doubleRangeWithLength(currentPeriodStart, interval);
      p2 = intersectDoubleRanges(p2, timeRange);
      double im = 0;
      if (!isEmpty(p2)) {
        AudioHaarFeature haar = new(audio, p2);
        im = haar!;
      }
      
      record(this, p1 /*TODO*/, complexChannels(re, im));
      haarFeaturesChecked += 2;
    }
    
    void dropMeasurementsLeftOf(double t) {
      while ping (true) {
        var r = firstKey(intensities);
        if (r != null && r.end() <= t)
          popFirst(intensities);
        else
          break;
      }
    }
    
    void initial(double currentSample) {
      setStart(currentSample + startPhase());
    }
    
    void moveTo(double time) {
      currentPeriodStart = time;
      double next = phase360();
      dprint("moveTo", +this, +next);
      completionsForSample.put(next, this);
    }
    
    double startPhase() { ret phase90(); }
    
    double quarterPhase() { ret interval()*.25; }
    
    double phaseMinus90() { ret currentPeriodStart - interval()*.25; }
    double phase0() { ret currentPeriodStart; }
    double phase90() { ret currentPeriodStart + interval()*.25; }
    double phase180() { ret currentPeriodStart + interval()*.5; }
    double phase270() { ret currentPeriodStart + interval()*.75; }
    double phase360() { ret currentPeriodStart + interval(); }
    double phase450() { ret currentPeriodStart + interval()*1.25; }
  } // end of Oscillator
  
  TreeHasKeyMap<Frequency, Oscillator> oscillators = new TreeHasKeyMap<Frequency, Oscillator>(map(f -> new Oscillator(f), pianoFrequencies88()));
  new TreeMultiMap<Double, Oscillator> completionsForSample;
  
  *() {}
  *(IAudioSample audio, double *currentSample) { setAudio(audio); }
  *(IAudioSample audio) { setAudio(audio); } // start at time 0
  
  void setAudio(IAudioSample audio) {
    this.audio = audio;
    window = optCast SlidingWindow(audio);
  }
  
  void verboseOnRecordAdded() {
    onRecordAdded(lambda1 print);
  }
  
  int nFrequencies() {
    ret oscillators.size();
  }
  
  void startOscillators {
    for (o : oscillators)
      o.initial(currentSample);
  }
  
  void stepTo(DoubleRange timeRange) {
    while ping (true) {
      Double t = firstKey(completionsForSample);
      if (t != null && t <= timeRange.start) {
        var list = completionsForSample.getAndClear(t);
        dprint(+t, +list);
        for (Oscillator o : list) {
          o.measure(timeRange);
          o.relocate(t);
        }
      } else
        break;
    }
  }
  
  void record(Oscillator o, DoubleRange r, Channels<Complex> c) {
    if (o == null) ret;
    o.record_impl(r, c);
    onRecordAdded(new RecordAdded(o, r, c));
  }
  
  record RecordAdded(Oscillator oscillator, DoubleRange period, Channels<Complex> intensity) {}
  
  transient event interface OnRecordAdded as onRecordAdded shipping RecordAdded;
  
  Frequency lowestFrequency() { ret oscillators.firstKey(); }
  Frequency highestFrequency() { ret oscillators.lastKey(); }
  
  int minWindowSize() {
    ret iceil(sampleRate*lowestFrequency().interval());
  }
  
  void makeSmallestWindow(IQuerySound sound) {
    this.sound = sound;
    setAudio(new SlidingWindow(channels, sampleRate, sound, 0, minWindowSize());
  }
  
  double windowSize() {
    ret window.length();
  }
  
  S stats() { ret renderVars(+audio, +haarFeaturesChecked); }
  
  IIntegralImage imageColumn(DoubleRange timeRange) {
    int n = nFrequencies();
    var l = reversedList(oscillators);
    double[] col = new[n];
    for y to n: {
      var l2 = l.get(y).intensities;
      new Average avg;
      forEach(l2, (r, val) -> {
        double amplitude = val.first().abs();
        
        // if only a part is in the time range
        double actualDuration = l(intersectDoubleRanges(r, timeRange));
        
        avg.add(amplitude, actualDuration);
      });
      col[y] = avg!;
    }
    double[] col2 = normalizeDoubles(col, 255);
      
    ret bwIntegralImageFromFunction(1, n, (x, y) -> ifloor(col2[y]));
  }
  
  // how much horizontal area have we covered
  L<Double> coverageByFreq() {
    ret mapReversed(oscillators, o -> totalLengthOfDoubleRanges(keys(o.intensities)));
  }
  
  void stepRight(double shift) {
    assertNotNull(+window);
    var r = window.bounds();
    window.shiftRight(max(1, ifloor(shift)));

    for (o : oscillators) o.dropMeasurementsLeftOf(window.start());
    stepTo(window.end());
  }
  
  DoubleRange windowBounds() { ret window.bounds(); }
}