/// m07 io: effects as values. An IO is a plain-data description of a program; nothing runs until interpreted.
///   - `Pure a`          done, with a value
///   - `Effect (op, k)`  perform `op`, then continue with `k result`
module Snake.IO

open Snake.View

/// An operation an IO program can ask the outside world to perform.
type Op =
    | Draw of Shape
    | RandomSeed
    // m10: the stored best score, read and written.
    | LoadBest
    | SaveBest of int

/// What the outside world answers: `Done` for a `Draw` or a `SaveBest`, `Seed value` for a `RandomSeed`,
/// `Best value` for a `LoadBest`.
type OpResult =
    | Done
    | Seed of uint32
    | Best of int

type IO<'a> =
    | Pure of 'a
    | Effect of Op * (OpResult -> IO<'a>)

/// The result of `trace`: the final value and the operations performed, in execution order.
type Traced<'a> = { Result: 'a; Ops: Op list }

let pure (a: 'a) : IO<'a> = Pure a

let effect (op: Op) : IO<OpResult> = Effect(op, pure)

// Pure: apply f now. Effect: keep the op, and extend the continuation so f runs after k.
// Nothing is performed here, we only build a bigger description.
let rec bind (f: 'a -> IO<'b>) (io: IO<'a>) : IO<'b> =
    match io with
    | Pure a -> f a
    | Effect(op, k) -> Effect(op, fun result -> bind f (k result))

let map (f: 'a -> 'b) (io: IO<'a>) : IO<'b> = bind (fun a -> Pure(f a)) io

let sequence (ios: IO<unit> list) : IO<unit> =
    List.foldBack (fun io rest -> bind (fun () -> rest) io) ios (pure ())

let draw (shape: Shape) : IO<unit> = effect (Draw shape) |> map ignore

// A function of unit: F# evaluates module-level values as soon as the module is used, and a description
// is cheap to rebuild. An interpreter that answers a RandomSeed with anything but a Seed is broken; say so loudly.
let randomSeed () : IO<uint32> =
    effect RandomSeed
    |> map (fun result ->
        match result with
        | Seed value -> value
        | _ -> failwith "RandomSeed must be answered with a Seed")

let drawScene (scene: Scene) : IO<unit> = sequence (List.map draw scene)

// m10: the stored best score. Reading it answers a number (built like randomSeed); saving answers Done, like a draw.
let loadBest () : IO<int> =
    effect LoadBest
    |> map (fun result ->
        match result with
        | Best value -> value
        | _ -> failwith "LoadBest must be answered with a Best")

let saveBest (score: int) : IO<unit> = effect (SaveBest score) |> map ignore

// Answer each op with a canned result, collecting the ops as we go. Tail recursion: the compiler turns it
// into a loop, so long programs cannot overflow the stack, and still nothing is mutated.
// `best` (m10) answers LoadBest, the way `seed` answers RandomSeed.
let traceWith (seed: uint32) (best: int) (io: IO<'a>) : Traced<'a> =
    let rec go io performed =
        match io with
        | Pure a -> { Result = a; Ops = List.rev performed }
        | Effect(op, k) ->
            let answer =
                match op with
                | RandomSeed -> Seed seed
                | LoadBest -> Best best
                | Draw _
                | SaveBest _ -> Done

            go (k answer) (op :: performed)

    go io []

// The Module 7 interpreter is the "no stored best" case.
let trace (seed: uint32) (io: IO<'a>) : Traced<'a> = traceWith seed 0 io