buildcraft refinery control system for opencomputers

----------------------------------------------------------------
-- Colors
----------------------------------------------------------------
local colors = {
  white        = 0xFFFFFF,
  black        = 0x000000,
  gray         = 0x808080,
  lightGray    = 0xC0C0C0,
  darkGray     = 0x404040,

  red          = 0xFF0000,
  darkRed      = 0x800000,
  orange       = 0xFFA500,
  yellow       = 0xFFFF00,
  gold         = 0xFFD700,

  green        = 0x00FF00,
  darkGreen    = 0x006400,
  lime         = 0x32CD32,
  teal         = 0x008080,
  cyan         = 0x00FFFF,

  blue         = 0x0000FF,
  lightBlue    = 0xADD8E6,
  darkBlue     = 0x00008B,
  navy         = 0x001F3F,
  purple       = 0x800080,

  pink         = 0xFFC0CB,
  magenta      = 0xFF00FF,
  violet       = 0x8A2BE2,
  brown        = 0x8B4513,
  tan          = 0xD2B48C,

  -- UI theme
  surface      = 0x11161C,
  surfaceHi    = 0x171E26,
  borderDim    = 0x1C2530,
  borderHi     = 0x243142,
  text         = 0xE6EEF7,
  textDim      = 0x8AA0B5,
  accent       = 0x3DA3FF,
  accentAlt    = 0x56E39F,
  danger       = 0xFF5C5C,
  barEmpty     = 0x1B222B,
  btnOn        = 0x1F3D2A,
  btnOff       = 0x20252B,

  ----------------------------------------------------------------
  -- Additions
  ----------------------------------------------------------------
  silver       = 0xC0C0C0, -- alias of lightGray for convenience
  charcoal     = 0x36454F,
  slate        = 0x708090,
  olive        = 0x808000,
  forestGreen  = 0x228B22,
  indigo       = 0x4B0082,
  lavender     = 0xE6E6FA,
  turquoise    = 0x40E0D0,
  coral        = 0xFF7F50,
  amber        = 0xFFBF00,
  royalBlue    = 0x4169E1,
  hotPink      = 0xFF69B4,

  ----------------------------------------------------------------
  -- Neon (high-saturation, pop on dark backgrounds)
  ----------------------------------------------------------------
  neonPink     = 0xFF6EC7,
  neonGreen    = 0x39FF14,
  neonBlue     = 0x1F51FF,
  neonPurple   = 0xB026FF,
  neonOrange   = 0xFF5F1F,
  neonYellow   = 0xE9FF00,
  neonCyan     = 0x18FFFF,
  neonRed      = 0xFF073A
}

----------------------------------------------------------------
-- Requires
----------------------------------------------------------------
local component = require("component")
local button    = require("button")
local progBar   = require("progressBar")  -- kept for compatibility if other code uses it
local panel     = require("panel")
local tankBar   = require("tankBar")
local term      = require("term")
local event     = require("event")
local Line      = require("line")

local gpu       = component.gpu
local redstone  = component.redstone

----------------------------------------------------------------
-- Hardware addresses (edit to your setup)
----------------------------------------------------------------
local gpuAddresses = {
  primary   = "956e2810-a2cd-42e4-9df3-8926be4b5a12",
  secondary = "f9429421-7ac6-4fd0-8e68-a45c64dc2f9a"
}
local screenAddresses = {
  primary   = "46a0b52b-3166-4f2f-b6cc-73432b0ed4b6",
  secondary = "d817695c-bd51-4912-ba82-5928c57775c6"
}

----------------------------------------------------------------
-- State
----------------------------------------------------------------
local tasks = {}
local fluidMovingInPipe = false

----------------------------------------------------------------
-- Bind two screens/GPUs: returns gpu2 proxy bound to secondary
----------------------------------------------------------------
local function BindScreens()
  component.setPrimary("gpu", gpuAddresses.primary)
  gpu.bind(screenAddresses.primary)
  local gpu2 = component.proxy(gpuAddresses.secondary)
  gpu2.bind(screenAddresses.secondary)
  return gpu2
end
local gpu2 = BindScreens()

----------------------------------------------------------------
-- Tanks & addresses
----------------------------------------------------------------
local tanks = {
  bank_01 = {
    tank_01 = "94cee3b7-45f2-4f02-bd96-abe62b6a8b78",
    tank_02 = "88cf1273-1546-4cbf-9182-48e3a5ba79af",
    tank_03 = "2c4cdc29-ee56-4c4a-981a-72ec3bb469d1",
    tank_04 = "e5ce0c81-ceec-4224-8726-4821801f1245",
    tank_05 = "3dd07ec3-2666-4b78-812a-3d5e1653c432",
    tank_06 = "55776a61-951e-4ecc-8cd0-5ed95f91cbd1",
    tank_07 = "2a1d111c-ea8b-498a-90ca-180b9c2017e0",
    tank_08 = "5fc36d02-13a4-4aad-af2f-3a5bdf0df5d3",
    tank_09 = "6836a513-285b-46ce-a865-bafc6d82291a"
  },
  bank_02 = {
    tank_01 = "3c2d05db-97a7-4612-99dd-91cad1742443",
    tank_02 = "5335f1b2-14ce-4646-bffb-6d9963c1423c",
    tank_03 = "480a3682-cab9-4e68-8ec6-c6de1fc2f149",
    tank_04 = "bc9a16bf-05e9-4b4a-9b40-fcd9c07b21f8",
    tank_05 = "f028ba55-0d0d-494a-9bc2-d49ea39c97d9",
    tank_06 = "a62abe76-2afd-4b31-b040-41562ca9f948",
    tank_07 = "d530bcc2-7440-4d7d-9450-c034dc944e84",
    tank_08 = "62215813-4b69-4d4a-9221-79483975f72b",
    tank_09 = "ffee74d1-c3be-46bf-a50d-567678dc815f"
  }
}

