PakettiAutomationStack.lua

-- PakettiAutomationStack.lua
-- Visualize all automation envelopes on the selected track within the selected pattern
-- Requirements honored:
-- - Lua 5.1 only
-- - All functions are GLOBAL and defined before first use
-- - Uses my_keyhandler_func from main.lua
-- - After dialog opens, reactivate middle frame to pass keys back to Renoise
-- - Stable ViewBuilder layout (rebuild content instead of toggling visibility)
-- - Uses shared PakettiCanvasFontDrawText when available

-- Global state
PakettiAutomationStack_dialog = nil
PakettiAutomationStack_vb = nil
PakettiAutomationStack_header_canvas = nil
PakettiAutomationStack_container = nil
PakettiAutomationStack_track_canvases = {}
PakettiAutomationStack_canvas_width = 1400
PakettiAutomationStack_lane_height = 80
PakettiAutomationStack_gutter_height = 18
PakettiAutomationStack_gutter_width = 0
PakettiAutomationStack_zoom_levels = {1.0, 0.5, 0.25, 0.125}
PakettiAutomationStack_zoom_index = 1
PakettiAutomationStack_view_start_line = 1
PakettiAutomationStack_scrollbar_view = nil
PakettiAutomationStack_timer_running = false
PakettiAutomationStack_timer_interval_ms = 120
PakettiAutomationStack_last_hash = ""
PakettiAutomationStack_automations = {}
PakettiAutomationStack_vertical_page_index = 1
PakettiAutomationStack_vertical_page_size = 8
PakettiAutomationStack_vscrollbar_view = nil
PakettiAutomationStack_min_redraw_ms = 60
PakettiAutomationStack_min_redraw_ms_idle = 100 -- Slower refresh when not drawing
PakettiAutomationStack_min_redraw_ms_active = 16 -- ~60 FPS when actively drawing
PakettiAutomationStack_last_redraw_ms = 0
PakettiAutomationStack_is_drawing = false
PakettiAutomationStack_last_draw_line = -1
PakettiAutomationStack_last_draw_idx = -1
PakettiAutomationStack_last_draw_value = -1
PakettiAutomationStack_draw_playmode_index = 2 -- 1=Points,2=Lines,3=Curves
PakettiAutomationStack_selection_active = false
PakettiAutomationStack_selection_start_line = nil
PakettiAutomationStack_selection_end_line = nil
PakettiAutomationStack_selection_lane_index = nil
PakettiAutomationStack_show_all_vertically = false
PakettiAutomationStack_count_text_view = nil
PakettiAutomationStack_view_mode = 1 -- 1=Stack (multi lanes), 2=Single (overlay)
PakettiAutomationStack_env_popup_view = nil
PakettiAutomationStack_single_selected_index = 1
PakettiAutomationStack_single_canvas_height = 320
PakettiAutomationStack_copy_buffer = nil
PakettiAutomationStack_automation_hashes = {} -- Individual automation hashes for change detection

-- Single view background caching for performance
PakettiAutomationStack_background_cache = nil -- Cached rendering function for non-selected automations
PakettiAutomationStack_background_cache_valid = false -- Whether cache is valid
PakettiAutomationStack_cached_selected_index = nil -- Track which index was selected when cache was built
PakettiAutomationStack_cached_num_lines = nil -- Track pattern length when cache was built

-- Grid caching for performance
PakettiAutomationStack_grid_cache = nil -- Cached grid rendering function
PakettiAutomationStack_grid_cache_valid = false -- Whether grid cache is valid
PakettiAutomationStack_cached_grid_num_lines = nil -- Track pattern length for grid cache
PakettiAutomationStack_cached_grid_lpb = nil -- Track LPB for grid cache

-- Observable management for auto-updating
PakettiAutomationStack_track_observables = {} -- Track mute state observables
PakettiAutomationStack_tracks_observable = nil -- Track list observable
PakettiAutomationStack_selection_range_observable = nil -- Sequencer selection range observable

-- Arbitrary Parameters Selection System
PakettiAutomationStack_arbitrary_mode = false -- false=current track, true=arbitrary selection
PakettiAutomationStack_selected_parameters = {} -- Array of {track_index, device_index, param_index}
PakettiAutomationStack_arbitrary_dialog = nil
PakettiAutomationStack_arbitrary_vb = nil
PakettiAutomationStack_parameter_checkboxes = {}

-- Show Same Parameters System
PakettiAutomationStack_show_same_mode = false -- false=normal modes, true=show same parameter name
PakettiAutomationStack_selected_param_name = "" -- The parameter name to filter by
PakettiAutomationStack_show_same_popup_view = nil

-- Preferences key for persistent storage
PakettiAutomationStack_prefs_key = "AutomationStack_SelectedParams"

-- Stacker Mode: Multi-pattern automation editing
PakettiAutomationStack_stacker_mode = false -- false=single pattern, true=multi-pattern
PakettiAutomationStack_stacker_seq_start = nil -- Start sequence index
PakettiAutomationStack_stacker_seq_end = nil -- End sequence index
PakettiAutomationStack_stacker_patterns = {} -- Array of {seq_index, pattern_index, pattern, num_lines, start_offset}
PakettiAutomationStack_stacker_total_lines = 0 -- Sum of all pattern lines

-- Utility draw text helper
function PakettiAutomationStack_DrawText(ctx, text, x, y, size)
  if type(PakettiCanvasFontDrawText) == "function" then
    PakettiCanvasFontDrawText(ctx, text, x, y, size)
  else
    -- Minimal fallback: small tick + no real text (keeps code safe if font not present)
    ctx.stroke_color = {200,200,200,255}
    ctx:begin_path(); ctx:move_to(x, y); ctx:line_to(x+6, y); ctx:stroke()
  end
end

-- Get track color utility function
function PakettiAutomationStack_GetTrackColor(track_index)
  local song = renoise.song()
  if not song or track_index < 1 or track_index > #song.tracks then 
    return {255, 255, 255} -- Default white
  end
  
  local track = song.tracks[track_index]
  local color = track.color
  if not color or #color < 3 then
    return {255, 255, 255} -- Default white if no color
  end
  
  return {color[1], color[2], color[3]}
end

-- Check if track is muted
function PakettiAutomationStack_IsTrackMuted(track_index)
  local song = renoise.song()
  if not song or track_index < 1 or track_index > #song.tracks then 
    return false
  end
  
  local track = song.tracks[track_index]
  -- Master track doesn't have mute state
  if track.type == renoise.Track.TRACK_TYPE_MASTER then
    return false
  end
  
  return track.mute_state == renoise.Track.MUTE_STATE_MUTED
end

-- Convert track color to canvas colors with alpha and brightness variations
function PakettiAutomationStack_TrackColorToCanvas(track_index, alpha, brightness_mult)
  local rgb = PakettiAutomationStack_GetTrackColor(track_index)
  alpha = alpha or 255
  brightness_mult = brightness_mult or 1.0
  
  -- Apply mute state - if muted, desaturate and darken significantly
  local is_muted = PakettiAutomationStack_IsTrackMuted(track_index)
  if is_muted then
    brightness_mult = brightness_mult * 0.3 -- Much darker when muted
    alpha = math.max(60, alpha * 0.4) -- Much more transparent when muted
    -- Desaturate by averaging with grey
    local grey = (rgb[1] + rgb[2] + rgb[3]) / 3
    rgb[1] = rgb[1] * 0.2 + grey * 0.8
    rgb[2] = rgb[2] * 0.2 + grey * 0.8
    rgb[3] = rgb[3] * 0.2 + grey * 0.8
  end
  
  -- Apply brightness multiplier and clamp
  local r = math.max(0, math.min(255, math.floor(rgb[1] * brightness_mult)))
  local g = math.max(0, math.min(255, math.floor(rgb[2] * brightness_mult)))
  local b = math.max(0, math.min(255, math.floor(rgb[3] * brightness_mult)))
  
  return {r, g, b, alpha}
end

-- Get contrasting track colors for automation drawing
function PakettiAutomationStack_GetTrackAutomationColors(track_index)
  local base_color = PakettiAutomationStack_TrackColorToCanvas(track_index, 235, 1.0)
  local bright_color = PakettiAutomationStack_TrackColorToCanvas(track_index, 255, 1.3)
  local dim_color = PakettiAutomationStack_TrackColorToCanvas(track_index, 180, 0.8)
  
  return base_color, bright_color, dim_color
end

-- Generate proper track name based on track type and position
function PakettiAutomationStack_GetTrackName(track_index)
  local song = renoise.song()
  if not song or track_index < 1 or track_index > #song.tracks then return "Unknown" end
  
  local track = song.tracks[track_index]
  
  if track.type == renoise.Track.TRACK_TYPE_MASTER then
    return track.name or "Master"
  elseif track.type == renoise.Track.TRACK_TYPE_SEND then
    return track.name or ("Send " .. string.format("%02d", track_index))
  elseif track.type == renoise.Track.TRACK_TYPE_GROUP then
    return track.name or ("Group " .. string.format("%02d", track_index))
  else -- TRACK_TYPE_SEQUENCER (regular tracks)
    -- Count sequencer tracks up to this point for proper numbering
    local sequencer_count = 0
    for i = 1, track_index do
      if song.tracks[i].type == renoise.Track.TRACK_TYPE_SEQUENCER then
        sequencer_count = sequencer_count + 1
      end
    end
    return track.name or ("Track " .. string.format("%02d", sequencer_count))
  end
end

-- Toggle track mute state
function PakettiAutomationStack_ToggleTrackMute(track_index)
  local song = renoise.song()
  if not song or track_index < 1 or track_index > #song.tracks then return end
  
  local track = song.tracks[track_index]
  -- Master track doesn't have mute state
  if track.type == renoise.Track.TRACK_TYPE_MASTER then return end
  
  if track.mute_state == renoise.Track.MUTE_STATE_MUTED then
    track:unmute()
    renoise.app():show_status("Automation Stack: Unmuted " .. PakettiAutomationStack_GetTrackName(track_index))
  else
    track:mute()
    renoise.app():show_status("Automation Stack: Muted " .. PakettiAutomationStack_GetTrackName(track_index))
  end
end

-- Key handler wrapper to support flood fill with Enter while delegating to my_keyhandler_func
function PakettiAutomationStack_KeyHandler(dialog, key)
  if key and key.modifiers == "" and (key.name == "return" or key.name == "enter") then
    local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack()
    if song and patt and PakettiAutomationStack_selection_active and PakettiAutomationStack_selection_lane_index then
      local start_l = PakettiAutomationStack_selection_start_line or 1
      local end_l = PakettiAutomationStack_selection_end_line or patt.number_of_lines
      if start_l > end_l then local tmp = start_l; start_l = end_l; end_l = tmp end
      local v = PakettiAutomationStack_last_draw_value
      if not v then v = 0.0 end
      for L = start_l, end_l do
        PakettiAutomationStack_WritePoint(PakettiAutomationStack_selection_lane_index, L, v, false)
      end
      PakettiAutomationStack_selection_active = false
      PakettiAutomationStack_selection_lane_index = nil
      PakettiAutomationStack_selection_start_line = nil
      PakettiAutomationStack_selection_end_line = nil
      PakettiAutomationStack_RequestUpdate()
      renoise.app():show_status("Automation Stack: Flood filled lines " .. tostring(start_l) .. "-" .. tostring(end_l))
      return nil
    end
  end
  if type(my_keyhandler_func) == "function" then
    return my_keyhandler_func(dialog, key)
  end
  return key
end

-- Safe access helpers
function PakettiAutomationStack_GetSongPatternTrack()
  local song = renoise.song()
  if not song then return nil, nil, nil end
  local patt_idx = song.selected_pattern_index
  if patt_idx < 1 or patt_idx > #song.patterns then return song, nil, nil end
  local patt = song:pattern(patt_idx)
  local track_idx = song.selected_track_index
  if track_idx < 1 or track_idx > #song.tracks then return song, patt, nil end
  local ptrack = patt:track(track_idx)
  return song, patt, ptrack
end

