if not bobmods.lib.tech then
  bobmods.lib.tech = {}
end

local function split_line(technology, tag)
  if data.raw.technology[technology][tag] then
    if not data.raw.technology[technology].normal[tag] then
      data.raw.technology[technology].normal[tag] = table.deepcopy(data.raw.technology[technology][tag])
    end
    if not data.raw.technology[technology].expensive[tag] then
      data.raw.technology[technology].expensive[tag] = table.deepcopy(data.raw.technology[technology][tag])
    end
  end
end

local function split_line_bool(technology, tag)
  if data.raw.technology[technology][tag] == true then
    data.raw.technology[technology].normal[tag] = true
    data.raw.technology[technology].expensive[tag] = true
  end
  if data.raw.technology[technology][tag] == false then
    data.raw.technology[technology].normal[tag] = false
    data.raw.technology[technology].expensive[tag] = false
  end
end

function bobmods.lib.tech.difficulty_split(technology)
  if type(technology) == "string" and data.raw.technology[technology] then
    if not data.raw.technology[technology].normal then
      data.raw.technology[technology].normal = {}
    end
    if not data.raw.technology[technology].expensive then
      data.raw.technology[technology].expensive = {}
    end

    split_line_bool(recipe, "upgrade")
    split_line_bool(recipe, "enabled")
    split_line_bool(recipe, "hidden")
    split_line_bool(recipe, "visible_when_disabled")

    split_line(recipe, "unit")
    split_line(recipe, "max_level")
    split_line(recipe, "prerequisites")
    split_line(recipe, "effects")
  else
    log(debug.traceback())
    bobmods.lib.error.recipe(recipe)
  end
end

local function add_new_science_pack(technology, pack, amount)
  if technology.unit and technology.unit.ingredients then
    local addit = true
    for i, ingredient in pairs(technology.unit.ingredients) do
      if ingredient[1] == pack or ingredient.name == pack then
        addit = false
      end
    end
    if addit then
      table.insert(technology.unit.ingredients, { pack, amount })
    end
  end
end

local function add_science_pack(technology, pack, amount)
  if technology.unit and technology.unit.ingredients then
    local addit = true
    for i, ingredient in pairs(technology.unit.ingredients) do
      if ingredient[1] == pack then
        addit = false
        ingredient[2] = ingredient[2] + amount
      end
      if ingredient.name == pack then
        addit = false
        ingredient.amount = ingredient.amount + amount
      end
    end
    if addit then
      table.insert(technology.unit.ingredients, { pack, amount })
    end
  end
end

local function remove_science_pack(technology, pack)
  if technology.unit and technology.unit.ingredients then
    for i, ingredient in pairs(technology.unit.ingredients) do
      if ingredient[1] == pack or ingredient.name == pack then
        table.remove(technology.unit.ingredients, i)
      end
    end
  end
end

local function replace_science_pack(technology, old, new)
  if technology.unit and technology.unit.ingredients then
    local doit = false
    local amount = 0
    for i, ingredient in pairs(technology.unit.ingredients) do
      if ingredient[1] == old then
        doit = true
        amount = ingredient[2] + amount
      end
      if ingredient.name == old then
        doit = true
        amount = ingredient.amount + amount
      end
    end
    if doit then
      remove_science_pack(technology, old)
      add_science_pack(technology, new, amount)
    end
  end
end

function bobmods.lib.tech.replace_science_pack(technology, old, new)
  if
    type(technology) == "string"
    and type(old) == "string"
    and type(new) == "string"
    and data.raw.technology[technology]
    --    data.raw.tool[old] and
    and data.raw.tool[new]
  then
    if data.raw.technology[technology].unit then
      replace_science_pack(data.raw.technology[technology], old, new)
    end
    if data.raw.technology[technology].normal and data.raw.technology[technology].normal.unit then
      replace_science_pack(data.raw.technology[technology].normal, old, new)
    end
    if data.raw.technology[technology].expensive and data.raw.technology[technology].expensive.unit then
      replace_science_pack(data.raw.technology[technology].expensive, old, new)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.item_of_type(old, "tool", "Old science pack")
    bobmods.lib.error.item_of_type(new, "tool", "New science pack")
  end
end