-- heat exchanger buffer tanks addresses
local heatExchangerCoolInputBufferTankAdress  = "f323adb7-e821-42ac-8cff-56cdf1d2cdda"
local heatExchangerHotInputBufferTankAdress   = "f1f957b1-d6bf-4df8-ac9c-0182ec1d5962"
local heatExchangerCoolOutputBufferTankAdress = "a6baca15-4841-4811-bbe4-11388a5b5305"
local heatExchangerHotOutputBufferTankAdress  = "3a5b7c59-0e5b-47fd-8fd1-65e6484500e1"

-- note distiller tank pumps into heat exchanger output buffer tanks for sorting
local distillerOutputTankTop    = "694c9e60-56c7-4156-9c7e-f6559008821f"
local distillerOutputTankBottom = "753c2514-1b77-46b4-9560-fd3bf532c177"

-- mass storage for cool oil (crude oil from ground)
local crudeOilTank = component.pp_tank

----------------------------------------------------------------
-- Redstone: bundled cable sides & channels
----------------------------------------------------------------
-- sides
local storageTankPumpsBank_01_Side        = 1 -- top
local storageTankinputBank_02_Side        = 3 -- back

-- channels
-- heat exchanger input and refinery valves
local heatExchangerInputChanel_cool = 0 -- white/north valve
local heatExchangerInputChanel_hot  = 1 -- orange/top

local refineryOutputBottomTankPump_channel = 5 -- HeatExchangerAndRefineryInputSide
local refineryOutputTopTankPump_channel    = 4 -- HeatExchangerAndRefineryInputSide

local fluidInTransit = false

local tankPumpMapping = {
  bank_01 = {
    tank_01 = { address = tanks.bank_01.tank_01, side = storageTankPumpsBank_01_Side, channel = 0 },
    tank_02 = { address = tanks.bank_01.tank_02, side = storageTankPumpsBank_01_Side, channel = 1 },
    tank_03 = { address = tanks.bank_01.tank_03, side = storageTankPumpsBank_01_Side, channel = 2 },
    tank_04 = { address = tanks.bank_01.tank_04, side = storageTankPumpsBank_01_Side, channel = 3 },
    tank_05 = { address = tanks.bank_01.tank_05, side = storageTankPumpsBank_01_Side, channel = 4 },
    tank_06 = { address = tanks.bank_01.tank_06, side = storageTankPumpsBank_01_Side, channel = 5 },
    tank_07 = { address = tanks.bank_01.tank_07, side = storageTankPumpsBank_01_Side, channel = 6 },
    tank_08 = { address = tanks.bank_01.tank_08, side = storageTankPumpsBank_01_Side, channel = 7 },
    tank_09 = { address = tanks.bank_01.tank_09, side = storageTankPumpsBank_01_Side, channel = 8 },
  },
  bank_02 = {
    tank_01 = { address = tanks.bank_02.tank_01, side = storageTankinputBank_02_Side, channel = 0 },
    tank_02 = { address = tanks.bank_02.tank_02, side = storageTankinputBank_02_Side, channel = 1 },
    tank_03 = { address = tanks.bank_02.tank_03, side = storageTankinputBank_02_Side, channel = 2 },
    tank_04 = { address = tanks.bank_02.tank_04, side = storageTankinputBank_02_Side, channel = 3 },
    tank_05 = { address = tanks.bank_02.tank_05, side = storageTankinputBank_02_Side, channel = 4 },
    tank_06 = { address = tanks.bank_02.tank_06, side = storageTankinputBank_02_Side, channel = 5 },
    tank_07 = { address = tanks.bank_02.tank_07, side = storageTankinputBank_02_Side, channel = 6 },
    tank_08 = { address = tanks.bank_02.tank_08, side = storageTankinputBank_02_Side, channel = 7 },
    tank_09 = { address = tanks.bank_02.tank_09, side = storageTankinputBank_02_Side, channel = 8 },
  }
}

local routMapping = {
  bank_01 = {
    tank_01 = { address = tanks.bank_01.tank_01, side = 4, channel = 0 },
    tank_02 = { address = tanks.bank_01.tank_02, side = 4, channel = 1 },
    tank_03 = { address = tanks.bank_01.tank_03, side = 4, channel = 2 },
    tank_04 = { address = tanks.bank_01.tank_04, side = 4, channel = 3 },
    tank_05 = { address = tanks.bank_01.tank_05, side = 4, channel = 4 },
    tank_06 = { address = tanks.bank_01.tank_06, side = 4, channel = 5 },
    tank_07 = { address = tanks.bank_01.tank_07, side = 4, channel = 6 },
    tank_08 = { address = tanks.bank_01.tank_08, side = 4, channel = 7 },
    tank_09 = { address = tanks.bank_01.tank_09, side = 4, channel = 8 },
  },
  bank_02 = {
    tank_01 = { address = tanks.bank_02.tank_01, side = 2, channel = 0 },
    tank_02 = { address = tanks.bank_02.tank_02, side = 2, channel = 1 },
    tank_03 = { address = tanks.bank_02.tank_03, side = 2, channel = 2 },
    tank_04 = { address = tanks.bank_02.tank_04, side = 2, channel = 3 },
    tank_05 = { address = tanks.bank_02.tank_05, side = 2, channel = 4 },
    tank_06 = { address = tanks.bank_02.tank_06, side = 2, channel = 5 },
    tank_07 = { address = tanks.bank_02.tank_07, side = 2, channel = 6 },
    tank_08 = { address = tanks.bank_02.tank_08, side = 2, channel = 7 },
    tank_09 = { address = tanks.bank_02.tank_09, side = 2, channel = 8 },
  },
  fluidProccessing = {
    hx= {hotInput = {address = heatExchangerHotInputBufferTankAdress, side = 5, channel = heatExchangerInputChanel_hot},
         coldInput = {address = heatExchangerCoolInputBufferTankAdress, side = 5, channel = heatExchangerInputChanel_cool}},
    distiller = {input = {address = nil, side = 5, channel = heatExchangerInputChanel_hot}}
  }
}

