package com.studentgui.uicomp;

import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;

import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextArea;
import javax.swing.SpinnerNumberModel;

/**
 * Reusable component that renders a wrapped descriptive label and a compact
 * integer input (0..4). The label is a non-editable JTextArea that wraps at
 * ~200px; the component adds a 20px left inset so the label appears offset.
 * The spinner is aligned to the first line of the label.
 */
public class PhaseScoreField extends JPanel {
    private static final long serialVersionUID = 1L;
    private static final org.slf4j.Logger LOG = org.slf4j.LoggerFactory.getLogger(PhaseScoreField.class);
    // Ensure we only log the font-adjustment debug once to avoid noisy output in headless tests.
    private static final java.util.concurrent.atomic.AtomicBoolean FONT_ADJUST_LOGGED = new java.util.concurrent.atomic.AtomicBoolean(false);
    /** Shared label font for all form labels so sizing stays consistent project-wide. */
    private static final Font DEFAULT_LABEL_FONT = new Font(Font.SANS_SERIF, Font.PLAIN, 28);
    /** Wrapped, read-only label area used to display the description text. */
    private final JTextArea labelArea;
    /** Numeric spinner used for 0..4 score entry. */
    private final JSpinner spinner;
    /** Container used to constrain the wrap width of the label area. */
    private final JPanel labelWrap;
    // Global label width (pixels) used to make all rows align; default ~200
    // Note: intentionally non-final so pages can adjust it at runtime.
    private static int globalLabelWidthPx = 200;

    /** Horizontal spacer panel inserted to tune the gap between label and spinner. */
    private final JPanel spacer;

    /**
     * Return the shared label font used across all PhaseScoreField instances.
     *
     * @return default label font (24pt sans-serif)
     */
    public static Font getLabelFont() { return DEFAULT_LABEL_FONT; }

    /**
     * Create a PhaseScoreField containing a wrapped label and a numeric spinner.
     *
     * @param labelText text label to display (may be multi-line)
     * @param initial initial integer value for the spinner (0..4)
     */
    public PhaseScoreField(final String labelText, final int initial) {
        super(new GridBagLayout());
    this.labelArea = new JTextArea(labelText);
    labelArea.setLineWrap(true);
    labelArea.setWrapStyleWord(true);
    labelArea.setEditable(false);
    labelArea.setOpaque(false);
    labelArea.setFocusable(false);
    // Use explicit font so the appearance doesn't change when switching LAFs
    Font labelFont = DEFAULT_LABEL_FONT;
    labelArea.setFont(labelFont);
    // Constrain width to the configured global label width so it doesn't expand.
    // Pages set GLOBAL_LABEL_WIDTH_PX to (maxLabelPx + 50). We render the label
    // area at (GLOBAL - 50) and insert a 50px spacer so the spinner sits
    // exactly 50px after the longest label text.
    int prefHeight = computePreferredHeight(labelFont, 2);
    int labelWidth = Math.max(40, globalLabelWidthPx - 50);
    java.awt.Dimension fixed = new java.awt.Dimension(labelWidth, prefHeight);
    // Wrap the JTextArea in a small container to guarantee horizontal size
    this.labelWrap = new JPanel(new java.awt.BorderLayout());
    this.labelWrap.setPreferredSize(fixed);
    this.labelWrap.setMinimumSize(fixed);
    this.labelWrap.setMaximumSize(new java.awt.Dimension(labelWidth, Short.MAX_VALUE));
    this.labelWrap.add(labelArea, java.awt.BorderLayout.CENTER);

        this.spinner = new JSpinner(new SpinnerNumberModel(initial, 0, 4, 1));
        JComponent editor = spinner.getEditor();
        // Set explicit font for spinner editor to keep sizing consistent across themes
        Font spinnerFont = DEFAULT_LABEL_FONT;
        editor.setFont(spinnerFont);
        // The editor is typically a JSpinner.DefaultEditor containing a JTextField
        try {
            java.lang.reflect.Field f = editor.getClass().getDeclaredField("textField");
            f.setAccessible(true);
            Object tf = f.get(editor);
            if (tf instanceof javax.swing.JTextField tfField) {
                tfField.setFont(spinnerFont);
            }
        } catch (ReflectiveOperationException roe) {
            // Field may not exist on some LAF/editor implementations. Log this at most once
            // to avoid excessive noise during automated test runs.
            if (FONT_ADJUST_LOGGED.compareAndSet(false, true)) {
                LOG.trace("Could not adjust spinner editor textField font (field missing or inaccessible)");
            }
        }
        int spinnerHeight = Math.max(36, computePreferredHeight(spinnerFont, 1));
        editor.setPreferredSize(new Dimension(128, spinnerHeight));
        spinner.setPreferredSize(new Dimension(128, spinnerHeight + 4));

        setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); // left inset 20px

    GridBagConstraints gbc = new GridBagConstraints();
    // Label: fixed preferred width, do not expand horizontally
    gbc.gridx = 0;
    gbc.gridy = 0;
    gbc.anchor = GridBagConstraints.NORTHWEST;
    gbc.fill = GridBagConstraints.NONE; // keep label at preferred size
    gbc.weightx = 0.0;
    gbc.insets = new Insets(2, 2, 2, 8);
    add(labelWrap, gbc);

    // Spacer: compute width so the spinner ends up 50px after the rendered label text
    gbc.gridx = 1;
    gbc.gridy = 0;
    gbc.anchor = GridBagConstraints.NORTHWEST;
    gbc.fill = GridBagConstraints.NONE;
    gbc.weightx = 0.0;
    // Compute rendered text pixel width for this label (safe to call here)
    int textPx = computeMaxLabelPixelWidth(labelFont, new String[] { labelText });
    int paddingWithinWrap = Math.max(0, labelWidth - textPx);
    int spacerWidth = Math.max(0, 50 - paddingWithinWrap);
    this.spacer = new JPanel(); this.spacer.setPreferredSize(new java.awt.Dimension(spacerWidth, 1));
    add(this.spacer, gbc);

