/// m09 runtime: the single impure place in the course (with the web/ glue); everything else only builds values.
/// Here we interpret IO descriptions against a Platform and hold the one mutable variable, the current stream.
module Snake.Runtime

open Snake.View
open Snake.IO
open Snake.Stream

/// The outside world, as the runtime sees it.
type Platform =
    { FillRect: int -> int -> int -> int -> string -> unit
      FillText: int -> int -> string -> string -> int -> string -> unit
      RandomSeed: unit -> uint32
      StartClock: (int64 -> unit) -> unit
      OnKeyDown: (string -> unit) -> unit
      OnKeyUp: (string -> unit) -> unit }

// Perform one op on the platform and return its answer.
let private perform (p: Platform) (op: Op) : OpResult =
    match op with
    | RandomSeed -> Seed(p.RandomSeed())
    | Draw(Rect(x, y, w, h, color)) ->
        p.FillRect x y w h color
        Done
    | Draw(Text(x, y, text, color, size, align)) ->
        p.FillText x y text color size align
        Done

// Tail recursive, so it compiles to a loop: a scene is hundreds of ops and the stack must not grow with them.
let rec runIO (p: Platform) (io: IO<'a>) : 'a =
    match io with
    | Pure a -> a
    | Effect(op, k) -> runIO p (k (perform p op))

let runApp (p: Platform) (main: IO<Stream<IO<unit>>>) : unit =
    // The one mutable variable. F# closures cannot capture a `let mutable`, so it is a ref cell.
    let stream = ref (runIO p main)

    let feed (event: Event) =
        let ios, next = Stream.step event stream.Value
        stream.Value <- next
        List.iter (runIO p) ios

    p.OnKeyDown(fun key -> feed (KeyDown key))
    p.OnKeyUp(fun key -> feed (KeyUp key))
    p.StartClock(fun t -> feed (Time t))