local valves = {
   routingValveProccessingInput = {
     state = "",
     stateControls = {openNorth = 0, openTop = 2, openEast = 3}
   },
}

----------------------------------------------------------------
-- UI registries
----------------------------------------------------------------
local primaryScreenChildren   = {}
local secondaryScreenChildren = {}
local heatableFluidsAvailable = {}
local coolableFluidsAvailable = {}

----------------------------------------------------------------
-- Tabs (framework) — TANKS (left side of secondary screen)
----------------------------------------------------------------
local tabs = {}                 -- { {name="…"}, … }
local tabButtons = {}           -- buttons across the top
local currentTab = 1
local TabContent = {}           -- [tabIndex] = { child1, child2, ... }

-- area that a tab "owns" on the secondary screen
local tabHost = { x = 3, y = 7, w = 50, h = 40, gpu = nil }

local function clear_tab_host()
  local g = tabHost.gpu or gpu2
  g.setBackground(colors.surface or 0x11161C)
  g.fill(tabHost.x, tabHost.y, tabHost.w, tabHost.h, " ")
end

local function draw_tab_underline(idx, on)
  local btn = tabButtons[idx]
  if not btn then return end
  local g = btn.gpu or gpu2
  local ux = btn.x
  local uy = btn.y + btn.h
  local uw = btn.w
  g.setBackground(on and (colors.accent or 0x3DA3FF) or (colors.borderDim or 0x1C2530))
  g.fill(ux, uy, uw, 1, " ")
end

local function draw_tabbar()
  for i = 1, #tabButtons do
    tabButtons[i]:draw()
    draw_tab_underline(i, i == currentTab)
  end
end

local function draw_tabcontent()
  clear_tab_host()
  local list = TabContent[currentTab]
  if not list then return end
  for i = 1, #list do
    if list[i].draw then list[i]:draw() end
  end
end

local function select_tab(i)
  if i < 1 or i > #tabs or i == currentTab then return end
  currentTab = i
  draw_tabbar()
  draw_tabcontent()
end

-- API: add a new tab button + storage for its children
function AddNewTab(name, color)
  local idx = #tabs + 1
  tabs[idx] = { name = name, color = color }
  TabContent[idx] = {}

  local x = 2 + (idx - 1) * 10      -- 9 wide + 1 gap
  local y = 2
  local btn = button:new(x, y, 9, 5, name, function() select_tab(idx) end)
  btn.gpu = gpu2
  btn.behavior = "momentary"
  table.insert(tabButtons, btn)
  table.insert(secondaryScreenChildren, btn)
  return idx
end

-- API: add any drawable element to a tab (it will be drawn only when active)
function AddToTab(tabIndex, el)
  TabContent[tabIndex] = TabContent[tabIndex] or {}
  table.insert(TabContent[tabIndex], el)
end

----------------------------------------------------------------
-- Button Panel Tabs (right-side panel on secondary screen)
----------------------------------------------------------------
local btnTabs = {}                 -- { {name="…"}, … }
local btnTabButtons = {}           -- buttons within the right panel header
local btnCurrentTab = 1
local ButtonTabContent = {}        -- [tabIndex] = { el1, el2, ... }

-- host area inside the right panel (panel at 55,7 size 100x40)
local btnTabHost = { x = 57, y = 12, w = 96, h = 33, gpu = nil }

local function clear_btn_tab_host()
  local g = btnTabHost.gpu or gpu2
  g.setBackground(colors.surface or 0x11161C)
  g.fill(btnTabHost.x, btnTabHost.y, btnTabHost.w, btnTabHost.h, " ")
end

local function draw_btn_tab_underline(idx, on)
  local btn = btnTabButtons[idx]
  if not btn then return end
  local g = btn.gpu or gpu2
  local ux = btn.x
  local uy = btn.y + btn.h
  local uw = btn.w
  g.setBackground(on and (colors.accent or 0x3DA3FF) or (colors.borderDim or 0x1C2530))
  g.fill(ux, uy, uw, 1, " ")
end

local function draw_buttonpanel_tabbar()
  for i = 1, #btnTabButtons do
    btnTabButtons[i]:draw()
    draw_btn_tab_underline(i, i == btnCurrentTab)
  end
end

local function draw_buttonpanel_tabcontent()
  clear_btn_tab_host()
  local list = ButtonTabContent[btnCurrentTab]
  if not list then return end
  for i = 1, #list do
    if list[i].draw then list[i]:draw() end
  end
end

local function select_buttonpanel_tab(i)
  if i < 1 or i > #btnTabs or i == btnCurrentTab then return end
  btnCurrentTab = i
  draw_buttonpanel_tabbar()
  draw_buttonpanel_tabcontent()
end

-- API: add a new tab to the button panel
function AddNewButtonPanelTab(name, color)
  local idx = #btnTabs + 1
  btnTabs[idx] = { name = name, color = color }
  ButtonTabContent[idx] = {}

  -- tab bar across top of the panel (start at x=57, y=8), 9 wide + 1 gap
  local x = 57 + (idx - 1) * 10
  local y = 8
  local tabBtn = button:new(x, y, 9, 3, name, function() select_buttonpanel_tab(idx) end)
  tabBtn.gpu = gpu2
  tabBtn.behavior = "momentary"
  table.insert(btnTabButtons, tabBtn)
  table.insert(secondaryScreenChildren, tabBtn) -- so clicks are handled
  return idx
end