function bobmods.lib.tech.add_new_science_pack(technology, pack, amount)
  if
    type(technology) == "string"
    and type(pack) == "string"
    and type(amount) == "number"
    and data.raw.technology[technology]
    and data.raw.tool[pack]
  then
    if data.raw.technology[technology].unit then
      add_new_science_pack(data.raw.technology[technology], pack, amount)
    end
    if data.raw.technology[technology].normal and data.raw.technology[technology].normal.unit then
      add_new_science_pack(data.raw.technology[technology].normal, pack, amount)
    end
    if data.raw.technology[technology].expensive and data.raw.technology[technology].expensive.unit then
      add_new_science_pack(data.raw.technology[technology].expensive, pack, amount)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.item_of_type(pack, "tool", "Science pack")
  end
end

function bobmods.lib.tech.add_science_pack(technology, pack, amount)
  if
    type(technology) == "string"
    and type(pack) == "string"
    and type(amount) == "number"
    and data.raw.technology[technology]
    and data.raw.tool[pack]
  then
    if data.raw.technology[technology].unit then
      add_science_pack(data.raw.technology[technology], pack, amount)
    end
    if data.raw.technology[technology].normal and data.raw.technology[technology].normal.unit then
      add_science_pack(data.raw.technology[technology].normal, pack, amount)
    end
    if data.raw.technology[technology].expensive and data.raw.technology[technology].expensive.unit then
      add_science_pack(data.raw.technology[technology].expensive, pack, amount)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.item_of_type(pack, "tool", "Science pack")
  end
end

function bobmods.lib.tech.add_science_packs(technology, science_packs)
  if type(technology) == "string" and type(science_packs) == "table" then
    for i, science_pack in pairs(science_packs) do
      if
        type(science_pack) == "table"
        and type(science_pack[1]) == "string"
        and data.raw.tool[science_pack[1]]
        and type(science_pack[2]) == "number"
      then
        bobmods.lib.tech.add_science_pack(technology, science_pack[1], science_pack[2])
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
end

function bobmods.lib.tech.remove_science_pack(technology, pack)
  if type(technology) == "string" and type(pack) == "string" and data.raw.technology[technology] then
    if data.raw.technology[technology].unit then
      remove_science_pack(data.raw.technology[technology], pack)
    end
    if data.raw.technology[technology].normal and data.raw.technology[technology].normal.unit then
      remove_science_pack(data.raw.technology[technology].normal, pack)
    end
    if data.raw.technology[technology].expensive and data.raw.technology[technology].expensive.unit then
      remove_science_pack(data.raw.technology[technology].expensive, pack)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
end

function bobmods.lib.tech.clear_science_packs(technology)
  if type(technology) == "string" and data.raw.technology[technology] then
    if data.raw.technology[technology].unit then
      data.raw.technology[technology].unit.ingredients = {}
    end
    if data.raw.technology[technology].normal and data.raw.technology[technology].normal.unit then
      data.raw.technology[technology].normal.unit.ingredients = {}
    end
    if data.raw.technology[technology].expensive and data.raw.technology[technology].expensive.unit then
      data.raw.technology[technology].expensive.unit.ingredients = {}
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
end

function bobmods.lib.tech.set_science_packs(technology, science_packs)
  if type(technology) == "string" and data.raw.technology[technology] and type(science_packs) == "table" then
    bobmods.lib.tech.clear_science_packs(technology)
    bobmods.lib.tech.add_science_packs(technology, science_packs)
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
end

function bobmods.lib.tech.set_science_pack_count(technology, count)
  if type(technology) == "string" and data.raw.technology[technology] then
    local prototype = data.raw.technology[technology]
    if prototype.unit then
      prototype.unit.count = count
    end
    if prototype.normal and prototype.normal.unit then
      prototype.normal.unit.count = count
    end
    if prototype.expensive and prototype.expensive.unit then
      prototype.expensive.unit.count = count
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
end

function bobmods.lib.tech.replace_difficulty_science_pack(technology, difficulty, old, new)
  if
    type(technology) == "string"
    and type(old) == "string"
    and type(new) == "string"
    and data.raw.technology[technology]
    --    data.raw.tool[old] and
    and data.raw.tool[new]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty].unit then
      replace_science_pack(data.raw.technology[technology][difficulty], old, new)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.item_of_type(old, "tool", "Old science pack")
    bobmods.lib.error.item_of_type(new, "tool", "New science pack")
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.add_new_difficulty_science_pack(technology, difficulty, pack, amount)
  if
    type(technology) == "string"
    and type(pack) == "string"
    and type(amount) == "number"
    and data.raw.technology[technology]
    and data.raw.tool[pack]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty].unit then
      add_new_science_pack(data.raw.technology[technology][difficulty], pack, amount)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.item_of_type(pack, "tool", "Science pack")
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.add_difficulty_science_pack(technology, difficulty, pack, amount)
  if
    type(technology) == "string"
    and type(pack) == "string"
    and type(amount) == "number"
    and data.raw.technology[technology]
    and data.raw.tool[pack]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty].unit then
      add_science_pack(data.raw.technology[technology][difficulty], pack, amount)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.item_of_type(pack, "tool", "Science pack")
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.remove_difficulty_science_pack(technology, difficulty, pack)
  if
    type(technology) == "string"
    and type(pack) == "string"
    and data.raw.technology[technology]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty].unit then
      remove_science_pack(data.raw.technology[technology][difficulty], pack)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.difficulty(difficulty)
  end
