BowelyzerAnalyzer{

  var <synths;
  var <analyzerGroup;
  var <monitoringGroup;

  *new{
    arg config;
    ^super.new.init(config);
  }

  init{
    arg config;
    synths = Dictionary.new(config.at(\inputs).size);
    this.setupGroups;
    this.addSynthsFromConfig(config);
    Routine{
      1.wait;
      this.startSynthsFromConfig(config);
    }.play;
  }

  // setup a synth group for the analyzers
  setupGroups{
    analyzerGroup = Group.new;
    monitoringGroup = Group.after(analyzerGroup);
    NodeWatcher.register(analyzerGroup);
    NodeWatcher.register(monitoringGroup);
  }

  // add synths for the defined channels
  addSynthsFromConfig{
    arg config;
    config.at(\inputs).keysValuesDo({|name, inputChannel|
      ("Adding SynthDef \""++name++"\" on input "++inputChannel).postln;
      SynthDef(name, {
        arg sendReplyFreq,
        amplitudeAttackTime,
        amplitudeReleaseTime,
        hfHainsworth,
        hfFoote,
        hfThreshold,
        hfWaitTime,
        pitchInitFreq,
        pitchMinFreq,
        pitchMaxFreq,
        pitchExecFreq,
        pitchMaxBinsPerOctave,
        pitchMedian,
        pitchAmpThreshold,
        pitchPeakThreshold,
        pitchDownSample
        ;
        var amplitude, input, detect, pitch, hasPitch;
        //TODO: Add volume for SoundIn
        input = SoundIn.ar(bus: inputChannel);
        amplitude = Amplitude.kr(
          in: input,
          attackTime: amplitudeAttackTime,
          releaseTime: amplitudeReleaseTime
        );
        detect = A2K.kr(
          PV_HainsworthFoote.ar(
            FFT(LocalBuf(2048), input),
            proph: hfHainsworth,
            propf: hfFoote,
            threshold: hfThreshold,
            waittime: hfWaitTime
          )
        );
        # pitch, hasPitch = Pitch.kr(
          in: input,
          initFreq: pitchInitFreq,
          minFreq: pitchMinFreq,
          maxFreq: pitchMaxFreq,
          execFreq: pitchExecFreq,
          maxBinsPerOctave: pitchMaxBinsPerOctave,
          median: pitchMedian,
          ampThreshold: pitchAmpThreshold,
          peakThreshold: pitchPeakThreshold,
          downSample: pitchDownSample
        );
        SendReply.kr(
          Impulse.kr(sendReplyFreq),
          "/"++name,
          [amplitude, pitch, hasPitch, detect]
        );
      }).add;
    });
  }

  startSynthsFromConfig{
    arg config;
    config.at(\controls).keysValuesDo({|name, controls|
      postln("Starting synth \""++name++"\".");
      synths.add(name -> Synth(
        name,
        [
          sendReplyFreq: controls.at(\sendReplyFreq),
          amplitudeAttackTime: controls.at(\amplitudeAttackTime),
          amplitudeReleaseTime: controls.at(\amplitudeReleaseTime),
          hfHainsworth: controls.at(\hfhainsworth),
          hfFoote: controls.at(\hfFoote),
          hfThreshold: controls.at(\hfThreshold),
          hfWaitTime: controls.at(\hfWaitTime),
          pitchInitFreq: controls.at(\pitchInitFreq),
          pitchMinFreq: controls.at(\pitchMinFreq),
          pitchMaxFreq: controls.at(\pitchMaxFreq),
          pitchExecFreq: controls.at(\pitchExecFreq),
          pitchMaxBinsPerOctave: controls.at(\pitchMaxBinsPerOctave),
          pitchMedian: controls.at(\pitchMedian),
          pitchAmpThreshold: controls.at(\pitchAmpThreshold),
          pitchPeakThreshold: controls.at(\pitchPeakThreshold),
          pitchDownSample: controls.at(\pitchDownSample)
        ],
        analyzerGroup
        );
      );
    });
  }

  setSynthControl{
    arg name, control;
    synths.at(name).set(control[0], control[1]);
  }

  startAnalysisSynth{
    arg name;
    synths.at(name).run(true);
  }

  stopAnalysisSynth{
    arg name;
    synths.at(name).run(false);
  }

  startAllAnalysisSynths{
    analyzerGroup.run(true);
  }

  stopAllAnalysisSynths{
    analyzerGroup.run(false);
  }
}