require("lunit")

local serialization = require("serialization")
local BaseControl = require("bc")

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

function test_construct()
  local function is_a_bc(bc)
    assert_true(bc.local_nouns ~= nil)
    assert_true(bc.local_verbs ~= nil)
  end

  -- Short init
  is_a_bc(BaseControl())
  is_a_bc(BaseControl:new())
  is_a_bc(BaseControl:finalize())
  is_a_bc(BaseControl:finalize({}, 10))
  is_a_bc(BaseControl:finalize({}))

  -- Long init
  local bc = BaseControl:new()
  bc:finalize()
  is_a_bc(bc)

  local bc = BaseControl:new()
  bc:finalize({}, 10)
  is_a_bc(bc)

  local bc = BaseControl:new()
  bc:finalize({})
  is_a_bc(bc)
end

function test_register()
  local bc = BaseControl:new()
  bc:register("register1", 1234)
  bc:finalize()

  -- Register after finalizing
  local bc = BaseControl:finalize()
  assert_error_match("after finalizing", function()
    bc:register("register2", 4321)
  end)

  -- Register exisiting
  local bc = BaseControl:new()
  bc:register("register3", 123)
  assert_error_match("already registered", function()
    bc:register("register3", 12)
  end)
end

function test_register_batch()
  local bc = BaseControl:new()
  bc:register{
    rb1=1234,
    rb2=4321,
    rb3v=function() end,
  }
  bc:finalize()

  assert_true(bc:has_noun("rb1"))
  assert_true(bc:has_noun("rb2"))
  assert_true(bc:has_verb("rb3v"))
end

function test_available()
  local bc = BaseControl:new()
  bc:register("available1", 1234)
  bc:register("available2v", function() end)
  bc:finalize()

  assert_equal(1234, bc.local_nouns["available1"])
  assert_true(bc.local_verbs["available2v"] ~= nil)
end

function test_get()
  local bc = BaseControl:new()
  bc:register("get1", 1234)
  bc:register("get2v", function() end)
  bc:finalize()

  assert_equal(1234, bc:get("get1"), "wrong value for noun")
  assert_error_match("unknown", function()
    bc:get("get2")
  end)
  assert_error_match("not a noun", function()
    bc:get("get2v")
  end)
end

function test_set()
  local bc = BaseControl:new()
  bc:register("set1", 31415)
  bc:register("set2v", function() end)
  bc:finalize()

  assert_equal(31415, bc:get("set1"), "wrong value for noun")
  bc:set("set1", 14142)
  assert_equal(14142, bc:get("set1"), "wrong value for noun")

  assert_error_match("not a local", function()
    bc:set("set2", 12345)
  end)

  assert_error_match("can't be cast into a noun", function()
    bc:set("set2v", 12345)
  end)

  assert_pass(function()
    bc:set("set2v", function() end)
  end)

  assert_error_match("can't be cast into a verb", function()
    bc:set("set1", function() end)
  end)
end

function test_has_iter_nouns()
  local bc = BaseControl:new(
    BaseControl.Network(31213) -- Network isolation
  )
  bc:register("hin1", 123)
  bc:register("hin2v", function() end)
  bc:register("hin3", 321)
  bc:finalize()

  assert_true(bc:has_noun("hin1"), "exisiting noun not found")
  assert_false(bc:has_noun("hin2"), "non-existing noun found")
  assert_false(bc:has_noun("hin2v"), "verb found as noun")
  assert_true(bc:has_noun("hin3"), "exisiting noun not found")

  local nouns = bc:nouns()
  table.sort(nouns)
  assert_equal(2, #nouns, "noun-list incorrect")
  assert_equal("hin1", nouns[1], "noun-list incorrect")
  assert_equal("hin3", nouns[2], "noun-list incorrect")
end

function test_call_verb()
  local bc = BaseControl:new()
  local flag1, flag2 = 0, 0
  bc:register("call1", function(a, b)
    flag1 = a + b
    flag2 = flag2 + 1
  end)
  bc:finalize()

  bc:call("call1", 1, 2)
  assert_equal(3, flag1, "call failed")
  assert_equal(1, flag2, "call failed")

  bc:call("call1", 10, 10)
  assert_equal(20, flag1, "call failed")
  assert_equal(2, flag2, "call failed")
end

function test_has_iter_verbs()
  local bc = BaseControl:new(
    BaseControl.Network(31214) -- Network isolation
  )
  bc:register("hiv1v", function() end)
  bc:register("hiv2", 123)
  bc:register("hiv3v", function() end)
  bc:finalize()

  assert_true(bc:has_verb("hiv1v"), "exisiting verb not found")
  assert_false(bc:has_verb("hiv2v"), "non-existing verb found")
  assert_false(bc:has_verb("hiv2"), "noun found as verb")
  assert_true(bc:has_verb("hiv3v"), "exisiting verb not found")

  local verbs = bc:verbs()
  table.sort(verbs)
  assert_equal(2, #verbs, "verb-list incorrect")
  assert_equal("hiv1v", verbs[1], "verb-list incorrect")
  assert_equal("hiv3v", verbs[2], "verb-list incorrect")
end

function test_iter_empty()
  local bc = BaseControl:new(
    BaseControl.Network(31211) -- Network isolation
  ):finalize()

  assert_equal(31211, bc.network.port, "wrong port")
  assert_equal(0, #bc:nouns(), "nouns found in empty network")
  assert_equal(0, #bc:verbs(), "verbs found in empty network")
end