Riepilogo e sfida finale

import gleam/dict.{type Dict}
import gleam/erlang/process.{type Subject}
import gleam/otp/actor
import gleam/result

pub type BookingError {
  NoSuchSeat
  AlreadyTaken(by: String)
}

pub opaque type Message {
  Book(
    seat: Int,
    customer: String,
    reply_to: Subject(Result(Nil, BookingError)),
  )
  Bookings(reply_to: Subject(Dict(Int, String)))
}

type State {
  State(seats: Int, bookings: Dict(Int, String))
}

/// Starts a box office for a hall with seats numbered from 1 to `seats`.
pub fn start(seats: Int) -> Result(Subject(Message), actor.StartError) {
  actor.new(State(seats:, bookings: dict.new()))
  |> actor.on_message(handle_message)
  |> actor.start
  |> result.map(fn(started) { started.data })
}

pub fn book(
  office: Subject(Message),
  seat seat: Int,
  for customer: String,
) -> Result(Nil, BookingError) {
  actor.call(office, waiting: 100, sending: fn(reply_to) {
    Book(seat:, customer:, reply_to:)
  })
}

pub fn bookings(office: Subject(Message)) -> Dict(Int, String) {
  actor.call(office, waiting: 100, sending: Bookings)
}

fn handle_message(
  state: State,
  message: Message,
) -> actor.Next(State, Message) {
  case message {
    Book(seat:, customer:, reply_to:) ->
      case check(state, seat) {
        Ok(Nil) -> {
          actor.send(reply_to, Ok(Nil))
          let bookings = dict.insert(state.bookings, seat, customer)
          actor.continue(State(..state, bookings:))
        }
        Error(error) -> {
          actor.send(reply_to, Error(error))
          actor.continue(state)
        }
      }
    Bookings(reply_to) -> {
      actor.send(reply_to, state.bookings)
      actor.continue(state)
    }
  }
}

fn check(state: State, seat: Int) -> Result(Nil, BookingError) {
  case dict.get(state.bookings, seat) {
    _ if seat < 1 || seat > state.seats -> Error(NoSuchSeat)
    Ok(owner) -> Error(AlreadyTaken(by: owner))
    Error(Nil) -> Ok(Nil)
  }
}

import box_office.{type BookingError, type Message, AlreadyTaken, NoSuchSeat}
import gleam/dict
import gleam/erlang/process.{type Subject}
import gleam/int
import gleam/io

pub fn main() -> Nil {
  let assert Ok(office) = box_office.start(10)
  report("Ada", 1, box_office.book(office, seat: 1, for: "Ada"))
  report("Joe", 1, box_office.book(office, seat: 1, for: "Joe"))
  report("Joe", 11, box_office.book(office, seat: 11, for: "Joe"))

  let results = process.new_subject()
  int.range(from: 1, to: 9, with: Nil, run: fn(_, n) {
    let fan = "fan " <> int.to_string(n)
    process.spawn(fn() { process.send(results, try_all_seats(office, fan)) })
    Nil
  })
  let #(booked, refused) = collect(results, 8, #(0, 0))
  io.println(
    "Fans booked "
    <> int.to_string(booked)
    <> " seats, "
    <> int.to_string(refused)
    <> " requests refused",
  )
  let sold = dict.size(box_office.bookings(office))
  io.println("Seats sold: " <> int.to_string(sold) <> " of 10")
}

fn report(
  customer: String,
  seat: Int,
  result: Result(Nil, BookingError),
) -> Nil {
  let seat = "seat " <> int.to_string(seat)
  case result {
    Ok(Nil) -> io.println(customer <> ": " <> seat <> " booked")
    Error(NoSuchSeat) ->
      io.println(customer <> ": " <> seat <> " does not exist")
    Error(AlreadyTaken(by:)) ->
      io.println(customer <> ": " <> seat <> " is taken by " <> by)
  }
}

/// Tries to book every seat, and returns how many bookings succeeded and failed.
fn try_all_seats(office: Subject(Message), fan: String) -> #(Int, Int) {
  int.range(from: 1, to: 11, with: #(0, 0), run: fn(acc, seat) {
    case box_office.book(office, seat:, for: fan) {
      Ok(Nil) -> #(acc.0 + 1, acc.1)
      Error(_) -> #(acc.0, acc.1 + 1)
    }
  })
}

fn collect(
  results: Subject(#(Int, Int)),
  left: Int,
  total: #(Int, Int),
) -> #(Int, Int) {
  case left {
    0 -> total
    _ -> {
      let #(booked, refused) = process.receive_forever(results)
      collect(results, left - 1, #(total.0 + booked, total.1 + refused))
    }
  }
}