WorkListController.java

package com.enventek.plant.worklist.newlist;

import com.enventek.plant.components.ButtonPopup;
import com.enventek.plant.components.MainComponent;
import com.enventek.plant.components.MsgBox;
import com.enventek.plant.datasource.DataSource;
import com.enventek.plant.datasource.DataSourceChangeListenerWeb;
import com.enventek.plant.datasource.FileObject;
import com.enventek.plant.datasource.file.FileBaseDataSource;
import com.enventek.plant.datasource.file.objects.FSItem;
import com.enventek.plant.hibernate.objects.Batch;
import com.enventek.plant.hibernate.objects.Board;
import com.enventek.plant.hibernate.objects.Cutting;
import com.enventek.plant.hibernate.objects.Truss;
import com.enventek.plant.utils.ErrorHandler;
import com.enventek.plant.utils.Globals;
import com.enventek.plant.utils.Item;
import com.enventek.plant.utils.configuration.AppConfig;
import com.enventek.plant.utils.savedState.FileMetadataManager;
import com.enventek.plant.utils.savedState.SavedStateUtils;
import com.enventek.plant.worklist.DataSourceTableModel;
import com.enventek.plant.worklist.WorkListSearch;
import com.enventek.plant.worklist.WorkListUtils;
import com.enventek.plant.worklist.WorkOrderUtils;
import com.enventek.plant.worklist.newlist.NewWorkList.StateProviderListener;

import org.apache.commons.configuration2.HierarchicalConfiguration;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
import java.awt.*;
import java.awt.event.*;
import java.util.List;
import javax.swing.Timer;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

@SuppressWarnings("unchecked")
public class WorkListController implements DataSourceChangeListenerWeb {
	static final Logger logger = LogManager.getLogger(WorkListController.class);

	private final WorkListUI ui;
	final WorkListState state;
	private final WorkListUtilities utils;
	private WorkListBackupManager wlBackupManager;
	private WorkOrderController woController;

	private List<DataSource> allDataSources = new ArrayList<>();
	private DataSource currentDataSource;

	private final List<WorkListBehaviorListener> workListBehaviorlisteners = new ArrayList<>();
	private StateProviderListener stateProviderListener;
	final MainComponent main = MainComponent.getInstance();

	private HierarchicalConfiguration settings;
	private WorkOrderUtils workOrderUtils; // optional
	public static String fileName;
	public static boolean configHidden = false;

	private Timer delayTimer;
	private static WorkListUtils workListUtils;

	private DefaultListModel unfilteredList;
	private int selectedIndexForSimple = 0;
	private final AtomicInteger programmaticSelectDepth = new AtomicInteger(0);

	// NEW: navigation stack (history of list models)
	private final Deque<DefaultListModel> history = new ArrayDeque<>();

	private final ExecutorService refreshPool = Executors.newSingleThreadExecutor(r -> {
		Thread t = new Thread(r, "WorkList-Refresh");
		t.setDaemon(true);
		return t;
	});

	public WorkListController(WorkListUI ui, WorkListState state, WorkListUtilities utils) {
		this.ui = ui;
		this.state = state;
		this.utils = utils;

	}

	public List<DataSource> getAllDataSources() {
		return allDataSources;
	}

	// Add this method to create the backup manager
	public void setWorkListBackupManager(WorkListBackupManager backupManager) {
		this.wlBackupManager = backupManager;
	}

