!include once #1027304 // Eclipse Collections

import org.eclipse.collections.impl.map.mutable.primitive.*;

// compressor that takes input byte by byte and compresses

// as soon as possible.

// byte mode+case-sensitive only

// We now may have literals and pairs in any order

final sclass LCStreamingCompressor {

  LineComp_PairIndex.Ch chain;

  abstract sclass Chunk {

    abstract S text(L<Chunk> chunks);

    IntPair getPair() { null; }

  }

  srecord CPair(int i1, int i2) > Chunk {

    CPair(IntPair p) { i1 = p.a; i2 = p.b; }

    S text(L<Chunk> chunks) {

      ret linesLL_rtrim(chunks.get(i1).text(chunks), chunks.get(i2).text(chunks));

    }

    IntPair getPair() {

      ret IntPair(i1, i2);

    }

  }

  srecord CPrim(char c) > Chunk {

    S text(L<Chunk> chunks) { ret str(c); }

  }

  bool verbose = false, verboseCompressionSteps = false;

  new LineComp_PairIndex pairIndex;

  new L<Chunk> chunks;

  new Map<Char, Int> literalIndex;

  new LongIntHashMap existingPairsIndex; // formerly Map<IntPair, Int>

  //new Map<Int, OptimizedMultiSet<Int>> popularRightPartners;

  *() {

    // start with a single empty chain

    pairIndex.existingPairsIndex = existingPairsIndex;

    chain = pairIndex.newChain("main", null);

    pairIndex.haveChains();

    //pairIndex.onAddingPair = ll(lambda1 registerPartners);

    //pairIndex.onRemovingPair = ll(lambda1 unregisterPartners);

  }

  /*void registerPartners(LineComp_PairIndex.Node node) {

    IntPair p = node.pair();

    OptimizedMultiSet<Int> ms = popularRightPartners.get(p.a);

    if (ms == null) popularRightPartners.put(p.a, ms = new OptimizedMultiSet);

    ms.add(p.b);

    print("Added partners: " + p + " => " + popularRightPartners);

  }

  void unregisterPartners(LineComp_PairIndex.Node node) {

    IntPair p = node.pair();

    OptimizedMultiSet<Int> ms = popularRightPartners.get(p.a);

    ms.remove(p.b);

    if (ms.isEmpty())

      popularRightPartners.remove(p.a);

    print("Removed partners: " + p + " => " + popularRightPartners);

  }*/

  void append(S s) {

    fOr (char c : characters(s))

      append(c);

  }

  void append(char c) {

    pairIndex.verbose = verboseCompressionSteps;

    // add literal to chain

    Int idx = literalIndex.get(c);

    if (idx == null)

      literalIndex.put(c, idx = addAndReturnIndex(chunks, new CPrim(c)));

    pairIndex.firstChain.add(pairIndex, idx);

    while (compressionStep()) {}    

  }

  S exportEncoding() {

    new LS buf;

    buf.add("STREAMING BYTECOMP"); // magic signature

    for (Chunk c : chunks) {

      if (c cast CPair)

        buf.add(c.i1 + " " + c.i2);

      else

        buf.add("prim " + ((CPrim) c).c);

    }

    buf.add("main=" + joinWithSpace(chain.toList()));

    ret lines_rtrim(buf);

  }

  bool compressionStep() {

    IntPair toCompress;

    bool change;

    // Compress only most popular pair in one step

    while ping ((toCompress = pairIndex.mostPopularDuplicate()) != null) {

      int count = pairIndex.getCount(toCompress);

      Int idx = makeCPair(toCompress);

      int dups = pairIndex.numberOfDuplicates();

      if (verboseCompressionSteps) print("Compressing pair " + toCompress + " (count=" + count + ") -> " + idx + ", " + (dups-1) + " remaining");

      pairIndex.replacePair(toCompress.a, toCompress.b, idx);

      set change;

    }

    ret change;

  }

  Int makeCPair(IntPair p) {

    long l = intPairToLong(p);

    S text = null;

    int idx = existingPairsIndex.getIfAbsent(l, -1);

    if (idx < 0) {

      idx = addAndReturnIndex(chunks, new CPair(p));

      existingPairsIndex.put(l, idx);

    }

    ret idx;

  }

  S itemToString(int idx) {

    if (idx < 0) null;

    new StringBuilder buf;

    itemToString_step(buf, idx);

    ret str(buf);

  }

  void itemToString_step(StringBuilder buf, int idx) {

    Chunk c = chunks.get(idx);

    if (c cast CPair) {

      itemToString_step(buf, c.i1);

      itemToString_step(buf, c.i2);

    } else

      buf.append(((CPrim) c).c);

  }

  int nItems() { ret l(chunks); }

  IntPair getPair(int idx) {

    ret chunks.get(idx).getPair();

  }

  S text() {

    new StringBuilder buf;

    for (int idx : chain.toList())

      itemToString_step(buf, idx);

    ret str(buf);

  }

  int tailValue() {

    ret chain.tail == null ? -1 : chain.tail.value;

  }

  /*public LCStreamingCompressor clone() {

    new LCStreamingCompressor c;

    c.chunks = cloneList(chunks);

    c.pairIndex = pairIndex.clone();

    c.literalIndex = cloneMap(literalIndex);

    c.existingPairsIndex = new LongIntHashMap(existingPairsIndex);

    ret c;

  }*/

}