Riepilogo e sfida finale

//// Books on the shelf, and how they are written to and read from JSON.

import gleam/dynamic/decode
import gleam/int
import gleam/json

/// A book, with the year it was published and whether it has been read.
pub type Book {
  Book(title: String, year: Int, read: Bool)
}

/// A new book, not read yet.
pub fn new(title: String, year: Int) -> Book {
  Book(title:, year:, read: False)
}

/// The same book, marked as read.
pub fn mark_read(book: Book) -> Book {
  Book(..book, read: True)
}

/// A one-line description, like `[x] Dune (1965)`.
pub fn to_string(book: Book) -> String {
  let mark = case book.read {
    True -> "[x] "
    False -> "[ ] "
  }
  mark <> book.title <> " (" <> int.to_string(book.year) <> ")"
}

pub fn to_json(book: Book) -> json.Json {
  json.object([
    #("title", json.string(book.title)),
    #("year", json.int(book.year)),
    #("read", json.bool(book.read)),
  ])
}

pub fn decoder() -> decode.Decoder(Book) {
  use title <- decode.field("title", decode.string)
  use year <- decode.field("year", decode.int)
  use read <- decode.field("read", decode.bool)
  decode.success(Book(title:, year:, read:))
}

//// Saving the shelf to a JSON file, and loading it back.

import gleam/dynamic/decode
import gleam/json
import gleam/result
import shelf/book.{type Book}
import simplifile

const path = "shelf.json"

pub type StorageError {
  CannotRead(simplifile.FileError)
  CannotWrite(simplifile.FileError)
  Corrupted
}

/// All the books on the shelf. A shelf that was never saved is empty.
pub fn load() -> Result(List(Book), StorageError) {
  case simplifile.read(path) {
    Ok(text) ->
      json.parse(text, decode.list(book.decoder()))
      |> result.replace_error(Corrupted)
    Error(simplifile.Enoent) -> Ok([])
    Error(error) -> Error(CannotRead(error))
  }
}

/// Replaces the saved shelf with these books.
pub fn save(books: List(Book)) -> Result(Nil, StorageError) {
  let text = json.array(books, book.to_json) |> json.to_string
  simplifile.write(to: path, contents: text)
  |> result.map_error(CannotWrite)
}

pub fn describe_error(error: StorageError) -> String {
  case error {
    CannotRead(error) ->
      "cannot read " <> path <> ": " <> simplifile.describe_error(error)
    CannotWrite(error) ->
      "cannot write " <> path <> ": " <> simplifile.describe_error(error)
    Corrupted -> path <> " is not a valid shelf"
  }
}

import argv
import gleam/bool
import gleam/int
import gleam/io
import gleam/list
import gleam/result
import gleam/string
import shelf/book
import shelf/storage.{type StorageError}

pub type CommandError {
  InvalidYear
  InvalidNumber
  NoSuchBook(number: Int)
  StorageFailed(StorageError)
}

const usage = "Usage:
  shelf add <title> <year>
  shelf list
  shelf read <number>"

pub fn main() -> Nil {
  let result = case argv.load().arguments {
    ["add", title, year] -> add(title, year)
    ["list"] -> list_books()
    ["read", number] -> mark_read(number)
    _ -> Ok(usage)
  }
  case result {
    Ok(message) -> io.println(message)
    Error(error) -> io.println("Error: " <> explain(error))
  }
}

fn add(title: String, year: String) -> Result(String, CommandError) {
  use year <- result.try(int.parse(year) |> result.replace_error(InvalidYear))
  use books <- result.try(load())
  let new_book = book.new(title, year)
  use Nil <- result.try(save(list.append(books, [new_book])))
  Ok("Added " <> book.to_string(new_book))
}

fn list_books() -> Result(String, CommandError) {
  use books <- result.try(load())
  case books {
    [] -> Ok("The shelf is empty")
    _ ->
      books
      |> list.index_map(fn(item, index) {
        int.to_string(index + 1) <> ". " <> book.to_string(item)
      })
      |> string.join(with: "\n")
      |> Ok
  }
}

fn mark_read(number: String) -> Result(String, CommandError) {
  use number <- result.try(
    int.parse(number) |> result.replace_error(InvalidNumber),
  )
  use <- bool.guard(when: number < 1, return: Error(NoSuchBook(number)))
  use books <- result.try(load())
  use target <- result.try(
    books
    |> list.drop(number - 1)
    |> list.first
    |> result.replace_error(NoSuchBook(number)),
  )
  let updated =
    list.index_map(books, fn(item, index) {
      case index + 1 == number {
        True -> book.mark_read(item)
        False -> item
      }
    })
  use Nil <- result.try(save(updated))
  Ok("Marked as read: " <> book.to_string(book.mark_read(target)))
}

fn load() -> Result(List(book.Book), CommandError) {
  storage.load() |> result.map_error(StorageFailed)
}

fn save(books: List(book.Book)) -> Result(Nil, CommandError) {
  storage.save(books) |> result.map_error(StorageFailed)
}

fn explain(error: CommandError) -> String {
  case error {
    InvalidYear -> "the year must be a number"
    InvalidNumber -> "the book number must be a number"
    NoSuchBook(number) -> "there is no book number " <> int.to_string(number)
    StorageFailed(error) -> storage.describe_error(error)
  }
}