-- API: add any element to a button-panel tab
function AddToButtonPanelTab(tabIndex, el)
  ButtonTabContent[tabIndex] = ButtonTabContent[tabIndex] or {}
  table.insert(ButtonTabContent[tabIndex], el)
end

----------------------------------------------------------------
-- (Optional) Heat Exchanger schematic placeholder
----------------------------------------------------------------
function CreateHeatEx_Image(x, y)
  local line_01 = Line:new(x, y+2, x+20, y+2, colors.silver, 1, " ")
  local line_02 = Line:new(x+20, y+1, x+20, y-2, colors.silver, 1, " ")
  line_01.gpu = gpu
  line_02.gpu = gpu
  local line_03 = Line:new(x-2, y+2, x-2, y-2, colors.silver, 1, " ")
  local line_04 = Line:new(x-1, y-2, x+18, y-2, colors.silver, 1, " ")
  local line_05 = Line:new(x-3, y+1, x+21, y+1, colors.cyan, 1, " ")
  local line_06 = Line:new(x-3, y-1, x+21, y-1, colors.cyan, 1, " ")
  line_06.gpu = gpu
  line_05.gpu = gpu
  line_03.gpu = gpu
  line_04.gpu = gpu
  table.insert(primaryScreenChildren, line_06)
  table.insert(primaryScreenChildren, line_05)
  table.insert(primaryScreenChildren, line_01)
  table.insert(primaryScreenChildren, line_02)
  table.insert(primaryScreenChildren, line_03)
  table.insert(primaryScreenChildren, line_04)
end

function CreateDistiller_Image(x, y)
  local line_01 = Line:new(x, y, x+8, y, colors.darkRed, 5, " ")
  line_01.gpu = gpu
  table.insert(primaryScreenChildren, line_01)
end

function CreateStorageOutput_image(x, y)
  local stor = {}
  stor.line_01 = Line:new(x, y, x+11, y, colors.charcoal, 30, " ")
  stor.line_01.gpu = gpu
  stor.pumpActive = "none"
  table.insert(primaryScreenChildren, stor.line_01)
  return stor
end

function CreateStorageInput_image(x, y)
  local stor = {}
  stor.line_01 = Line:new(x, y, x+11, y, colors.charcoal, 30, " ")
  stor.line_01.gpu = gpu
  stor.pumpActive = "none"
  table.insert(primaryScreenChildren, stor.line_01)
  return stor
end

function CreatePipes()
  local pipes = {
    pipe_01 = {
      lines = {
        line_01 = Line:new(22, 15, 57, 15, colors.brown, 1, " ")
      },
      inuse = false
    },

    pipe_02 = {
      lines = {
        line_01 = Line:new(22, 22, 59, 22, colors.brown, 1, " "),
        line_02 = Line:new(59, 22, 59, 17, colors.brown, 1, " ")
      },
      inuse = false
    },

    pipe_03 = {
      lines = {
        line_01 = Line:new(79, 13, 79, 7, colors.brown, 1, " "),
        line_02 = Line:new(79, 7, 129, 7, colors.brown, 1, " ")
      },
      inuse = false
    },

    pipe_04 = {
      lines = {
        line_01 = Line:new(79, 13, 79, 7, colors.brown, 1, " ")
      },
      inuse = false
    },

    pipe_05 = {
      lines = {
        line_01 = Line:new(81, 15, 129, 15, colors.brown, 1, " ")
      },
      inuse = false
    },

    pipe_06 = {
      lines = {
        line_01 = Line:new(22, 33, 69, 33, colors.brown, 1, " ")
      },
      inuse = false
    },

    pipe_07 = {
      lines = {
        line_01 = Line:new(76, 30, 129, 30, colors.brown, 1, " ")
      },
      inuse = false
    },

    pipe_08 = {
      lines = {
        line_01 = Line:new(76, 36, 133, 36, colors.brown, 1, " ")
      },
      inuse = false
    },
  }

  -- hook all pipe lines to gpu + primaryScreenChildren
  for _, pipe in pairs(pipes) do
    for _, line in pairs(pipe.lines) do
      line.gpu = gpu
      table.insert(primaryScreenChildren, line)
    end
  end

  return pipes
end









function ToggleDistillerValve()
  if redstone.getBundledInput(5, 9) > 0 then
    redstone.setBundledOutput(5, 9, 0)
  else
    redstone.setBundledOutput(5, 9, 255)
  end
end




function FindTankWithFluid(fluid, tempState)
  for _, bank in pairs(tanks) do
    for _, tankAddr in pairs(bank) do
      local tankProxy = component.proxy(tankAddr)
      if tankProxy then
        local contents = tankProxy.getFluidInTank(1)
        if contents and contents[1] then
          local f = contents[1]
          local hasFluid = f.name and f.name == fluid
          local hasTemp = not tempState or (f.label and f.label:lower():find(tempState:lower()))
          if hasFluid and hasTemp then
            return tankAddr
          end
        end
      end
    end
  end
  return nil -- no match found
end

function EnableCoolSideHxBufferPump()
  -- Prevent overlapping transfers
  TogglePump(5, 6)
end

function EnableHotSideHxBufferPump()
  TogglePump(5, 8)
end



----------------------------------------------------------------
-- Screens: layout & widgets
----------------------------------------------------------------
function LoadScreens()
  -- main containers on secondary screen

  -- right-side control stack panel (background only)
  local _buttonPanel = panel:new(55, 7, 100, 40)
  _buttonPanel.gpu = gpu2
  table.insert(secondaryScreenChildren, _buttonPanel)

  -- TANK tabs host (left)
  tabHost.x, tabHost.y, tabHost.w, tabHost.h = 2, 7, 42, 40
  tabHost.gpu = gpu2

  -- BUTTON-PANEL tabs host (right, inside the panel)
  btnTabHost.x, btnTabHost.y, btnTabHost.w, btnTabHost.h = 57, 12, 96, 33
  btnTabHost.gpu = gpu2

  -- create BUTTON-PANEL tabs
  local bt1 = AddNewButtonPanelTab("Valves")
  local bt2 = AddNewButtonPanelTab("Pumps")
  local bt3 = AddNewButtonPanelTab("Config")

  -- controls for Valves tab (positioned inside btnTabHost)
  local hx = btnTabHost.x + 2
  local hy = btnTabHost.y + 2

