WorkOrderController.java

package com.enventek.plant.worklist.newlist;

import com.enventek.plant.hibernate.objects.Board;
import com.enventek.plant.hibernate.objects.Truss;
import com.enventek.plant.utils.Item;
import com.enventek.plant.worklist.WorkOrderUtils;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import javax.swing.*;
import java.util.Optional;

/**
 * WorkOrderController
 *
 * Encapsulates all logic for managing active work order streams.
 * Handles progression through jobs, saving/restoring state, and
 * interaction with the worklist UI/Controller.
 */
public class WorkOrderController {
    private static final Logger logger = LogManager.getLogger(WorkOrderController.class);

    private final WorkListState state;
    private final WorkListUI ui;
    private final WorkOrderUtils workOrderUtils;

    private boolean activeWorkStream = false;
    private boolean selectedByWO = false;

    public WorkOrderController(WorkListUI ui, WorkListState state, WorkOrderUtils workOrderUtils) {
        this.ui = ui;
        this.state = state;
        this.workOrderUtils = workOrderUtils;
    }

    /* ----------------------------
     * Public API
     * ---------------------------- */

    public void startWorkStream() {
        logger.info("Starting work order stream");
        activeWorkStream = true;
        selectedByWO = false;
        // TODO: restore saved stream state if available
    }

    public void stopWorkStream() {
        logger.info("Stopping work order stream");
        activeWorkStream = false;
        selectedByWO = false;
    }

    public boolean isActiveWorkStream() {
        return activeWorkStream;
    }

    public void setSelectedByWO(boolean selectedByWO) {
        this.selectedByWO = selectedByWO;
    }

    public boolean isSelectedByWO() {
        return selectedByWO;
    }

    /**
     * Called when a user selects an item while in work order mode.
     * Handles progression logic.
     */
    public void handleSelection(Object selectedValue) {
        if (!activeWorkStream || selectedValue == null) {
            return;
        }

        logger.debug("WorkOrder selection: {}", selectedValue);

        if (selectedValue instanceof Item item) {
            Object value = item.getValue();
            if (value instanceof Board board) {
                processBoard(board);
            } else if (value instanceof Truss truss) {
                processTruss(truss);
            } else {
                processGeneric(item);
            }
        } else {
            logger.warn("Unknown selection type in WorkOrder: {}", selectedValue.getClass());
        }
    }

    /**
     * Move to the next item in the work stream.
     */
    public void moveToNext(JList<?> list) {
        if (!activeWorkStream || list == null) return;

        int current = list.getSelectedIndex();
        int next = current + 1;

        if (next < list.getModel().getSize()) {
            list.setSelectedIndex(next);
            logger.debug("Moved WorkOrder stream to index {}", next);
        } else {
            logger.info("End of work order stream reached");
            stopWorkStream();
        }
    }

    /**
     * Check if a saved work stream exists.
     */
    public boolean hasWorkStreamSaved() {
        // TODO: integrate with SavedStateUtils
        return false;
    }

    public void loadWorkStreamSaved() {
        // TODO: load saved work order stream from SavedStateUtils
        logger.info("Loading saved work stream (not yet implemented)");
    }

    /* ----------------------------
     * Internal Handlers
     * ---------------------------- */

    private void processBoard(Board board) {
        logger.info("Processing Board in WorkOrder: {}", board.getJobName());
        // TODO: implement progression logic
    }

    private void processTruss(Truss truss) {
        logger.info("Processing Truss in WorkOrder: {}", truss.getJobName());
        // TODO: implement progression logic
    }

    private void processGeneric(Item item) {
        logger.info("Processing Item in WorkOrder: {}", item);
        // TODO: implement progression logic
    }
}