	// ============ Lifecycle ============
	public void init() {
		// selection model that blocks while process is running
		ui.itemList.setSelectionModel(new DefaultListSelectionModel() {
			@Override
			public void setSelectionInterval(int i0, int i1) {
				if (!state.isProcessInProgress())
					super.setSelectionInterval(i0, i1);
			}

			@Override
			public void addSelectionInterval(int i0, int i1) {
				if (!state.isProcessInProgress())
					super.addSelectionInterval(i0, i1);
			}
		});

		// delayed re-enable (touchscreen)
		delayTimer = new Timer(100, e -> {
			delayTimer.stop();
			ui.itemList.setEnabled(true);
		});
		delayTimer.setRepeats(false);

		// selection listener (main brain)
		// component resize trick to invalidate cell sizes (like old)
		ui.itemList.addComponentListener(new ComponentAdapter() {
			@Override
			public void componentResized(ComponentEvent e) {
				ui.itemList.setFixedCellHeight(10);
				ui.itemList.setFixedCellHeight(-1);
			}
		});

		// top/back button
		ui.backButton.addActionListener(evt -> {
			// NEW: if we have history, go back. Otherwise keep old Search
			// behavior.
			if (canGoBack()) {
				goBack();
				ui.getMainPanel().firePropertyChange("backToBatch", true, false);
				return;
			}

			if ("Search".equals(ui.backButton.getText())) {
				search();
			}
			DataSource ds = getDataSource();
			if (ds != null) {
				clearHistory(); // back to top level view
				DefaultListModel model = ds.getModel(null);
				ui.itemList.setModel(model);
			}
			ui.backButton.setText("Search");
			ui.backButton.setIcon(ui.searchIcon);
			ui.getMainPanel().firePropertyChange("backToBatch", true, false);
		});

		// config button
		ui.configButton.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseReleased(MouseEvent evt) {
				if (state.isProcessInProgress()) {
					evt.consume();
					return;
				}
				if (ui.configPanel.isVisible()) {
					if (workOrderUtils != null && !workOrderUtils.checkAndHandleActiveWorkStream()) {
						refresh();
					}
					DataSourceTableModel model = (DataSourceTableModel) ui.configPanel.tableData.getModel();
					int row = ui.configPanel.tableData.getSelectedRow();
					model.setDefaultIndex(row);
					settings.setProperty("dataSource.defaultIdx", row);
					AppConfig.save(settings, fileName);

					notifyDataSourceChanged();
					if (workOrderUtils != null && workOrderUtils.getWorkOrder() != null) {
						workOrderUtils.getWorkOrder().refresh();
					}
					Map<String, Object> extra = new HashMap<>();
					extra.put("eventType", "datasourceChange");
					DataSource ds = getDataSource();
					extra.put("dataSourceName", ds != null ? ds.getName() : "null");
					// workListUtils.sendUpdateToWeb("Datasource changed",
					// extra);
					hideConfigPanel();
				} else
					showConfigPanel();

				updateRefreshButtonState();
			}
		});

		// refresh button
		ui.refreshButton.addActionListener(e -> refresh());

		// done button toggle
		ui.doneButton.addActionListener(e -> {
			DataSource ds = getDataSource();
			if (ds == null)
				return;
			if (ui.doneButton.getModel().isSelected())
				refreshDone();
			else
				refresh();
		});
	}
	
	
	// ============ Setup ============
	public void setup(HierarchicalConfiguration cfg, String postfix) throws Exception {
		this.settings = cfg;

		// workListUtils = new WorkListUtilsProxy(this).delegate(); // (proxy
		// keeps references tidy)

		ui.configPanel.setTableData(settings);
		selectDefaultDataSource();

		if (getDataSource() != null) {
			logger.debug("datasource: {}", getDataSource().getName());
		}

		refresh();
		

		// Setup work order if enabled
	    setupWorkOrderIfEnabled();

		if (ui.itemList.getVisibleRowCount() == 0) {
			ui.topText.setText("Select a Datasource");
		} else if (SavedStateUtils.isInitialized() && !"-1".equals(SavedStateUtils.getJobName())
				&& workOrderUtils != null && workOrderUtils.hasWorkStreamSaved()) {
			if (state.isSavedStateActive()) {
				refresh();
				workOrderUtils.loadWorkStreamSaved();
			}
		} else if (SavedStateUtils.isInitialized() && !"-1".equals(SavedStateUtils.getJobName())
				&& !state.hasWorkStreamSaved()) {
			wlBackupManager.loadWorkListSavedAsync();
		}
		
		
	}


private void setupWorkOrderIfEnabled() throws Exception {
    // If Workorder is enabled on the worklist.
    if (settings.getBoolean("workOrder", true) && SavedStateUtils.isInitialized()
            && FileMetadataManager.isInitialized()) {
        
        // Initialize WorkOrderUtils and WorkOrderController
        
        this.woController = new WorkOrderController(ui, state, workOrderUtils);
        
        // Get the icon and setup the button
        ImageIcon workOrderIcon = workOrderUtils.getIcon();
        ui.setupWorkOrderButton(workOrderIcon);
        
        // Add action listener to the work order button
        ui.getWorkOrderButton().addActionListener(e -> {
            workOrderUtils.WorkOrderButtonAction();
        });
        
        // Initialize the work order controller
       
    }
}

