BowelyzerConfig{

  const <controlsWithSlider = #[
    \amplitudeAttackTime,
    \amplitudeReleaseTime,
    \hfHainsworth,
    \hfFoote,
    \hfThreshold,
    \hfWaitTime,
    \pitchInitFreq,
    \pitchMinFreq,
    \pitchMaxFreq,
    \pitchExecFreq,
    \pitchMaxBinsPerOctave,
    \pitchMedian,
    \pitchAmpThreshold,
    \pitchPeakThreshold,
    \pitchDownSample,
    \sendReplyFreq
  ];
  const <controlsWithRanger = #[
    \freqRange
  ];
  const <controlsWithKnob = #[
    \test
  ];

  const <hasToBeString = #[
    \forwardAddress,
    \hubAddress,
    \synthServerAddress
  ];

  const <hasToBeInteger = #[
    \forwardPort,
    \hubPort,
    \synthServerPort,
    \pitchMedian,
    \pitchDownSample
  ];
  const <hasToBeDictionary = #[
    \inputs,
    \controls,
    \left,
    \right
  ];
  const <hasToBeFloat = #[
    \amplitudeAttackTime,
    \amplitudeReleaseTime,
    \hfHainsworth,
    \hfFoote,
    \hfThreshold,
    \hfWaitTime,
    \pitchInitFreq,
    \pitchMinFreq,
    \pitchMaxFreq,
    \pitchExecFreq,
    \pitchMaxBinsPerOctave,
    \pitchAmpThreshold,
    \pitchPeakThreshold,
    \sendReplyFreq
  ];

  const <hasToBeBool = #[
    \active,
    \onlyForwardOnNewPitch
  ];

  const <hasToBeArray = #[
    \freqRange
  ];

  const <controlGroupsGUI = #[
    \general,
    \amplitude,
    \pitch,
    \hf
  ];

  const <generalControlGroupGUI = #[
    \sendReplyFreq,
    \freqRange,
    \fundamental
  ];

  var <config,
  <configFilePath,
  <defaultConfig,
  <defaultControls,
  <changed = false;

  *controlContainedIn{
    arg control;
    if(BowelyzerConfig.controlsWithSlider.includes(control),{
      ^\slider;
    });
    if(BowelyzerConfig.controlsWithRanger.includes(control),{
      ^\ranger;
    });
    if(BowelyzerConfig.controlsWithKnob.includes(control),{
      ^\knob;
    });
  }

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

  init{
    arg configFile;
    this.addControlSpecs;
    this.createDefaultConfig;
    config = Dictionary.new;
    if(configFile.notNil,{
      if(this.readConfigurationFile(configFile).not,{
        error("Reading of configuration file failed. Using default.");
        config = defaultConfig;
      });
    },{
      ("No configuration file provided. Using default.").postln;
      config = defaultConfig;
      configFilePath = "";
    });
    this.showConfig;
  }

  // add ControlSpecs to the global Dictionary
  addControlSpecs{
    ControlSpec.specs[\amplitudeAttackTime] = ControlSpec(0.001, 10, \lin, 0.001, 0.01, units: "s");
    ControlSpec.specs[\amplitudeReleaseTime] = ControlSpec(0.001, 10, \lin, 0.001, 0.01, units: "s");
    ControlSpec.specs[\hfHainsworth] = ControlSpec(0.0, 1.0, \lin, 0.001, 1.0, units: "");
    ControlSpec.specs[\hfFoote] = ControlSpec(0.0, 1.0, \lin, 0.001, 0.0, units: "");
    ControlSpec.specs[\hfThreshold] = ControlSpec(0.0, 10.0, \lin, 0.001, 1.0, units: "");
    ControlSpec.specs[\hfWaitTime] = ControlSpec(0.0, 1.0, \lin, 0.001, 0.04, units: "s");
    ControlSpec.specs[\pitchInitFreq] = ControlSpec(20.0, 20000.0, \exp, 0.01, 440.0, units: "Hz");
    ControlSpec.specs[\pitchMinFreq] = ControlSpec(20.0, 20000.0, \exp, 0.01, 60.0, units: "Hz");
    ControlSpec.specs[\pitchMaxFreq] = ControlSpec(20.0, 20000.0, \exp, 0.01, 4000.0, units: "Hz");
    ControlSpec.specs[\pitchExecFreq] = ControlSpec(20.0, 20000.0, \exp, 0.01, 100.0, units: "Hz");
    ControlSpec.specs[\pitchMaxBinsPerOctave] = ControlSpec(1, 64, \lin, 1, 16, units: "bins");
    ControlSpec.specs[\pitchMedian] = ControlSpec(1, 64, \lin, 1, 1, units: "");
    ControlSpec.specs[\pitchAmpThreshold] = ControlSpec(0.01, 1.0, \lin, 0.01, 0.01, units: "dB");
    ControlSpec.specs[\pitchPeakThreshold] = ControlSpec(0.01, 1.0, \lin, 0.01, 0.5, units: "dB");
    ControlSpec.specs[\pitchDownSample] = ControlSpec(1, 100, \lin, 1, 1, units: "samples");
    ControlSpec.specs[\sendReplyFreq] = ControlSpec(1, 100, \exp, 0.1, 20, units: "Hz");
    ControlSpec.specs[\freqRange] = ControlSpec(20, 20000, \exp, 0.01, 20, units: "Hz");
    ControlSpec.specs[\input] = ControlSpec(0, Server.default.options.numInputBusChannels-1, \lin, 1, 0, units: "channels");
    ControlSpec.specs[\port] = ControlSpec(1, 65535, \lin, 1, 0, units: "ports");
  }

  // create the default configuration
  createDefaultConfig{
    defaultControls = Dictionary.with(*[
      \active -> true,
      \amplitudeAttackTime -> 0.01,
      \amplitudeReleaseTime -> 0.1,
      \hfHainsworth -> 1.0,
      \hfFoote -> 0.0,
      \hfThreshold -> 0.3,
      \hfWaitTime -> 0.04,
      \pitchInitFreq -> 440,
      \pitchMinFreq -> 60,
      \pitchMaxFreq -> 4000,
      \pitchExecFreq -> 100,
      \pitchMaxBinsPerOctave -> 16,
      \pitchMedian -> 1,
      \pitchAmpThreshold -> 0.01,
      \pitchPeakThreshold -> 0.5,
      \pitchDownSample -> 1,
      \sendReplyFreq ->20,
      \freqRange -> [20, 20000],
      \onlyForwardOnNewPitch -> false
    ]);
    defaultConfig = Dictionary.with(*[
      \inputs -> Dictionary.with(*[
        \left -> 0,
        \right -> 1
      ]),
      \synthServerAddress -> "127.0.0.1",
      \synthServerPort -> 57110,
      \hubAddress -> "127.0.0.1",
      \hubPort -> 57120,
      \forwardAddress -> "127.0.0.1",
      \forwardPort -> 57120,
      \controls -> Dictionary.with(*[
        \left -> defaultControls,
        \right -> defaultControls
      ])
    ]);
  }

  // read configuration from file
  readConfigurationFile{
    arg configFile;
    var configFromFile, reader, path;
    path = PathName.new(configFile.asString);
    if(path.isFile,{
      postln("Reading configuration file: "++configFile);
      try{
        configFromFile = (configFile.asString).parseYAMLFile;
        configFromFile.keysValuesDo({|key, value|
          switch(key.asSymbol,
            \controls,{
              // adding names dictionary
              config.put(key.asSymbol, Dictionary.new(value.size));
              // going through the names and their associated dictionaries
              value.keysValuesDo({|name, dictionary|
                if(dictionary.isKindOf(Dictionary),{
                  config.at(key.asSymbol).put(name.asSymbol, Dictionary.new(dictionary.size));
                  // going through each control dictionary with controls and their values
                  dictionary.keysValuesDo({|control, controlValue|
                    if(defaultControls.includesKey(control.asSymbol),{
                      config.at(key.asSymbol).at(name.asSymbol).put(control.asSymbol, this.getControlValue(control.asSymbol, controlValue));
                    });
                  });
                },{
                  error("This element should be of type Dictionary: "++dictionary);
                });
              });
            },
            \inputs,{
              config.put(key.asSymbol, Dictionary.new());
              value.keysValuesDo({|name, channel|
                config.at(\inputs).put(name.asSymbol, channel.asInteger);
              });
            },
            {
              if(defaultConfig.includesKey(key.asSymbol),{
                config.put(key.asSymbol, this.getSettingValue(key.asSymbol, value));
              },{
                error("Key is not included in known configuration: "++key);
              });
            }
          );
        });
        postln("Reading of configuration complete. Now validating...");
        if(this.validateConfig,{
          postln("Validation complete.");
          configFilePath = configFile;
          ^true;
        },{
          postln("Validation failed.");
          ^false;
        });
      }{
        ("Failed parsing the file: "++configFile).error;
        ("Make sure its JSON syntax is valid!").error;
        ^false;
      };
    }, {
      error("File not readable:"++configFile.asString);
      ^false;
    });
  }

  // write a valid JSON file from configuration
  writeConfigurationFile{
  arg fileName;
  var configFile,
  path,
  overwriteConfigFilePath = false,
  writeFinished = false;
  if(fileName.isNil, {
    if(configFilePath.notNil && (configFilePath != ""), {
      path = configFilePath;
    },{
      "No configuration file defined!".error;
    });
  },{
    path = fileName;
    overwriteConfigFilePath = true;
  });
  if(path.notNil && (path != ""), {
    ("Writing configuration to file: "++path).postln;
    try{
      configFile = File.use(
        path.asString,
        "w",
        {|configFile|
          var controlNamesSize = config.at(\controls).size,
          currentControlName = 0,
          controlsSize = defaultControls.size,
          currentControl = 0,
          inputsSize = config.at(\inputs).size,
          currentInput = 0;
          configFile.write("{\n");
          // global settings
          config.order.do({|key|
            var value = config.at(key);
            if((key != \controls) && (key != \inputs), {
              if(hasToBeString.includes(key), {
                configFile.write("  \""++key++"\": \""++value++"\",\n");
              });
              if(hasToBeInteger.includes(key),{
                configFile.write("  \""++key++"\": "++value++",\n");
              });
            });
          });
          // controls
          configFile.write("  \"controls\": {\n");
          config.at(\controls).order.do({|key|
            currentControlName = currentControlName+1;
            configFile.write("    \""++key++"\": {\n");
            config.at(\controls).at(key).order.do({|control|
              var controlValue = config.at(\controls).at(key).at(control);
              currentControl = currentControl+1;
              if(currentControl == controlsSize,{
                configFile.write("      \""++control++"\": "++controlValue++"\n");
              },{
                configFile.write("      \""++control++"\": "++controlValue++",\n");
              });
            });
            // closing brace
            if(currentControlName == controlNamesSize,{
              configFile.write("    }\n");
            },{
              configFile.write("    },\n");
            });
            currentControl = 0;
          });
          // closing brace for controls
          configFile.write("  },\n");
          // inputs
          configFile.write("  \"inputs\": {\n");
          config.at(\inputs).order.do({|key|
            var value = config.at(\inputs).at(key);
            currentInput = currentInput+1;
            if(currentInput == inputsSize,{
              configFile.write("    \""++key++"\": "++value++"\n");
            },{
              configFile.write("    \""++key++"\": "++value++",\n");
            });
          });
          // closing brace for inputs
          configFile.write("  }\n");
          // closing brace for notation
          configFile.write("}\n");
          configFile.close;
          writeFinished = true;
        }
      );
    }{
      ("Failed writing the file: "++path).error;
      ^false;
    }
  });
    if(writeFinished && overwriteConfigFilePath, {
      configFilePath = fileName;
    });
    ^true;
  }

  // return a control value as correct type and within its defined ControlSpec range
  getControlValue{
    arg control, value;
    if(defaultControls.includesKey(control.asSymbol),{
      if(hasToBeFloat.includes(control.asSymbol),{
        ^control.asSymbol.asSpec.constrain(value.asFloat).asFloat;
      });
      if(hasToBeInteger.includes(control.asSymbol),{
        ^control.asSymbol.asSpec.constrain(value.asInteger).asInteger;
      });
      if(hasToBeBool.includes(control.asSymbol),{
        switch(value,
          0,{^false},
          1,{^true},
          "true",{^true},
          "false",{^false}
        );
      });
      if(hasToBeArray.includes(control.asSymbol), {
        ^value.collect({|item, i|
          item.asFloat;
        });
      });
    },{
    ^nil;
    });
  }

  //get a setting value as correct type
  getSettingValue{
    arg setting, value;
    if(defaultConfig.includesKey(setting.asSymbol),{
      if(hasToBeString.includes(setting.asSymbol),{
        ^value.asString;
      });
      if(hasToBeInteger.includes(setting.asSymbol),{
        ^value.asInteger;
      });
    },{
      ^nil;
    });
  }

  // validate/extend/fix the config and return true if it's useable
  validateConfig{
    var broken = false;
    //fail if there are no inputs defined
    if(config.includesKey(\inputs).not,{
      "No inputs defined!".error;
      ^false;
    });
    // if there are no controls defined at all, add at least a Dictionary for them
    if(config.includesKey(\controls).not,{
      config.put(\controls, Dictionary.new(config.at(\inputs).size));
    });
    // go through the defaultConfig/defaultControl collection and compare it to the provided config
    defaultConfig.keysValuesDo({|key, value|
      if(key != \controls && key != \inputs,{
        // if a standard setting is not in the configuration, add it from the default
        if(config.includesKey(key).not,{
          config.put(key, value);
        });
      });
    });
    // go through the inputs and add controls, if there are none setup for them
    config.at(\inputs).keysValuesDo({|name, channel|
      // if there are no controls defined for the input at all, add a Dictionary the size of the defaultControls
      if(config.at(\controls).includesKey(name).not,{
        config.at(\controls).put(name, Dictionary.new(defaultControls.size));
      });
    });
    // go through each control dictionary
    config.at(\controls).keysValuesDo({|name, controlDictionary|
      if(config.at(\inputs).includesKey(name),{
        // go through the defaultControl Dictionary and add missing controls to controls from config
        defaultControls.keysValuesDo({|defaultControl, defaultControlValue|
          if(controlDictionary.includesKey(defaultControl).not,{
            config.at(\controls).at(name).put(defaultControl, defaultControlValue);
          });
        });
      },{
        // remove controls for non-existing inputs
        config.at(\controls).removeAt(name);
      });
    });
    ^true;
  }

  // add an input with standard controls to the config
  addInput{
    arg name;
    var id = this.createUniqueIdentifier;
    if((name.notNil && (name != "") && config.at(\inputs).includesKey(name).not), {
      id = name;
    });
    config.at(\inputs).put(id, 0);
    this.validateConfig;
    ^id;
  }

  // create a unique identifier of the form msg[number]
  createUniqueIdentifier{
    var msg = \msg1,
    iterator = 0;
    while({
      config.at(\inputs).includesKey(msg)
    },{
      iterator = (msg.asString.replace("msg", "").asInteger) + 1;
      msg = ("msg"++iterator).asSymbol;
    });
    ^msg.asSymbol;
  }

  //print the current config
  showConfig{
    postln("Configuration is: ");
    config.keysValuesDo{|key, value|
      switch(key,
        \controls, {
          postln(key++" ("++key.class++") -> ("++value.class++")");
          value.keysValuesDo({|subKey, subValue|
            postln("  "++subKey++" ("++subKey.class++") -> ("++subValue.class++")");
            subValue.keysValuesDo({|subSubKey, subSubValue|
              postln("    "++subSubKey++" ("++subSubKey.class++") -> "++subSubValue++" ("++subSubValue.class++")");
            });
          });
        },
        \inputs, {
          postln(key++" ("++key.class++") -> ("++value.class++")");
          value.keysValuesDo({|subKey, subValue|
            postln("  "++subKey++" ("++subKey.class++") -> "++subValue++" ("++subValue.class++")");
          });
        },
        {postln(key++" ("++key.class++") -> "++value++" ("++value.class++")");}
      );
    };
  }

  getSynthControl{
    arg name, control;
    if(config.at(\controls).includesKey(name) && config.at(\controls).at(name).includes(control),{
      ^config.at(\controls).at(name).at(control);
    },{
      ^false;
    });
  }

  // sets a control to a value for a synth
  setSynthControl{
    arg name, control;
    if(config.at(\controls).includesKey(name) && config.at(\controls).at(name).includes(control[0]),{
      config.at(\controls).at(name).put(control[0], control[1]);
      ^true;
    },{
      ^false;
    });
  }

}