function ToggleHXHotValve()
  if redstone.getBundledInput(5, 1) > 0 then
    redstone.setBundledOutput(5, 1, 0)
  else
    redstone.setBundledOutput(5, 1, 255)
  end
end

  local btnTHHV = button:new(hx, hy, 30, 3, "toggle HX Hot valve", ToggleHXHotValve)
  btnTHHV.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTHHV)

function ToggleHXCoolValve()
  if redstone.getBundledInput(5, 0) > 0 then
    redstone.setBundledOutput(5, 0, 0)
  else
    redstone.setBundledOutput(5, 0, 255)
  end
end

  local btnTHCV = button:new(hx, hy + 4, 30, 3, "toggle HX Cool valve", ToggleHXCoolValve)
  btnTHCV.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTHCV)

function ToggleDistillerValve()
  if redstone.getBundledInput(5, 9) > 0 then
    redstone.setBundledOutput(5, 9, 0)
  else
    redstone.setBundledOutput(5, 9, 255)
  end
end

  local btnTDV = button:new(hx, hy + 8, 30, 3, "toggle Distiller valve", ToggleDistillerValve)
  btnTDV.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTDV)



----------------------------------------------------------------
  -- BANK 1 valves
  --------------------------------------------------------------

function ToggleB1T1Valve()
  if redstone.getBundledInput(routMapping.bank_01.tank_01.side, routMapping.bank_01.tank_01.channel) > 0 then
    redstone.setBundledOutput(routMapping.bank_01.tank_01.side, routMapping.bank_01.tank_01.channel, 0)
  else
    redstone.setBundledOutput(routMapping.bank_01.tank_01.side, routMapping.bank_01.tank_01.channel, 255)
  end