public WorkOrderController getWorkOrderController() {
    return woController;
}
	// Helper to pick default datasource
	private void selectDefaultDataSource() {
		DataSource ds = getDataSource();
		if (ds != null) {
			int idx = DataSource.getDefaultIdx(settings);
			if ((idx >= ui.configPanel.tableData.getRowCount()) || idx < 0) {
				ui.configPanel.setSelectedDataSourceIdx(0);
			} else {
				ui.configPanel.setSelectedDataSourceIdx(idx);
			}
		}
	}

	// ============ Public API ============

	public DataSource getDataSource() {
		DataSource ds = ui.configPanel.getDataSource();
		if (ds != null && ds.workList == null) {
			ds.workList = null;
		}
		return ds;
	}

	public void refresh() {
		if (!state.refreshInProgress.compareAndSet(false, true))
			return;

		final long t0 = System.currentTimeMillis();
		state.setDoneList(false);
		ui.doneButton.getModel().setSelected(false);
		clearHistory(); // NEW: start fresh

		final DataSource current = getDataSource();
		if (current == null) {
			state.refreshInProgress.set(false);
			return;
		}

		refreshPool.submit(() -> {
			try {
				long a0 = System.nanoTime();
				current.refresh();
				DefaultListModel model = current.getModel(null);
				long a1 = System.nanoTime();

				SwingUtilities.invokeLater(() -> {
					try {
						// === Set model and restore custom renderer ===
						ui.itemList.setModel(model);
						ui.itemList.setFixedCellHeight(-1);
						ui.itemList.setCellRenderer(ui.renderer); // critical
																	// for
																	// proper
																	// rendering
						ui.itemList.revalidate();
						ui.itemList.repaint();

						// === Select first item if needed ===
						if (model != null && model.getSize() > 0) {
							Object first = model.getElementAt(0);
							if (first != null && "Default Job".equals(String.valueOf(first))) {
								ui.itemList.setSelectedIndex(0);
							} else if (state.isSimple()) {
								ui.itemList.setSelectedIndex(0);
							}
						}

						// === Visual/layout controls ===
						if (!state.isSimple()) {
							hideConfigPanel();
							ui.backButton.setText("Search");
							ui.backButton.setIcon(ui.searchIcon);
							ui.configButton.setIcon(current.getConfigIcon());
							ui.doneButton.setVisible(true);
							ui.doneButton.setEnabled(true);
						}

						ui.doneButton.setVisible(current.isCompletable());

						logger.debug("Refresh took {}ms (build={}ms)", (System.currentTimeMillis() - t0),
								Math.round((a1 - a0) / 1e6));
					} finally {
						if (SavedStateUtils.isInitialized() && FileMetadataManager.isInitialized()) {
							FileMetadataManager.scanDataSourceFilesAsyncDebounced(current, 250);
						}
						state.refreshInProgress.set(false);
					}
				});
			} catch (Throwable t) {
				try {
					ErrorHandler.HandleError(t, "WorkList refresh failed", true);
				} finally {
					state.refreshInProgress.set(false);
				}
			}
		});
	}

	public synchronized void refreshDone() {
		DataSource current = getDataSource();
		if (current == null)
			return;

		if (current instanceof FileBaseDataSource) {
			if (!ensureDoneFolderExistsForCurrentSource((FileBaseDataSource) current))
				return;
		}

		clearHistory(); // NEW: viewing "Done" resets navigation
		current.refreshCompleted();
		DefaultListModel model = current.getModel(null);
		ui.itemList.setModel(model);
		state.setDoneList(true);
		ui.doneButton.setSelected(true);
	}

	public boolean loadNextItem(Object currentJob) {
		logger.debug("load next item");
		DataSource dataSource = getDataSource();
		if (dataSource == null)
			return false;

		refresh(); // see new files
		DefaultListModel<Item> model = dataSource.getModel(null);

		for (int i = 0; i < model.size(); i++) {
			if (utils.jobNameCompare(String.valueOf(model.get(i)), String.valueOf(currentJob))) {
				ui.itemList.setSelectedIndex(Math.min(i + 1, model.size() - 1));
				break;
			}
		}
		return true;
	}

	public boolean loadItem(String dataSouceName, String jobName, String itemName) {
		logger.debug("Entering loadItem2 Loading: {} - {}", jobName, itemName);
		if (jobName != null)
			jobName = jobName.trim();
		if (itemName != null)
			itemName = itemName.trim();

		List<DataSource> datasources = ui.configPanel.getAllDataSource();
		if (dataSouceName == null)
			dataSouceName = datasources.get(0).getName();
		dataSouceName = dataSouceName.trim();

		for (int i = 0; i < datasources.size(); i++) {
			DataSource dS = datasources.get(i);
			if (dS.getName().trim().equalsIgnoreCase(dataSouceName)) {
				ui.configPanel.setSelectedDataSourceIdx(i);
				clearHistory(); // NEW: explicit navigation replaces stack
				DefaultListModel model = dS.getModel(null);
				ui.itemList.setModel(model);
				boolean found = loadItemFromDataSource(ui.itemList, dS, jobName, itemName);
				if (!found) {
					logger.debug("first search unsuccessful; refreshing datasource");
					refresh();
					return loadItemFromDataSource(ui.itemList, dS, jobName, itemName);
				}
				return true;
			}
		}
		logger.debug("datasource or item not found. Jobname:{} itemName:{}", jobName, itemName);
		return false;
	}

	public void loadItem(String dataSouceName, String jobName, int itemOffset) {
		logger.debug("entering loadItem (offset)");
		if (jobName != null)
			jobName = jobName.trim();
		if (dataSouceName != null)
			dataSouceName = dataSouceName.trim();

		List<DataSource> dataSources = ui.configPanel.getAllDataSource();
		for (int i = 0; i < dataSources.size(); i++) {
			DataSource dS = dataSources.get(i);
			if (dS.getName().trim().equalsIgnoreCase(dataSouceName)) {
				if (i != ui.configPanel.getSelectedDataSourceIdx()) {
					ui.configPanel.setSelectedDataSourceIdx(i);
					refresh();
				}

				DefaultListModel model = (DefaultListModel) ui.itemList.getModel();
				for (int j = 0; j < model.getSize(); j++) {
					Object job = model.getElementAt(j);
					if (utils.jobNameCompare(job.toString(), jobName)) {
						if (itemOffset == -1) {
							ui.itemList.setSelectedIndex(j);
							return;
						}

						// dS.getModel(job) already returns a ListModel<Item>
						DefaultListModel lm = dS.getModel(job);
						if (lm != null) {
							// NEW: entering sublist uses stack
							enterFolder(lm);
							if (itemOffset < lm.getSize()) {
								ui.itemList.setSelectedIndex(itemOffset);
								logger.debug("Item found and loaded");
								return;
							} else {
								logger.debug("Offset incorrect: {} / {}", itemOffset, lm.getSize());
							}
						}
					}
				}
			}
		}
		logger.debug("datasource or item not found");
	}

	// ============ Filtering/Search ============
	private JDialog searchDialog;
	WorkListSearch wls;

	public void enableSearch() {
		ui.manualButton.setVisible(true);
		ui.manualButton.setIcon(ui.searchIcon);
		ui.manualButton.setText("Search");
		ui.manualButton.addActionListener(e -> search());
	}

	public void search() {
		unfilteredList = null;
		Frame frm = (Frame) SwingUtilities.getWindowAncestor(ui.getMainPanel());
		if (wls == null)
			wls = new WorkListSearch(main, null);

		wls.setSize((int) ((frm.getWidth() - ui.getMainPanel().getWidth() * 1.1)), (int) (frm.getHeight() * 0.6));
		Point loc = wls.getLocation();
		wls.setLocation(loc.x - (frm.getWidth() - wls.getWidth()) / 2 + 10, loc.y);
		wls.setVisible(true);
		loc = wls.getLocation();
		wls.setLocation(loc.x - (frm.getWidth() - wls.getWidth()) / 2 + 10, loc.y);
		main.displayAlert("", wls, wls.getSize(), false, new Point(0, 0));
	}

	public void setFilterString(String filter) {
		filter = filter.toLowerCase(Locale.ROOT);
		if (filter.length() == 0 && unfilteredList != null) {
			ui.itemList.setModel(unfilteredList);
			unfilteredList = null;
			return;
		}
		if (unfilteredList == null)
			unfilteredList = (DefaultListModel) ui.itemList.getModel();

		DefaultListModel filtered = new DefaultListModel<>();
		for (int i = 0; i < unfilteredList.getSize(); i++) {
			String info = String.valueOf(unfilteredList.getElementAt(i)).toLowerCase(Locale.ROOT);
			if (info.contains(filter))
				filtered.addElement(unfilteredList.getElementAt(i));
		}
		ui.itemList.setModel(filtered);
	}

	// ============ UI helpers ============
	public void setSimpleWorkList(boolean issimple) {
		state.setSimple(issimple);
		if (issimple) {
			ui.buttonPanel.setVisible(false);
			ui.topPanel.setVisible(false);
			ui.configButton.setVisible(false);
			ui.getMainPanel().add(ui.scrollPane, "0,1,1,6");
		} else {
			ui.buttonPanel.setVisible(true);
			ui.topPanel.setVisible(true);
			ui.configButton.setVisible(true);
			ui.getMainPanel().add(ui.scrollPane, "0,3,1,4");
		}
	}

	private void showConfigPanel() {
		logger.info("showConfigPanel");
		ui.configPanel.setVisible(true);
		ui.topPanel.setVisible(false);
		ui.scrollPane.setVisible(false);
		ui.buttonPanel.setVisible(false);
		configHidden = false;
		ui.getMainPanel().revalidate();
	}

	private void hideConfigPanel() {
		logger.info("hideConfigPanel");
		ui.configPanel.setVisible(false);
		ui.topPanel.setVisible(true);
		ui.scrollPane.setVisible(true);
		ui.buttonPanel.setVisible(true);
		configHidden = true;
		ui.getMainPanel().revalidate();
	}

	public void updateRefreshButtonState() {
		ui.refreshButton.setEnabled(!isWorkOrderStreamActive());
	}

	public void setIgnoreAdjusting(boolean ignoreAdjusting) {
		state.setIgnoreAdjusting(ignoreAdjusting);
	}

	// ============ Swipe popup ============
	public void handleSwipePopup() {
		final DataSource current = getDataSource();
		if (current == null)
			return;

		ArrayList<Item> optionList = current.getSwipeItems(state.isDoneList(), ui.itemList.getSelectedValue());
		if (optionList.isEmpty()
				|| (optionList.size() == 1 && "Cancel".equals(String.valueOf(optionList.get(0).getValue()))))
			return;

		final MouseMotionListener[] saved = ui.itemList.getMouseMotionListeners();
		for (MouseMotionListener l : saved)
			ui.itemList.removeMouseMotionListener(l);
		ui.itemList.setEnabled(false);

		boolean disableDelete = isWorkOrderStreamActive() && workOrderUtils.hasWorkStreamSaved();
		if (disableDelete)
			optionList.removeIf(it -> "Delete".equalsIgnoreCase(String.valueOf(it.getValue())));

		ButtonPopup bp = new ButtonPopup(
				"<html><h3><center>" + ui.itemList.getSelectedValue().toString() + "</center></h3></html>", optionList,
				false);

		final AWTEventListener[] holder = new AWTEventListener[1];
		AWTEventListener outsideClick = new AWTEventListener() {
			@Override
			public void eventDispatched(AWTEvent event) {
				if (!(event instanceof MouseEvent me) || me.getID() != MouseEvent.MOUSE_PRESSED)
					return;
				Object src = me.getSource();
				if (src instanceof Component clicked) {
					if (!SwingUtilities.isDescendingFrom(clicked, ui.getMainPanel())
							&& !SwingUtilities.isDescendingFrom(clicked, bp)) {
						bp.forceClose();
						Toolkit.getDefaultToolkit().removeAWTEventListener(holder[0]);
					}
				}
			}
		};
		holder[0] = outsideClick;
		Toolkit.getDefaultToolkit().addAWTEventListener(outsideClick, AWTEvent.MOUSE_EVENT_MASK);

		bp.addPopupMenuListener(new PopupMenuListener() {
			@Override
			public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
				Toolkit.getDefaultToolkit().removeAWTEventListener(outsideClick);
				for (MouseMotionListener l : saved)
					ui.itemList.addMouseMotionListener(l);
				ui.itemList.setEnabled(true);

				try {
					ui.itemList.setSelectedIndex(Globals.selectedDrag);
					if (ui.itemList.getModel().getSize() == 0 || bp.choosenValue == null)
						return;

					int selectedIndex = ui.itemList.getSelectedIndex();
					boolean refreshList = current.handleSwipe(state.isDoneList(), String.valueOf(bp.choosenValue),
							ui.itemList.getSelectedValue(), isWorkOrderStreamActive(),
							workOrderUtils != null && workOrderUtils.hasWorkStreamSaved(), selectedIndex);

					if (refreshList) {
						Item objItem = (Item) ui.itemList.getSelectedValue();
						if (objItem.getValue() instanceof FSItem || objItem.getValue() instanceof Cutting
								|| objItem.getValue() instanceof Batch) {
							DefaultListModel<Item> modelC = current.getModel(null);
							modelC.removeElementAt(Globals.selectedDrag);
						}
					}

					if (Globals.DELETE_ITEM) {
						DefaultListModel model = (DefaultListModel) ui.itemList.getModel();
						model.removeElementAt(Globals.selectedDrag);
					}
				} catch (Exception ex) {
					ErrorHandler.HandleError(ex, "handle swipe exception");
				} finally {
					bp.choosenValue = null;
					ui.itemList.repaint();
				}
			}

			@Override
			public void popupMenuCanceled(PopupMenuEvent e) {
				Toolkit.getDefaultToolkit().removeAWTEventListener(outsideClick);
			}

			@Override
			public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
				Globals.selectedDrag = ui.itemList.getSelectedIndex();
			}
		});

		int popSize = (int) (ui.getMainPanel().getWidth() * 0.7);
		bp.setPopupSize(popSize, popSize);
		bp.setOpaque(false);
		bp.setBackground(new Color(30, 30, 30, 200));
		bp.show(ui.getMainPanel(), (ui.getMainPanel().getWidth() - popSize) / 2,
				(ui.getMainPanel().getHeight() - popSize) / 2);
		bp.setVisible(true);
	}

	// ============ Internals ============

	private boolean ensureDoneFolderExistsForCurrentSource(FileBaseDataSource fileDs) {
		List<String> allowed = Arrays.asList("File", "SMBJ", "JCIFS");
		boolean match = fileDs.getConnectionTypes().stream()
				.anyMatch(type -> allowed.stream().anyMatch(allowedType -> allowedType.equalsIgnoreCase(type)));
		if (!match)
			return true;

		String path = fileDs.getRootCompletedDirectory().getPath();
		if (!fileDs.getRootCompletedDirectory().isExisting()) {
			String response = MsgBox.askQuestion(
					"The Done folder does not exist:\n\n" + path + "\n\nWould you like to create it now?", "Yes,No");
			if ("Yes".equals(response)) {
				try {
					fileDs.getRootCompletedDirectory().createEmpty(true);
					logger.info("Created done folder: {}", path);
					int index = ui.configPanel.getSelectedDataSourceIdx();
					String prefix = "dataSource.source(" + index + ")";
					settings.setProperty(prefix + ".donePath", path);
					AppConfig.save(settings, fileName);
					return true;
				} catch (Exception e) {
					MsgBox.displayError("Failed to create the Done folder:\n" + e.getMessage(), "Error");
					logger.error("Failed to create done folder: {}", e.getMessage(), e);
					return false;
				}
			} else {
				MsgBox.displayError("Done folder does not exist.", "Done Folder Missing");
				return false;
			}
		}
		return true;
	}

	private boolean loadItemFromDataSource(JList itemlist, DataSource dataSource, String jobName, String itemName) {
		ListModel model = itemlist.getModel();
		for (int j = 0; j < model.getSize(); j++) {
			Item job = (Item) model.getElementAt(j);
			if (utils.jobNameCompare(job.toString(), jobName)) {
				Object og = dataSource.getModel(job);
				if (og instanceof ListModel) {
					ListModel lm = (ListModel) og;
					itemlist.setModel(lm);
					for (int k = 0; k < lm.getSize(); k++) {
						Item trussItem = (Item) lm.getElementAt(k);
						Object value = trussItem.getValue();
						if (itemName == null) {
							// load first item always
							ui.itemList.setSelectedIndex(0);
							logger.debug("First item selected");
						} else if (value instanceof Truss) {
							Truss t = (Truss) value;
							if (c4SoftwareNameCompare(t.getName().trim(), itemName)
									|| t.getName().trim().equalsIgnoreCase(itemName)
									|| t.tpsName.trim().equalsIgnoreCase(itemName)
									|| t.getName().trim().equalsIgnoreCase(itemName + "#")) {
								ui.itemList.setSelectedIndex(k);
								logger.debug("Item found and loaded");
								return true;
							}
						} else {
							if (trussItem.toString().trim().equalsIgnoreCase(itemName)) {
								ui.itemList.setSelectedIndex(k);
								logger.debug("Item found and loaded");
								return true;
							}
						}
					}
				}
			}
		}
		return false;
	}

	private static boolean c4SoftwareNameCompare(String parsedName, String slString) {
		parsedName = parsedName.replace("*", "");
		slString = slString.replace("*", "");
		String testName = parsedName.replace("\"", "''");
		boolean pass = testName.equalsIgnoreCase(slString);
		pass = pass | (parsedName.replace("'", "-")).equalsIgnoreCase(slString);
		pass = pass | (parsedName.replace("'", "-").replace("\"", "-")).equalsIgnoreCase(slString);
		pass = pass | (parsedName.replace(" ", "")).equalsIgnoreCase(slString.replace(" ", ""));
		return pass;
	}

	// -------- Navigation helpers (NEW) --------
	void enterFolder(DefaultListModel newModel) {
		// Push current model
		DefaultListModel current = (DefaultListModel) ui.itemList.getModel();
		if (current != null)
			history.push(current);

		// Swap model
		ui.itemList.setModel(newModel);

		// UI affordances
		ui.backButton.setText("Back");
		ui.backButton.setIcon(ui.backIcon);
	}

	boolean canGoBack() {
		return !history.isEmpty();
	}

	private void goBack() {
		if (!history.isEmpty()) {
			ui.itemList.setModel(history.pop());
		}
		if (history.isEmpty()) {
			ui.backButton.setText("Search");
			ui.backButton.setIcon(ui.searchIcon);
		} else {
			ui.backButton.setText("Back");
			ui.backButton.setIcon(ui.backIcon);
		}
	}

	private void clearHistory() {
		history.clear();
		ui.backButton.setText("Search");
		ui.backButton.setIcon(ui.searchIcon);
	}

	void finalizeBackHeader(String nameHtml) {
		// Keep the back button consistent when in a sublist.
		if (canGoBack()) {
			ui.backButton.setText("Back");
			ui.backButton.setIcon(ui.backIcon);
		}
		ui.backButton.setText(nameHtml);
	}

	// Small proxy to reuse your existing WorkListUtils with this controller
	private static class WorkListUtilsProxy {
		private final WorkListController ctl;

		WorkListUtilsProxy(WorkListController ctl) {
			this.ctl = ctl;
		}

		WorkListUtils delegate() {
			return new WorkListUtils(new WorkListFacade(ctl));
		}

		// Minimal facade exposing what WorkListUtils expects from WorkList
		static class WorkListFacade extends com.enventek.plant.worklist.WorkList {
			private final WorkListController ctl;

			WorkListFacade(WorkListController ctl) {
				this.ctl = ctl;
			}

			@Override
			public DataSource getDataSource() {
				return ctl.getDataSource();
			}

			@Override
			public void triggerItemUpdateFromSelection() {
				Object sel = ctl.ui.itemList.getSelectedValue();
				if (sel != null)
					ctl.workListUtils.sendItemUpdate(sel);
			}
		}
	}

	// DataSourceChangeListenerWeb
	@Override
	public void onWebDataSourceChanged(HierarchicalConfiguration updatedSettings, DataSource ds) throws Exception {
		logger.info("DataSource has changed from Web");
		ui.changeDataSource(updatedSettings);
	}

	public void addWorkListBehaviorListener(WorkListBehaviorListener listener) {
		workListBehaviorlisteners.add(listener);
	}

	public void removeWorkListBehaviorListener(WorkListBehaviorListener listener) {
		workListBehaviorlisteners.remove(listener);
	}

	void notifyDataSourceChanged() {
		for (WorkListBehaviorListener listener : workListBehaviorlisteners) {
			try {
				listener.onWorkListDataSourceChanged();
			} catch (Exception e) {
				e.printStackTrace(); // Or log it properly
			}
		}
	}

	private boolean isWorkOrderStreamActive() {
		return workOrderUtils != null && workOrderUtils.isActiveWorkStream();
	}

	void notifySelectionListeners(Object selected) {
		for (WorkListBehaviorListener l : workListBehaviorlisteners)
			l.onWorkListSelectionChanged(selected);
	}

    public Timer getDelayTimer() {
        return delayTimer;
    }
    
    public DefaultListModel getUnfilteredList() {
        return unfilteredList;
    }
    
    public void setUnfilteredList(DefaultListModel model) {
        this.unfilteredList = model;
    }
    
   
    
}