end

local function has_recipe_unlock(technology, recipe)
  if technology.effects then
    for i, effect in pairs(technology.effects) do
      if effect.type == "unlock-recipe" and effect.recipe == recipe then
        return true
      end
    end
  end
  return false
end

local function add_recipe_unlock(technology, recipe)
  local addit = true
  if not technology.effects then
    technology.effects = {}
  end
  for i, effect in pairs(technology.effects) do
    if effect.type == "unlock-recipe" and effect.recipe == recipe then
      addit = false
    end
  end
  if addit then
    table.insert(technology.effects, { type = "unlock-recipe", recipe = recipe })
  end
end

local function remove_recipe_unlock(technology, recipe)
  if technology.effects then
    for i, effect in pairs(technology.effects) do
      if effect.type == "unlock-recipe" and effect.recipe == recipe then
        table.remove(technology.effects, i)
      end
    end
  end
end

function bobmods.lib.tech.has_recipe_unlock(technology, recipe)
  if
    type(technology) == "string"
    and type(recipe) == "string"
    and data.raw.technology[technology]
    and data.raw.recipe[recipe]
  then
    local hasit = false
    hasit = has_recipe_unlock(data.raw.technology[technology], recipe)

    if data.raw.technology[technology].normal then
      hasit = hasit or has_recipe_unlock(data.raw.technology[technology].normal, recipe)
    end
    if data.raw.technology[technology].expensive then
      hasit = hasit or has_recipe_unlock(data.raw.technology[technology].expensive, recipe)
    end
    return hasit
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.recipe(recipe)
    return false
  end
end

function bobmods.lib.tech.add_recipe_unlock(technology, recipe)
  if
    type(technology) == "string"
    and type(recipe) == "string"
    and data.raw.technology[technology]
    and data.raw.recipe[recipe]
  then
    add_recipe_unlock(data.raw.technology[technology], recipe)

    if data.raw.technology[technology].normal then
      add_recipe_unlock(data.raw.technology[technology].normal, recipe)
    end
    if data.raw.technology[technology].expensive then
      add_recipe_unlock(data.raw.technology[technology].expensive, recipe)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.recipe(recipe)
  end
end

function bobmods.lib.tech.remove_recipe_unlock(technology, recipe)
  if
    type(technology) == "string"
    and type(recipe) == "string"
    and data.raw.technology[technology]
    --    data.raw.recipe[recipe] --don't check to see if something we're removing exists.
  then
    remove_recipe_unlock(data.raw.technology[technology], recipe)

    if data.raw.technology[technology].normal then
      remove_recipe_unlock(data.raw.technology[technology].normal, recipe)
    end
    if data.raw.technology[technology].expensive then
      remove_recipe_unlock(data.raw.technology[technology].expensive, recipe)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.recipe(recipe)
  end
end

function bobmods.lib.tech.has_difficulty_recipe_unlock(technology, difficulty, recipe)
  if
    type(technology) == "string"
    and type(recipe) == "string"
    and data.raw.technology[technology]
    and data.raw.recipe[recipe]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if data.raw.technology[technology][difficulty] then
      return has_recipe_unlock(data.raw.technology[technology][difficulty], recipe)
    else
      return has_recipe_unlock(data.raw.technology[technology], recipe)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.recipe(recipe)
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.add_difficulty_recipe_unlock(technology, difficulty, recipe)
  if
    type(technology) == "string"
    and type(recipe) == "string"
    and data.raw.technology[technology]
    and data.raw.recipe[recipe]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty] then
      add_recipe_unlock(data.raw.technology[technology][difficulty], recipe)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.recipe(recipe)
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.remove_difficulty_recipe_unlock(technology, difficulty, recipe)
  if
    type(technology) == "string"
    and type(recipe) == "string"
    and data.raw.technology[technology]
    --    data.raw.recipe[recipe] --don't check to see if something we're removing exists.
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty] then
      remove_recipe_unlock(data.raw.technology[technology][difficulty], recipe)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.recipe(recipe)
    bobmods.lib.error.difficulty(difficulty)
  end