end

  local btnTB1T1 = button:new(hx+31, hy, 30, 3, "toggle bank-tank 01 valve", ToggleB1T1Valve)
  btnTB1T1.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T1)

  function ToggleB1T2Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_02.side, routMapping.bank_01.tank_02.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_02.side, routMapping.bank_01.tank_02.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_02.side, routMapping.bank_01.tank_02.channel, 255)
    end
  end
  local btnTB1T2 = button:new(hx+31, hy+3, 30, 3, "toggle bank-tank 02 valve", ToggleB1T2Valve)
  btnTB1T2.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T2)

  function ToggleB1T3Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_03.side, routMapping.bank_01.tank_03.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_03.side, routMapping.bank_01.tank_03.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_03.side, routMapping.bank_01.tank_03.channel, 255)
    end
  end
  local btnTB1T3 = button:new(hx+31, hy+3*2, 30, 3, "toggle bank-tank 03 valve", ToggleB1T3Valve)
  btnTB1T3.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T3)

  function ToggleB1T4Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_04.side, routMapping.bank_01.tank_04.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_04.side, routMapping.bank_01.tank_04.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_04.side, routMapping.bank_01.tank_04.channel, 255)
    end
  end
  local btnTB1T4 = button:new(hx+31, hy+3*3, 30, 3, "toggle bank-tank 04 valve", ToggleB1T4Valve)
  btnTB1T4.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T4)

  function ToggleB1T5Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_05.side, routMapping.bank_01.tank_05.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_05.side, routMapping.bank_01.tank_05.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_05.side, routMapping.bank_01.tank_05.channel, 255)
    end
  end
  local btnTB1T5 = button:new(hx+31, hy+3*4, 30, 3, "toggle bank-tank 05 valve", ToggleB1T5Valve)
  btnTB1T5.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T5)

  function ToggleB1T6Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_06.side, routMapping.bank_01.tank_06.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_06.side, routMapping.bank_01.tank_06.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_06.side, routMapping.bank_01.tank_06.channel, 255)
    end
  end
  local btnTB1T6 = button:new(hx+31, hy+3*5, 30, 3, "toggle bank-tank 06 valve", ToggleB1T6Valve)
  btnTB1T6.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T6)

  function ToggleB1T7Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_07.side, routMapping.bank_01.tank_07.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_07.side, routMapping.bank_01.tank_07.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_07.side, routMapping.bank_01.tank_07.channel, 255)
    end
  end
  local btnTB1T7 = button:new(hx+31, hy+3*6, 30, 3, "toggle bank-tank 07 valve", ToggleB1T7Valve)
  btnTB1T7.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T7)

  function ToggleB1T8Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_08.side, routMapping.bank_01.tank_08.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_08.side, routMapping.bank_01.tank_08.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_08.side, routMapping.bank_01.tank_08.channel, 255)
    end
  end
  local btnTB1T8 = button:new(hx+31, hy+3*7, 30, 3, "toggle bank-tank 08 valve", ToggleB1T8Valve)
  btnTB1T8.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T8)

  function ToggleB1T9Valve()
    if redstone.getBundledInput(routMapping.bank_01.tank_09.side, routMapping.bank_01.tank_09.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_01.tank_09.side, routMapping.bank_01.tank_09.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_01.tank_09.side, routMapping.bank_01.tank_09.channel, 255)
    end
  end
  local btnTB1T9 = button:new(hx+31, hy+3*8, 30, 3, "toggle bank-tank 09 valve", ToggleB1T9Valve)
  btnTB1T9.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB1T9)

  ----------------------------------------------------------------
  -- BANK 2 valves
  ----------------------------------------------------------------
  function ToggleB2T1Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_01.side, routMapping.bank_02.tank_01.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_01.side, routMapping.bank_02.tank_01.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_01.side, routMapping.bank_02.tank_01.channel, 255)
    end
  end
  local btnTB2T1 = button:new(hx+62, hy, 30, 3, "toggle bank2-tank 01 valve", ToggleB2T1Valve)
  btnTB2T1.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T1)

  function ToggleB2T2Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_02.side, routMapping.bank_02.tank_02.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_02.side, routMapping.bank_02.tank_02.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_02.side, routMapping.bank_02.tank_02.channel, 255)
    end
  end
  local btnTB2T2 = button:new(hx+62, hy+3*1, 30, 3, "toggle bank2-tank 02 valve", ToggleB2T2Valve)
  btnTB2T2.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T2)

  function ToggleB2T3Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_03.side, routMapping.bank_02.tank_03.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_03.side, routMapping.bank_02.tank_03.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_03.side, routMapping.bank_02.tank_03.channel, 255)
    end
  end
  local btnTB2T3 = button:new(hx+62, hy+3*2, 30, 3, "toggle bank2-tank 03 valve", ToggleB2T3Valve)
  btnTB2T3.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T3)

  function ToggleB2T4Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_04.side, routMapping.bank_02.tank_04.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_04.side, routMapping.bank_02.tank_04.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_04.side, routMapping.bank_02.tank_04.channel, 255)
    end
  end
  local btnTB2T4 = button:new(hx+62, hy+3*3, 30, 3, "toggle bank2-tank 04 valve", ToggleB2T4Valve)
  btnTB2T4.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T4)

  function ToggleB2T5Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_05.side, routMapping.bank_02.tank_05.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_05.side, routMapping.bank_02.tank_05.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_05.side, routMapping.bank_02.tank_05.channel, 255)
    end
  end
  local btnTB2T5 = button:new(hx+62, hy+3*4, 30, 3, "toggle bank2-tank 05 valve", ToggleB2T5Valve)
  btnTB2T5.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T5)

  function ToggleB2T6Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_06.side, routMapping.bank_02.tank_06.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_06.side, routMapping.bank_02.tank_06.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_06.side, routMapping.bank_02.tank_06.channel, 255)
    end
  end
  local btnTB2T6 = button:new(hx+62, hy+3*5, 30, 3, "toggle bank2-tank 06 valve", ToggleB2T6Valve)
  btnTB2T6.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T6)

  function ToggleB2T7Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_07.side, routMapping.bank_02.tank_07.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_07.side, routMapping.bank_02.tank_07.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_07.side, routMapping.bank_02.tank_07.channel, 255)
    end
  end
  local btnTB2T7 = button:new(hx+62, hy+3*6, 30, 3, "toggle bank2-tank 07 valve", ToggleB2T7Valve)
  btnTB2T7.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T7)

  function ToggleB2T8Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_08.side, routMapping.bank_02.tank_08.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_08.side, routMapping.bank_02.tank_08.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_08.side, routMapping.bank_02.tank_08.channel, 255)
    end
  end
  local btnTB2T8 = button:new(hx+62, hy+3*7, 30, 3, "toggle bank2-tank 08 valve", ToggleB2T8Valve)
  btnTB2T8.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T8)

  function ToggleB2T9Valve()
    if redstone.getBundledInput(routMapping.bank_02.tank_09.side, routMapping.bank_02.tank_09.channel) > 0 then
      redstone.setBundledOutput(routMapping.bank_02.tank_09.side, routMapping.bank_02.tank_09.channel, 0)
    else
      redstone.setBundledOutput(routMapping.bank_02.tank_09.side, routMapping.bank_02.tank_09.channel, 255)
    end
  end
  local btnTB2T9 = button:new(hx+62, hy+3*8, 30, 3, "toggle bank2-tank 09 valve", ToggleB2T9Valve)
  btnTB2T9.gpu = gpu2
  AddToButtonPanelTab(bt1, btnTB2T9)
