// Turn Epsilon into a library
  #include "library.h"
  #include "display.h"
  #include <ion.h>
  #include <mutex>
  #include <condition_variable>
  
  void PREFIXED(main)() {
    Ion::Display::Blackbox::setFrameBufferActive(true);
    ion_main(0, nullptr);
  }
  
  static std::mutex m;
  static std::condition_variable cv;
  static Ion::Events::Event sEvent = Ion::Events::None;
  
  enum class State {
    WaitingForEvent,
    EventAvailable,
    Processing,
    Processed
  };
  
  static State state = State::WaitingForEvent;
  
  Ion::Events::Event Ion::Events::getEvent(int * timeout) {
    if (state == State::Processing) {
      std::lock_guard<std::mutex> lk(m);
      state = State::Processed;
      cv.notify_one();
    }
  
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, []{return (state == State::EventAvailable);});
    state = State::Processing;
  
    lk.unlock();
    cv.notify_one();
  
    return sEvent;
  }
  
  void PREFIXED(send_event)(int c) {
    Ion::Events::Event e = Ion::Events::None;
    if (c == EOF) {
      e = Ion::Events::Termination;
    } else {
      e = Ion::Events::Event(c);
      if (!(e.isDefined() && e.isKeyboardEvent())) {
        return;
      }
    }
  
    sEvent = e;
    {
      std::lock_guard<std::mutex> lk(m);
      state = State::EventAvailable;
    }
    cv.notify_one();
  }
  
  void PREFIXED(wait_event_processed)() {
    if (state == State::EventAvailable || state == State::Processing) {
      std::unique_lock<std::mutex> lk(m);
      cv.wait(lk, []{return state == State::Processed;});
      state = State::WaitingForEvent;
    }
    cv.notify_one();
  }
  
  
  const KDColor * PREFIXED(frame_buffer)() {
    return Ion::Display::Blackbox::frameBufferAddress();
  }
  
  void PREFIXED(write_frame_buffer_to_file)(const char * c) {
    Ion::Display::Blackbox::writeFrameBufferToFile(c);
  }