-- Build stacker patterns array from sequencer selection
function PakettiAutomationStack_BuildStackerPatterns()
  PakettiAutomationStack_stacker_patterns = {}
  PakettiAutomationStack_stacker_total_lines = 0
  PakettiAutomationStack_stacker_seq_start = nil
  PakettiAutomationStack_stacker_seq_end = nil
  
  local song = renoise.song()
  if not song then return false end
  
  local selection_range = song.sequencer.selection_range
  -- selection_range returns {0, 0} if no selection, else {start, end}
  if not selection_range or selection_range[1] == 0 or selection_range[2] == 0 then
    -- No selection - disable stacker mode
    return false
  end
  
  local seq_start = selection_range[1]
  local seq_end = selection_range[2]
  
  -- Ensure valid range
  if seq_start > seq_end then
    local tmp = seq_start
    seq_start = seq_end
    seq_end = tmp
  end
  
  -- Clamp to valid sequence range
  local seq_count = #song.sequencer.pattern_sequence
  if seq_start < 1 then seq_start = 1 end
  if seq_end > seq_count then seq_end = seq_count end
  
  PakettiAutomationStack_stacker_seq_start = seq_start
  PakettiAutomationStack_stacker_seq_end = seq_end
  
  local cumulative_offset = 0
  for seq_idx = seq_start, seq_end do
    local pattern_index = song.sequencer.pattern_sequence[seq_idx]
    local pattern = song:pattern(pattern_index)
    local num_lines = pattern.number_of_lines
    
    local entry = {
      seq_index = seq_idx,
      pattern_index = pattern_index,
      pattern = pattern,
      num_lines = num_lines,
      start_offset = cumulative_offset -- 0-based offset for this pattern's first line
    }
    PakettiAutomationStack_stacker_patterns[#PakettiAutomationStack_stacker_patterns + 1] = entry
    cumulative_offset = cumulative_offset + num_lines
  end
  
  PakettiAutomationStack_stacker_total_lines = cumulative_offset
  
  print("Stacker: Built " .. #PakettiAutomationStack_stacker_patterns .. " patterns, total " .. PakettiAutomationStack_stacker_total_lines .. " lines")
  return true
end

-- Convert global line (1-based across all patterns) to pattern-local coordinates
-- Returns: seq_index, pattern_index, local_line, pattern_entry_index
function PakettiAutomationStack_GlobalLineToPatternLine(global_line)
  if not PakettiAutomationStack_stacker_mode or #PakettiAutomationStack_stacker_patterns == 0 then
    -- Not in stacker mode, return current pattern info
    local song = renoise.song()
    if not song then return nil, nil, global_line, nil end
    local seq_idx = song.selected_sequence_index
    local patt_idx = song.selected_pattern_index
    return seq_idx, patt_idx, global_line, nil
  end
  
  -- Find which pattern this global line falls into
  local global_0based = global_line - 1
  for i, entry in ipairs(PakettiAutomationStack_stacker_patterns) do
    local pattern_end_offset = entry.start_offset + entry.num_lines
    if global_0based < pattern_end_offset then
      local local_line = global_0based - entry.start_offset + 1
      return entry.seq_index, entry.pattern_index, local_line, i
    end
  end
  
  -- Past the end - return last pattern's last line
  local last = PakettiAutomationStack_stacker_patterns[#PakettiAutomationStack_stacker_patterns]
  if last then
    return last.seq_index, last.pattern_index, last.num_lines, #PakettiAutomationStack_stacker_patterns
  end
  
  return nil, nil, global_line, nil
end

-- Convert pattern-local line to global line (1-based)
function PakettiAutomationStack_PatternLineToGlobalLine(pattern_entry_index, local_line)
  if not PakettiAutomationStack_stacker_mode or #PakettiAutomationStack_stacker_patterns == 0 then
    return local_line
  end
  
  local entry = PakettiAutomationStack_stacker_patterns[pattern_entry_index]
  if not entry then return local_line end
  
  return entry.start_offset + local_line
end

-- Get total lines for current view (stacker or single pattern)
function PakettiAutomationStack_GetTotalLines()
  if PakettiAutomationStack_stacker_mode and PakettiAutomationStack_stacker_total_lines > 0 then
    return PakettiAutomationStack_stacker_total_lines
  end
  
  local song, patt, _ = PakettiAutomationStack_GetSongPatternTrack()
  if patt then
    return patt.number_of_lines
  end
  return 64 -- Default fallback
end

-- Zoom and mapping
function PakettiAutomationStack_GetWindowLines(total_lines)
  local z = PakettiAutomationStack_zoom_levels[PakettiAutomationStack_zoom_index] or 1.0
  local win = math.max(1, math.floor(total_lines * z + 0.5))
  if win > total_lines then win = total_lines end
  return win
end

function PakettiAutomationStack_ClampView(total_lines)
  local win = PakettiAutomationStack_GetWindowLines(total_lines)
  local max_start = math.max(1, total_lines - win + 1)
  if PakettiAutomationStack_view_start_line < 1 then PakettiAutomationStack_view_start_line = 1 end
  if PakettiAutomationStack_view_start_line > max_start then PakettiAutomationStack_view_start_line = max_start end
end

function PakettiAutomationStack_MapTimeToX(t, total_lines)
  local win = PakettiAutomationStack_GetWindowLines(total_lines)
  local view_start_t = (PakettiAutomationStack_view_start_line - 1)
  -- Account for gutters - use effective width, not full canvas width
  local eff_w = math.max(1, PakettiAutomationStack_canvas_width - (2*PakettiAutomationStack_gutter_width))
  if win <= 1 then
    return PakettiAutomationStack_gutter_width + eff_w / 2
  end
  -- Map the pattern length to canvas width, but extend slightly beyond the last line
  -- This allows clicking at the right edge to map to the last valid line
  local divisor = total_lines + 0.9  -- Add 0.9 to allow clicking at right edge to reach line 64
  local x = PakettiAutomationStack_gutter_width + ((t - view_start_t) / divisor) * eff_w
  return x
end

function PakettiAutomationStack_LineToX(line_index, total_lines)
  return PakettiAutomationStack_MapTimeToX((line_index - 1), total_lines)
end

-- Inverse mapping: canvas x to pattern line
function PakettiAutomationStack_XToLine(x, total_lines)
  local win = PakettiAutomationStack_GetWindowLines(total_lines)
  local view_start_t = (PakettiAutomationStack_view_start_line - 1)
  local eff_w = math.max(1, PakettiAutomationStack_canvas_width - (2*PakettiAutomationStack_gutter_width))
  -- Remove gutter offset first (inverse of forward mapping)
  local x_eff = x - PakettiAutomationStack_gutter_width
  -- Map effective canvas width to 0-based time (inverse of forward mapping)
  -- Use the same extended divisor as the forward mapping
  local divisor = total_lines + 0.9
  local t_0based = (x_eff / eff_w) * divisor
  -- Add back the view start offset to get the actual time
  local actual_time = t_0based + view_start_t
  -- Convert from 0-based time back to 1-based line number
  -- Use proper rounding to avoid off-by-one errors
  -- Allow clicking at right edge to reach line 65 (the actual end)
  local line = math.max(1, math.min(total_lines + 1, math.floor(actual_time + 0.5) + 1))
  
  
  return line
end

function PakettiAutomationStack_UpdateScrollbars()
  local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack()
  if not song or not patt then return end
  -- Use stacker total lines if in stacker mode
  local num_lines = PakettiAutomationStack_GetTotalLines()
  PakettiAutomationStack_ClampView(num_lines)
  if PakettiAutomationStack_scrollbar_view then
    local win = PakettiAutomationStack_GetWindowLines(num_lines)
    PakettiAutomationStack_scrollbar_view.min = 1
    PakettiAutomationStack_scrollbar_view.max = num_lines + 1
    PakettiAutomationStack_scrollbar_view.pagestep = win
    PakettiAutomationStack_scrollbar_view.value = PakettiAutomationStack_view_start_line
  end
end

function PakettiAutomationStack_SetZoomIndex(idx)
  PakettiAutomationStack_zoom_index = math.max(1, math.min(#PakettiAutomationStack_zoom_levels, idx))
  PakettiAutomationStack_UpdateScrollbars()
  PakettiAutomationStack_RequestUpdate()
end

-- Hash builder for quick change detection
function PakettiAutomationStack_BuildAutomationHash()
  local song, patt, ptrack = PakettiAutomationStack_GetSongPatternTrack()
  if not song or not patt or not ptrack then return "" end
  local acc = {tostring(patt.number_of_lines), tostring(song.selected_track_index), tostring(#song.tracks)}
  
  -- Include track count and mute states for change detection
  for track_idx = 1, #song.tracks do
    local track = song.tracks[track_idx]
    if track then
      local mute_state = "active"
      if track.type ~= renoise.Track.TRACK_TYPE_MASTER then
        if track.mute_state == renoise.Track.MUTE_STATE_MUTED then
          mute_state = "muted"
        elseif track.mute_state == renoise.Track.MUTE_STATE_OFF then
          mute_state = "off"
        end
      end
      acc[#acc+1] = "t" .. tostring(track_idx) .. ":" .. mute_state .. ":" .. (track.name or "")
    end
  end
  
  local track = song.tracks[song.selected_track_index]
  if not track then return table.concat(acc, ":") end
  for d = 1, #track.devices do
    local dev = track.devices[d]
    for pi = 1, #dev.parameters do
      local param = dev.parameters[pi]
      if param.is_automatable then
        local a = ptrack:find_automation(param)
        if a then
          local ok1, pm = pcall(function() return a.playmode end)
          acc[#acc+1] = tostring(pm or "?")
          acc[#acc+1] = tostring(param.name or "?")
          local points = a.points
          if points then
            acc[#acc+1] = tostring(#points)
            local sumt = 0; local sumv = 0
            for j = 1, #points do
              local p = points[j]
              sumt = sumt + (p.time or 0)
              sumv = sumv + math.floor(((p.value or 0)*1000)+0.5)
            end
            acc[#acc+1] = tostring(sumt)
            acc[#acc+1] = tostring(sumv)
          end
        end
      end
    end
  end
  return table.concat(acc, ":")
end

-- Build individual automation hashes for change detection
function PakettiAutomationStack_BuildIndividualHashes()
  local song, patt, ptrack = PakettiAutomationStack_GetSongPatternTrack()
  if not song or not patt or not ptrack then return {} end
  local hashes = {}
  local track = song.tracks[song.selected_track_index]
  if not track then return hashes end
  local auto_index = 1
  for d = 1, #track.devices do
    local dev = track.devices[d]
    for pi = 1, #dev.parameters do
      local param = dev.parameters[pi]
      if param.is_automatable then
        local a = ptrack:find_automation(param)
        if a then
          local acc = {}
          local ok1, pm = pcall(function() return a.playmode end)
          acc[#acc+1] = tostring(pm or "?")
          acc[#acc+1] = tostring(param.name or "?")
          local points = a.points
          if points then
            acc[#acc+1] = tostring(#points)
            local sumt = 0; local sumv = 0
            for j = 1, #points do
              local p = points[j]
              sumt = sumt + (p.time or 0)
              sumv = sumv + math.floor(((p.value or 0)*1000)+0.5)
            end
            acc[#acc+1] = tostring(sumt)
            acc[#acc+1] = tostring(sumv)
          end
          hashes[auto_index] = table.concat(acc, ":")
          auto_index = auto_index + 1
        end
      end
    end
  end
  return hashes
end

-- Detect which automation changed and auto-select it
function PakettiAutomationStack_DetectChangedAutomation()
  local new_hashes = PakettiAutomationStack_BuildIndividualHashes()
  for i = 1, #new_hashes do
    local old_hash = PakettiAutomationStack_automation_hashes[i]
    local new_hash = new_hashes[i]
    if old_hash and old_hash ~= new_hash then
      -- This automation changed, auto-select it
      if PakettiAutomationStack_view_mode == 2 then
        -- Single view mode
        PakettiAutomationStack_single_selected_index = i
        PakettiAutomationStack_UpdateEnvPopup()
        local entry = PakettiAutomationStack_automations[i]
        if entry then
          renoise.app():show_status("Auto-selected: " .. (entry.device_name or "Device") .. ": " .. (entry.name or "Parameter"))
        end
      end
      break -- Only select the first changed automation
    end
  end
  PakettiAutomationStack_automation_hashes = new_hashes
end

-- Enumerate all automatable parameters from all tracks
function PakettiAutomationStack_GetAllParameters()
  local song = renoise.song()
  if not song then return {} end
  local all_params = {}
  
  for track_idx = 1, #song.tracks do
    local track = song.tracks[track_idx]
    local track_name = PakettiAutomationStack_GetTrackName(track_idx)
    
    for dev_idx = 1, #track.devices do
      local dev = track.devices[dev_idx]
      local device_name = dev.display_name or "Device"
      
      for param_idx = 1, #dev.parameters do
        local param = dev.parameters[param_idx]
        if param.is_automatable then
          local param_key = track_idx .. "_" .. dev_idx .. "_" .. param_idx
          local display_name = string.format("Track%02d: %s: %s", 
            track_idx, device_name, param.name or "Parameter")
          
          all_params[#all_params+1] = {
            key = param_key,
            track_index = track_idx,
            device_index = dev_idx,
            param_index = param_idx,
            track_name = track_name,
            device_name = device_name,
            param_name = param.name or "Parameter",
            display_name = display_name,
            parameter = param
          }
        end
      end
    end
  end
  
  return all_params
end

-- Get all unique parameter names that currently have automation data
function PakettiAutomationStack_GetUniqueAutomatedParameterNames()
  local song, patt = PakettiAutomationStack_GetSongPatternTrack()
  if not song or not patt then return {} end
  
  local unique_names = {}
  local name_counts = {} -- Track how many times each name appears
  
  for track_idx = 1, #song.tracks do
    local track = song.tracks[track_idx]
    local pattern_track = patt:track(track_idx)
    if pattern_track then
      for dev_idx = 1, #track.devices do
        local dev = track.devices[dev_idx]
        for param_idx = 1, #dev.parameters do
          local param = dev.parameters[param_idx]
          if param.is_automatable then
            local automation = pattern_track:find_automation(param)
            if automation and automation.points and #automation.points > 0 then
              local param_name = param.name or "Parameter"
              if not name_counts[param_name] then
                name_counts[param_name] = 0
                unique_names[#unique_names+1] = param_name
              end
              name_counts[param_name] = name_counts[param_name] + 1
            end
          end
        end
      end
    end
  end
  
  -- Sort by name and add count information
  table.sort(unique_names)
  local result = {}
  for i = 1, #unique_names do
    local name = unique_names[i]
    local count = name_counts[name]
    local display_name = string.format("%s (%d)", name, count)
    result[#result+1] = {
      name = name,
      count = count,
      display_name = display_name
    }
  end
  
  return result
end

-- Check if a parameter is selected for arbitrary display
function PakettiAutomationStack_IsParameterSelected(track_idx, dev_idx, param_idx)
  for i = 1, #PakettiAutomationStack_selected_parameters do
    local sel = PakettiAutomationStack_selected_parameters[i]
    if sel.track_index == track_idx and sel.device_index == dev_idx and sel.param_index == param_idx then
      return true
    end
  end
  return false
end

-- Add parameter to selection
function PakettiAutomationStack_AddParameter(track_idx, dev_idx, param_idx)
  if not PakettiAutomationStack_IsParameterSelected(track_idx, dev_idx, param_idx) then
    PakettiAutomationStack_selected_parameters[#PakettiAutomationStack_selected_parameters+1] = {
      track_index = track_idx,
      device_index = dev_idx,
      param_index = param_idx
    }
  end
end

-- Remove parameter from selection
function PakettiAutomationStack_RemoveParameter(track_idx, dev_idx, param_idx)
  for i = #PakettiAutomationStack_selected_parameters, 1, -1 do
    local sel = PakettiAutomationStack_selected_parameters[i]
    if sel.track_index == track_idx and sel.device_index == dev_idx and sel.param_index == param_idx then
      table.remove(PakettiAutomationStack_selected_parameters, i)
      break
    end
  end
end

-- Save selected parameters to preferences
function PakettiAutomationStack_SaveSelectedParameters()
  local params_table = {}
  for i = 1, #PakettiAutomationStack_selected_parameters do
    local sel = PakettiAutomationStack_selected_parameters[i]
    local param_string = sel.track_index .. "_" .. sel.device_index .. "_" .. sel.param_index
    params_table[#params_table+1] = param_string
  end
  renoise.tool().preferences[PakettiAutomationStack_prefs_key] = table.concat(params_table, ",")
end

-- Load selected parameters from preferences
function PakettiAutomationStack_LoadSelectedParameters()
  local params_string = renoise.tool().preferences[PakettiAutomationStack_prefs_key]
  PakettiAutomationStack_selected_parameters = {}
  
  if params_string and params_string.value and params_string.value ~= "" then
    local param_strings = {}
    for param_str in params_string.value:gmatch("[^,]+") do
      param_strings[#param_strings+1] = param_str
    end
    
    for i = 1, #param_strings do
      local parts = {}
      for part in param_strings[i]:gmatch("[^_]+") do
        parts[#parts+1] = tonumber(part)
      end
      
      if #parts == 3 then
        PakettiAutomationStack_selected_parameters[#PakettiAutomationStack_selected_parameters+1] = {
          track_index = parts[1],
          device_index = parts[2],
          param_index = parts[3]
        }
      end
    end
  end
end

-- Rebuild automation list (modified to support arbitrary parameters and show same)
function PakettiAutomationStack_RebuildAutomations()
  PakettiAutomationStack_automations = {}
  local song, patt, ptrack = PakettiAutomationStack_GetSongPatternTrack()
  if not song or not patt then return end
  
  if PakettiAutomationStack_show_same_mode then
    -- Show Same mode: find all automations with the selected parameter name
    if PakettiAutomationStack_selected_param_name and PakettiAutomationStack_selected_param_name ~= "" then
      for track_idx = 1, #song.tracks do
        local track = song.tracks[track_idx]
        local pattern_track = patt:track(track_idx)
        if pattern_track then
          for dev_idx = 1, #track.devices do
            local dev = track.devices[dev_idx]
            for param_idx = 1, #dev.parameters do
              local param = dev.parameters[param_idx]
              if param.is_automatable and (param.name or "Parameter") == PakettiAutomationStack_selected_param_name then
                local a = pattern_track:find_automation(param)
                -- Show parameter even if no automation exists yet (allows creating new automation)
                local entry = {
                  automation = a, -- May be nil for new automation
                  parameter = param,
                  pattern_track = pattern_track, -- Store for creating automation later
                  name = param.name or "Parameter",
                  device_name = dev.display_name or "Device",
                  track_name = PakettiAutomationStack_GetTrackName(track_idx),
                  track_index = track_idx,
                  playmode = a and a.playmode or PAKETTI_PLAYMODE_LINES
                }
                PakettiAutomationStack_automations[#PakettiAutomationStack_automations+1] = entry
              end
            end
          end
        end
      end
    end
  elseif PakettiAutomationStack_arbitrary_mode then
    -- Arbitrary mode: show selected parameters from any track
    for i = 1, #PakettiAutomationStack_selected_parameters do
      local sel = PakettiAutomationStack_selected_parameters[i]
      local track = song.tracks[sel.track_index]
      if track then
        local pattern_track = patt:track(sel.track_index)
        if pattern_track then
          local dev = track.devices[sel.device_index]
          if dev then
            local param = dev.parameters[sel.param_index]
            if param and param.is_automatable then
              local a = pattern_track:find_automation(param)
              -- Show parameter even if no automation exists yet (allows creating new automation)
              local entry = {
                automation = a, -- May be nil for new automation
                parameter = param,
                pattern_track = pattern_track, -- Store for creating automation later
                name = param.name or "Parameter",
                device_name = dev.display_name or "Device",
                track_name = PakettiAutomationStack_GetTrackName(sel.track_index),
                track_index = sel.track_index,
                playmode = a and a.playmode or PAKETTI_PLAYMODE_LINES
              }
              PakettiAutomationStack_automations[#PakettiAutomationStack_automations+1] = entry
            end
          end
        end
      end
    end
  else
    -- Current track mode: prioritize parameters with automation data
    if not ptrack then return end
    local track = song.tracks[song.selected_track_index]
    if not track then return end
    
    local automations_with_data = {}
    local automations_without_data = {}
    
    -- First pass: collect all automatable parameters
    for d = 1, #track.devices do
      local dev = track.devices[d]
      for pi = 1, #dev.parameters do
        local param = dev.parameters[pi]
        if param.is_automatable then
          local a = ptrack:find_automation(param)
          local entry = {
            automation = a, -- May be nil for new automation
            parameter = param,
            pattern_track = ptrack, -- Store for creating automation later
            name = param.name or "Parameter",
            device_name = dev.display_name or "Device",
            track_name = PakettiAutomationStack_GetTrackName(song.selected_track_index),
            track_index = song.selected_track_index,
            playmode = a and a.playmode or PAKETTI_PLAYMODE_LINES,
            device_index = d,
            param_index = pi
          }
          
          -- Check if this parameter has automation data
          local has_data = false
          if a and a.points and #a.points > 0 then
            has_data = true
          end
          
          if has_data then
            automations_with_data[#automations_with_data+1] = entry
          else
            -- Skip mixer parameters unless they have data
            local is_mixer_param = (param.name == "Panning" or param.name == "Volume" or param.name == "Width")
            if not is_mixer_param then
              automations_without_data[#automations_without_data+1] = entry
            end
          end
        end
      end
    end
    
    -- Add automations with data first
    for i = 1, #automations_with_data do
      PakettiAutomationStack_automations[#PakettiAutomationStack_automations+1] = automations_with_data[i]
    end
    
    -- If no automations with data, show first device's first few parameters
    if #automations_with_data == 0 then
      local first_device_params = {}
      for i = 1, #automations_without_data do
        local entry = automations_without_data[i]
        if entry.device_index == 1 then -- First device only
          first_device_params[#first_device_params+1] = entry
        end
      end
      
      -- Add first 4 parameters from first device
      for i = 1, math.min(4, #first_device_params) do
        PakettiAutomationStack_automations[#PakettiAutomationStack_automations+1] = first_device_params[i]
      end
    end
  end
  PakettiAutomationStack_UpdateEnvPopup()
  
  -- Invalidate background cache since automation list changed
  PakettiAutomationStack_InvalidateBackgroundCache()
end

-- Redraw throttling with context-aware rates
function PakettiAutomationStack_RequestUpdate()
  local now_ms = os.clock() * 1000
  -- Use faster throttle when actively drawing, slower when idle
  local throttle_ms = PakettiAutomationStack_is_drawing and PakettiAutomationStack_min_redraw_ms_active or PakettiAutomationStack_min_redraw_ms_idle
  if (now_ms - PakettiAutomationStack_last_redraw_ms) >= throttle_ms then
    if PakettiAutomationStack_header_canvas and PakettiAutomationStack_header_canvas.visible then PakettiAutomationStack_header_canvas:update() end
    if PakettiAutomationStack_track_canvases and #PakettiAutomationStack_track_canvases > 0 then
      for i = 1, #PakettiAutomationStack_track_canvases do
        local c = PakettiAutomationStack_track_canvases[i]
        if c and c.visible then c:update() end
      end
    end
    PakettiAutomationStack_last_redraw_ms = now_ms
  end
end

-- Rendering helpers
function PakettiAutomationStack_DrawGrid(ctx, W, H, num_lines, lpb)
  local win = PakettiAutomationStack_GetWindowLines(num_lines)
  local pixels_per_line = W / win
  -- background
  ctx:set_fill_linear_gradient(0, 0, 0, H)
  ctx:add_fill_color_stop(0, {25,25,35,255})
  ctx:add_fill_color_stop(1, {15,15,25,255})
  ctx:begin_path(); ctx:rect(0,0,W,H); ctx:fill()
  -- gutters (only if gutter_width > 0)
  local gutter = PakettiAutomationStack_gutter_width
  if gutter > 0 then
    ctx.fill_color = {18,18,24,255}; ctx:fill_rect(0, 0, gutter, H)
    ctx.fill_color = {14,14,20,255}; ctx:fill_rect(W - gutter, 0, gutter, H)
  end
  -- grid
  if pixels_per_line >= 6 then
    for line = PakettiAutomationStack_view_start_line, math.min(num_lines, PakettiAutomationStack_view_start_line + win - 1) do
      local x = PakettiAutomationStack_LineToX(line, num_lines)
      if ((line-1) % (lpb*4)) == 0 then
        ctx.stroke_color = {110,110,160,255}; ctx.line_width = 3
      elseif ((line-1) % lpb) == 0 then
        ctx.stroke_color = {80,80,120,220}; ctx.line_width = 2
      else
        ctx.stroke_color = {40,40,60,130}; ctx.line_width = 1
      end
      ctx:begin_path(); ctx:move_to(x, 0); ctx:line_to(x, H); ctx:stroke()
    end
  else
    ctx.line_width = 1
    for line = PakettiAutomationStack_view_start_line, math.min(num_lines, PakettiAutomationStack_view_start_line + win - 1) do
      if ((line-1) % lpb) == 0 then
        local x = PakettiAutomationStack_LineToX(line, num_lines)
        ctx.stroke_color = {70,70,100,220}
        ctx:begin_path(); ctx:move_to(x, 0); ctx:line_to(x, H); ctx:stroke()
      end
    end
  end
  
  -- Draw pattern boundaries in stacker mode
  if PakettiAutomationStack_stacker_mode and #PakettiAutomationStack_stacker_patterns > 1 then
    ctx.line_width = 2
    for i = 2, #PakettiAutomationStack_stacker_patterns do
      local entry = PakettiAutomationStack_stacker_patterns[i]
      -- Pattern boundary is at start_offset + 1 (first line of this pattern in global coords)
      local boundary_line = entry.start_offset + 1
      local x = PakettiAutomationStack_LineToX(boundary_line, num_lines)
      -- Draw dashed orange line for pattern boundary
      ctx.stroke_color = {255, 140, 0, 255}
      local dash_len = 6
      local gap_len = 4
      local y = 0
      while y < H do
        ctx:begin_path()
        ctx:move_to(x, y)
        ctx:line_to(x, math.min(y + dash_len, H))
        ctx:stroke()
        y = y + dash_len + gap_len
      end
    end
  end
end

-- Draw a single automation into an existing canvas with track-based colors or custom colors
function PakettiAutomationStack_DrawAutomation(entry, ctx, W, H, num_lines, color_main, color_point, line_width, use_track_colors)
  if not entry or not entry.automation then return end
  local a = entry.automation
  local points = a.points or {}
  local mode = a.playmode or PAKETTI_PLAYMODE_POINTS
  local gutter = PakettiAutomationStack_gutter_width
  if #points == 0 then return end
  
  -- Use track colors if enabled and we have a track index, otherwise use provided colors
  local main_color = color_main
  local point_color = color_point
  
  if use_track_colors and entry.track_index then
    local base_color, bright_color, dim_color = PakettiAutomationStack_GetTrackAutomationColors(entry.track_index)
    main_color = base_color
    point_color = bright_color
  end
  
  if mode == PAKETTI_PLAYMODE_POINTS then
    ctx.stroke_color = main_color
    ctx.line_width = line_width
    for i = 1, #points do
      local p = points[i]
      local x = PakettiAutomationStack_MapTimeToX((p.time or 1) - 1, num_lines)
      local y = PakettiAutomationStack_ValueToY(p.value, H)
      -- Remove gutter constraints since gutter_width = 0
      if gutter > 0 then
        if x < gutter then x = gutter end
        if x > W - gutter then x = W - gutter end
      end
      ctx:begin_path(); ctx:move_to(x, H-1); ctx:line_to(x, y); ctx:stroke()
      ctx.stroke_color = point_color
      ctx.line_width = math.max(1, line_width - 1)
      ctx:begin_path(); ctx:move_to(x-1, y); ctx:line_to(x+1, y); ctx:stroke()
      ctx.stroke_color = main_color
      ctx.line_width = line_width
    end
  elseif mode == PAKETTI_PLAYMODE_LINES then
    ctx.stroke_color = main_color
    ctx.line_width = line_width
    ctx:begin_path()
    local p1 = points[1]
    local x1 = PakettiAutomationStack_MapTimeToX((p1.time or 1) - 1, num_lines)
    local y1 = PakettiAutomationStack_ValueToY(p1.value, H)
    if x1 < gutter then x1 = gutter end
    if x1 > W - gutter then x1 = W - gutter end
    ctx:move_to(x1, y1)
    for i = 2, #points do
      local p = points[i]
      local x = PakettiAutomationStack_MapTimeToX((p.time or 1) - 1, num_lines)
      local y = PakettiAutomationStack_ValueToY(p.value, H)
      -- Remove gutter constraints since gutter_width = 0
      if gutter > 0 then
        if x < gutter then x = gutter end
        if x > W - gutter then x = W - gutter end
      end
      ctx:line_to(x, y)
    end
    -- Draw line from last point to end of pattern (finishing line)
    if #points > 0 then
      local last_point = points[#points]
      local last_y = PakettiAutomationStack_ValueToY(last_point.value, H)
      -- Extend to the actual end of the canvas (right edge) - no gutter constraints
      local end_x = W
      ctx:line_to(end_x, last_y)
    end
    ctx:stroke()
  else
    ctx.stroke_color = main_color
    ctx.line_width = line_width
    for seg = 1, (#points - 1) do
      local p0 = points[math.max(1, seg-1)]
      local p1c = points[seg]
      local p2 = points[seg+1]
      local p3 = points[math.min(#points, seg+2)]
      local x1 = PakettiAutomationStack_MapTimeToX((p1c.time or 1) - 1, num_lines)
      local y1 = PakettiAutomationStack_ValueToY(p1c.value, H)
      local x2 = PakettiAutomationStack_MapTimeToX((p2.time or 1) - 1, num_lines)
      local y2 = PakettiAutomationStack_ValueToY(p2.value, H)
      if x2 <= x1 then x2 = x1 + 1 end
      local steps = math.max(8, math.floor((x2 - x1) / 6))
      local function hermite(t, y_0, y_1, y_2, y_3)
        local m1 = 0.5 * (y_2 - y_0)
        local m2 = 0.5 * (y_3 - y_1)
        local t2 = t * t
        local t3 = t2 * t
        local h00 = 2*t3 - 3*t2 + 1
        local h10 = t3 - 2*t2 + t
        local h01 = -2*t3 + 3*t2
        local h11 = t3 - t2
        return h00*y_1 + h10*m1 + h01*y_2 + h11*m2
      end
      ctx:begin_path()
      for s = 0, steps do
        local t = s / steps
        local x = x1 + (x2 - x1) * t
        local y = hermite(t, PakettiAutomationStack_ValueToY(p0.value, H), y1, y2, PakettiAutomationStack_ValueToY(p3.value, H))
        if s == 0 then ctx:move_to(x, y) else ctx:line_to(x, y) end
      end
      ctx:stroke()
    end
  end
end

-- Collect all automation points across stacker patterns for a given parameter
-- Returns array of {time, value} with time as global line offset
function PakettiAutomationStack_CollectStackerPoints(entry)
  if not entry or not entry.parameter then return {} end
  
  local song = renoise.song()
  if not song then return {} end
  
  local param = entry.parameter
  local track_idx = entry.track_index or song.selected_track_index
  local all_points = {}
  
  for patt_entry_idx, patt_entry in ipairs(PakettiAutomationStack_stacker_patterns) do
    local pattern = patt_entry.pattern
    if pattern then
      local pattern_track = pattern:track(track_idx)
      if pattern_track then
        local automation = pattern_track:find_automation(param)
        if automation and automation.points then
          local mode = automation.playmode or PAKETTI_PLAYMODE_LINES
          for _, p in ipairs(automation.points) do
            local global_time = patt_entry.start_offset + (p.time or 1)
            all_points[#all_points + 1] = {
              time = global_time,
              value = p.value,
              playmode = mode,
              pattern_entry_idx = patt_entry_idx
            }
          end
        end
      end
    end
  end
  
  -- Sort by global time
  table.sort(all_points, function(a, b) return a.time < b.time end)
  
  return all_points
end

-- Invalidate the background cache for Single view
function PakettiAutomationStack_InvalidateBackgroundCache()
  PakettiAutomationStack_background_cache_valid = false
end

-- Invalidate the grid cache
function PakettiAutomationStack_InvalidateGridCache()
  PakettiAutomationStack_grid_cache_valid = false
end

-- Build cached grid rendering
function PakettiAutomationStack_BuildGridCache(W, H, num_lines, lpb)
  local win = PakettiAutomationStack_GetWindowLines(num_lines)
  local pixels_per_line = W / win
  local gutter = PakettiAutomationStack_gutter_width
  
  -- Pre-calculate all grid line positions and styles
  local grid_lines = {}
  
  if pixels_per_line >= 6 then
    for line = PakettiAutomationStack_view_start_line, math.min(num_lines, PakettiAutomationStack_view_start_line + win - 1) do
      local x = PakettiAutomationStack_LineToX(line, num_lines)
      local style
      if ((line-1) % (lpb*4)) == 0 then
        style = {color = {110,110,160,255}, width = 3}
      elseif ((line-1) % lpb) == 0 then
        style = {color = {80,80,120,220}, width = 2}
      else
        style = {color = {40,40,60,130}, width = 1}
      end
      grid_lines[#grid_lines+1] = {x=x, style=style}
    end
  else
    for line = PakettiAutomationStack_view_start_line, math.min(num_lines, PakettiAutomationStack_view_start_line + win - 1) do
      if ((line-1) % lpb) == 0 then
        local x = PakettiAutomationStack_LineToX(line, num_lines)
        grid_lines[#grid_lines+1] = {x=x, style={color={70,70,100,220}, width=1}}
      end
    end
  end
  
  -- Return a rendering function
  return function(ctx)
    -- Background
    ctx:set_fill_linear_gradient(0, 0, 0, H)
    ctx:add_fill_color_stop(0, {25,25,35,255})
    ctx:add_fill_color_stop(1, {15,15,25,255})
    ctx:begin_path(); ctx:rect(0,0,W,H); ctx:fill()
    
    -- Gutters (only if gutter_width > 0)
    if gutter > 0 then
      ctx.fill_color = {18,18,24,255}; ctx:fill_rect(0, 0, gutter, H)
      ctx.fill_color = {14,14,20,255}; ctx:fill_rect(W - gutter, 0, gutter, H)
    end
    
    -- Grid lines from cache
    for i = 1, #grid_lines do
      local line_data = grid_lines[i]
      ctx.stroke_color = line_data.style.color
      ctx.line_width = line_data.style.width
      ctx:begin_path(); ctx:move_to(line_data.x, 0); ctx:line_to(line_data.x, H); ctx:stroke()
    end
  end
end

-- Build cached background rendering for non-selected automations in Single view
function PakettiAutomationStack_BuildBackgroundCache(W, H, num_lines, sel)
  -- Build a closure that captures all the drawing commands for non-selected automations
  local cached_commands = {}
  
  for i = 1, #PakettiAutomationStack_automations do
    if i ~= sel then
      local entry = PakettiAutomationStack_automations[i]
      local automation_commands = {}
      
      if entry and entry.automation then
        local a = entry.automation
        local points = a.points or {}
        local mode = a.playmode or PAKETTI_PLAYMODE_POINTS
        
        if #points > 0 then
          -- Determine colors
          local main_color, point_color
          if entry.track_index then
            main_color = PakettiAutomationStack_TrackColorToCanvas(entry.track_index, 90, 0.7)
            point_color = PakettiAutomationStack_TrackColorToCanvas(entry.track_index, 80, 1.0)
          else
            main_color = {90,190,170,90}
            point_color = {200,255,255,80}
          end
          
          automation_commands.main_color = main_color
          automation_commands.point_color = point_color
          automation_commands.mode = mode
          automation_commands.points = points
          automation_commands.paths = {}
          
          -- Pre-calculate all curve segments
          if mode == PAKETTI_PLAYMODE_LINES or 
             mode == PAKETTI_PLAYMODE_CURVES then
            for seg = 1, (#points - 1) do
              local p0 = points[math.max(1, seg-1)]
              local p1c = points[seg]
              local p2 = points[seg+1]
              local p3 = points[math.min(#points, seg+2)]
              local x1 = PakettiAutomationStack_MapTimeToX((p1c.time or 1) - 1, num_lines)
              local y1 = PakettiAutomationStack_ValueToY(p1c.value, H)
              local x2 = PakettiAutomationStack_MapTimeToX((p2.time or 1) - 1, num_lines)
              local y2 = PakettiAutomationStack_ValueToY(p2.value, H)
              if x2 <= x1 then x2 = x1 + 1 end
              
              -- VIEWPORT CULLING: Skip segments entirely outside visible canvas
              if x2 >= 0 and x1 <= W then
                local path = {x1=x1, y1=y1, x2=x2, y2=y2, points_data={}}
                
                if mode == PAKETTI_PLAYMODE_CURVES then
                  -- Reduce quality for background automations (half the steps)
                  local steps = math.max(4, math.floor((x2 - x1) / 10))
                  local function hermite(t, y_0, y_1, y_2, y_3)
                  local m1 = 0.5 * (y_2 - y_0)
                  local m2 = 0.5 * (y_3 - y_1)
                  local t2 = t * t
                  local t3 = t2 * t
                  local h00 = 2*t3 - 3*t2 + 1
                  local h10 = t3 - 2*t2 + t
                  local h01 = -2*t3 + 3*t2
                  local h11 = t3 - t2
                  return h00*y_1 + h10*m1 + h01*y_2 + h11*m2
                end
                
                for s = 0, steps do
                  local t = s / steps
                  local x = x1 + (x2 - x1) * t
                  local y = hermite(t, PakettiAutomationStack_ValueToY(p0.value, H), y1, y2, PakettiAutomationStack_ValueToY(p3.value, H))
                  path.points_data[#path.points_data+1] = {x=x, y=y}
                end
              end
              
              automation_commands.paths[#automation_commands.paths+1] = path
              end -- End viewport culling check
            end
          end
          
          cached_commands[#cached_commands+1] = automation_commands
        end
      end
    end
  end
  
  -- Return a function that renders the cached commands
  return function(ctx)
    for _, auto_cmd in ipairs(cached_commands) do
      -- Draw the automation using cached data
      ctx.stroke_color = auto_cmd.main_color
      ctx.line_width = 2
      
      if auto_cmd.mode == PAKETTI_PLAYMODE_POINTS then
        -- Draw points mode (no lines)
        ctx.fill_color = auto_cmd.point_color
        for _, pt in ipairs(auto_cmd.points) do
          local x = PakettiAutomationStack_MapTimeToX((pt.time or 1) - 1, num_lines)
          local y = PakettiAutomationStack_ValueToY(pt.value, H)
          -- VIEWPORT CULLING: Skip points outside visible canvas
          if x >= -4 and x <= W + 4 then
            ctx:begin_path()
            ctx:rect(x-2, y-2, 4, 4)
            ctx:fill()
          end
        end
      elseif auto_cmd.mode == PAKETTI_PLAYMODE_LINES then
        -- Draw lines mode
        for _, path in ipairs(auto_cmd.paths) do
          ctx:begin_path()
          ctx:move_to(path.x1, path.y1)
          ctx:line_to(path.x2, path.y2)
          ctx:stroke()
        end
        -- Draw points
        ctx.fill_color = auto_cmd.point_color
        for _, pt in ipairs(auto_cmd.points) do
          local x = PakettiAutomationStack_MapTimeToX((pt.time or 1) - 1, num_lines)
          local y = PakettiAutomationStack_ValueToY(pt.value, H)
          -- VIEWPORT CULLING: Skip points outside visible canvas
          if x >= -4 and x <= W + 4 then
            ctx:begin_path()
            ctx:rect(x-2, y-2, 4, 4)
            ctx:fill()
          end
        end
      elseif auto_cmd.mode == PAKETTI_PLAYMODE_CURVES then
        -- Draw curves mode using pre-calculated points
        for _, path in ipairs(auto_cmd.paths) do
          ctx:begin_path()
          for i, pt in ipairs(path.points_data) do
            if i == 1 then
              ctx:move_to(pt.x, pt.y)
            else
              ctx:line_to(pt.x, pt.y)
            end
          end
          ctx:stroke()
        end
        -- Draw points
        ctx.fill_color = auto_cmd.point_color
        for _, pt in ipairs(auto_cmd.points) do
          local x = PakettiAutomationStack_MapTimeToX((pt.time or 1) - 1, num_lines)
          local y = PakettiAutomationStack_ValueToY(pt.value, H)
          -- VIEWPORT CULLING: Skip points outside visible canvas
          if x >= -4 and x <= W + 4 then
            ctx:begin_path()
            ctx:rect(x-2, y-2, 4, 4)
            ctx:fill()
          end
        end
      end
    end
  end
end

-- Single view renderer (overlay all automations, highlight selected)
function PakettiAutomationStack_RenderSingleCanvas(canvas_w, canvas_h)
  return function(ctx)
    local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack()
    local W = canvas_w or PakettiAutomationStack_canvas_width
    local H = canvas_h or PakettiAutomationStack_single_canvas_height
    ctx:clear_rect(0, 0, W, H)
    if not song or not patt then return end
    local num_lines = patt.number_of_lines
    local lpb = song.transport.lpb
    
    -- Check if we need to rebuild the grid cache
    if not PakettiAutomationStack_grid_cache_valid or
       PakettiAutomationStack_cached_grid_num_lines ~= num_lines or
       PakettiAutomationStack_cached_grid_lpb ~= lpb then
      -- Rebuild grid cache
      PakettiAutomationStack_grid_cache = PakettiAutomationStack_BuildGridCache(W, H, num_lines, lpb)
      PakettiAutomationStack_grid_cache_valid = true
      PakettiAutomationStack_cached_grid_num_lines = num_lines
      PakettiAutomationStack_cached_grid_lpb = lpb
    end
    
    -- Draw cached grid
    if PakettiAutomationStack_grid_cache then
      PakettiAutomationStack_grid_cache(ctx)
    end

    if #PakettiAutomationStack_automations == 0 then return end
    local sel = PakettiAutomationStack_single_selected_index
    if sel < 1 then sel = 1 end
    if sel > #PakettiAutomationStack_automations then sel = #PakettiAutomationStack_automations end

    -- Check if we need to rebuild the background cache
    if not PakettiAutomationStack_background_cache_valid or 
       PakettiAutomationStack_cached_selected_index ~= sel or
       PakettiAutomationStack_cached_num_lines ~= num_lines then
      -- Rebuild cache
      PakettiAutomationStack_background_cache = PakettiAutomationStack_BuildBackgroundCache(W, H, num_lines, sel)
      PakettiAutomationStack_background_cache_valid = true
      PakettiAutomationStack_cached_selected_index = sel
      PakettiAutomationStack_cached_num_lines = num_lines
    end
    
    -- Draw cached background (all non-selected automations as static composite)
    if PakettiAutomationStack_background_cache then
      PakettiAutomationStack_background_cache(ctx)
    end
    
    -- Draw selected on top (using track colors with full opacity)
    local sel_entry = PakettiAutomationStack_automations[sel]
    if sel_entry then
      PakettiAutomationStack_DrawAutomation(sel_entry, ctx, W, H, num_lines, nil, nil, 3, true)
    end
    -- Title for selected automation only
    if sel_entry then
      local label
      if PakettiAutomationStack_arbitrary_mode and sel_entry.track_index then
        label = string.format("Track%02d: %s: %s", 
          sel_entry.track_index, (sel_entry.device_name or "DEVICE"), (sel_entry.name or "PARAM"))
      else
        label = string.format("%s: %s", (sel_entry.device_name or "DEVICE"), (sel_entry.name or "PARAM"))
      end
      
      -- Get track color for title background
      local track_idx = sel_entry.track_index or renoise.song().selected_track_index
      local track_color = PakettiAutomationStack_TrackColorToCanvas(track_idx, 180, 0.4)
      local track_border = PakettiAutomationStack_TrackColorToCanvas(track_idx, 255, 0.9)
      
      -- Draw colored background with track color
      ctx.fill_color = track_color
      ctx:begin_path(); ctx:rect(2, 2, W - 4, 12); ctx:fill()
      
      -- Draw colored border
      ctx.stroke_color = track_border
      ctx.line_width = 1
      ctx:begin_path(); ctx:rect(2, 2, W - 4, 12); ctx:stroke()
      
      -- Add mute indicator if track is muted
      local is_muted = PakettiAutomationStack_IsTrackMuted(track_idx)
      local mute_suffix = is_muted and " (MUTED - CLICK TO UNMUTE)" or ""
      
      -- Draw text with high contrast color or dimmed if muted
      if is_muted then
        ctx.stroke_color = {200, 200, 200, 255} -- Slightly dimmed for muted tracks
      else
        ctx.stroke_color = {255, 255, 255, 255}
      end
      PakettiAutomationStack_DrawText(ctx, string.upper(label .. mute_suffix), 6, 4, 8)
    end
  end
end

-- Mouse handler for Single view (operates on selected automation)
function PakettiAutomationStack_SingleMouse(ev, lane_h)
  local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack(); if not song or not patt then return end
  if #PakettiAutomationStack_automations == 0 then return end
  local num_lines = patt.number_of_lines
  local x = ev.position.x
  local y = ev.position.y
  local line = PakettiAutomationStack_XToLine(x, num_lines)
  local value = PakettiAutomationStack_YToValue(y, lane_h)
  local mods = tostring(ev.modifiers or "")
  local is_alt = (string.find(mods:lower(), "alt", 1, true) ~= nil) or (string.find(mods:lower(), "option", 1, true) ~= nil)
  local idx = PakettiAutomationStack_single_selected_index
  if idx < 1 then idx = 1 end
  if idx > #PakettiAutomationStack_automations then idx = #PakettiAutomationStack_automations end
  if ev.type == "down" and ev.button == "left" then
    -- Check if click is on the label area (top 14 pixels)
    if y <= 14 then
      local entry = PakettiAutomationStack_automations[idx]
      if entry and entry.track_index then
        PakettiAutomationStack_ToggleTrackMute(entry.track_index)
        -- Also show the automation envelope for this parameter
        PakettiAutomationStack_ShowAutomationEnvelope(entry)
        PakettiAutomationStack_RequestUpdate()
        return
      end
    end
    PakettiAutomationStack_is_drawing = true
    PakettiAutomationStack_last_draw_line = line
    PakettiAutomationStack_last_draw_idx = idx
    PakettiAutomationStack_last_draw_value = value
    
    -- Show automation envelope in lower frame for visual feedback
    local entry = PakettiAutomationStack_automations[idx]
    if entry then
      PakettiAutomationStack_ShowAutomationEnvelope(entry)
    end
    
    PakettiAutomationStack_WritePoint(idx, line, value, is_alt)
    PakettiAutomationStack_RequestUpdate()
  elseif ev.type == "down" and ev.button == "right" then
    local entry = PakettiAutomationStack_automations[idx]
    if entry and entry.automation then
      local a = entry.automation
      if a.points and #a.points > 0 then
        for i = #a.points, 1, -1 do
          local pt = a.points[i]
          if pt and pt.time then
            local L = math.floor(pt.time)
            if L < 1 then L = 1 end
            a:remove_point_at(L)
          end
        end
        PakettiAutomationStack_RequestUpdate()
      end
    end
  elseif ev.type == "move" then
    if PakettiAutomationStack_is_drawing and PakettiAutomationStack_last_draw_idx == idx then
      if line ~= PakettiAutomationStack_last_draw_line or math.abs(value - PakettiAutomationStack_last_draw_value) >= 0.001 then
        local start_l = PakettiAutomationStack_last_draw_line
        local end_l = line
        if start_l and end_l then
          local step = (end_l >= start_l) and 1 or -1
          local count = math.abs(end_l - start_l)
          if count <= 1 then
            PakettiAutomationStack_WritePoint(idx, line, value, is_alt)
          else
            for L = start_l, end_l, step do
              local t = (count > 0) and (math.abs(L - start_l) / count) or 1.0
              local v = PakettiAutomationStack_last_draw_value + (value - PakettiAutomationStack_last_draw_value) * t
              PakettiAutomationStack_WritePoint(idx, L, v, is_alt)
            end
          end
        end
        PakettiAutomationStack_last_draw_line = line
        PakettiAutomationStack_last_draw_value = value
        PakettiAutomationStack_RequestUpdate()
      end
    end
  elseif ev.type == "up" and ev.button == "left" then
    PakettiAutomationStack_is_drawing = false
    PakettiAutomationStack_last_draw_idx = -1
    PakettiAutomationStack_RequestUpdate()
  end
end

-- Update popup items from current automations
function PakettiAutomationStack_UpdateEnvPopup()
  if not PakettiAutomationStack_env_popup_view then return end
  local items_with_content = {}
  local items_without_content = {}
  
  for i = 1, #PakettiAutomationStack_automations do
    local e = PakettiAutomationStack_automations[i]
    local label
    if PakettiAutomationStack_arbitrary_mode and e.track_index then
      label = string.format("Track%02d: %s: %s", e.track_index, (e.device_name or "Device"), (e.name or "Param"))
    else
      label = string.format("%s: %s", (e.device_name or "Device"), (e.name or "Param"))
    end
    
    -- Check if this automation has content (points)
    local has_content = false
    if e.automation and e.automation.points and #e.automation.points > 0 then
      has_content = true
    end
    
    if has_content then
      items_with_content[#items_with_content+1] = label
    else
      items_without_content[#items_without_content+1] = label
    end
  end
  
  -- Combine: content first, then empty ones
  local items = {}
  for i = 1, #items_with_content do
    items[#items+1] = items_with_content[i]
  end
  for i = 1, #items_without_content do
    items[#items+1] = items_without_content[i]
  end
  
  -- If no automations exist, show all available parameters for the current track
  if #items == 0 then
    local song = renoise.song()
    if song and not PakettiAutomationStack_arbitrary_mode then
      local current_track = song.tracks[song.selected_track_index]
      if current_track then
        for dev_idx = 1, #current_track.devices do
          local dev = current_track.devices[dev_idx]
          for param_idx = 1, #dev.parameters do
            local param = dev.parameters[param_idx]
            if param.is_automatable then
              local label = string.format("%s: %s", (dev.display_name or "Device"), (param.name or "Parameter"))
              items[#items+1] = label
            end
          end
        end
      end
    end
    -- If still no items, show "(none)"
    if #items == 0 then items = {"(none)"} end
  end
  
  PakettiAutomationStack_env_popup_view.items = items
  if PakettiAutomationStack_single_selected_index < 1 then PakettiAutomationStack_single_selected_index = 1 end
  if PakettiAutomationStack_single_selected_index > #items then PakettiAutomationStack_single_selected_index = #items end
  PakettiAutomationStack_env_popup_view.value = PakettiAutomationStack_single_selected_index
end

-- Copy / Paste
function PakettiAutomationStack_CopySelectedEnvelope()
  local idx = PakettiAutomationStack_single_selected_index
  if idx < 1 or idx > #PakettiAutomationStack_automations then renoise.app():show_status("Automation Stack: Nothing to copy") return end
  local entry = PakettiAutomationStack_automations[idx]
  if not entry or not entry.automation then renoise.app():show_status("Automation Stack: No automation to copy") return end
  local a = entry.automation
  local buf = { playmode = a.playmode, points = {} }
  local pts = a.points or {}
  for i = 1, #pts do
    local p = pts[i]
    buf.points[#buf.points+1] = { time = p.time, value = p.value }
  end
  PakettiAutomationStack_copy_buffer = buf
  renoise.app():show_status("Automation Stack: Copied " .. tostring(#buf.points) .. " points")
end

function PakettiAutomationStack_PasteIntoSelectedEnvelope()
  renoise.song():describe_undo("Paketti: Paste Into Automation Stack Envelope")
  if not PakettiAutomationStack_copy_buffer or not PakettiAutomationStack_copy_buffer.points then
    renoise.app():show_status("Automation Stack: Copy buffer is empty")
    return
  end
  local idx = PakettiAutomationStack_single_selected_index
  if idx < 1 or idx > #PakettiAutomationStack_automations then renoise.app():show_status("Automation Stack: No destination envelope") return end
  local entry = PakettiAutomationStack_automations[idx]
  if not entry or not entry.automation then renoise.app():show_status("Automation Stack: No destination envelope") return end
  local a = entry.automation
  -- Clear existing points
  local pts = a.points or {}
  for i = #pts, 1, -1 do
    local pt = pts[i]
    if pt and pt.time then a:remove_point_at(math.floor(pt.time)) end
  end
  -- Paste
  a.playmode = PakettiAutomationStack_copy_buffer.playmode or a.playmode
  for i = 1, #PakettiAutomationStack_copy_buffer.points do
    local p = PakettiAutomationStack_copy_buffer.points[i]
    a:add_point_at(math.floor(p.time), p.value)
  end
  
  -- Invalidate background cache since automation was modified
  PakettiAutomationStack_InvalidateBackgroundCache()
  PakettiAutomationStack_RequestUpdate()
  renoise.app():show_status("Automation Stack: Pasted " .. tostring(#PakettiAutomationStack_copy_buffer.points) .. " points")
end

function PakettiAutomationStack_ValueToY(v, H)
  if v < 0 then v = 0 end
  if v > 1 then v = 1 end
  -- Account for the red rectangle area: rect(2, 2, W - 4, 12) goes from y=2 to y=14
  local header_start = 2
  local header_end = 14
  local drawing_height = H - header_end
  return header_end + (drawing_height - (v * drawing_height))
end

function PakettiAutomationStack_YToValue(y, H)
  -- Account for the red rectangle area: rect(2, 2, W - 4, 12) goes from y=2 to y=14
  local header_start = 2
  local header_end = 14
  local drawing_height = H - header_end
  local v = 1.0 - ((y - header_end) / drawing_height)
  if v < 0 then v = 0 end
  if v > 1 then v = 1 end
  return v
end

function PakettiAutomationStack_PlaymodeForIndex(idx)
  if idx == 1 then return PAKETTI_PLAYMODE_POINTS end
  if idx == 3 then return PAKETTI_PLAYMODE_CURVES end
  return PAKETTI_PLAYMODE_LINES
end

-- Create bridge points at pattern boundaries when drawing crosses them
-- This ensures curve continuity across patterns
function PakettiAutomationStack_WriteBridgePoints(automation_index, start_line, end_line, start_value, end_value, remove)
  renoise.song():describe_undo("Paketti: Write Automation Bridge Points")
  if not PakettiAutomationStack_stacker_mode or #PakettiAutomationStack_stacker_patterns <= 1 then
    return -- No bridging needed in single pattern mode
  end
  
  -- Find which patterns the start and end lines are in
  local _, _, _, start_patt_idx = PakettiAutomationStack_GlobalLineToPatternLine(start_line)
  local _, _, _, end_patt_idx = PakettiAutomationStack_GlobalLineToPatternLine(end_line)
  
  if not start_patt_idx or not end_patt_idx or start_patt_idx == end_patt_idx then
    return -- Both in same pattern, no bridging needed
  end
  
  -- Determine direction
  local direction = (end_line > start_line) and 1 or -1
  local min_patt = math.min(start_patt_idx, end_patt_idx)
  local max_patt = math.max(start_patt_idx, end_patt_idx)
  
  -- For each pattern boundary we cross, create bridge points
  for patt_idx = min_patt, max_patt - 1 do
    local boundary_entry = PakettiAutomationStack_stacker_patterns[patt_idx]
    local next_entry = PakettiAutomationStack_stacker_patterns[patt_idx + 1]
    if boundary_entry and next_entry then
      -- The boundary is at the end of this pattern / start of next pattern
      local boundary_global_line = boundary_entry.start_offset + boundary_entry.num_lines
      local next_start_global_line = next_entry.start_offset + 1
      
      -- Calculate interpolated value at the boundary
      local total_dist = math.abs(end_line - start_line)
      if total_dist > 0 then
        local dist_to_boundary = math.abs(boundary_global_line - start_line)
        local t = dist_to_boundary / total_dist
        local boundary_value = start_value + (end_value - start_value) * t
        
        -- Write point at end of current pattern (boundary_global_line maps to last line of pattern)
        PakettiAutomationStack_WritePoint(automation_index, boundary_global_line, boundary_value, remove)
        
        -- Write point at start of next pattern
        PakettiAutomationStack_WritePoint(automation_index, next_start_global_line, boundary_value, remove)
        
        print("BRIDGE: Created bridge points at boundary between patterns " .. patt_idx .. " and " .. (patt_idx + 1) .. " at value " .. boundary_value)
      end
    end
  end
end

-- Show automation envelope in lower frame for visual feedback
function PakettiAutomationStack_ShowAutomationEnvelope(entry)
  if not entry or not entry.parameter then return end
  
  local success, error_msg = pcall(function()
    local song = renoise.song()
    
    -- Show automation frame and make it active
    renoise.app().window.lower_frame_is_visible = true
    renoise.app().window.active_lower_frame = renoise.ApplicationWindow.LOWER_FRAME_TRACK_AUTOMATION
    
    -- Make sure we're looking at the right track
    if entry.track_index then
      song.selected_track_index = entry.track_index
    end
    
    -- Select this parameter's automation envelope
    song.selected_automation_parameter = entry.parameter
    
    -- Force a refresh of the automation data to ensure consistency
    PakettiAutomationStack_RequestUpdate()
  end)
  
  if not success then
    print("AUTOMATION_ERROR: Failed to select parameter '" .. (entry.parameter.name or "Unknown") .. "': " .. tostring(error_msg))
  end
end

-- Write or remove point for a lane
function PakettiAutomationStack_WritePoint(automation_index, line, value, remove)
  renoise.song():describe_undo("Paketti: Write Automation Stack Point")
  local song, patt, ptrack = PakettiAutomationStack_GetSongPatternTrack(); if not song or not patt or not ptrack then return end
  local entry = PakettiAutomationStack_automations[automation_index]; if not entry then return end
  
  local target_ptrack = ptrack
  local num_lines = patt.number_of_lines
  local original_line = line
  local local_line = line
  
  -- In stacker mode, convert global line to pattern-local coordinates
  if PakettiAutomationStack_stacker_mode and #PakettiAutomationStack_stacker_patterns > 0 then
    local seq_idx, pattern_idx, loc_line, patt_entry_idx = PakettiAutomationStack_GlobalLineToPatternLine(line)
    if seq_idx and pattern_idx and patt_entry_idx then
      local stacker_entry = PakettiAutomationStack_stacker_patterns[patt_entry_idx]
      if stacker_entry then
        num_lines = stacker_entry.num_lines
        local_line = loc_line
        -- Get the pattern track for this specific pattern
        local target_pattern = song:pattern(pattern_idx)
        if target_pattern then
          target_ptrack = target_pattern:track(entry.track_index or song.selected_track_index)
        end
        print("STACKER WRITE: global_line=" .. line .. " -> pattern " .. pattern_idx .. " local_line=" .. local_line)
      end
    end
  end
  
  -- Clamp line to valid pattern range for automation writing
  -- Allow writing to the precise end of the pattern (64.99609375 for 64-line pattern)
  if local_line > num_lines then
    local_line = num_lines + (num_lines - 1) / num_lines  -- This gives 64.99609375 for 64-line pattern
  end
  local_line = math.max(1, local_line)
  
  -- DEBUG: Show what we're trying to write
  print("WRITE DEBUG: original_line=" .. original_line .. ", local_line=" .. local_line .. ", num_lines=" .. num_lines .. ", value=" .. value .. ", remove=" .. tostring(remove))
  
  -- In stacker mode, we need to find automation on the target pattern, not the entry's cached automation
  local a = nil
  local param = entry.parameter
  
  if PakettiAutomationStack_stacker_mode and target_ptrack then
    -- Find or create automation on the target pattern track
    a = target_ptrack:find_automation(param)
  else
    a = entry.automation
  end
  
  -- If no automation exists yet, create it by adding the first point
  if not a and not remove then
    print("DEBUG: No automation exists, creating new one...")
    -- Use the target pattern track
    local ptrack_to_use = target_ptrack or entry.pattern_track or ptrack
    print("DEBUG: param=" .. (param and param.name or "nil") .. ", is_automatable=" .. (param and tostring(param.is_automatable) or "nil"))
    if param and param.is_automatable then
      -- Create automation by adding first point - this automatically creates the envelope
      local desired = PakettiAutomationStack_PlaymodeForIndex(PakettiAutomationStack_draw_playmode_index)
      
      -- Create automation envelope if it doesn't exist
      if not ptrack_to_use:find_automation(param) then
        print("DEBUG: Creating new automation envelope...")
        -- Create the automation envelope for this parameter
        a = ptrack_to_use:create_automation(param)
        if a then
          print("DEBUG: Automation envelope created successfully")
          if not PakettiAutomationStack_stacker_mode then
            entry.automation = a -- Store it back in the entry for next time (only in single pattern mode)
          end
          a.playmode = desired -- Only set playmode for newly created automation
        else
          print("DEBUG: Failed to create automation envelope")
        end
      else
        print("DEBUG: Found existing automation envelope")
        -- Get existing automation - DON'T change its playmode
        a = ptrack_to_use:find_automation(param)
        if a and not PakettiAutomationStack_stacker_mode then
          entry.automation = a -- Store it back in the entry for next time
          -- Keep existing playmode - don't modify it
        end
      end
    end
    
    if not a then return end -- Still couldn't create automation
  elseif not a then
    return -- Can't remove from non-existent automation
  end
  
  -- Don't change playmode of existing automation - preserve original mode
  -- Only new automation envelopes get the playmode set during creation above
  
  if remove then
    if a:has_point_at(local_line) then a:remove_point_at(local_line) end
  else
    -- Normalize already 0..1
    if a:has_point_at(local_line) then a:remove_point_at(local_line) end
    a:add_point_at(local_line, value)
    print("ADDED point at local_line " .. local_line .. " with value " .. value)
  end
  
  -- Invalidate background cache since automation was modified
  PakettiAutomationStack_InvalidateBackgroundCache()
end

-- Mouse handler per lane
function PakettiAutomationStack_LaneMouse(automation_index, ev, lane_h)
  local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack(); if not song or not patt then return end
  -- Use stacker total lines if in stacker mode
  local num_lines = PakettiAutomationStack_GetTotalLines()
  local x = ev.position.x
  local y = ev.position.y
  local line = PakettiAutomationStack_XToLine(x, num_lines)
  local value = PakettiAutomationStack_YToValue(y, lane_h)
  local mods = tostring(ev.modifiers or "")
  local is_alt = (string.find(mods:lower(), "alt", 1, true) ~= nil) or (string.find(mods:lower(), "option", 1, true) ~= nil)

  if ev.type == "down" and ev.button == "left" then
    -- Check if click is on the label area (top 14 pixels)
    if y <= 14 then
      local entry = PakettiAutomationStack_automations[automation_index]
      if entry and entry.track_index then
        PakettiAutomationStack_ToggleTrackMute(entry.track_index)
        -- Also show the automation envelope for this parameter
        PakettiAutomationStack_ShowAutomationEnvelope(entry)
        PakettiAutomationStack_RequestUpdate()
        return
      end
    end
    local is_shift = (string.find(mods:lower(), "shift", 1, true) ~= nil)
    if is_shift then
      PakettiAutomationStack_selection_active = true
      PakettiAutomationStack_selection_start_line = line
      PakettiAutomationStack_selection_end_line = line
      PakettiAutomationStack_selection_lane_index = automation_index
      PakettiAutomationStack_last_draw_value = value
      PakettiAutomationStack_RequestUpdate()
      return
    end
    PakettiAutomationStack_is_drawing = true
    PakettiAutomationStack_last_draw_line = line
    PakettiAutomationStack_last_draw_idx = automation_index
    PakettiAutomationStack_last_draw_value = value
    
    -- Show automation envelope in lower frame for visual feedback
    local entry = PakettiAutomationStack_automations[automation_index]
    if entry then
      PakettiAutomationStack_ShowAutomationEnvelope(entry)
    end
    
    PakettiAutomationStack_WritePoint(automation_index, line, value, is_alt)
    PakettiAutomationStack_RequestUpdate()
  elseif ev.type == "down" and ev.button == "right" then
    -- Right-click: clear all points in this automation lane
    local entry = PakettiAutomationStack_automations[automation_index]
    if entry and entry.automation then
      local a = entry.automation
      if a.points and #a.points > 0 then
        -- Remove from end to start to avoid index shifts
        for i = #a.points, 1, -1 do
          local pt = a.points[i]
          if pt and pt.time then
            local L = math.floor(pt.time)
            if L < 1 then L = 1 end
            a:remove_point_at(L)
          end
        end
        PakettiAutomationStack_RequestUpdate()
      end
    end
  elseif ev.type == "move" then
    local is_shift = (string.find(mods:lower(), "shift", 1, true) ~= nil)
    if PakettiAutomationStack_selection_active and PakettiAutomationStack_selection_lane_index == automation_index and is_shift then
      PakettiAutomationStack_selection_end_line = line
      PakettiAutomationStack_RequestUpdate()
      return
    end
    if PakettiAutomationStack_is_drawing and PakettiAutomationStack_last_draw_idx == automation_index then
      if line ~= PakettiAutomationStack_last_draw_line or math.abs(value - PakettiAutomationStack_last_draw_value) >= 0.001 then
        -- Continuous draw: write point on the current line and interpolate if we skipped lines
        local start_l = PakettiAutomationStack_last_draw_line
        local end_l = line
        if start_l and end_l then
          local step = (end_l >= start_l) and 1 or -1
          local count = math.abs(end_l - start_l)
          
          -- In stacker mode, create bridge points at pattern boundaries for curve continuity
          if PakettiAutomationStack_stacker_mode and count > 1 then
            PakettiAutomationStack_WriteBridgePoints(automation_index, start_l, end_l, 
              PakettiAutomationStack_last_draw_value, value, is_alt)
          end
          
          if count <= 1 then
            PakettiAutomationStack_WritePoint(automation_index, line, value, is_alt)
          else
            -- interpolate values across lines
            for L = start_l, end_l, step do
              local t = (count > 0) and (math.abs(L - start_l) / count) or 1.0
              local v = PakettiAutomationStack_last_draw_value + (value - PakettiAutomationStack_last_draw_value) * t
              PakettiAutomationStack_WritePoint(automation_index, L, v, is_alt)
            end
          end
        end
        PakettiAutomationStack_last_draw_line = line
        PakettiAutomationStack_last_draw_value = value
        PakettiAutomationStack_RequestUpdate()
      end
    end
  elseif ev.type == "up" and ev.button == "left" then
    PakettiAutomationStack_is_drawing = false
    PakettiAutomationStack_last_draw_idx = -1
    PakettiAutomationStack_RequestUpdate()
  end
end

-- Render a single automation lane
function PakettiAutomationStack_RenderLaneCanvas(automation_index, canvas_w, canvas_h)
  return function(ctx)
    local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack()
    local W = canvas_w or PakettiAutomationStack_canvas_width
    local H = canvas_h or PakettiAutomationStack_lane_height
    ctx:clear_rect(0, 0, W, H)
    if not song or not patt then return end
    -- Use stacker total lines if in stacker mode
    local num_lines = PakettiAutomationStack_GetTotalLines()
    local lpb = song.transport.lpb

    PakettiAutomationStack_DrawGrid(ctx, W, H, num_lines, lpb)

    local entry = PakettiAutomationStack_automations[automation_index]
    if not entry then return end
    
    -- Handle case where automation doesn't exist yet (empty lane ready for drawing)

    -- Label block with track, device and parameter formatted as "TRACKXX: DEVICE: PARAMETER"
    local label
    if PakettiAutomationStack_arbitrary_mode and entry.track_index then
      label = string.format("Track%02d: %s: %s", 
        entry.track_index, (entry.device_name or "DEVICE"), (entry.name or "PARAM"))
    elseif PakettiAutomationStack_stacker_mode then
      -- Show stacker info in label
      local stacker_info = ""
      if PakettiAutomationStack_stacker_seq_start and PakettiAutomationStack_stacker_seq_end then
        stacker_info = string.format(" [Seq %d-%d]", PakettiAutomationStack_stacker_seq_start, PakettiAutomationStack_stacker_seq_end)
      end
      label = string.format("%s: %s%s", (entry.device_name or "DEVICE"), (entry.name or "PARAM"), stacker_info)
    else
      label = string.format("%s: %s", (entry.device_name or "DEVICE"), (entry.name or "PARAM"))
    end
    
    -- Get track color for label background
    local track_idx = entry.track_index or song.selected_track_index
    local track_color = PakettiAutomationStack_TrackColorToCanvas(track_idx, 150, 0.3)
    local track_border = PakettiAutomationStack_TrackColorToCanvas(track_idx, 255, 0.8)
    
    -- Draw colored background with track color
    ctx.fill_color = track_color
    ctx:begin_path(); ctx:rect(2, 2, W - 4, 12); ctx:fill()
    
    -- Draw colored border
    ctx.stroke_color = track_border
    ctx.line_width = 1
    ctx:begin_path(); ctx:rect(2, 2, W - 4, 12); ctx:stroke()
    
    -- Add mute indicator if track is muted
    local is_muted = PakettiAutomationStack_IsTrackMuted(track_idx)
    local mute_suffix = is_muted and " (MUTED - CLICK TO UNMUTE)" or ""
    
    -- Draw text with high contrast color or dimmed if muted
    if is_muted then
      ctx.stroke_color = {150, 150, 150, 255} -- Dimmed text for muted tracks
    else
      ctx.stroke_color = {255, 255, 255, 255}
    end
    PakettiAutomationStack_DrawText(ctx, string.upper(label .. mute_suffix), 6, 4, 8)

    local gutter = PakettiAutomationStack_gutter_width

    -- Draw zero-line reference
    ctx.stroke_color = {80,80,100,200}
    ctx.line_width = 1
    local start_x = (gutter > 0) and gutter or 0
    local end_x = (gutter > 0) and (W - gutter) or W
    ctx:begin_path(); ctx:move_to(start_x, PakettiAutomationStack_ValueToY(0.5, H)); ctx:line_to(end_x, PakettiAutomationStack_ValueToY(0.5, H)); ctx:stroke()

    -- Collect points - in stacker mode, collect from all patterns
    local points = {}
    local mode = PAKETTI_PLAYMODE_LINES
    
    if PakettiAutomationStack_stacker_mode and #PakettiAutomationStack_stacker_patterns > 0 then
      -- Collect points from all stacker patterns
      points = PakettiAutomationStack_CollectStackerPoints(entry)
      -- Use the playmode from the first pattern that has automation
      if #points > 0 then
        mode = points[1].playmode or PAKETTI_PLAYMODE_LINES
      end
    else
      -- Single pattern mode - use existing automation
      local a = entry.automation
      if a and a.points then
        for _, p in ipairs(a.points) do
          points[#points + 1] = {time = p.time, value = p.value}
        end
        mode = a.playmode or PAKETTI_PLAYMODE_LINES
      end
    end

    if #points == 0 then
      -- Empty lane - show as ready for drawing with a subtle indicator
      local dim_color = PakettiAutomationStack_TrackColorToCanvas(track_idx, 60, 0.5)
      ctx.stroke_color = dim_color
      ctx.line_width = 1
      -- Draw dotted line to indicate this is a drawable empty lane
      local step = 20
      for x = start_x, end_x, step do
        ctx:begin_path()
        ctx:move_to(x, PakettiAutomationStack_ValueToY(0.5, H))
        ctx:line_to(math.min(x + 10, end_x), PakettiAutomationStack_ValueToY(0.5, H))
        ctx:stroke()
      end
      return
    end

    -- Get track-based colors
    local base_color, bright_color, dim_color = PakettiAutomationStack_GetTrackAutomationColors(track_idx)

    if mode == PAKETTI_PLAYMODE_POINTS then
      -- Vertical bars with dots at values
      ctx.stroke_color = base_color
      ctx.line_width = 2
      for i = 1, #points do
        local p = points[i]
        local x = PakettiAutomationStack_MapTimeToX((p.time or 1) - 1, num_lines)
        local y = PakettiAutomationStack_ValueToY(p.value, H)
        if x < gutter then x = gutter end
        if x > W - gutter then x = W - gutter end
        ctx:begin_path(); ctx:move_to(x, H-1); ctx:line_to(x, y); ctx:stroke()
        -- square marker to properly cover grid lines
        ctx.fill_color = bright_color
        ctx:fill_rect(x-2, y-2, 4, 4)
        ctx.stroke_color = base_color; ctx.line_width = 2
      end
    elseif mode == PAKETTI_PLAYMODE_LINES then
      -- Linear segments between points
      ctx.stroke_color = base_color
      ctx.line_width = 3
      ctx:begin_path()
      local p1 = points[1]
      local x1 = PakettiAutomationStack_MapTimeToX((p1.time or 1) - 1, num_lines)
      local y1 = PakettiAutomationStack_ValueToY(p1.value, H)
      if x1 < gutter then x1 = gutter end
      if x1 > W - gutter then x1 = W - gutter end
      ctx:move_to(x1, y1)
      for i = 2, #points do
        local p = points[i]
        local x = PakettiAutomationStack_MapTimeToX((p.time or 1) - 1, num_lines)
        local y = PakettiAutomationStack_ValueToY(p.value, H)
        if x < gutter then x = gutter end
        if x > W - gutter then x = W - gutter end
        ctx:line_to(x, y)
      end
      -- Draw line from last point to end of pattern (finishing line)
      if #points > 0 then
        local last_point = points[#points]
        local last_y = PakettiAutomationStack_ValueToY(last_point.value, H)
        -- Extend to the actual end of the canvas (right edge) - no gutter constraints
        local end_x_line = W
        ctx:line_to(end_x_line, last_y)
      end
      ctx:stroke()
      -- square point markers to properly cover grid lines
      ctx.fill_color = bright_color
      for i = 1, #points do
        local p = points[i]
        local x = PakettiAutomationStack_MapTimeToX((p.time or 1) - 1, num_lines)
        local y = PakettiAutomationStack_ValueToY(p.value, H)
        if x < gutter then x = gutter end
        if x > W - gutter then x = W - gutter end
        ctx:fill_rect(x-2, y-2, 4, 4)
      end
    else
      -- Curves: smooth by Catmull-Rom / Hermite sampling between points
      ctx.stroke_color = base_color
      ctx.line_width = 3
      for seg = 1, (#points - 1) do
        local p0 = points[math.max(1, seg-1)]
        local p1c = points[seg]
        local p2 = points[seg+1]
        local p3 = points[math.min(#points, seg+2)]
        local x1 = PakettiAutomationStack_MapTimeToX((p1c.time or 1) - 1, num_lines)
        local y1 = PakettiAutomationStack_ValueToY(p1c.value, H)
        local x2 = PakettiAutomationStack_MapTimeToX((p2.time or 1) - 1, num_lines)
        local y2 = PakettiAutomationStack_ValueToY(p2.value, H)
        if x2 <= x1 then x2 = x1 + 1 end
        local steps = math.max(8, math.floor((x2 - x1) / 6))
        local function hermite(t, y_0, y_1, y_2, y_3)
          local m1 = 0.5 * (y_2 - y_0)
          local m2 = 0.5 * (y_3 - y_1)
          local t2 = t * t
          local t3 = t2 * t
          local h00 = 2*t3 - 3*t2 + 1
          local h10 = t3 - 2*t2 + t
          local h01 = -2*t3 + 3*t2
          local h11 = t3 - t2
          return h00*y_1 + h10*m1 + h01*y_2 + h11*m2
        end
        ctx:begin_path()
        for s = 0, steps do
          local t = s / steps
          local x = x1 + (x2 - x1) * t
          local y = hermite(t, PakettiAutomationStack_ValueToY(p0.value, H), y1, y2, PakettiAutomationStack_ValueToY(p3.value, H))
          if s == 0 then ctx:move_to(x, y) else ctx:line_to(x, y) end
        end
        ctx:stroke()
      end
    end
  end
end

-- Header canvas renderer (timeline + playhead) and click-to-jump
function PakettiAutomationStack_RenderHeaderCanvas(canvas_w, canvas_h)
  local function on_mouse(ev)
    if not ev or ev.type ~= "down" then return end
    local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack(); if not song or not patt then return end
    local x = ev.position.x
    local num_lines = PakettiAutomationStack_GetTotalLines()
    local target_line = PakettiAutomationStack_XToLine(x, num_lines)
    if target_line < 1 then target_line = 1 end
    if target_line > num_lines then target_line = num_lines end
    
    -- In stacker mode, need to jump to correct pattern and local line
    if PakettiAutomationStack_stacker_mode and #PakettiAutomationStack_stacker_patterns > 0 then
      local seq_idx, patt_idx, local_line, _ = PakettiAutomationStack_GlobalLineToPatternLine(target_line)
      if seq_idx and local_line then
        song.selected_sequence_index = seq_idx
        song.selected_line_index = local_line
        song.transport:start_at(renoise.SongPos(seq_idx, local_line))
      end
    else
      song.selected_line_index = target_line
      song.transport:start_at(renoise.SongPos(renoise.song().selected_sequence_index, target_line))
    end
  end
  return function(ctx)
    local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack()
    local W = canvas_w or PakettiAutomationStack_canvas_width
    local H = canvas_h or (PakettiAutomationStack_gutter_height + 4)
    ctx:clear_rect(0, 0, W, H)
    if not song or not patt then return end
    local num_lines = PakettiAutomationStack_GetTotalLines()
    local win = PakettiAutomationStack_GetWindowLines(num_lines)
    local view_start = PakettiAutomationStack_view_start_line
    local view_end = math.min(num_lines, view_start + win - 1)
    local lpb = song.transport.lpb
    local gutter = PakettiAutomationStack_gutter_width
    -- background and gutters
    ctx:set_fill_linear_gradient(0, 0, 0, H)
    ctx:add_fill_color_stop(0, {22,22,30,255})
    ctx:add_fill_color_stop(1, {12,12,20,255})
    ctx:begin_path(); ctx:rect(0,0,W,H); ctx:fill()
    -- gutters (only if gutter_width > 0)
    if gutter > 0 then
      ctx.fill_color = {18,18,24,255}; ctx:fill_rect(0, 0, gutter, H)
      ctx.fill_color = {14,14,20,255}; ctx:fill_rect(W - gutter, 0, gutter, H)
    end
    -- Grid ticks and row labels along the header timeline
    local row_label_size = 7
    local eff_w = math.max(1, W - (2*PakettiAutomationStack_gutter_width))
    local pixels_per_line = eff_w / win
    -- Use smaller step size when zoomed in enough to show individual lines
    local step = (pixels_per_line >= 12) and 1 or ((lpb >= 2) and lpb or 1)
    
    for line = view_start, view_end, step do
      local x = PakettiAutomationStack_LineToX(line, num_lines)
      -- tick
      ctx.stroke_color = {90,90,120,255}
      ctx:begin_path(); ctx:move_to(x, 0); ctx:line_to(x, H); ctx:stroke()
      
      -- Smart row labeling: every 4th line when > 32 lines, otherwise every line
      local should_show_label = true
      if num_lines > 32 then
        -- Only show labels on "Grey Lines" (every 4th line: 1, 5, 9, 13, etc.)
        should_show_label = ((line - 1) % 4 == 0)
      end
      
      if should_show_label then
        -- label above the tick - show full range without artificial 100-limit
        local label = string.format("%03d", (line - 1))  -- Convert 1-based internal to 0-based visual display
        -- Set bright white color for better visibility
        ctx.stroke_color = {255,255,255,255}
        PakettiAutomationStack_DrawText(ctx, label, x + 2, 2, row_label_size)
        -- Restore original color for tick marks
        ctx.stroke_color = {90,90,120,255}
      end
    end
    -- Draw pattern boundaries and labels in stacker mode
    if PakettiAutomationStack_stacker_mode and #PakettiAutomationStack_stacker_patterns > 1 then
      ctx.stroke_color = {255, 140, 0, 255}
      ctx.line_width = 2
      for i, entry in ipairs(PakettiAutomationStack_stacker_patterns) do
        -- Draw boundary line at start of each pattern (except first)
        if i > 1 then
          local boundary_line = entry.start_offset + 1
          local x = PakettiAutomationStack_LineToX(boundary_line, num_lines)
          ctx:begin_path()
          ctx:move_to(x, 0)
          ctx:line_to(x, H)
          ctx:stroke()
        end
        -- Draw pattern sequence number label
        local label_line = entry.start_offset + 1
        local label_x = PakettiAutomationStack_LineToX(label_line, num_lines)
        ctx.stroke_color = {255, 180, 80, 255}
        local seq_label = string.format("S%02d", entry.seq_index)
        PakettiAutomationStack_DrawText(ctx, seq_label, label_x + 4, H - 10, 7)
        ctx.stroke_color = {255, 140, 0, 255}
      end
    end
    
    -- playhead
    local x_play = nil
    local play_line = nil
    if song.transport.playing then
      local pos = song.transport.playback_pos
      -- In stacker mode, convert playhead to global line
      if PakettiAutomationStack_stacker_mode and #PakettiAutomationStack_stacker_patterns > 0 then
        -- Check if playback is in one of our stacker patterns
        for i, entry in ipairs(PakettiAutomationStack_stacker_patterns) do
          if pos and pos.sequence and pos.line and pos.sequence == entry.seq_index then
            play_line = entry.start_offset + pos.line
            break
          end
        end
      elseif pos and pos.sequence and pos.line and pos.sequence == renoise.song().selected_sequence_index then
        play_line = pos.line
      end
    else
      -- Not playing - show selected line position
      if PakettiAutomationStack_stacker_mode and #PakettiAutomationStack_stacker_patterns > 0 then
        -- Find current sequence in stacker and convert to global line
        local current_seq = song.selected_sequence_index
        for i, entry in ipairs(PakettiAutomationStack_stacker_patterns) do
          if entry.seq_index == current_seq then
            play_line = entry.start_offset + song.selected_line_index
            break
          end
        end
      else
        play_line = song.selected_line_index
      end
    end
    if play_line then x_play = PakettiAutomationStack_LineToX(play_line, num_lines) end
    if x_play then
      ctx.stroke_color = {255,200,120,255}; ctx.line_width = 3
      -- FAT PINK LINE at the absolute leftmost drawable position
      local start_x = (gutter > 0) and gutter or 0
      ctx:begin_path(); ctx:move_to(start_x, 0); ctx:line_to(start_x, H); ctx:stroke()
      -- Also draw the timeline position indicator
      ctx.line_width = 2
      ctx:begin_path(); ctx:move_to(x_play, 0); ctx:line_to(x_play, H); ctx:stroke()
    end
  end, on_mouse
end

-- Build canvases for current page of automations
function PakettiAutomationStack_RebuildCanvases()
  if not PakettiAutomationStack_container then return end
  -- Remove existing children
  if PakettiAutomationStack_container.views then
    while #PakettiAutomationStack_container.views > 0 do
      PakettiAutomationStack_container:remove_child(PakettiAutomationStack_container.views[1])
    end
  end
  PakettiAutomationStack_track_canvases = {}

  local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack(); if not song or not patt then return end
  local total = #PakettiAutomationStack_automations

  if PakettiAutomationStack_view_mode == 2 then
    -- Single view: one tall canvas + selection popup and buttons row
    local cw = PakettiAutomationStack_canvas_width
    local ch = PakettiAutomationStack_single_canvas_height
    local single_canvas = PakettiAutomationStack_vb:canvas{
      width = cw,
      height = ch,
      mode = "plain",
      render = PakettiAutomationStack_RenderSingleCanvas(cw, ch),
      mouse_events = {"down","up","move"},
      mouse_handler = function(ev) PakettiAutomationStack_SingleMouse(ev, ch) end
    }
    PakettiAutomationStack_container:add_child(single_canvas)
    PakettiAutomationStack_track_canvases[#PakettiAutomationStack_track_canvases+1] = single_canvas

    -- Always create a new popup view to avoid ViewBuilder reuse errors
    -- Use a unique ID to prevent duplicate ID errors
    local popup_id = "pas_env_popup_" .. tostring(os.clock() * 1000000) -- Unique ID based on timestamp
    local popup_view = PakettiAutomationStack_vb:popup{ 
      id = popup_id, 
      items = {"(none)"}, 
      width = 400, 
      value = 1, -- Always start with value 1 to avoid index errors
      notifier = function(val)
        PakettiAutomationStack_single_selected_index = val
        -- Show automation envelope for the selected parameter
        local entry = PakettiAutomationStack_automations[val]
        if entry then
          PakettiAutomationStack_ShowAutomationEnvelope(entry)
        end
        PakettiAutomationStack_RequestUpdate()
      end 
    }
    
    local select_row = PakettiAutomationStack_vb:row{
      PakettiAutomationStack_vb:text{ text = "Envelope:" },
      popup_view,
      PakettiAutomationStack_vb:button{ text = "Copy", notifier = function() PakettiAutomationStack_CopySelectedEnvelope() end },
      PakettiAutomationStack_vb:button{ text = "Paste", notifier = function() PakettiAutomationStack_PasteIntoSelectedEnvelope() end }
    }
    PakettiAutomationStack_container:add_child(select_row)
    PakettiAutomationStack_env_popup_view = PakettiAutomationStack_vb.views[popup_id]
    PakettiAutomationStack_UpdateEnvPopup()
  else
    -- Stack view: paged lanes
    local start_idx = ((PakettiAutomationStack_vertical_page_index - 1) * PakettiAutomationStack_vertical_page_size) + 1
    if start_idx < 1 then start_idx = 1 end
    if start_idx > total then start_idx = math.max(1, total - PakettiAutomationStack_vertical_page_size + 1) end
    local end_idx = math.min(total, start_idx + PakettiAutomationStack_vertical_page_size - 1)

    for i = start_idx, end_idx do
      local cw = PakettiAutomationStack_canvas_width
      local ch = PakettiAutomationStack_lane_height
      local idx_for_canvas = i
      local c = PakettiAutomationStack_vb:canvas{
        width = cw,
        height = ch,
        mode = "plain",
        render = PakettiAutomationStack_RenderLaneCanvas(idx_for_canvas, cw, ch),
        mouse_events = {"down","up","move"},
        mouse_handler = function(ev) PakettiAutomationStack_LaneMouse(idx_for_canvas, ev, ch) end
      }
      PakettiAutomationStack_container:add_child(c)
      PakettiAutomationStack_track_canvases[#PakettiAutomationStack_track_canvases+1] = c
    end
  end

  -- Update vertical scrollbar bounds
  if PakettiAutomationStack_vscrollbar_view then
    local pages = math.max(1, math.ceil(total / PakettiAutomationStack_vertical_page_size))
    PakettiAutomationStack_vscrollbar_view.min = 1
    PakettiAutomationStack_vscrollbar_view.max = math.max(2, pages)
    if PakettiAutomationStack_vertical_page_index > pages then PakettiAutomationStack_vertical_page_index = pages end
    PakettiAutomationStack_vscrollbar_view.value = PakettiAutomationStack_vertical_page_index
  end
  if PakettiAutomationStack_count_text_view then
    PakettiAutomationStack_count_text_view.text = "(" .. tostring(total) .. ")"
  end
end

-- Create Arbitrary Parameters Selection Dialog
function PakettiAutomationStack_ShowParameterSelectionDialog()
  if PakettiAutomationStack_arbitrary_dialog and PakettiAutomationStack_arbitrary_dialog.visible then
    PakettiAutomationStack_arbitrary_dialog:close()
    return
  end
  
  PakettiAutomationStack_arbitrary_vb = renoise.ViewBuilder()
  PakettiAutomationStack_parameter_checkboxes = {}
  
  local all_params = PakettiAutomationStack_GetAllParameters()
  if #all_params == 0 then
    renoise.app():show_status("Automation Stack: No automatable parameters found")
    return
  end
  
  local rows = {}
  local current_track = -1
  local track_column = nil
  
  -- Add header row
  local header_row = PakettiAutomationStack_arbitrary_vb:row{
    PakettiAutomationStack_arbitrary_vb:text{ text = "Check parameters you want to display, then click APPLY:", font = "bold", style = "strong" },
  }
  
  local quick_buttons_row = PakettiAutomationStack_arbitrary_vb:row{
    PakettiAutomationStack_arbitrary_vb:button{ text = "Select All", width = 80, notifier = function()
      -- Select all
      for key, checkbox in pairs(PakettiAutomationStack_parameter_checkboxes) do
        checkbox.value = true
      end
      PakettiAutomationStack_UpdateParameterSelection()
    end },
    PakettiAutomationStack_arbitrary_vb:button{ text = "Select None", width = 80, notifier = function()
      -- Deselect all
      for key, checkbox in pairs(PakettiAutomationStack_parameter_checkboxes) do
        checkbox.value = false
      end
      PakettiAutomationStack_UpdateParameterSelection()
    end },
    
    PakettiAutomationStack_arbitrary_vb:button{ 
      text = "Show Selected Parameters", 
      --width = 280, 
      --height = 24,
      notifier = function()
        PakettiAutomationStack_UpdateParameterSelection()
        
        -- Check if any parameters are selected
        if #PakettiAutomationStack_selected_parameters == 0 then
          renoise.app():show_status("Automation Stack: Please select at least one parameter before applying")
          return
        end
        
        PakettiAutomationStack_SaveSelectedParameters()
        PakettiAutomationStack_arbitrary_mode = true
        PakettiAutomationStack_show_same_mode = false -- Clear show same mode
        
        -- Close the parameter selection dialog first
        PakettiAutomationStack_arbitrary_dialog:close()
        
        -- Ensure main automation stack dialog is open and updated
        if not PakettiAutomationStack_dialog or not PakettiAutomationStack_dialog.visible then
          -- Main dialog not visible, reopen it
          PakettiAutomationStack_ReopenDialog()
        else
          -- Main dialog is open, just update it
          PakettiAutomationStack_RebuildAutomations()
          PakettiAutomationStack_RebuildCanvases()
          PakettiAutomationStack_RequestUpdate()
        end
        
        renoise.app():show_status("Automation Stack: Showing " .. tostring(#PakettiAutomationStack_selected_parameters) .. " selected parameters from multiple tracks")
      end 
    }
  }
  rows[#rows+1] = header_row
  rows[#rows+1] = quick_buttons_row
  
  -- Group parameters by track and device
  local current_device_key = ""
  local device_params = {}
  local device_label_added = false
  
  -- Helper function to flush device parameters with their label
  local function flush_device_params()
    if #device_params > 0 then
      -- For mixer parameters, show them in a single line with checkboxes
      if device_params[1] and device_params[1].device_name == "Mixer" then
        -- Create a single row with track name, "Mixer:" text, and checkboxes
        local mixer_row_views = {
          PakettiAutomationStack_arbitrary_vb:text{ 
            text = device_params[1].track_name .. ": ", 
            font = "bold", 
            style = "strong"
          },
          PakettiAutomationStack_arbitrary_vb:text{ 
            text = "Mixer ", 
            font = "bold"
          }
        }
        
        for i = 1, #device_params do
          local dp = device_params[i]
          mixer_row_views[#mixer_row_views+1] = dp.checkbox
          mixer_row_views[#mixer_row_views+1] = PakettiAutomationStack_arbitrary_vb:text{ 
            text = dp.param_name
          }
          if i < #device_params then
            mixer_row_views[#mixer_row_views+1] = PakettiAutomationStack_arbitrary_vb:space{ width = 3 }
          end
        end
        
        local mixer_row = PakettiAutomationStack_arbitrary_vb:row{ views = mixer_row_views }
        rows[#rows+1] = mixer_row
      elseif device_params[1] and device_params[1].device_name == "Mixer & Transport" then
        -- Special handling for Master track: put everything on one single row
        local mixer_row_views = {
          PakettiAutomationStack_arbitrary_vb:text{ 
            text = device_params[1].track_name .. ": ", 
            font = "bold", 
            style = "strong"
          },
          PakettiAutomationStack_arbitrary_vb:text{ 
            text = "Mixer ", 
            font = "bold"
          }
        }
        
        for i = 1, #device_params do
          local dp = device_params[i]
          mixer_row_views[#mixer_row_views+1] = dp.checkbox
          mixer_row_views[#mixer_row_views+1] = PakettiAutomationStack_arbitrary_vb:text{ 
            text = dp.param_name
          }
          if i < #device_params then
            mixer_row_views[#mixer_row_views+1] = PakettiAutomationStack_arbitrary_vb:space{ width = 3 }
          end
        end
        
        local mixer_row = PakettiAutomationStack_arbitrary_vb:row{ views = mixer_row_views }
        rows[#rows+1] = mixer_row
      else
        -- Add device label first for non-mixer devices
        if not device_label_added and device_params[1] then
          local device_label_row = PakettiAutomationStack_arbitrary_vb:row{
            
            PakettiAutomationStack_arbitrary_vb:text{ 
              text = device_params[1].device_name .. ":", 
              font = "bold",
              width = 120
            }
          }
          rows[#rows+1] = device_label_row
        end
        
        -- Split parameters into rows with consistent column widths
        local params_per_row = 5  -- Reduced from 10 for better alignment
        local column_width = 120  -- Fixed column width for consistent alignment
        
        for start_idx = 1, #device_params, params_per_row do
          local end_idx = math.min(start_idx + params_per_row - 1, #device_params)
          local device_row_views = {
            
          }
          
          -- Add checkboxes and labels for this chunk of parameters
          for j = start_idx, end_idx do
            local dp = device_params[j]
            device_row_views[#device_row_views+1] = dp.checkbox
            device_row_views[#device_row_views+1] = PakettiAutomationStack_arbitrary_vb:text{ 
              text = dp.param_name, width = column_width
            }
          end
          
          local device_row = PakettiAutomationStack_arbitrary_vb:row{ views = device_row_views }
          rows[#rows+1] = device_row
        end
      end
      
      device_params = {}
      device_label_added = false
    end
  end
  
  for i = 1, #all_params do
    local param = all_params[i]
    local device_key = param.track_index .. "_" .. param.device_index
    
    -- Add track separator if this is a new track
    if param.track_index ~= current_track then
      -- Flush any pending device params from previous track
      flush_device_params()
      
      current_track = param.track_index
      -- Don't add track separator here - we'll add it with the mixer parameters
      current_device_key = "" -- Reset device key for new track
    end
    
    -- If we're starting a new device, flush the previous device's parameters
    if device_key ~= current_device_key then
      flush_device_params()
      current_device_key = device_key
    end
    
    -- Create checkbox for this parameter
    local is_selected = PakettiAutomationStack_IsParameterSelected(
      param.track_index, param.device_index, param.param_index)
    
    local checkbox = PakettiAutomationStack_arbitrary_vb:checkbox{
      value = is_selected,
      notifier = function() PakettiAutomationStack_UpdateParameterSelection() end
    }
    
    PakettiAutomationStack_parameter_checkboxes[param.key] = checkbox
    
    -- Add to current device group
    device_params[#device_params+1] = {
      checkbox = checkbox,
      param_name = param.param_name,
      device_name = param.device_name,
      track_name = param.track_name
    }
  end
  
  -- Flush final device params
  flush_device_params()
  
  -- Add apply and cancel buttons at the bottom for convenience
  local bottom_button_row = PakettiAutomationStack_arbitrary_vb:row{
    PakettiAutomationStack_arbitrary_vb:button{ 
      text = "Show Selected Parameters", 
      --width = 280, 
      notifier = function()
        PakettiAutomationStack_UpdateParameterSelection()
        
        -- Check if any parameters are selected
        if #PakettiAutomationStack_selected_parameters == 0 then
          renoise.app():show_status("Automation Stack: Please select at least one parameter before applying")
          return
        end
        
        PakettiAutomationStack_SaveSelectedParameters()
        PakettiAutomationStack_arbitrary_mode = true
        PakettiAutomationStack_show_same_mode = false -- Clear show same mode
        
        -- Close the parameter selection dialog first
        PakettiAutomationStack_arbitrary_dialog:close()
        
        -- Ensure main automation stack dialog is open and updated
        if not PakettiAutomationStack_dialog or not PakettiAutomationStack_dialog.visible then
          -- Main dialog not visible, reopen it
          PakettiAutomationStack_ReopenDialog()
        else
          -- Main dialog is open, just update it
          PakettiAutomationStack_RebuildAutomations()
          PakettiAutomationStack_RebuildCanvases()
          PakettiAutomationStack_RequestUpdate()
        end
        
        renoise.app():show_status("Automation Stack: Showing " .. tostring(#PakettiAutomationStack_selected_parameters) .. " selected parameters from multiple tracks")
      end 
    },
    PakettiAutomationStack_arbitrary_vb:space{ width = 20 },
    PakettiAutomationStack_arbitrary_vb:button{ 
      text = "Cancel", 
      width = 100, 
      notifier = function()
        PakettiAutomationStack_arbitrary_dialog:close()
      end 
    }
  }
  rows[#rows+1] = bottom_button_row
  
  -- Create scrollable content
  local content_column = PakettiAutomationStack_arbitrary_vb:column{
    --spacing = 2,
    views = rows
  }
  
  local scrollable_content = content_column
  
  PakettiAutomationStack_arbitrary_dialog = renoise.app():show_custom_dialog(
    "Select Arbitrary Parameters", scrollable_content)
end

-- Update parameter selection from checkboxes
function PakettiAutomationStack_UpdateParameterSelection()
  -- Clear current selection
  PakettiAutomationStack_selected_parameters = {}
  
  -- Build new selection from checkboxes
  local all_params = PakettiAutomationStack_GetAllParameters()
  for i = 1, #all_params do
    local param = all_params[i]
    local checkbox = PakettiAutomationStack_parameter_checkboxes[param.key]
    if checkbox and checkbox.value then
      PakettiAutomationStack_AddParameter(
        param.track_index, param.device_index, param.param_index)
    end
  end
end

-- Update Show Same dropdown with available parameter names
function PakettiAutomationStack_UpdateShowSamePopup()
  if not PakettiAutomationStack_show_same_popup_view then return end
  
  local param_names = PakettiAutomationStack_GetUniqueAutomatedParameterNames()
  local items = {"(none)"}
  local selected_index = 1
  
  for i = 1, #param_names do
    items[#items+1] = param_names[i].display_name
    -- Check if this was the previously selected parameter
    if param_names[i].name == PakettiAutomationStack_selected_param_name then
      selected_index = #items
    end
  end
  
  PakettiAutomationStack_show_same_popup_view.items = items
  PakettiAutomationStack_show_same_popup_view.value = selected_index
end

-- Build the ViewBuilder content
function PakettiAutomationStack_BuildContent()
  local controls_row = PakettiAutomationStack_vb:row{
    PakettiAutomationStack_vb:switch{
      id = "pas_zoom_switch",
      items = {"Full","1/2","1/4","1/8"},
      width = 100,
      value = PakettiAutomationStack_zoom_index,
      notifier = function(val) PakettiAutomationStack_SetZoomIndex(val) end
    },
    PakettiAutomationStack_vb:text{ text = "New Envelope:" },
    PakettiAutomationStack_vb:switch{
      id = "pas_mode_switch",
      items = {"Points","Lines","Curves"},
      width = 150,
      value = PakettiAutomationStack_draw_playmode_index,
      notifier = function(val)
        PakettiAutomationStack_draw_playmode_index = val
        -- Only update the setting for new envelopes - don't modify existing ones
        renoise.app():show_status("Automation Stack: New envelopes will be created as " .. (val == 1 and "Points" or val == 2 and "Lines" or "Curves"))
      end
    },
    PakettiAutomationStack_vb:text{ text = "View:" },
    PakettiAutomationStack_vb:switch{
      id = "pas_view_switch",
      items = {"Stack","Single"},
      width = 80,
      value = (PakettiAutomationStack_view_mode == 2) and 2 or 1,
      notifier = function(val)
        PakettiAutomationStack_view_mode = (val == 2) and 2 or 1
        PakettiAutomationStack_RebuildCanvases()
        PakettiAutomationStack_RequestUpdate()
      end
    },
    PakettiAutomationStack_vb:text{ text = "Show:" },
    PakettiAutomationStack_vb:switch{
      id = "pas_show_switch",
      items = {"8","16"},
      width = 70,
      value = PakettiAutomationStack_show_all_vertically and 2 or 1,
      notifier = function(val)
        PakettiAutomationStack_show_all_vertically = (val == 2)
        if val == 1 then
          PakettiAutomationStack_vertical_page_size = 8
        else
          PakettiAutomationStack_vertical_page_size = 16
        end
        PakettiAutomationStack_vertical_page_index = 1
        PakettiAutomationStack_RebuildCanvases()
        PakettiAutomationStack_RequestUpdate()
      end
    },
    PakettiAutomationStack_vb:text{ text = "Page:" },
    PakettiAutomationStack_vb:scrollbar{ id = "pas_vscroll", min = 1, max = 2, value = PakettiAutomationStack_vertical_page_index, step = 1, pagestep = 1, autohide = false, notifier = function(val)
      PakettiAutomationStack_vertical_page_index = val
      PakettiAutomationStack_RebuildCanvases()
      PakettiAutomationStack_RequestUpdate()
    end },
    PakettiAutomationStack_vb:text{ id = "pas_count_text", text = "(0)" },
    PakettiAutomationStack_vb:button{ 
      text = "Arbitrary Parameters", 
      width = 100, 
      notifier = function() PakettiAutomationStack_ShowParameterSelectionDialog() end 
    },
    PakettiAutomationStack_vb:button{ 
      text = "Current Track", 
      width = 80, 
      notifier = function() 
        PakettiAutomationStack_arbitrary_mode = false
        PakettiAutomationStack_show_same_mode = false
        PakettiAutomationStack_RebuildAutomations()
        PakettiAutomationStack_RebuildCanvases()
        PakettiAutomationStack_RequestUpdate()
        renoise.app():show_status("Automation Stack: Showing current track")
      end 
    },
    PakettiAutomationStack_vb:button{ text = "Refresh", width = 50, notifier = function() PakettiAutomationStack_ForceRefresh() end }
  }

  local show_same_row = PakettiAutomationStack_vb:row{
    PakettiAutomationStack_vb:text{ text = "Show Same:" },
    PakettiAutomationStack_vb:popup{ 
      id = "pas_show_same_popup", 
      items = {"(none)"}, 
      width = 300, 
      value = 1, 
      notifier = function(val)
        local param_names = PakettiAutomationStack_GetUniqueAutomatedParameterNames()
        if val == 1 then
          -- "(none)" selected
          PakettiAutomationStack_selected_param_name = ""
          PakettiAutomationStack_show_same_mode = false
        elseif val > 1 and val <= (#param_names + 1) then
          -- Parameter name selected
          local param_index = val - 1
          PakettiAutomationStack_selected_param_name = param_names[param_index].name
          PakettiAutomationStack_show_same_mode = true
          PakettiAutomationStack_arbitrary_mode = false
        end
        PakettiAutomationStack_RebuildAutomations()
        PakettiAutomationStack_RebuildCanvases()
        PakettiAutomationStack_RequestUpdate()
        if PakettiAutomationStack_show_same_mode then
          renoise.app():show_status("Automation Stack: Showing all '" .. PakettiAutomationStack_selected_param_name .. "' parameters")
        end
      end 
    },
    PakettiAutomationStack_vb:button{ 
      text = "Refresh List", 
      width = 100, 
      notifier = function() 
        PakettiAutomationStack_UpdateShowSamePopup()
        renoise.app():show_status("Automation Stack: Updated Show Same list")
      end 
    }
  }

  -- Stacker mode row: multi-pattern automation editing
  local stacker_info_text = "(No selection)"
  if PakettiAutomationStack_stacker_mode and PakettiAutomationStack_stacker_seq_start and PakettiAutomationStack_stacker_seq_end then
    stacker_info_text = string.format("Seq %d-%d (%d lines)", 
      PakettiAutomationStack_stacker_seq_start, 
      PakettiAutomationStack_stacker_seq_end,
      PakettiAutomationStack_stacker_total_lines)
  end
  
  local stacker_row = PakettiAutomationStack_vb:row{
    PakettiAutomationStack_vb:checkbox{
      id = "pas_stacker_checkbox",
      value = PakettiAutomationStack_stacker_mode,
      notifier = function(val)
        if val then
          -- Try to enable stacker mode by reading sequencer selection
          local success = PakettiAutomationStack_BuildStackerPatterns()
          if success then
            PakettiAutomationStack_stacker_mode = true
            -- Update info text
            local info_view = PakettiAutomationStack_vb.views["pas_stacker_info"]
            if info_view then
              info_view.text = string.format("Seq %d-%d (%d lines)", 
                PakettiAutomationStack_stacker_seq_start, 
                PakettiAutomationStack_stacker_seq_end,
                PakettiAutomationStack_stacker_total_lines)
            end
            PakettiAutomationStack_RebuildAutomations()
            PakettiAutomationStack_RebuildCanvases()
            PakettiAutomationStack_RequestUpdate()
            renoise.app():show_status("Automation Stacker: Multi-pattern mode enabled - Seq " .. 
              PakettiAutomationStack_stacker_seq_start .. "-" .. PakettiAutomationStack_stacker_seq_end)
          else
            -- No selection - revert checkbox
            PakettiAutomationStack_stacker_mode = false
            local checkbox_view = PakettiAutomationStack_vb.views["pas_stacker_checkbox"]
            if checkbox_view then checkbox_view.value = false end
            renoise.app():show_status("Automation Stacker: Select patterns in Pattern Matrix first (Shift+Click)")
          end
        else
          PakettiAutomationStack_stacker_mode = false
          PakettiAutomationStack_stacker_patterns = {}
          PakettiAutomationStack_stacker_total_lines = 0
          local info_view = PakettiAutomationStack_vb.views["pas_stacker_info"]
          if info_view then
            info_view.text = "(Single pattern mode)"
          end
          PakettiAutomationStack_RebuildAutomations()
          PakettiAutomationStack_RebuildCanvases()
          PakettiAutomationStack_RequestUpdate()
          renoise.app():show_status("Automation Stack: Single pattern mode")
        end
      end
    },
    PakettiAutomationStack_vb:text{ text = "Stacker Mode (Multi-Pattern)" },
    PakettiAutomationStack_vb:text{ id = "pas_stacker_info", text = stacker_info_text, width = 150 },
    PakettiAutomationStack_vb:button{
      text = "Read Selection",
      width = 100,
      notifier = function()
        local success = PakettiAutomationStack_BuildStackerPatterns()
        if success then
          PakettiAutomationStack_stacker_mode = true
          -- Update checkbox and info
          local checkbox_view = PakettiAutomationStack_vb.views["pas_stacker_checkbox"]
          if checkbox_view then checkbox_view.value = true end
          local info_view = PakettiAutomationStack_vb.views["pas_stacker_info"]
          if info_view then
            info_view.text = string.format("Seq %d-%d (%d lines)", 
              PakettiAutomationStack_stacker_seq_start, 
              PakettiAutomationStack_stacker_seq_end,
              PakettiAutomationStack_stacker_total_lines)
          end
          PakettiAutomationStack_RebuildAutomations()
          PakettiAutomationStack_RebuildCanvases()
          PakettiAutomationStack_RequestUpdate()
          renoise.app():show_status("Automation Stacker: Selection updated - Seq " .. 
            PakettiAutomationStack_stacker_seq_start .. "-" .. PakettiAutomationStack_stacker_seq_end .. 
            " (" .. PakettiAutomationStack_stacker_total_lines .. " lines)")
        else
          renoise.app():show_status("Automation Stacker: No pattern matrix selection found")
        end
      end
    }
  }

  local header_row = PakettiAutomationStack_vb:row{ spacing = 0, PakettiAutomationStack_vb:canvas{ id = "pas_header_canvas", width = PakettiAutomationStack_canvas_width, height = PakettiAutomationStack_gutter_height + 6, mode = "plain", mouse_events = {"down"}, mouse_handler = function(ev)
      local _render, on_mouse = PakettiAutomationStack_RenderHeaderCanvas(PakettiAutomationStack_canvas_width, PakettiAutomationStack_gutter_height + 6)
      if on_mouse then on_mouse(ev) end
    end, render = (function()
      local render_func = PakettiAutomationStack_RenderHeaderCanvas(PakettiAutomationStack_canvas_width, PakettiAutomationStack_gutter_height + 6)
      return render_func
    end)() } }

  local tracks_col = PakettiAutomationStack_vb:column{ id = "pas_tracks_container", spacing = 0 }
  local bottom_row = PakettiAutomationStack_vb:row{
    PakettiAutomationStack_vb:text{ text = "Scroll:" },
    PakettiAutomationStack_vb:scrollbar{ id = "pas_hscroll", min = 1, max = 2, value = 1, step = 1, pagestep = 1, autohide = false, notifier = function(val)
      PakettiAutomationStack_view_start_line = val
      PakettiAutomationStack_UpdateScrollbars()
      PakettiAutomationStack_RequestUpdate()
    end }
  }

  local main_content = PakettiAutomationStack_vb:column{ controls_row, show_same_row, stacker_row, header_row, tracks_col, bottom_row }
  
  -- Wrap in a container with exact canvas width to match dialog to canvas
  return PakettiAutomationStack_vb:column{
    PakettiAutomationStack_vb:space{ width = PakettiAutomationStack_canvas_width, height = 1 },
    main_content
  }
end

-- Reopen / build dialog
function PakettiAutomationStack_ReopenDialog()
  if PakettiAutomationStack_dialog and PakettiAutomationStack_dialog.visible then PakettiAutomationStack_dialog:close() end
  PakettiAutomationStack_vb = renoise.ViewBuilder()
  local content = PakettiAutomationStack_BuildContent()
  PakettiAutomationStack_dialog = renoise.app():show_custom_dialog("Paketti Automation Stack", content, PakettiAutomationStack_KeyHandler)
  PakettiAutomationStack_header_canvas = PakettiAutomationStack_vb.views.pas_header_canvas
  PakettiAutomationStack_scrollbar_view = PakettiAutomationStack_vb.views.pas_hscroll
  PakettiAutomationStack_vscrollbar_view = PakettiAutomationStack_vb.views.pas_vscroll
  PakettiAutomationStack_container = PakettiAutomationStack_vb.views.pas_tracks_container
  PakettiAutomationStack_count_text_view = PakettiAutomationStack_vb.views.pas_count_text
  PakettiAutomationStack_show_same_popup_view = PakettiAutomationStack_vb.views.pas_show_same_popup
  renoise.app().window.active_middle_frame = renoise.app().window.active_middle_frame
  
  -- Setup observables for auto-updating
  PakettiAutomationStack_SetupObservables()
  
  PakettiAutomationStack_RebuildAutomations()
  -- Initialize automation hashes for change detection
  PakettiAutomationStack_automation_hashes = PakettiAutomationStack_BuildIndividualHashes()
  -- Update Show Same dropdown with available parameters
  PakettiAutomationStack_UpdateShowSamePopup()
  PakettiAutomationStack_UpdateScrollbars()
  PakettiAutomationStack_RebuildCanvases()
  PakettiAutomationStack_RequestUpdate()
  if not PakettiAutomationStack_timer_running then renoise.tool():add_timer(PakettiAutomationStack_TimerTick, PakettiAutomationStack_timer_interval_ms); PakettiAutomationStack_timer_running = true end
end

-- Public entry
function PakettiAutomationStackShowDialog()
  if PakettiAutomationStack_dialog and PakettiAutomationStack_dialog.visible then
    PakettiAutomationStack_dialog:close()
    PakettiAutomationStack_Cleanup()
    return
  end
  local song, patt, _ptrack = PakettiAutomationStack_GetSongPatternTrack()
  if not song or not patt then
    renoise.app():show_status("Automation Stack: No song/pattern available")
    return
  end
  -- Load saved parameter selections
  PakettiAutomationStack_LoadSelectedParameters()
  PakettiAutomationStack_ReopenDialog()
end

-- Force refresh from UI button
function PakettiAutomationStack_ForceRefresh()
  PakettiAutomationStack_RebuildAutomations()
  PakettiAutomationStack_UpdateScrollbars()
  PakettiAutomationStack_RebuildCanvases()
  PakettiAutomationStack_RequestUpdate()
  renoise.app():show_status("Automation Stack: Refreshed")
end

-- Timer: detect changes and update
function PakettiAutomationStack_TimerTick()
  if not PakettiAutomationStack_dialog or not PakettiAutomationStack_dialog.visible then return end
  local hash = PakettiAutomationStack_BuildAutomationHash()
  if hash ~= PakettiAutomationStack_last_hash then
    PakettiAutomationStack_last_hash = hash
    -- Detect which specific automation changed for auto-selection
    PakettiAutomationStack_DetectChangedAutomation()
    PakettiAutomationStack_RebuildAutomations()
    PakettiAutomationStack_RebuildCanvases()
    PakettiAutomationStack_RequestUpdate()
  else
    -- Even if overall hash didn't change, check for individual automation changes
    PakettiAutomationStack_DetectChangedAutomation()
    PakettiAutomationStack_RequestUpdate()
  end
end

-- Setup observables for auto-updating
function PakettiAutomationStack_SetupObservables()
  PakettiAutomationStack_CleanupObservables() -- Clean up existing first
  
  local song = renoise.song()
  if not song then return end
  
  -- Track list observable (for when tracks are added/removed)
  if song.tracks_observable then
    -- Use pcall to safely check and add notifier in case the observable becomes invalid
    local success, result = pcall(function()
      if not song.tracks_observable:has_notifier(PakettiAutomationStack_OnTracksChanged) then
        song.tracks_observable:add_notifier(PakettiAutomationStack_OnTracksChanged)
        PakettiAutomationStack_tracks_observable = song.tracks_observable
      end
    end)
    -- If pcall failed, the observable is no longer valid, so skip it
    if not success then
      -- Observable is no longer valid, skip setting it up
    end
  end
  
  -- Sequencer selection range observable (for stacker mode - pattern matrix selection)
  if song.sequencer and song.sequencer.selection_range_observable then
    local success, result = pcall(function()
      if not song.sequencer.selection_range_observable:has_notifier(PakettiAutomationStack_OnSelectionRangeChanged) then
        song.sequencer.selection_range_observable:add_notifier(PakettiAutomationStack_OnSelectionRangeChanged)
        PakettiAutomationStack_selection_range_observable = song.sequencer.selection_range_observable
      end
    end)
    if not success then
      -- Observable is no longer valid, skip setting it up
    end
  end
  
  -- Individual track mute state observables
  for track_idx = 1, #song.tracks do
    local track = song.tracks[track_idx]
    if track and track.type ~= renoise.Track.TRACK_TYPE_MASTER and track.mute_state_observable then
      -- Use pcall to safely check and add notifier in case the observable becomes invalid
      local success, result = pcall(function()
        if not track.mute_state_observable:has_notifier(PakettiAutomationStack_OnTrackMuteChanged) then
          track.mute_state_observable:add_notifier(PakettiAutomationStack_OnTrackMuteChanged)
          PakettiAutomationStack_track_observables[track_idx] = track.mute_state_observable
        end
      end)
      -- If pcall failed, the observable is no longer valid, so skip it
      if not success then
        -- Observable is no longer valid, skip setting it up
      end
    end
  end
end

-- Cleanup observables
function PakettiAutomationStack_CleanupObservables()
  -- Clean up tracks observable
  if PakettiAutomationStack_tracks_observable then
    -- Use pcall to safely check and remove notifier in case the observable becomes invalid
    local success, result = pcall(function()
      if PakettiAutomationStack_tracks_observable:has_notifier(PakettiAutomationStack_OnTracksChanged) then
        PakettiAutomationStack_tracks_observable:remove_notifier(PakettiAutomationStack_OnTracksChanged)
      end
    end)
    -- If pcall failed, the observable is no longer valid, so just clear it
    if not success then
      -- Observable is no longer valid, just clear the reference
    end
    PakettiAutomationStack_tracks_observable = nil
  end
  
  -- Clean up selection range observable
  if PakettiAutomationStack_selection_range_observable then
    local success, result = pcall(function()
      if PakettiAutomationStack_selection_range_observable:has_notifier(PakettiAutomationStack_OnSelectionRangeChanged) then
        PakettiAutomationStack_selection_range_observable:remove_notifier(PakettiAutomationStack_OnSelectionRangeChanged)
      end
    end)
    if not success then
      -- Observable is no longer valid, just clear the reference
    end
    PakettiAutomationStack_selection_range_observable = nil
  end
  
  -- Clean up track mute observables
  for track_idx, observable in pairs(PakettiAutomationStack_track_observables) do
    if observable then
      -- Use pcall to safely check and remove notifier in case the observable becomes invalid
      local success, result = pcall(function()
        if observable:has_notifier(PakettiAutomationStack_OnTrackMuteChanged) then
          observable:remove_notifier(PakettiAutomationStack_OnTrackMuteChanged)
        end
      end)
      -- If pcall failed, the observable is no longer valid, so just continue
      if not success then
        -- Observable is no longer valid, just continue to next one
      end
    end
  end
  PakettiAutomationStack_track_observables = {}
end

-- Observable callbacks
function PakettiAutomationStack_OnTracksChanged()
  if not PakettiAutomationStack_dialog or not PakettiAutomationStack_dialog.visible then return end
  
  -- Refresh track observables since tracks changed
  PakettiAutomationStack_SetupObservables()
  
  -- Force refresh the display
  PakettiAutomationStack_RebuildAutomations()
  PakettiAutomationStack_RebuildCanvases()
  PakettiAutomationStack_RequestUpdate()
  
  renoise.app():show_status("Automation Stack: Track list changed - updated display")
end

function PakettiAutomationStack_OnTrackMuteChanged()
  if not PakettiAutomationStack_dialog or not PakettiAutomationStack_dialog.visible then return end
  
  -- Just request a visual update since mute state changed
  PakettiAutomationStack_RequestUpdate()
end

-- Called when pattern matrix selection range changes
function PakettiAutomationStack_OnSelectionRangeChanged()
  if not PakettiAutomationStack_dialog or not PakettiAutomationStack_dialog.visible then return end
  
  -- Only auto-update if we're in stacker mode or if stacker mode was enabled but had no selection
  local song = renoise.song()
  if not song then return end
  
  local selection_range = song.sequencer.selection_range
  local has_selection = selection_range and selection_range[1] > 0 and selection_range[2] > 0
  
  if has_selection then
    -- Rebuild stacker patterns with new selection
    local success = PakettiAutomationStack_BuildStackerPatterns()
    if success then
      -- Enable stacker mode if not already
      PakettiAutomationStack_stacker_mode = true
      
      -- Update UI checkbox and info text if they exist
      if PakettiAutomationStack_vb then
        local checkbox_view = PakettiAutomationStack_vb.views["pas_stacker_checkbox"]
        if checkbox_view then checkbox_view.value = true end
        local info_view = PakettiAutomationStack_vb.views["pas_stacker_info"]
        if info_view then
          info_view.text = string.format("Seq %d-%d (%d lines)", 
            PakettiAutomationStack_stacker_seq_start, 
            PakettiAutomationStack_stacker_seq_end,
            PakettiAutomationStack_stacker_total_lines)
        end
      end
      
      -- Rebuild display
      PakettiAutomationStack_RebuildAutomations()
      PakettiAutomationStack_RebuildCanvases()
      PakettiAutomationStack_RequestUpdate()
      
      renoise.app():show_status("Automation Stacker: Selection updated - Seq " .. 
        PakettiAutomationStack_stacker_seq_start .. "-" .. PakettiAutomationStack_stacker_seq_end .. 
        " (" .. PakettiAutomationStack_stacker_total_lines .. " lines)")
    end
  end
end

-- Cleanup
function PakettiAutomationStack_Cleanup()
  if PakettiAutomationStack_timer_running then
    renoise.tool():remove_timer(PakettiAutomationStack_TimerTick)
    PakettiAutomationStack_timer_running = false
  end
  
  -- Cleanup observables
  PakettiAutomationStack_CleanupObservables()
  
  PakettiAutomationStack_dialog = nil
  PakettiAutomationStack_vb = nil
  PakettiAutomationStack_header_canvas = nil
  PakettiAutomationStack_container = nil
  PakettiAutomationStack_track_canvases = {}
  PakettiAutomationStack_scrollbar_view = nil
  PakettiAutomationStack_vscrollbar_view = nil
  PakettiAutomationStack_automation_hashes = {} -- Clear automation hashes
  -- Close arbitrary parameter dialog if open
  if PakettiAutomationStack_arbitrary_dialog and PakettiAutomationStack_arbitrary_dialog.visible then
    PakettiAutomationStack_arbitrary_dialog:close()
  end
  PakettiAutomationStack_arbitrary_dialog = nil
  PakettiAutomationStack_arbitrary_vb = nil
  PakettiAutomationStack_parameter_checkboxes = {}
  -- Reset Show Same state
  PakettiAutomationStack_show_same_popup_view = nil
  -- Reset Stacker state
  PakettiAutomationStack_stacker_mode = false
  PakettiAutomationStack_stacker_patterns = {}
  PakettiAutomationStack_stacker_total_lines = 0
  PakettiAutomationStack_stacker_seq_start = nil
  PakettiAutomationStack_stacker_seq_end = nil
end

-- Show Automation Stack in single view mode
function PakettiAutomationStackShowSingleView()
  PakettiAutomationStack_view_mode = 2 -- Set to single view mode
  PakettiAutomationStackShowDialog()
end

-- Show Automation Stack in stacker (multi-pattern) mode
function PakettiAutomationStackShowStackerView()
  -- Try to build stacker patterns from selection first
  local success = PakettiAutomationStack_BuildStackerPatterns()
  if success then
    PakettiAutomationStack_stacker_mode = true
    renoise.app():show_status("Automation Stacker: Multi-pattern mode - Seq " .. 
      PakettiAutomationStack_stacker_seq_start .. "-" .. PakettiAutomationStack_stacker_seq_end .. 
      " (" .. PakettiAutomationStack_stacker_total_lines .. " lines)")
  else
    PakettiAutomationStack_stacker_mode = false
    renoise.app():show_status("Automation Stacker: No pattern matrix selection - select patterns first (Shift+Click in Pattern Matrix)")
  end
  PakettiAutomationStackShowDialog()
end

-- Debug function to print all automation points for currently selected automation
function PakettiAutomationStackDebugPrintAutomationPoints()
  local song = renoise.song()
  if not song then
    print("DEBUG: No song loaded")
    return
  end
  
  local selected_parameter = song.selected_automation_parameter
  if not selected_parameter then
    print("DEBUG: No automation parameter selected")
    return
  end
  
  local selected_device = song.selected_automation_device
  if not selected_device then
    print("DEBUG: No automation device selected")
    return
  end
  
  local pattern = song.selected_pattern
  if not pattern then
    print("DEBUG: No pattern selected")
    return
  end
  
  local track_index = song.selected_track_index
  local pattern_track = pattern:track(track_index)
  if not pattern_track then
    print("DEBUG: No pattern track found")
    return
  end
  
  local automation = pattern_track:find_automation(selected_parameter)
  if not automation then
    print("DEBUG: No automation found for selected parameter")
    return
  end
  
  print("=== AUTOMATION POINTS DEBUG ===")
  print("Parameter: " .. (selected_parameter.name or "unnamed"))
  print("Device: " .. (selected_device.display_name or "unnamed"))
  print("Track: " .. song.selected_track.name)
  print("Pattern: " .. pattern.name)
  print("Number of points: " .. #automation.points)
  print("---")
  
  if #automation.points == 0 then
    print("No automation points found")
  else
    for i, point in ipairs(automation.points) do
      print(string.format("Point %d: Line=%.2f, Value=%.6f", i, point.time, point.value))
    end
    
    -- Show the last point specifically
    local last_point = automation.points[#automation.points]
    print("---")
    print("LAST POINT:")
    print("  Line: " .. last_point.time)
    print("  Value: " .. last_point.value)
    print("  Raw time: " .. tostring(last_point.time))
    print("  Raw value: " .. tostring(last_point.value))
  end
  
  print("=== END DEBUG ===")
end

PakettiAddMenuEntry{ name = "Main Menu:Tools:Automation Stack", invoke = function() PakettiAutomationStackShowDialog() end }
PakettiAddMenuEntry{ name = "Main Menu:Tools:Automation Stack - Single View", invoke = function() PakettiAutomationStackShowSingleView() end }
PakettiAddMenuEntry{ name = "Main Menu:Tools:Automation Stack - Stacker (Multi-Pattern)", invoke = function() PakettiAutomationStackShowStackerView() end }
PakettiAddMenuEntry{ name = "Main Menu:Tools:Automation Stack - Select Arbitrary Parameters", invoke = function() PakettiAutomationStack_ShowParameterSelectionDialog() end }
PakettiAddMenuEntry{ name = "Main Menu:Tools:Automation Stack - Debug Print Points", invoke = function() PakettiAutomationStackDebugPrintAutomationPoints() end }

PakettiAddMenuEntry{ name = "Pattern Editor:Paketti:Automation:Automation Stack", invoke = function() PakettiAutomationStackShowDialog() end }
PakettiAddMenuEntry{ name = "Pattern Editor:Paketti:Automation:Automation Stack - Single View", invoke = function() PakettiAutomationStackShowSingleView() end }
PakettiAddMenuEntry{ name = "Pattern Editor:Paketti:Automation:Automation Stack - Stacker (Multi-Pattern)", invoke = function() PakettiAutomationStackShowStackerView() end }
PakettiAddMenuEntry{ name = "Pattern Editor:Paketti:Automation:Automation Stack - Select Arbitrary Parameters", invoke = function() PakettiAutomationStack_ShowParameterSelectionDialog() end }
renoise.tool():add_keybinding{ name = "Pattern Editor:Paketti:Automation Stack...", invoke = function() PakettiAutomationStackShowDialog() end }
renoise.tool():add_keybinding{ name = "Pattern Editor:Paketti:Automation Stack - Single View...", invoke = function() PakettiAutomationStackShowSingleView() end }
renoise.tool():add_keybinding{ name = "Pattern Editor:Paketti:Automation Stack - Stacker (Multi-Pattern)...", invoke = function() PakettiAutomationStackShowStackerView() end }
renoise.tool():add_keybinding{ name = "Pattern Editor:Paketti:Automation Stack - Select Arbitrary Parameters...", invoke = function() PakettiAutomationStack_ShowParameterSelectionDialog() end }
PakettiAddMenuEntry{ name = "Pattern Editor:Paketti:Automation:Debug Print Points", invoke = function() PakettiAutomationStackDebugPrintAutomationPoints() end }