require "lunit"

bc = require("bc")
ser = require("serialization")

module("test_bc", package.seeall, lunit.testcase)

function test_init()
  bci = bc:init("a1", {["light"]=false}, {["toggle_light"]=function() end})
end

function test_set_get_noun()
  bci = bc:init("a1", {["light"]=true}, {["toggle_light"]=function() end})
  assert_equal(true, bci:get_noun("light"), "First get failed with wrong value")
  bci:set_noun("light", false)
  assert_equal(false, bci:get_noun("light"), "Second get failed with wrong value")
end

function test_request_noun()
  bci = bc:init("a1", {["light"]=true}, {["toggle_light"]=function() end})
  local i = false
  local expct = true
  remote = require("modem"):init("some_addr", function(laddr, raddr, p, d, msg)
    m = ser.unserialize(msg)
    if m.ty == 3 and m.noun == "light" and m.value == expct then
      i = true
    end
  end)
  remote:send("a1", 1234, ser.serialize({ty=1, noun="light"}))
  assert_true(i, "Noun response did not happen or was incorrect")
  -- Reset and change noun
  i = false
  bci:set_noun("light", false)
  expct = false
  remote:send("a1", 1234, ser.serialize({ty=1, noun="light"}))
  assert_true(i, "Noun response did not happen or was incorrect")
end

function test_call_verb()
  bci = bc:init("a1", {["light"]=true}, {["toggle_light"]=function(b)
    b:set_noun("light", not b:get_noun("light"))
  end})
  remote = require("modem"):init("some_addr", function(laddr, raddr, p, d, msg) end)
  -- Call verb
  remote:send("a1", 1234, ser.serialize({ty=2, verb="toggle_light"}))
  assert_equal(false, bci:get_noun("light"), "Verb did not do its job")
end

function test_multinode_call_verb()
  bc1 = bc:init("a1", {["light"]=true}, {["toggle_light"]=function(b)
    b:set_noun("light", not b:get_noun("light"))
  end})
  bc2 = bc:init("a2", {}, {})
  bc1:call_verb("toggle_light")
  assert_equal(false, bc1:get_noun("light"), "First verb invokation did not go to plan")
  bc2:call_verb("toggle_light")
  assert_equal(true, bc1:get_noun("light"), "Second verb invokation did not go to plan")
end

function test_multinode_get_noun()
  key = "foobar"
  bc1 = bc:init("a1", {["light"]=key}, {["toggle_light"]=function(b)
    b:set_noun("light", not b:get_noun("light"))
  end})
  bc2 = bc:init("a2", {}, {})
  assert_equal(key, bc1:get_noun("light"), "Local get failed")
  assert_equal(key, bc2:get_noun("light"), "Remote get failed")
end

function test_multinode_listening()
  bc1 = bc:init("a1", {["foo"]=123}, {})
  bc2 = bc:init("a2", {}, {})
  local i = false
  -- Local listening
  local id = bc1:listen_noun("foo", "onchange", nil, function(bc, foo)
    i = true
  end)
  bc1:set_noun("foo", 111)
  assert_true(i, "Local listening failed")
  i = false
  bc1:listen_cancel("foo", id) -- Test wether cancelling works
  local j = false
  local rid = bc2:listen_noun("foo", "onchange", nil, function(bc, foo)
    j = true
  end)
  bc1:set_noun("foo", 1234)
  assert_true(j, "Remote listening failed")
  assert_false(i, "Cancelling local listener failed")
  bc2:listen_cancel("foo", rid)
  j = false
  bc1:set_noun("foo", 34)
  assert_false(j, "Cancelling remote listener failed")
end

function test_listen_modes()
  bci = bc:init("a1", {["noun"]=10}, {})
  local i = false
  local id = 0
  -- onchange
  id = bci:listen_noun("noun", "onchange", nil, function(bc, noun)
    i = true
  end)
  bci:set_noun("noun", 11)
  assert_true(i, "Listening \"onchange\" failed")
  bci:listen_cancel("noun", id)
  i = false
  -- onrising
  id = bci:listen_noun("noun", "onrising", nil, function(bc, noun)
    i = true
  end)
  bci:set_noun("noun", 10)
  assert_false(i, "Listening \"onrising\" failed(A)")
  bci:set_noun("noun", 11)
  assert_true(i, "Listening \"onrising\" failed(B)")
  bci:listen_cancel("noun", id)
  i = false
  -- onfalling
  id = bci:listen_noun("noun", "onfalling", nil, function(bc, noun)
    i = true
  end)
  bci:set_noun("noun", 12)
  assert_false(i, "Listening \"onfalling\" failed(A)")
  bci:set_noun("noun", 10)
  assert_true(i, "Listening \"onfalling\" failed(B)")
  bci:listen_cancel("noun", id)
  i = false
  -- onvalue
  id = bci:listen_noun("noun", "onvalue", 99, function(bc, noun)
    i = true
  end)
  bci:set_noun("noun", 100)
  assert_false(i, "Listening \"onvalue\" failed(A)")
  bci:set_noun("noun", 99)
  assert_true(i, "Listening \"onvalue\" failed(B)")
  bci:listen_cancel("noun", id)
  i = false
  -- onabove
  id = bci:listen_noun("noun", "onabove", 100, function(bc, noun)
    i = true
  end)
  bci:set_noun("noun", 10)
  assert_false(i, "Listening \"onabove\" failed(A)")
  bci:set_noun("noun", 110)
  assert_true(i, "Listening \"onabove\" failed(B)")
  bci:listen_cancel("noun", id)
  i = false
  -- onbelow
  id = bci:listen_noun("noun", "onbelow", 10, function(bc, noun)
    i = true
  end)
  bci:set_noun("noun", 11)
  assert_false(i, "Listening \"onbelow\" failed(A)")
  bci:set_noun("noun", 1)
  assert_true(i, "Listening \"onbelow\" failed(B)")
  bci:listen_cancel("noun", id)
end