    // Spinner sits immediately to the right of the spacer
    gbc.gridx = 2;
    gbc.gridy = 0;
    gbc.anchor = GridBagConstraints.NORTHWEST;
    gbc.fill = GridBagConstraints.NONE;
    gbc.weightx = 0.0;
    add(spinner, gbc);

    // Filler: consumes remaining horizontal space so the spinner doesn't get pushed to the far right
    gbc.gridx = 3;
    gbc.gridy = 0;
    gbc.anchor = GridBagConstraints.NORTHWEST;
    gbc.fill = GridBagConstraints.HORIZONTAL;
    gbc.weightx = 1.0;
    add(new JPanel(), gbc);

    // After layout, adjust spacer so the visible gap between label and spinner is exactly 50px
    javax.swing.SwingUtilities.invokeLater(() -> {
        int labelRight = labelWrap.getX() + labelWrap.getWidth();
        int actualGap = spinner.getX() - labelRight;
        int desiredGap = 50;
        int currentSpacer = this.spacer.getPreferredSize().width;
        int delta = desiredGap - actualGap;
        if (delta != 0) {
            int newWidth = Math.max(0, currentSpacer + delta);
            this.spacer.setPreferredSize(new java.awt.Dimension(newWidth, 1));
            this.spacer.revalidate();
            this.revalidate();
            this.repaint();
        }
    });
    }

    /**
     * Set a global label width used by all PhaseScoreField instances created
     * after calling this method. This helps align the spinner input across
     * multiple rows so the entry fields start at a consistent position.
     *
     * @param px target global label width in pixels (will be clamped to a sensible minimum)
     */
    public static void setGlobalLabelWidth(final int px) {
        globalLabelWidthPx = Math.max(80, px);
    }

    private static int computePreferredHeight(final Font font, final int approxLines) {
        if (font == null) {
            return 40;
        }
        javax.swing.JLabel probe = new javax.swing.JLabel();
        java.awt.FontMetrics fm = probe.getFontMetrics(font);
        int h = fm.getHeight() * Math.max(1, approxLines) + 6;
        return Math.max(40, h);
    }

    /**
     * Return the configured global label width in pixels used by new instances.
     *
     * @return global label width in pixels
     */
    public static int getGlobalLabelWidth() { return globalLabelWidthPx; }

    /**
     * Compute the pixel width of the longest label string using the given
     * font. Returns the maximum string width in pixels.
    *
    * @param font font to use when measuring (may be null to use default)
    * @param labels array of label texts to measure
    * @return maximum string width in pixels (>=0)
     */
    public static int computeMaxLabelPixelWidth(final java.awt.Font font, final String[] labels) {
        if (labels == null || labels.length == 0) {
            return globalLabelWidthPx;
        }
        javax.swing.JLabel probe = new javax.swing.JLabel();
        java.awt.FontMetrics fm = probe.getFontMetrics(font != null ? font : DEFAULT_LABEL_FONT);
        int max = 0;
        for (String s : labels) {
            if (s != null) {
                max = Math.max(max, fm.stringWidth(s));
            }
        }
        return max;
    }

    /**
     * Set the visible label text for this row.
     *
     * @param text new label text
     */
    public void setLabel(final String text) { labelArea.setText(text); }

    /**
     * Get the current label text for this field.
     *
     * @return label text
     */
    public String getLabel() { return labelArea.getText(); }

    /**
     * Get the integer value currently selected in the spinner.
     *
     * @return spinner integer value (0..4)
     */
    public int getValue() {
        // If the user is mid-edit in the spinner's text field, try to commit the edit
        try {
            java.awt.Component ed = spinner.getEditor();
            if (ed instanceof javax.swing.JSpinner.DefaultEditor editorComp) {
                javax.swing.JFormattedTextField tf = editorComp.getTextField();
                try { tf.commitEdit(); } catch (java.text.ParseException pe) { LOG.trace("Spinner editor parse error", pe); }
            }
    } catch (IllegalArgumentException | IllegalStateException re) { LOG.trace("Unexpected error committing spinner edit", re); }
        return (Integer) spinner.getValue();
    }

    /**
     * Set the spinner value clamped to the valid range (0..4).
     *
     * @param v desired spinner value
     */
    public void setValue(final int v) { spinner.setValue(Math.max(0, Math.min(4, v))); }

    @Override
    /**
     * Set the Swing component name for this field and propagate the same name
     * to the internal spinner so automated UI tests and accessibility tools
     * can locate both elements reliably.
     *
     * @param name component name to set for this row and its spinner
     */

    public void setName(final String name) {
        super.setName(name);
        spinner.setName(name);
    }

    // Diagnostics: expose spinner X and label wrap width (useful to verify layout)
    /**
     * Get the X coordinate of the spinner inside this component (pixels).
     *
     * @return spinner X position in pixels
     */
    public int getSpinnerX() { return spinner.getLocation().x; }

    /**
     * Return the configured label wrap container's current width in pixels.
     *
     * @return label wrap width in pixels
     */
    public int getLabelWrapWidth() { return labelWrap.getWidth(); }

    /**
     * Actual horizontal gap in pixels between the label wrap right edge and the spinner left edge.
     *
     * @return pixel gap between label and spinner
     */
    public int getActualGap() {
        int labelRight = labelWrap.getX() + labelWrap.getWidth();
        return spinner.getX() - labelRight;
    }
}