// Previously used class "Q" (#1000934) used 328 bytes when idle.
// Now we're at 32 (factor 10+).
// And we can evaporate this even further by merging the queue
// with the object it belongs to. Probably we'll end up paying nothing
// for an idle object while still enjoying the experience of being
// able to start a thread instantly whenever needed.

sclass CompactQ extends Meta is AutoCloseable {

  // Object size at this point: 12 bytes for Java + 4 bytes for Meta
  //   (assuming you have 32 GB or less of Java RAM)
  //
  // So let's keep saving space.
  
  // Step 1 - no name... well, no reserved name field, anyway.
  // Most queues can probably be identified from context.
  // if you want to give your event queue a name - put it in Meta
  // with these convenient procedures:
  
  S name() { ret or2((S) metaGet("name"), toString()); }
  void name(S name) { metaSet(+name); }
  
  // Object size now: Still 16 bytes unless you foolishly insist on a
  // custom queue name which you could definitely achieve in a much
  // more efficient way (hint _subclassing_).
  
  // Now we do need to expend 4 more bytes. The items in the queue
  // have to go somewhere. But!
  
  // No syncLinkedList or something - just an AppendableChain which
  // is a minimalist approach but above the honor level of elegance
  // and flexibility and absolutely not in the way in these circumstances.
  // It's all O(1) after all.
  //
  // All sync is done on the main object BTW. (CompactQ.this)
  
  AppendableChain<Runnable> q;
  
  // Object size now: 20b
  
  // retired also goes to meta. In the end you don't even notice a
  // difference. It's just another setter and getter and they are
  // clearly not hard to make either.
  //
  // Of course, you will notice that we store "unretired" as null
  // (meaning no entry at all, saving all the space) instead of false;
  // even in the case that someone retires their event queue and then
  // _unretires_ it.
  //
  // In the end, one can say we are really really pedantic but we do
  // have a style.
  
  synchronized bool retired() { ret metaGet("retired") != null; }
  synchronized void retired(bool b) { metaPut("retired", trueOrNull(b)); }
  
  // Object size: still 20b. Miraculous!
  //
  // ...Here comes a good one.
  
  // The "enter" field is an optional thread ownership marker, e.g.
  // for modules in the Java OS because otherwise thread control is
  // a nightmare.
  //
  // Well... it still kind of is. But I see the way forward with one
  // clean re-architecture that we should one day just do. We just need
  // central instances of thread managing. This cannot be decentra-
  // lized.
  //
  // Oh, and having slashed absolutely everything else, we keep this
  // one as an actual field.
  //
  // The field type is so a customer's enter procedure can do
  // whatever fancy things they fashion as long as they provide an
  // AutoCloseable that will be called for cleanup.
  
  IF0<AutoCloseable> enter;
  
  // New size: 24b
  
  // We do want to know who is servicing us currently...
  
  Thread thread;       // 28b
  bool startingThread;
  
  // ...and finally the biggest boolean ever brings us to 32 bytes.
  
  // Optional monitoring
  
  ifdef CompactQ_Stats
    new AtomicLong bouts; // how often we have stopped and started
    int biggestSize;      // how long the queue was at the worst moment
  endifdef

  AutoCloseable enter() { ret callF(enter); }
  
  synchronized bool running() { ret thread != null; }

  bool done() { ret !running() && (isEmpty() || retired() || !licensed()); }
  
  // This is way smarter than the half-awake sleep(1) method
  // Basically we take a place at the end of the line and when we're
  // at the counter we see if anyone came in behind us. And repeat
  // if necessary.
  //
  // Note that for this to work reliably we require that items in
  // the queue are auto-closed in case they can't be dispatched
  void waitUntilDone {
    while (!done())
      putFlagInPipe();
  }
  
  void putFlagInPipe() {
    flagSleep(flag -> add(raiseFlagOnRunAndClose(flag)));
  }
  
  // Yes, in JavaX functions can have any number of names
  public synchronized void close aka cancel() {
    retired(true);
    clear();
    if (thread == null) ret;
    // threadBeingCancelled = new WeakReference(thread); // optional
    cancelAndInterruptThread(thread);
    thread = null;
  }
  
  // Forget all the entries but don't cancel or interrupt currently
  // executing task
  public void clear {
    L<Runnable> items;
    synchronized {
      items = cloneList(q);
      q = null;
    }
    cleanUp(items);
  }

  // append to q (do later)
  void add(Runnable r) {
    if (r == null) ret;
    synchronized {
      // cleanly reject if necessary
      if (retired()) ret with cleanUp(r);
      
      q = chainPlus(q, r);
      ifdef CompactQ_Stats biggestSize = max(size(), biggestSize); endifdef
    }
    checkForAction();
  }
  
  // prepend to q (do next)
  void addInFront(Runnable r) {
    if (r == null) ret;
    synchronized {
      // cleanly reject if necessary
      if (retired()) ret with cleanUp(r);
      
      q = itemPlusChain(r, q);
      ifdef CompactQ_Stats biggestSize = max(size(), biggestSize); endifdef
    }
    checkForAction();
  }
  
  protected void checkForAction() {
    synchronized {
      if (done() || running() || startingThread)
        ret;
      // There seems to be work, so we start a thread.
      set startingThread;
    }

    try {
      // At this point, we are no longer synchronized, but
      // we know we are uncontested.
      // No one else will try to start a thread.
      temp enter();
      startThread(name(), () -> {
        try {
          temp enter();

          // Put us in the book.
          synchronized {
            startingThread = false;
            thread = currentThread();
          }

          // And off we go!
          _bout();
        } finally {
          thread = null;
          startingThread = false;
        }
      });
    } on fail {
      close();
    }
  }
  
  synchronized Runnable _grabWork() {
    Runnable r = first(q);
    q = popFirst(q);
    ret r;
  }
  
  // work as long there is work
  void _bout {
    ifdef CompactQ_Stats inc(bouts); endifdef
    while (licensed() && !retired()) {
      Runnable r = _grabWork();
      if (r != null)
        pcall { r.run(); }
      else {
        onIdle();
        
        // Try once more because onIdle may have strategically waited
        // for 1 ms or something to see if more work came in.
        
        if ((r = _grabWork()) != null)
          pcall { r.run(); } // get back in the game
        else
          break;
      }
    }
  }
  
  synchronized bool isEmpty() { ret q == null; }
  synchronized int size() { ret l(q); }
  
  O mutex() { this; } // clients can synchronize on this
  
  // export procedure following JavaX synchronization rules
  // (only synchronize on one object at a time. exceptions granted
  // when proof of harmlessness is given.)
  synchronized L<Runnable> snapshot() { ret cloneList_unsynced(q); }
  
  // you can override this
  void onIdle {}
}