// A = compressor type (e.g. s), Data = data type

persistable sclass CompressionSearch_AnyType<A, Data> extends Probabilistic {

  replace Regime with CompressionRegime_AnyType<A>.

  // user-set

  settable Regime regime;

  gettable Data inputData;

  settable long inputSize; // in bytes

  event onNewBest;

  event onDisqualified(Submission s);

  // public output variables

  new Best<Submission> best;

  new L<AbstractCompressor_AnyType> strategies;

  *() { init(); }

  *(Regime *regime) { init(); }

  *(Regime *regime, Data *inputData, long *inputSize) { init(); }

  void init {

    best.onChange = r newBest;

  }

  // can submit concurrently!

  Submission submit(A compression, O notes default null) {

    ret _submit(compression, notes);

  }

  // private (although Submission is returned)

  class Submission {

    settable O notes;

    toString {

      if (!correct()) ret linesLL("BAD");

      ret linesLL(

        (isHardChecked() ? " HARD " : "MAYBE ") + ifloor(score()*100),

        "Exact compression ratio: " + scoreRatio(),

        "Code:",

        indentx(shorten(500, str(decompressor()))),

        "Code as bytes:",

        indentx(shorten(500, bytesToHex(compressed())))

      );

    }

    void setDecompressor(A decompressor) {

      this.decompressor_cache = decompressor;

    }

    Data inputData() { ret inputData; }

    simplyCached byte[] compressed() {

      ret decompressor_cache == null ?: regime.decompressorToBytes(decompressor_cache);

    }

    simplyCached A decompressor() {

      ret compressed_cache == null ?: regime.decompressorFromBytes(compressed_cache);

    }

    simplyCached S decompressor_str() {

      ret strOrNull(decompressor());

    }

    int compressedSize aka nBytes() { ret l(compressed()); }

    simplyCached Ratio scoreRatio() {

      ret Ratio(inputSize(), compressedSize());

    }

    simplyCached double score() {

      ret scoreRatio()!;

    }

    bool decompressed;

    O decompressedValue;

    O decompressed() {

      if (!decompressed) {

        decompressedValue = regime.runDecompressor(decompressor());

        set decompressed;

      }

      ret decompressedValue;

    }

    bool checkUnder(Regime regime) {

      ret checkResult(regime.runDecompressor(decompressor()));

    }

    simplyCached bool isHardChecked() {

      if (!correct()) false;

      var nextRegime = regime.harderRegime();

      if (nextRegime == null) true;

      ret checkUnder(nextRegime);

    }

    bool checkResult(O decompressed) {

      ret eq(toByteList(decompressed), inputData());

    }

    simplyCached Bool correct() {

      ret eq(toByteList(decompressed()), inputData());

    }

  } // end of Submission

  Submission _submit(A compression, O notes) {

    if (compression == null) null;

    print("Received submission");

    print("Code: " + takeFirst(500, str(compression)));

    new Submission s;

    s.notes(notes);

    print("Notes: " + takeFirst(500, str(notes)));

    s.setDecompressor(compression);

    print("Size: " + nBytes(s.nBytes()));

    if (s.score() > best.score())

      if (!s.correct()) {

        warn("Compressor didn't verify");

        disqualified(s);

      } else {

        print("Score: " + s.score());

        best.put(s, s.score();

      }

    ret s;

  }

  Submission bestSubmission() {

    methodForEach flush(strategies);

    ret best!;

  }

  Submission bestHardSubmission() {

    var s = best!;

    if (s == null || !s.isHardChecked()) null;

    ret s;

  }

  A bestCompression aka get() {

    var s = bestSubmission();

    ret s?.decompressor();

  }

  bool has() { ret bestSubmission() != null; }

  void addStrategy(AbstractCompressor_AnyType<A, Data> compressor) {

    if (compressor == null) ret;

    initAction(compressor);

    compressor.setSearch(this);

    strategies.add(compressor);

    compressor.run();

  }

  run {}

}