--------------------------------------------------------
---
--------------------------------------------------------
---
  ----------------------------------------------------------------
  -- PUMPS tab controls (BANK 1 + BANK 2)
  ----------------------------------------------------------------
  -- reuse the same base coords pattern as valves
  local px = btnTabHost.x + 2
  local py = btnTabHost.y + 2

  --------------------------------------------------------------
  -- BANK 1 pumps
  --------------------------------------------------------------
  function ToggleB1T1Pump()
    local m = tankPumpMapping.bank_01.tank_01
    TogglePump(m.side, m.channel)
  end

  local btnPB1T1 = button:new(px, py, 30, 3, "toggle B1 tank 01 pump", ToggleB1T1Pump)
  btnPB1T1.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T1)

  function ToggleB1T2Pump()
    local m = tankPumpMapping.bank_01.tank_02
    TogglePump(m.side, m.channel)
  end
  local btnPB1T2 = button:new(px, py+3*1, 30, 3, "toggle B1 tank 02 pump", ToggleB1T2Pump)
  btnPB1T2.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T2)

  function ToggleB1T3Pump()
    local m = tankPumpMapping.bank_01.tank_03
    TogglePump(m.side, m.channel)
  end
  local btnPB1T3 = button:new(px, py+3*2, 30, 3, "toggle B1 tank 03 pump", ToggleB1T3Pump)
  btnPB1T3.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T3)

  function ToggleB1T4Pump()
    local m = tankPumpMapping.bank_01.tank_04
    TogglePump(m.side, m.channel)
  end
  local btnPB1T4 = button:new(px, py+3*3, 30, 3, "toggle B1 tank 04 pump", ToggleB1T4Pump)
  btnPB1T4.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T4)

  function ToggleB1T5Pump()
    local m = tankPumpMapping.bank_01.tank_05
    TogglePump(m.side, m.channel)
  end
  local btnPB1T5 = button:new(px, py+3*4, 30, 3, "toggle B1 tank 05 pump", ToggleB1T5Pump)
  btnPB1T5.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T5)

  function ToggleB1T6Pump()
    local m = tankPumpMapping.bank_01.tank_06
    TogglePump(m.side, m.channel)
  end
  local btnPB1T6 = button:new(px, py+3*5, 30, 3, "toggle B1 tank 06 pump", ToggleB1T6Pump)
  btnPB1T6.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T6)

  function ToggleB1T7Pump()
    local m = tankPumpMapping.bank_01.tank_07
    TogglePump(m.side, m.channel)
  end
  local btnPB1T7 = button:new(px, py+3*6, 30, 3, "toggle B1 tank 07 pump", ToggleB1T7Pump)
  btnPB1T7.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T7)

  function ToggleB1T8Pump()
    local m = tankPumpMapping.bank_01.tank_08
    TogglePump(m.side, m.channel)
  end
  local btnPB1T8 = button:new(px, py+3*7, 30, 3, "toggle B1 tank 08 pump", ToggleB1T8Pump)
  btnPB1T8.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T8)

  function ToggleB1T9Pump()
    local m = tankPumpMapping.bank_01.tank_09
    TogglePump(m.side, m.channel)
  end
  local btnPB1T9 = button:new(px, py+3*8, 30, 3, "toggle B1 tank 09 pump", ToggleB1T9Pump)
  btnPB1T9.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB1T9)

  --------------------------------------------------------------
  -- BANK 2 pumps
  --------------------------------------------------------------
  function ToggleB2T1Pump()
    local m = tankPumpMapping.bank_02.tank_01
    TogglePump(m.side, m.channel)
  end
  local btnPB2T1 = button:new(px+31, py, 30, 3, "toggle B2 tank 01 pump", ToggleB2T1Pump)
  btnPB2T1.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T1)

  function ToggleB2T2Pump()
    local m = tankPumpMapping.bank_02.tank_02
    TogglePump(m.side, m.channel)
  end
  local btnPB2T2 = button:new(px+31, py+3*1, 30, 3, "toggle B2 tank 02 pump", ToggleB2T2Pump)
  btnPB2T2.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T2)

  function ToggleB2T3Pump()
    local m = tankPumpMapping.bank_02.tank_03
    TogglePump(m.side, m.channel)
  end
  local btnPB2T3 = button:new(px+31, py+3*2, 30, 3, "toggle B2 tank 03 pump", ToggleB2T3Pump)
  btnPB2T3.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T3)

  function ToggleB2T4Pump()
    local m = tankPumpMapping.bank_02.tank_04
    TogglePump(m.side, m.channel)
  end
  local btnPB2T4 = button:new(px+31, py+3*3, 30, 3, "toggle B2 tank 04 pump", ToggleB2T4Pump)
  btnPB2T4.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T4)

  function ToggleB2T5Pump()
    local m = tankPumpMapping.bank_02.tank_05
    TogglePump(m.side, m.channel)
  end
  local btnPB2T5 = button:new(px+31, py+3*4, 30, 3, "toggle B2 tank 05 pump", ToggleB2T5Pump)
  btnPB2T5.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T5)

  function ToggleB2T6Pump()
    local m = tankPumpMapping.bank_02.tank_06
    TogglePump(m.side, m.channel)
  end
  local btnPB2T6 = button:new(px+31, py+3*5, 30, 3, "toggle B2 tank 06 pump", ToggleB2T6Pump)
  btnPB2T6.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T6)

  function ToggleB2T7Pump()
    local m = tankPumpMapping.bank_02.tank_07
    TogglePump(m.side, m.channel)
  end
  local btnPB2T7 = button:new(px+31, py+3*6, 30, 3, "toggle B2 tank 07 pump", ToggleB2T7Pump)
  btnPB2T7.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T7)

  function ToggleB2T8Pump()
    local m = tankPumpMapping.bank_02.tank_08
    TogglePump(m.side, m.channel)
  end
  local btnPB2T8 = button:new(px+31, py+3*7, 30, 3, "toggle B2 tank 08 pump", ToggleB2T8Pump)
  btnPB2T8.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T8)

  function ToggleB2T9Pump()
    local m = tankPumpMapping.bank_02.tank_09
    TogglePump(m.side, m.channel)
  end
  local btnPB2T9 = button:new(px+31, py+3*8, 30, 3, "toggle B2 tank 09 pump", ToggleB2T9Pump)
  btnPB2T9.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPB2T9)

--------------------------------------------------------------
  -- HX buffer pumps
  --------------------------------------------------------------
  function StartHXCoolBufferPump()
    EnableCoolSideHxBufferPump()
  end
  local btnPHXC = button:new(px+62, py, 30, 3, "toggle HX cool pump", StartHXCoolBufferPump)
  btnPHXC.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPHXC)

  function StartHXHotBufferPump()
    EnableHotSideHxBufferPump()
  end
  local btnPHXH = button:new(px+62, py+3*1, 30, 3, "toggle HX hot pump", StartHXHotBufferPump)
  btnPHXH.gpu = gpu2
  AddToButtonPanelTab(bt2, btnPHXH)

  -- remember: the tab buttons themselves were inserted into secondaryScreenChildren by AddNewButtonPanelTab()

  -- draw schematics (primary screen)
  CreateHeatEx_Image(60, 15)
  CreateDistiller_Image(70, 33)
  CreateStorageOutput_image(10, 20)
  CreateStorageInput_image(130, 20)
  CreatePipes()


  -- create LEFT tabs (tanks)
  local t1 = AddNewTab("Bank 1")
  local t2 = AddNewTab("Bank 2")
  local t3 = AddNewTab("HX")   -- placeholder for heat exchanger view

  -- initial active tabs
  currentTab    = 1
  btnCurrentTab = 1
