// CompressionSearch

// The terms are flying all over the place with this one

// (compressor, decompressor, compression, decompression, ...)

// Basic idea: INPUT DATA (byte list) is compressed into a

//   CUSTOM OBJECT (called the "COMPRESSION"), which, when run

//     under a fitting COMPRESSION REGIME produces the INPUT DATA.

//

//   Every compression can also be converted to and from a byte array

//     (the compression regime does this).

sclass CompressionSearch<A> extends Probabilistic {

  // user-set

  settable CompressionRegime<A> regime;

  settable L<Byte> inputData;

  // public output variables

  new Best<Submission> best;

  *(CompressionRegime<A> *regime) {}

  *(CompressionRegime<A> *regime, LByte *inputData) {}

  *(CompressionRegime<A> *regime, byte[] inputData) { this.inputData = byteArrayToList(inputData); }

  // can submit concurrently!

  Submission submit(A compression) { ret _submit(compression); }

  // private (although Submission is returned)

  class Submission {

    toString {

      ret linesLL(

        "Compressor " + (correct() ? "correct" : "incorrect"),

        "Compression factor " + score(),

        "Code:",

        indentx(str(decompressor())),

        "Code as bytes:",

        indentx(bytesToHex(compressed()))

      );

    }

    void setDecompressor(A decompressor) {

      this.decompressor_cache = decompressor;

    }

    LByte inputData() { ret inputData; }

    byte[] inputDataAsArray() { ret byteListToArray(inputData); }

    simplyCached byte[] compressed() {

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

    }

    simplyCached A decompressor() {

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

    }

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

    simplyCached double score() {

      ret doubleRatio(inputDataSize(), compressedSize());

    }

    bool decompressed;

    O decompressedValue;

    O decompressed() {

      if (!decompressed) {

        decompressedValue = regime.runDecompressor(decompressor());

        set decompressed;

      }

      ret decompressedValue;

    }

    simplyCached Bool correct() {

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

    }

  }

  int inputDataSize() { ret l(inputData); }

  Submission _submit(A compression) {

    if (compression == null) null;

    new Submission s;

    s.setDecompressor(compression);

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

      if (!s.correct())

        warn("Compressor didn't verify");

      else

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

    ret s;

  }

  A bestCompression aka get() {

    var s = best!;

    ret s?.decompressor();

  }

  void addStrategy(AbstractCompressor compressor) {

    if (compressor == null) ret;

    initAction(compressor);

    compressor.setSearch(this);

    compressor.run();

  }

  run {}

}