end

local function add_prerequisite(technology, prerequisite)
  local addit = true
  if technology.prerequisites then
    for i, check in ipairs(technology.prerequisites) do
      if check == prerequisite then
        addit = false
      end
    end
  else
    technology.prerequisites = {}
  end
  if addit then
    table.insert(technology.prerequisites, prerequisite)
  end
end

local function remove_prerequisite(technology, prerequisite)
  if technology.prerequisites then
    for i, check in ipairs(technology.prerequisites) do
      if check == prerequisite then
        table.remove(technology.prerequisites, i)
      end
    end
  end
end

local function replace_prerequisite(technology, old, new)
  if technology.prerequisites then
    for i, prerequisite in ipairs(technology.prerequisites) do
      if prerequisite == old then
        remove_prerequisite(technology, old)
        add_prerequisite(technology, new)
      end
    end
  end
end

function bobmods.lib.tech.replace_prerequisite(technology, old, new)
  if
    type(technology) == "string"
    and type(old) == "string"
    and type(new) == "string"
    and data.raw.technology[technology]
    --    data.raw.technology[old] and
    and data.raw.technology[new]
  then
    replace_prerequisite(data.raw.technology[technology], old, new)

    if data.raw.technology[technology].normal then
      replace_prerequisite(data.raw.technology[technology].normal, old, new)
    end
    if data.raw.technology[technology].expensive then
      replace_prerequisite(data.raw.technology[technology].expensive, old, new)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(old, "Old prerequisite", "Old prerequisite technology")
    bobmods.lib.error.technology(new, "New prerequisite", "New prerequisite technology")
  end
end