end

function DrawScreens()
  if primaryScreenChildren then
    for i = 1, #primaryScreenChildren do
      if primaryScreenChildren[i].draw then
        primaryScreenChildren[i]:draw()
      end
    end
  end
  if secondaryScreenChildren then
    for i = 1, #secondaryScreenChildren do
      if secondaryScreenChildren[i].draw then
        secondaryScreenChildren[i]:draw()
      end
    end
  end
end

function UpdateScreens()
  -- put periodic screen updates here if needed
  DrawScreens()
end

----------------------------------------------------------------
-- Helpers
----------------------------------------------------------------
function GetFluidLevelInTank(addr)
  local t = component.proxy(addr)
  local tt = t.getTankLevel(1)
  return tt
end

function OpenValve(side, channel)      redstone.setBundledOutput(side, channel, 255) end
function CloseValve(side, channel)     redstone.setBundledOutput(side, channel, 0)   end

function TogglePump(side, channel)
  if redstone.getBundledInput(side, channel) > 0 then
    redstone.setBundledOutput(side, channel, 0)
  else
    redstone.setBundledOutput(side, channel, 255)
  end


end


function CreateTask()
  -- stub
end

function TestFunc()
  gpu.set(1, 1, tostring(GetFluidLevelInTank(tanks.bank_01.tank_01)))
end

function DrawBG()
  -- Secondary screen background
  gpu2.setBackground(0xFFFDD0)
  gpu2.fill(1, 1, 160, 50, " ")
  gpu2.setBackground(0x000000)

  -- Primary screen background
  gpu.setBackground(0xFF65D0)
  gpu.fill(1, 1, 160, 50, " ")
  gpu.setBackground(0x000000)
end

----------------------------------------------------------------
-- Tank bar builders wired to tabs
----------------------------------------------------------------
local tankBarBuffer = 4

local function make_bank_bars(bankAddresses, startX, startY, g)
  local bars = {}
  for i = 1, 9 do
    local key  = string.format("tank_%02d", i)
    local y    = startY + tankBarBuffer * (i - 1)
    local addr = bankAddresses[key]
    if addr then
      local b = tankBar.new(startX, y, addr)
      b.gpu = g
      if b.progressBar then b.progressBar.gpu = g end
      b.showLabel = true
      bars[key] = b
    end
  end
  return bars
end

local function build_bank_for_tab(tabIndex, bankAddresses, startX, startY)
  local bars = make_bank_bars(bankAddresses, startX, startY, gpu2)
  -- attach each bar to the tab so it's drawn only when that tab is active
  for i = 1, 9 do
    local key = string.format("tank_%02d", i)
    if bars[key] then AddToTab(tabIndex, bars[key]) end
  end
  return bars
end

-- Build the HX (heat exchanger) buffer tanks into a tab.
-- Uses same relative coords as bank tabs, so switching tabs keeps layout stable.
local function build_hx_for_tab(tabIndex, startX, startY)
  local spacing = tankBarBuffer
  local bars = {}

  local function add(key, addr, row)
    if not addr then return end
    local b = tankBar.new(startX, startY + spacing * (row - 1), addr)
    b.gpu = gpu2
    if b.progressBar then b.progressBar.gpu = gpu2 end
    b.showLabel = true
    AddToTab(tabIndex, b)
    bars[key] = b
  end

  -- 4 buffer tanks
  add("coolIn",  heatExchangerCoolInputBufferTankAdress,  1)
  add("hotIn",   heatExchangerHotInputBufferTankAdress,   2)
  add("coolOut", heatExchangerCoolOutputBufferTankAdress, 3)
  add("hotOut",  heatExchangerHotOutputBufferTankAdress,  4)

  -- Optional: distiller outputs
  -- add("distTop",    distillerOutputTankTop,    5)
  -- add("distBottom", distillerOutputTankBottom, 6)

  return bars
end

----------------------------------------------------------------
-- Boot: layout, background, tab content, first paint
----------------------------------------------------------------
LoadScreens()
DrawBG()
DrawScreens()

-- Build content into tabs
local bars_bank_01 = build_bank_for_tab(1, tanks.bank_01, 5,  8)
local bars_bank_02 = build_bank_for_tab(2, tanks.bank_02, 5, 8)
local hx_bars      = build_hx_for_tab(3, 5, 8)

-- First paint for tabs
draw_tabbar()
draw_tabcontent()

-- First paint for button-panel tabs
draw_buttonpanel_tabbar()
draw_buttonpanel_tabcontent()

term.setCursor(1, 1)

----------------------------------------------------------------
-- Main loop
----------------------------------------------------------------
while true do
  local ev, a, b, c = event.pull(0.5)
  if b then
    gpu.set(1,1,"           ")
    gpu.set(1,1, "x:"..b.." y:"..c)
  end
  -- handle buttons on primary screen
  for i = 1, #primaryScreenChildren do
    local el = primaryScreenChildren[i]
    if el and el.type == "button" and el.handle then
      el:handle(ev, a, b, c)
    end
  end

  -- handle elements on secondary screen (includes tab buttons + panel tab buttons)
  for i = 1, #secondaryScreenChildren do
    local el = secondaryScreenChildren[i]
    if el and el.type == "button" and el.handle then
      el:handle(ev, a, b, c)
    end
  end

  -- handle ACTIVE button-panel tab contents (so only visible tab’s controls react)
  do
    local list = ButtonTabContent[btnCurrentTab]
    if list then
      for i = 1, #list do
        local el = list[i]
        if el and el.type == "button" and el.handle then
          el:handle(ev, a, b, c)
        end
      end
    end
  end

  -- periodic UI updates if needed
   --UpdateScreens()

  os.sleep(0.5)
end