import any
import result:Result
import expect

pub external type Map(key, value);

pub external fn new() -> Map(key, value))
  = "maps" "new"

test new {
  new()
    |> size
    |> expect:equal(_, 0)
}

pub external fn size(Map(_, _)) -> Int
  = "maps" "size"

test size {
  []
    |> from_list
    |> size
    |> expect:equal(_, 0)

  [
    {1, 1},
  ]
    |> from_list
    |> size
    |> expect:equal(_, 1)

  [
    {"", 1.0},
    {"", 2.0},
  ]
    |> from_list
    |> size
    |> expect:equal(_, 2)
}

external fn is_key(key, Map(key, _)) -> Bool
  = "maps" "is_key"

pub fn has_key(map, key) {
  is_key(key, map)
}

test has_key {
  []
    |> from_list
    |> has_key(_, 1)
    |> expect:false

  [
    {1, 0},
  ]
    |> from_list
    |> has_key(_, 1)
    |> expect:true

  [
    {4, 0},
    {1, 0},
  ]
    |> from_list
    |> has_key(_, 1)
    |> expect:true

  [
    {4, 0},
    {1, 0},
  ]
    |> from_list
    |> has_key(_, 0)
    |> expect:false
}

pub fn from_record(record: {r}) -> Map(Atom, any:Any) {
  any:unsafeCoerce(record)
}

test from_record {
  map = from_record({ name = "Jane" })

  map
    |> size
    |> expect:equal(_, 1)

  map
    |> expect:equal(_, from_list([{"name", "Jane"}]))
}

pub external fn to_list(Map(key, value)) -> List(Tuple(key, value))
  = "maps" "to_list"

pub external fn from_list(List(Tuple(key, value))) -> Map(key, value)
  = "maps" "from_list"

test from_list {
  proplist = [
    {4, 0},
    {1, 0},
  ]
  map = from_list(proplist)

  map
    |> size
    |> expect:equal(_, 2)

  map
    |> to_list
    |> expect:equal(_, proplist)
}

pub external fn fetch(Map(key, value), key) -> Result(Unit, value)
  = "gleam__stdlib" "map_fetch";

test fetch {
  proplist = [
    {4, 0},
    {1, 1},
  ]
  map = from_list(proplist)

  map
    |> fetch(_, 4)
    |> expect:equal(_, result:Ok(0))

  map
    |> fetch(_, 1)
    |> expect:equal(_, result:Ok(1))

  map
    |> fetch(_, 2)
    |> expect:equal(_, result:Error(()))
}

external fn erl_put(key, value, Map(key, value)) -> Map(key, value)
  = "maps" "put";

pub fn put(map, key, value) {
  erl_put(key, value, map)
}

test put {
  new()
    |> put(_, "a", 0)
    |> put(_, "b", 1)
    |> put(_, "c", 2)
    |> expect:equal(_, result:Ok(from_list([{"a", 0}, {"b", 1}, {"c", 2}])))
}

external fn erl_map_values(fn(key, value) -> value, Map(key, value)) -> Map(key, value)
  = "maps" "map";

pub fn map_values(map, fun) {
  erl_map_values(fun, map)
}

test map_values {
  [
    {1, 0},
    {2, 1},
    {3, 2},
  ]
    |> from_list
    |> map_values(_, fn(k, v) { k + v })
    |> expect:equal(_, from_list([{1, 0}, {2, 3}, {3, 5}]))
}

pub external fn keys(Map(keys, _)) -> List(keys)
  = "maps" "keys"

test keys {
  [
    {"a", 0},
    {"b", 1},
    {"c", 2},
  ]
    |> from_list
    |> keys
    |> expect:equal(_, ["a", "b", "c"]))
}

pub external fn values(Map(_, values)) -> List(values)
  = "maps" "values"

test values {
  [
    {"a", 0},
    {"b", 1},
    {"c", 2},
  ]
    |> from_list
    |> values
    |> expect:equal(_, [0, 1, 2]))
}

external fn erl_filter(fn(key, value) -> Bool, Map(key, value)) -> Map(key, value)
  = "maps" "filter";

pub fn filter(map, fun) {
  filter(fun, map)
}

test map_values {
  [
    {1, 0},
    {3, 2},
    {2, 1},
  ]
    |> from_list
    |> filter(_, fn(k, v) { k + v < 4 })
    |> expect:equal(_, from_list([{1, 0}, {2, 3}]))
}