function bobmods.lib.tech.add_prerequisite(technology, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    and data.raw.technology[prerequisite]
  then
    add_prerequisite(data.raw.technology[technology], prerequisite)

    if data.raw.technology[technology].normal then
      add_prerequisite(data.raw.technology[technology].normal, prerequisite)
    end
    if data.raw.technology[technology].expensive then
      add_prerequisite(data.raw.technology[technology].expensive, prerequisite)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
  end
end

function bobmods.lib.tech.remove_prerequisite(technology, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    --    data.raw.technology[prerequisite]
  then
    remove_prerequisite(data.raw.technology[technology], prerequisite)

    if data.raw.technology[technology].normal then
      remove_prerequisite(data.raw.technology[technology].normal, prerequisite)
    end
    if data.raw.technology[technology].expensive then
      remove_prerequisite(data.raw.technology[technology].expensive, prerequisite)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
  end
end

function bobmods.lib.tech.replace_difficulty_prerequisite(technology, difficulty, old, new)
  if
    type(technology) == "string"
    and type(old) == "string"
    and type(new) == "string"
    and data.raw.technology[technology]
    --    data.raw.technology[old] and
    and data.raw.technology[new]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty] then
      replace_prerequisite(data.raw.technology[technology][difficulty], old, new)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(old, "Old prerequisite", "Old prerequisite technology")
    bobmods.lib.error.technology(new, "New prerequisite", "New prerequisite technology")
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.add_difficulty_prerequisite(technology, difficulty, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    and data.raw.technology[prerequisite]
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty] then
      add_prerequisite(data.raw.technology[technology][difficulty], prerequisite)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.remove_difficulty_prerequisite(technology, difficulty, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    --    data.raw.technology[prerequisite] and
    and (difficulty == "normal" or difficulty == "expensive")
  then
    if not data.raw.technology[technology][difficulty] then
      bobmods.lib.tech.difficulty_split(technology)
    end
    if data.raw.technology[technology][difficulty] then
      remove_prerequisite(data.raw.technology[technology][difficulty], prerequisite)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
    bobmods.lib.error.difficulty(difficulty)
  end
end

function bobmods.lib.tech.has_prerequisite(technology, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    and data.raw.technology[prerequisite]
  then
    if data.raw.technology[technology].prerequisites then
      for i, check in pairs(data.raw.technology[technology].prerequisites) do
        if check == prerequisite then
          return true
        end
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
  end
  return false
end

function bobmods.lib.tech.get_prerequisites(technology)
  local prerequisites = {}
  if type(technology) == "string" and data.raw.technology[technology] then
    if data.raw.technology[technology].prerequisites then
      for i, prerequisite in ipairs(data.raw.technology[technology].prerequisites) do
        table.insert(prerequisites, prerequisite)
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
  return prerequisites
end

function bobmods.lib.tech.get_prerequisites_in_tree(technology)
  local prerequisites = {}
  if type(technology) == "string" and data.raw.technology[technology] then
    local temp = {}
    if data.raw.technology[technology].prerequisites then
      for i, prerequisite in ipairs(data.raw.technology[technology].prerequisites) do
        if type(prerequisite) == "string" and data.raw.technology[prerequisite] then
          temp[prerequisite] = true
          if data.raw.technology[prerequisite].prerequisites then
            for j, prerequisite_in_tree in ipairs(bobmods.lib.tech.get_prerequisites_in_tree(prerequisite)) do
              temp[prerequisite_in_tree] = true
            end
          end
        else
          log(technology .. " has an invalid prerequisite.")
          bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
        end
      end
    end
    for prerequisite, _ in pairs(temp) do
      table.insert(prerequisites, prerequisite)
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
  return prerequisites
end

function bobmods.lib.tech.has_prerequisite_in_tree(technology, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    and data.raw.technology[prerequisite]
  then
    if data.raw.technology[technology].prerequisites then
      for i, check in pairs(data.raw.technology[technology].prerequisites) do
        if check == prerequisite or bobmods.lib.tech.has_prerequisite_in_tree(check, prerequisite) then
          return true
        end
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
  end
  return false
end

function bobmods.lib.tech.has_prerequisite_in_tree_only(technology, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    and data.raw.technology[prerequisite]
  then
    if data.raw.technology[technology].prerequisites then
      for i, check in ipairs(data.raw.technology[technology].prerequisites) do
        if check ~= prerequisite and bobmods.lib.tech.has_prerequisite_in_tree(check, prerequisite) then
          return true
        end
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
  end
  return false
end

function bobmods.lib.tech.get_redundant_prerequisites(technology)
  local redundant = {}
  if type(technology) == "string" and data.raw.technology[technology] then
    if data.raw.technology[technology].prerequisites then
      for i, prerequisite in ipairs(data.raw.technology[technology].prerequisites) do
        if bobmods.lib.tech.has_prerequisite_in_tree_only(technology, prerequisite) then
          table.insert(redundant, prerequisite)
        end
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
  return redundant
end

function bobmods.lib.tech.get_redundant_prerequisites_smart(technology)
  local redundant = {}
  if type(technology) == "string" and data.raw.technology[technology] then
    if data.raw.technology[technology].prerequisites then
      local technology_trunc = string.gsub(technology, "%A", "")
      for i, prerequisite in ipairs(data.raw.technology[technology].prerequisites) do
        if type(prerequisite) == "string" then
          local prerequisite_trunc = string.gsub(prerequisite, "%A", "")
          if
            technology_trunc ~= prerequisite_trunc
            and bobmods.lib.tech.has_prerequisite_in_tree_only(technology, prerequisite)
          then
            table.insert(redundant, prerequisite)
          end
        end
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
  return redundant
end

local prerequisites_cache = {}
--Cache holds prerequisites as tags instead of keys for faster sorting and checking.

local function get_prerequisites_in_tree_cached(technology)
  if type(technology) == "string" and data.raw.technology[technology] then
    if not prerequisites_cache[technology] then
      prerequisites_cache[technology] = {}
      if data.raw.technology[technology].prerequisites then
        for i, prerequisite in ipairs(data.raw.technology[technology].prerequisites) do
          if type(prerequisite) == "string" and data.raw.technology[prerequisite] then
            prerequisites_cache[technology][prerequisite] = true
            if data.raw.technology[prerequisite].prerequisites then
              for prerequisite_in_tree, _ in pairs(get_prerequisites_in_tree_cached(prerequisite)) do
                prerequisites_cache[technology][prerequisite_in_tree] = true
              end
            end
          else
            log(technology .. " has an invalid prerequisite.")
            bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
          end
        end
      end
    end
    return prerequisites_cache[technology]
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    return {}
  end
end

local function has_prerequisite_in_tree_only_cached(technology, prerequisite)
  if
    type(technology) == "string"
    and type(prerequisite) == "string"
    and data.raw.technology[technology]
    and data.raw.technology[prerequisite]
  then
    if data.raw.technology[technology].prerequisites then
      for i, check in ipairs(data.raw.technology[technology].prerequisites) do
        if check ~= prerequisite and get_prerequisites_in_tree_cached(check)[prerequisite] then
          return true
        end
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
    bobmods.lib.error.technology(prerequisite, "Prerequisite", "Prerequisite technology")
  end
  return false
end

local function get_redundant_prerequisites_smart_cached(technology)
  local redundant = {}
  if type(technology) == "string" and data.raw.technology[technology] then
    if data.raw.technology[technology].prerequisites then
      local technology_trunc = string.gsub(technology, "%A", "")
      for i, prerequisite in ipairs(data.raw.technology[technology].prerequisites) do
        if type(prerequisite) == "string" then
          local prerequisite_trunc = string.gsub(prerequisite, "%A", "")
          if
            technology_trunc ~= prerequisite_trunc
            and has_prerequisite_in_tree_only_cached(technology, prerequisite)
          then
            table.insert(redundant, prerequisite)
          end
        end
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology)
  end
  return redundant
end

local function duplicate_prerequisites_check_inner(technology_name, prerequisites)
  local prerequisites_list = {}
  local rebuild = false
  for i, prerequisite in ipairs(prerequisites) do
    if type(prerequisite) == "string" then
      if prerequisites_list[prerequisite] then -- duplicate value
        rebuild = true
      else
        prerequisites_list[prerequisite] = true
      end
    else --invalid value
      rebuild = true
    end
  end
  if rebuild == true then
    prerequisites = {}
    for prerequisite, _ in pairs(prerequisites_list) do
      table.insert(prerequisites, prerequisite)
    end
    return prerequisites
  end
end

local function duplicate_prerequisites_check(technology_name)
  if type(technology_name) == "string" and data.raw.technology[technology_name] then
    if data.raw.technology[technology_name].prerequisites then
      local prerequisites =
        duplicate_prerequisites_check_inner(technology_name, data.raw.technology[technology_name].prerequisites)
      if prerequisites then
        data.raw.technology[technology_name].prerequisites = prerequisites
      end
    end
    if data.raw.technology[technology_name].normal and data.raw.technology[technology_name].normal.prerequisites then
      local prerequisites =
        duplicate_prerequisites_check_inner(technology_name, data.raw.technology[technology_name].normal.prerequisites)
      if prerequisites then
        data.raw.technology[technology_name].normal.prerequisites = prerequisites
      end
    end
    if
      data.raw.technology[technology_name].expensive and data.raw.technology[technology_name].expensive.prerequisites
    then
      local prerequisites = duplicate_prerequisites_check_inner(
        technology_name,
        data.raw.technology[technology_name].expensive.prerequisites
      )
      if prerequisites then
        data.raw.technology[technology_name].expensive.prerequisites = prerequisites
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology_name)
  end
end

function bobmods.lib.tech.prerequisite_cleanup()
  log("Running technology prerequisite cleanup...")
  for technology_name, technology in pairs(data.raw.technology) do
    duplicate_prerequisites_check(technology_name)
    for i, prerequisite in pairs(get_redundant_prerequisites_smart_cached(technology_name)) do
      bobmods.lib.tech.remove_prerequisite(technology_name, prerequisite)
      --      log("removed " .. prerequisite .. " from " .. technology_name)
    end
  end
end

function bobmods.lib.tech.hide(technology_name)
  if type(technology_name) == "string" and data.raw.technology[technology_name] then
    local technology = data.raw.technology[technology_name]
    if technology.normal then
      technology.normal.hidden = true
      technology.normal.enabled = false
    end
    if technology.expensive then
      technology.expensive.hidden = true
      technology.expensive.enabled = false
    end
    if not technology.normal and not technology.expensive then
      technology.hidden = true
      technology.enabled = false
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology_name)
  end
end

function bobmods.lib.tech.ignore_tech_cost_multiplier(technology_name, ignore)
  if type(technology_name) == "string" and type(ignore) == "boolean" then
    local technology = data.raw.technology[technology_name]
    if technology then
      if technology.normal then
        technology.normal.ignore_tech_cost_multiplier = ignore
      end
      if technology.expensive then
        technology.expensive.ignore_tech_cost_multiplier = ignore
      end
      if not technology.normal and not technology.expensive then
        technology.ignore_tech_cost_multiplier = ignore
      end
    end
  else
    log(debug.traceback())
    bobmods.lib.error.technology(technology_name)
  end
end