Module:Test/lib/search

---

local search = {}

---------------
-- conductor --
---------------
-- sibling_key: optional, deprecate the whole thing
-- query: {key, value}
-- query: {key, }
-- query: {nil, value}
-- query: key (string or number)
function search.conductor(query, tbl)
  local f_name = "conductor"
  assert(query, string.format("bad argument #1 to '%s' (argument missing, search query)", f_name))
  assert(tbl, string.format("bad argument #2 to '%s' (argument missing, table to search through)", f_name))

  search.state = {
    ["args"] = {},
    ["queried"] = {}
  }
  search.ancestors = {}

  search.state.args.query = query
  search.state.args.table = tbl
--~   search.state.args.sibling_key = sibling_key

  local result = search.find_first(query, tbl)

  if result then
--~     search.generate_anscestry_of_last_search(result)
--~     result.ancestors = search.ancestors
    return result
  end
end

--------------
-- ancestry --
--------------
function search.generate_anscestry_of_last_search(quad)
  quad = quad or {}

  for _,v in ipairs(search.state.queried) do
    if v.value == quad.parent.table then
      table.insert(search.ancestors, quad.parent.key)
      search.generate_anscestry_of_last_search(v, search.state.queried, ancestors)
    elseif not quad.parent.key then return nil
    end
  end
end

----------------------
-- search_condition --
----------------------
-- note: if I want to search for true/false, will need to change this up a bit
function search.search_condition(query, key, value)
  local condition = false

  if type(query) == "string" or type(query) == "number" then
    condition = key == query
  elseif query[1] and query[2] then
    condition = key == query[1] and value == query[2]
  elseif query[1] then
    condition = key == query[1]
  elseif query[2] then
    condition = value == query[2]
  end

  return condition
end

----------------
-- find_first --
----------------
function search.find_first(query, tbl, tbl_key)
  local subtables = {}

  for k,v in pairs(tbl) do

    local quad = {
      key = k,
      value = v,
      parent = {
        key = tbl_key,
        table = tbl
      }
    }

    -- I do this to be able to generate ancestry for the searh
    -- functionality disabled at the moment
--~     table.insert(search.state.queried, quad)

    if search.search_condition(query, k, v) then
      return quad
    elseif type(v) == "table" then
      table.insert(subtables, k)
    end

  end

  -- By doing it like this it will first search through all of the children and after that
  -- descend into grandchildren.
  for _,k in ipairs(subtables) do
    local f = search.find_first(query, tbl[k], k)
    if f then return f
    end
  end
end

return search