// Sc = type of scores (e.g. Double)
// Sc can also be the actual instance created (e.g. a strategy)
// If Sc is not Comparable, you can supply an additional
// comparisonFunction.
sclass TunableParameters<Sc> {
  //replace Scrd with GenericallyScored<MapSO, Sc>.
  
  class Scrd extends Var<MapSO> {
    gettable Sc score;
  
    *() {}
    *(MapSO a, Sc score) { super(a); this.score = score; }
    
    toString {
      ret actualScoreFunction.get(score) + ": " + str(get());
    }
    
    bool isBest() { ret this == best; }
    bool tiesBest() { ret compareScrd(this, best) == 0; }
    
    O actualScore() { ret actualScoreFunction.get(score); }
  }
  
  settable IF1<MapSO, Sc> scoreFunction;
  settable IF2_OOInt<O> comparisonFunction;
  settable IF1<Sc, O> actualScoreFunction = l1 id;
  
  gettable Scrd best;
  new LinkedHashMap<S, Parameter> parameters;
  new L<Parameter> parameterList;
  gettable volatile long instancesTested;
  
  event testingInstance(MapSO instance);
  event fireInstanceScored(Scrd scored);
  event newBest(Scrd instance);
  
  abstract class Parameter<A> {
    settable S name;
    settable A defaultValue;
    
    abstract A randomValue();
    
    A get(MapSO instance) {
      ret (A) instance.get(name);
    }
    
    TunableParameters<Sc> tuner() { ret TunableParameters.this; }
  }
  
  class IntRangeParameter extends Parameter<Int> {
    settable IntRange range;
    settable int step = 1;
    
    Int randomValue() { ret random(range); }
    
    selfType fixedValue(int value) {
      defaultValue(value);
      range(intRange(value, value));
      this;
    }
  }
  
  class DoubleRangeParameter extends Parameter<Double> {
    settable DoubleRange range;
    settable double step = .1;
    
    Double randomValue() { ret random(range); }
    
    selfType fixedValue(double value) {
      defaultValue(value);
      range(doubleRange(value, value));
      this;
    }
  }
  
  <A extends Parameter> A add(A p) {
    parameters.put(p.name(), p);
    parameterList.add(p);
    ret p;
  }
  
  IntRangeParameter intParam(S name, int defaultValue, int min, int max) {
    new IntRangeParameter p;
    p.range(intRange(min, max)).+defaultValue.+name;
    ret add(p);
  }
  
  DoubleRangeParameter doubleParam(S name, double defaultValue, double min, double max, double step default .1) {
    new DoubleRangeParameter p;
    p.range(doubleRange(min, max)).+step.+defaultValue.+name;
    ret add(p);
  }
  
  MapSO randomInstance() {
    MapSO map = new LinkedHashMap;
    for (param : parameterList)
      map.put(param.name(), param.randomValue());
    ret map;
  }
  
  MapSO defaultInstance() {
    MapSO map = new LinkedHashMap;
    for (param : parameterList)
      map.put(param.name(), param.defaultValue());
    ret map;
  }
  
  Scrd tryARandomCombination() {
    ret tryInstance(randomInstance());
  }
  
  Scrd tryDefaultValues() {
    ret tryInstance(defaultInstance());
  }
  
  // replaces the parameter with a random value
  L<Scrd> varyEachParameterOnce(MapSO instance) {
    if (instance == null) null;
    new L<Scrd> out;
    for (param : parameterList) {
      O value = param.randomValue();
      if (eq(param.get(instance), value))
        continue;
      MapSO instance2 = cloneMap(instance);
      instance2.put(param.name(), value);
      out.add(tryInstance(instance2));
    }
    ret out;
  }
  
  Sc score(MapSO instance) {
    ++instancesTested;
    testingInstance(instance);
    ret scoreFunction.get(instance);
  }
  
  Scrd scored(MapSO instance) {
    Scrd scored = new(instance, score(instance));
    fireInstanceScored(scored);
    ret scored;
  }
  
  Scrd tryInstance(MapSO instance) {
    if (instance == null) null;
    Scrd scored = scored(instance);
    tryInstance(scored);
    ret scored;
  }
    
  void tryInstance(Scrd scored) {
    if (scored == null) ret;
    if (best == null || compareScrd(scored, best) > 0) {
      best = scored;
      newBest(scored);
    }
  }
  
  int compareScrd(Scrd a, Scrd b) {
    Sc scoreA = a.score();
    Sc scoreB = b.score();
    ret comparisonFunction == null ? cmp(scoreA, scoreB) : comparisonFunction.get(actualScoreFunction.get(scoreA), actualScoreFunction.get(scoreB));
  }
  
  toString {
    ret "Best: " + best + " (parameters: " + keys(parameters) + ")";
  }
  
  MapSO bestOrDefaultInstance() {
    if (best == null)
      tryDefaultValues();
    ret best!;
  }
}