use "collections"
use "random"
use "time"

actor Main
  new create(env: Env) =>
    let timers = Timers
    let rm = ResourceManager(env.out)
    Printer(env.out, timers, "p1", rm)
    Printer(env.out, timers, "p2", rm)
    User(env.out, rm, "bob")
    User(env.out, rm, "alice")
    env.out.print("helo " + Rand.int[U8](12).string())

actor User
  let _out: OutStream
  let _name: String val
  let _rm: ResourceManager tag
  var _ndoc: U8
  new create(out: OutStream, rm: ResourceManager tag, name': String) =>
    _out = out
    _name = name'
    _rm = rm
    // [1,4) docs to print
    _ndoc = Rand.int[U8](4) + 1
    var count: U8 = 0
    while count < _ndoc do
      _rm.print(PrintRequest(this, "doc #" + _ndoc.string()))
      count = count + 1
    end

  be receive_print(doc: String) =>
    _out.print(_name + " received doc #" + _ndoc.string())
    _ndoc = _ndoc - 1
    if _ndoc == 0 then
      _out.print(_name + " received all documents")
    end

class TimerReceiver is TimerNotify
  let _printer: Printer
  let _job: U64
  new iso create(printer: Printer tag, job: U64) =>
    _printer = printer
    _job = job
  fun ref apply(timer: Timer, count: U64): Bool =>
    _printer.ready(_job)
    false

actor Printer
  let _name: String val
  let _out: OutStream
  let _timers: Timers
  let _pn: PrintNotifier tag
  new create(out: OutStream, timers: Timers, name: String, pn: PrintNotifier tag) =>
    _out = out
    _timers = timers
    _name = name
    _pn = pn
    pn.printer_online(this)

  be print(job: U64) =>
    _out.print("Printer '" + _name + "': printing job #" + job.string())
    _pn.print_started(this, job)
    // flip state after some time
    // tick between 50-100ms
    let timer = Timer(TimerReceiver(this, job), (Rand.int[U64](50) + 50) * 1_000_000)
    _timers(consume timer)

  be ready(job: U64) =>
    _out.print("Printer '" + _name + "': finished printing job#" + job.string())
    _pn.print_completed(this, job)


primitive Unknown
primitive Ready
primitive Busy
type PrinterState is (Unknown | Ready | Busy)

interface PrintNotifier
  be printer_online(printer: Printer)
  be print_started(printer: Printer, job: U64)
  be print_completed(printer: Printer, job: U64)

class PrintRequest
  let user: User
  let doc: String
  new val create(user': User, doc': String) =>
    user = user'
    doc = doc'

actor ResourceManager
  let _out: OutStream
  let _printers: MapIs[Printer, PrinterState] = _printers.create()
  var _njobs: U64 = 0
  let _jobPR: Map[U64, PrintRequest val] = _jobPR.create()

  new create(out: OutStream) =>
    _out = out

  be print(pr: PrintRequest val) =>
    _njobs = _njobs + 1

    var free_printer_found = false
    for (printer, state) in _printers.pairs() do
      match state
      | Ready =>
        _jobPR(_njobs) = pr
        _printers(printer) = Busy
        printer.print(_njobs)
        free_printer_found = true
        break
      end
    end

    if not free_printer_found then
      // TODO add to queue
      _out.print("no free printers found")
    end

  be printer_online(printer: Printer) =>
    _printers(printer) = Ready

  be print_started(printer: Printer, job: U64) =>
    _printers(printer) = Busy

  be print_completed(printer: Printer, job: U64) =>
    _printers(printer) = Ready
    try
      (_, let pr) = _jobPR.remove(job)?
      pr.user.receive_print(pr.doc)
    else
      _out.print("job #" + job.string() + " not found!?")
    end
    // remove job and notify user