BowelyzerAnalyzer{

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

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

  init{
    arg config;
    synths = Dictionary.new(config.at("names").size);
    this.setupGroups;
    this.addAnalysisSynthsFromConfig(config);
    Routine{
      2.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
  addAnalysisSynthsFromConfig{
    arg config;
    config.at("names").size.do({|i|
      var name = config.at("names")[i];
      ("Adding SynthDef '"++name++"' on input "++(i+config.at("channelOffset")[i])).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: i+config.at("channelOffset")[i]);
        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),
          '/'++config.at("names")[i].asSymbol,
          [amplitude, pitch, hasPitch, detect]
        );
      }).add;
    });
  }

  startSynthsFromConfig{
    arg config;
    config.at("names").do({|name, i|
      var controls = config.at("controls").at(name);
      postln("Synths: "++name++" at "++i);
      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);
  }
}