import { createModuleLogger } from "../log_system/log_funcs.js";
import { inlineSvgIcons } from "../utils/icon_utils.js";
import { performanceDiagnostics } from "../utils/performance_diagnostics.js";

const log = createModuleLogger('resolution_master_interaction_methods');
const DRAG_ZOOM_BYPASS_PATCH_FLAG = '__resolutionMasterDragZoomBypassInstalled';
const DRAG_ZOOM_CAPTURE_PATCH_FLAG = '__resolutionMasterDragZoomCaptureInstalled';
const ORIGINAL_MOUSE_MODIFIERS_PROP = '__resolutionMasterOriginalMouseModifiers';
const BYPASSED_DRAG_ZOOM_EVENT_PROP = '__resolutionMasterBypassedDragZoom';
const HELP_DIALOG_SCALE = 0.7;

function getMouseModifiers(e) {
    return {
        ctrlKey: e?.[ORIGINAL_MOUSE_MODIFIERS_PROP]?.ctrlKey ?? !!e?.ctrlKey,
        shiftKey: e?.[ORIGINAL_MOUSE_MODIFIERS_PROP]?.shiftKey ?? !!e?.shiftKey,
        altKey: e?.[ORIGINAL_MOUSE_MODIFIERS_PROP]?.altKey ?? !!e?.altKey,
        metaKey: e?.[ORIGINAL_MOUSE_MODIFIERS_PROP]?.metaKey ?? !!e?.metaKey
    };
}

function isCtrlPrimaryMouseDown(e) {
    const modifiers = getMouseModifiers(e);
    return e?.button === 0 && modifiers.ctrlKey && !modifiers.altKey;
}

function getNodeUnderPointer(canvas, e) {
    if (typeof e.canvasX !== "number" || typeof e.canvasY !== "number") {
        canvas.adjustMouseEvent?.(e);
    }
    const nodes = canvas.visible_nodes?.length ? canvas.visible_nodes : canvas.graph?._nodes;
    return canvas.graph?.getNodeOnPos?.(e.canvasX, e.canvasY, nodes) || null;
}

function isOverResolutionMasterCanvas(canvas, e) {
    try {
        const node = getNodeUnderPointer(canvas, e);
        const rm = node?.resolutionMaster;
        if (!rm || node.flags?.collapsed || node.properties?.mode !== "Manual") {
            return false;
        }

        const relX = e.canvasX - node.pos[0];
        const relY = e.canvasY - node.pos[1];
        return [
            rm.controls?.canvas2d,
            rm.controls?.canvas2dRightHandle,
            rm.controls?.canvas2dTopHandle
        ].some(control => control && rm.isPointInControl(relX, relY, control));
    } catch (error) {
        log.debug('Could not test ResolutionMaster canvas shortcut target:', error);
        return false;
    }
}

function getKnownGraphCanvases(app) {
    const canvases = new Set();
    const addCanvas = (graphCanvas) => {
        if (graphCanvas?.canvas) {
            canvases.add(graphCanvas);
        }
    };

    addCanvas(app?.canvas);
    addCanvas(globalThis.LGraphCanvas?.active_canvas);

    const graphs = [
        app?.graph,
        app?.canvas?.graph,
        globalThis.LGraphCanvas?.active_canvas?.graph
    ];
    for (const graph of graphs) {
        graph?.list_of_graphcanvas?.forEach(addCanvas);
    }

    return [...canvases];
}

function isPointInsideElement(element, e) {
    if (!element?.getBoundingClientRect) return false;

    const rect = element.getBoundingClientRect();
    return e.clientX >= rect.left
        && e.clientX <= rect.right
        && e.clientY >= rect.top
        && e.clientY <= rect.bottom;
}

function getGraphCanvasFromMouseEvent(app, e) {
    const path = e.composedPath?.() || [];
    const target = e.target;
    const isNodeTarget = globalThis.Node && target instanceof globalThis.Node;
    const elementAtPoint = globalThis.document?.elementFromPoint?.(e.clientX, e.clientY);

    return getKnownGraphCanvases(app).find((graphCanvas) => {
        const element = graphCanvas.canvas;
        return element === target
            || element === elementAtPoint
            || path.includes(element)
            || (isNodeTarget && element?.contains?.(target))
            || isPointInsideElement(element, e);
    }) || null;
}

function temporarilyDisableDragZoom(canvas) {
    if (!canvas?.dragZoomEnabled) return;

    const previousDragZoomEnabled = canvas.dragZoomEnabled;
    canvas.dragZoomEnabled = false;
    globalThis.setTimeout?.(() => {
        canvas.dragZoomEnabled = previousDragZoomEnabled;
    }, 0);
}

function defineEventValue(e, key, value) {
    try {
        Object.defineProperty(e, key, {
            value,
            configurable: true
        });
        return true;
    } catch {
        return false;
    }
}

function suppressComfyCanvasShortcutModifiers(e) {
    if (!e || e[BYPASSED_DRAG_ZOOM_EVENT_PROP]) return;

    const originalModifiers = getMouseModifiers(e);
    defineEventValue(e, ORIGINAL_MOUSE_MODIFIERS_PROP, originalModifiers);
    defineEventValue(e, BYPASSED_DRAG_ZOOM_EVENT_PROP, true);

    const ctrlSuppressed = defineEventValue(e, 'ctrlKey', false);
    const shiftSuppressed = defineEventValue(e, 'shiftKey', false);
    const originalGetModifierState = typeof e.getModifierState === 'function'
        ? e.getModifierState.bind(e)
        : null;
    if (originalGetModifierState) {
        defineEventValue(e, 'getModifierState', (key) => {
            if (key === 'Control' || key === 'Ctrl' || key === 'Shift') {
                return false;
            }
            return originalGetModifierState(key);
        });
    }

    if (!ctrlSuppressed || !shiftSuppressed) {
        log.debug('Could not suppress canvas shortcut modifier on mouse event', {
            ctrlSuppressed,
            shiftSuppressed
        });
    }
}

export const interactionMethods = {
    installCanvasDragZoomBypass() {
        this.installCanvasDragZoomCaptureBypass();
        this.installProcessMouseDownDragZoomBypass();
    },

    installCanvasDragZoomCaptureBypass() {
        const win = globalThis.window;
        if (!win || win[DRAG_ZOOM_CAPTURE_PATCH_FLAG]) return;

        Object.defineProperty(win, DRAG_ZOOM_CAPTURE_PATCH_FLAG, {
            value: true,
            configurable: false
        });

        const handlePotentialCanvasShortcut = (e) => {
            if (!isCtrlPrimaryMouseDown(e)) return;

            const canvas = getGraphCanvasFromMouseEvent(this.app, e);
            if (!canvas || !isOverResolutionMasterCanvas(canvas, e)) return;

            temporarilyDisableDragZoom(canvas);
            suppressComfyCanvasShortcutModifiers(e);
        };

        win.addEventListener('pointerdown', handlePotentialCanvasShortcut, { capture: true });
        win.addEventListener('mousedown', handlePotentialCanvasShortcut, { capture: true });

        log.debug('Installed ResolutionMaster early canvas drag-zoom bypass');
    },

    installProcessMouseDownDragZoomBypass() {
        const prototype = globalThis.LGraphCanvas?.prototype;
        if (!prototype || prototype[DRAG_ZOOM_BYPASS_PATCH_FLAG]) return;

        const originalProcessMouseDown = prototype.processMouseDown;
        if (typeof originalProcessMouseDown !== "function") return;

        Object.defineProperty(prototype, DRAG_ZOOM_BYPASS_PATCH_FLAG, {
            value: true,
            configurable: false
        });

        prototype.processMouseDown = function(e) {
            if (this.dragZoomEnabled && isCtrlPrimaryMouseDown(e) && isOverResolutionMasterCanvas(this, e)) {
                const previousDragZoomEnabled = this.dragZoomEnabled;
                this.dragZoomEnabled = false;
                try {
                    return originalProcessMouseDown.apply(this, arguments);
                } finally {
                    this.dragZoomEnabled = previousDragZoomEnabled;
                }
            }

            return originalProcessMouseDown.apply(this, arguments);
        };

        log.debug('Installed ResolutionMaster canvas drag-zoom bypass');
    },

    getCanvasPointer(canvas) {
        return canvas?.pointer
            || this._capturedPointerCanvas?.pointer
            || this.node?.graph?.list_of_graphcanvas?.find((graphCanvas) => graphCanvas?.pointer)?.pointer
            || this.node?.graph?.canvas?.pointer
            || this.app?.canvas?.pointer
            || globalThis.LGraphCanvas?.active_canvas?.pointer
            || null;
    },

    scheduleCanvasPointerDrag(eMove, activeCanvas) {
        this._pendingCanvasPointerDragEvent = eMove;
        this._pendingCanvasPointerDragCanvas = activeCanvas;
        if (this._pendingCanvasPointerDragFrame !== null) return;

        const runPendingDrag = () => {
            this._pendingCanvasPointerDragFrame = null;
            this._pendingCanvasPointerDragCancel = null;
            const pendingEvent = this._pendingCanvasPointerDragEvent;
            const pendingCanvas = this._pendingCanvasPointerDragCanvas;
            this._pendingCanvasPointerDragEvent = null;
            this._pendingCanvasPointerDragCanvas = null;

            if (!pendingEvent || !this.node?.capture) return;
            this.handleMouseMove(pendingEvent, null, pendingCanvas);
        };

        if (globalThis.requestAnimationFrame) {
            this._pendingCanvasPointerDragFrame = globalThis.requestAnimationFrame(runPendingDrag);
            this._pendingCanvasPointerDragCancel = globalThis.cancelAnimationFrame?.bind(globalThis) || null;
            return;
        }

        if (globalThis.setTimeout) {
            this._pendingCanvasPointerDragFrame = globalThis.setTimeout(runPendingDrag, 16);
            this._pendingCanvasPointerDragCancel = globalThis.clearTimeout?.bind(globalThis) || null;
            return;
        }

        runPendingDrag();
    },

    cancelPendingCanvasPointerDragFrame() {
        if (this._pendingCanvasPointerDragFrame === null) return;
        this._pendingCanvasPointerDragCancel?.(this._pendingCanvasPointerDragFrame);
        this._pendingCanvasPointerDragFrame = null;
        this._pendingCanvasPointerDragCancel = null;
    },

    flushCanvasPointerDrag() {
        const pendingEvent = this._pendingCanvasPointerDragEvent;
        const pendingCanvas = this._pendingCanvasPointerDragCanvas;
        this.cancelPendingCanvasPointerDragFrame();
        this._pendingCanvasPointerDragEvent = null;
        this._pendingCanvasPointerDragCanvas = null;

        if (!pendingEvent || !this.node?.capture) return;
        this.handleMouseMove(pendingEvent, null, pendingCanvas);
    },

    clearCanvasPointerDrag() {
        this.cancelPendingCanvasPointerDragFrame();
        this._pendingCanvasPointerDragEvent = null;
        this._pendingCanvasPointerDragCanvas = null;
    },

    captureNodePointer(canvas) {
        const pointer = this.getCanvasPointer(canvas);
        if (pointer && ("onDrag" in pointer || "finally" in pointer)) {
            const activeCanvas = canvas
                || this._capturedPointerCanvas
                || this.node?.graph?.list_of_graphcanvas?.find((graphCanvas) => graphCanvas?.pointer === pointer)
                || this.node?.graph?.canvas
                || this.app?.canvas
                || globalThis.LGraphCanvas?.active_canvas
                || null;

            pointer.onDrag = (eMove) => {
                this.scheduleCanvasPointerDrag(eMove, activeCanvas);
            };
            pointer.finally = () => {
                this.flushCanvasPointerDrag();
                if (this.node?.capture) {
                    this.handleMouseUp(pointer.eUp || pointer.eMove || pointer.eDown);
                }
                this._usingCanvasPointerCallbacks = false;
                this._capturedPointerCanvas = null;
            };

            this._usingCanvasPointerCallbacks = true;
            this._capturedPointerCanvas = activeCanvas;
            return;
        }

        const legacyCanvas = canvas || this.node?.graph?.list_of_graphcanvas?.[0] || null;
        if (legacyCanvas && "node_capturing_input" in legacyCanvas) {
            legacyCanvas.node_capturing_input = this.node;
            this._capturedPointerCanvas = legacyCanvas;
            return;
        }

        if (!this._loggedLegacyCaptureFallback) {
            this._loggedLegacyCaptureFallback = true;
            log.warn('Canvas pointer API unavailable; falling back to deprecated captureInput', {
                nodeId: this.node?.id ?? null
            });
        }
        this.node.captureInput?.(true);
    },

    releaseNodePointer(canvas) {
        const pointer = this.getCanvasPointer(canvas);
        if (pointer && ("onDrag" in pointer || "finally" in pointer)) {
            this.clearCanvasPointerDrag();
            this._usingCanvasPointerCallbacks = false;
            this._capturedPointerCanvas = null;
            return;
        }

        const legacyCanvas = canvas || this._capturedPointerCanvas || this.node?.graph?.list_of_graphcanvas?.[0] || null;
        if (legacyCanvas?.node_capturing_input === this.node) {
            legacyCanvas.node_capturing_input = null;
            this._capturedPointerCanvas = null;
            return;
        }

        if (!this._loggedLegacyCaptureFallback) {
            this._loggedLegacyCaptureFallback = true;
            log.warn('Canvas pointer API unavailable; falling back to deprecated captureInput', {
                nodeId: this.node?.id ?? null
            });
        }
        this.node.captureInput?.(false);
        this.clearCanvasPointerDrag();
        this._usingCanvasPointerCallbacks = false;
        this._capturedPointerCanvas = null;
    },

    handleMouseDown(e, pos, canvas) {
        const node = this.node;
        const props = node.properties;

        const relX = e.canvasX - node.pos[0];
        const relY = e.canvasY - node.pos[1];

        if (props.mode === "Manual") {
            if (this.controls.canvas2dRightHandle && this.isPointInControl(relX, relY, this.controls.canvas2dRightHandle)) {
                node.capture = 'canvas2dRightHandle';
                this.captureNodePointer(canvas);
                return true;
            }

            if (this.controls.canvas2dTopHandle && this.isPointInControl(relX, relY, this.controls.canvas2dTopHandle)) {
                node.capture = 'canvas2dTopHandle';
                this.captureNodePointer(canvas);
                return true;
            }
            const c2d = this.controls.canvas2d;
            if (c2d && this.isPointInControl(relX, relY, c2d)) {
                node.capture = 'canvas2d';
                this.canvasDragAspectLock = this.createAspectLock();
                this.captureNodePointer(canvas);
                const modifiers = getMouseModifiers(e);
                this.updateCanvasValue(relX - c2d.x, relY - c2d.y, c2d.w, c2d.h, modifiers.shiftKey, modifiers.ctrlKey);
                return true;
            }
        }

        for (const key in this.controls) {
            if (this.isPointInControl(relX, relY, this.controls[key])) {
                log.debug(`Mouse down on control: ${key} at (${relX}, ${relY})`);

                if (key.endsWith('Btn') || key === 'detectedInfo') {
                    this.handleButtonClick(key);
                    return true;
                }
                if (key.endsWith('Slider')) {
                    node.capture = key;
                    this.captureNodePointer(canvas);
                    this.updateSliderValue(key, relX - this.controls[key].x, this.controls[key].w);
                    return true;
                }
                if (key.endsWith('Dropdown')) {
                    this.showDropdownMenu(key, e);
                    return true;
                }
                if (key.endsWith('Toggle')) {
                    this.handleToggleClick(key);
                    return true;
                }
                if (key.endsWith('Checkbox')) {
                    this.handleCheckboxClick(key);
                    return true;
                }
                if (key.endsWith('Radio')) {
                    this.handleRadioClick(key);
                    return true;
                }
                if (key.endsWith('ValueArea')) {
                    log.debug(`Detected ValueArea click: ${key}`);
                    if (key === 'latValueArea') {
                        this.showLatentTypeSelector(e);
                    } else {
                        this.customValueDialogManager.showCustomValueDialog(key, e);
                    }
                    return true;
                }
                if (key.endsWith('Header')) {
                    this.handleSectionHeaderClick(key);
                    return true;
                }
            }
        }

        log.debug(`No control found at (${relX}, ${relY}). Available controls:`, Object.keys(this.controls));

        return false;
    },

    handleMouseMove(e, pos, canvas) {
        const diagnosticsToken = performanceDiagnostics.start("handleMouseMove");
        try {
            const node = this.node;

            if (!node.capture) return false;
            if (this._usingCanvasPointerCallbacks && pos !== null) return true;
            if (e.buttons === 0) {
                this.handleMouseUp(e);
                return true;
            }

            const relX = e.canvasX - node.pos[0];
            const relY = e.canvasY - node.pos[1];

            if (node.capture === 'canvas2d') {
                const c2d = this.controls.canvas2d;
                if (c2d) {
                    this.updateCanvasValue(relX - c2d.x, relY - c2d.y, c2d.w, c2d.h, e.shiftKey, e.ctrlKey);
                }
                return true;
            }

            if (node.capture === 'canvas2dRightHandle') {
                const c2d = this.controls.canvas2d;
                if (c2d) {
                    this.updateCanvasValueWidth(relX - c2d.x, c2d.w, e.ctrlKey);
                }
                return true;
            }

            if (node.capture === 'canvas2dTopHandle') {
                const c2d = this.controls.canvas2d;
                if (c2d) {
                    this.updateCanvasValueHeight(relY - c2d.y, c2d.h, e.ctrlKey);
                }
                return true;
            }

            if (node.capture.endsWith('Slider')) {
                const control = this.controls[node.capture];
                if (control) {
                    this.updateSliderValue(node.capture, relX - control.x, control.w);
                }
                return true;
            }

            return false;
        } finally {
            performanceDiagnostics.end(diagnosticsToken);
        }
    },

    handleMouseHover(e, pos, canvas) {
        const node = this.node;
        const relX = e.canvasX - node.pos[0];
        const relY = e.canvasY - node.pos[1];

        let newHover = null;
        if (this.controls.canvas2dRightHandle && this.isPointInControl(relX, relY, this.controls.canvas2dRightHandle)) {
            newHover = 'canvas2dRightHandle';
        } else if (this.controls.canvas2dTopHandle && this.isPointInControl(relX, relY, this.controls.canvas2dTopHandle)) {
            newHover = 'canvas2dTopHandle';
        } else {
            for (const element in this.controls) {
                if (element !== 'canvas2dRightHandle' && element !== 'canvas2dTopHandle' &&
                    this.isPointInControl(relX, relY, this.controls[element])) {
                    newHover = element;
                    break;
                }
            }
        }
        this.tooltipMousePos = { x: e.canvasX, y: e.canvasY };
        if (newHover !== this.hoverElement) {
            this.hoverElement = newHover;
            this.handleTooltipHover(newHover, e);
            this.app?.graph?.setDirtyCanvas(true);
        }
    },

    handleTooltipHover(element, e) {
        if (this.tooltipTimer) {
            clearTimeout(this.tooltipTimer);
            this.tooltipTimer = null;
        }
        if (this.showTooltip) {
            this.showTooltip = false;
            this.tooltipElement = null;
            this.app?.graph?.setDirtyCanvas(true);
        }
        if (element && this.tooltips[element]) {
            const initialMousePos = { x: e.canvasX, y: e.canvasY };
            this.tooltipTimer = setTimeout(() => {
                this.tooltipElement = element;
                this.showTooltip = true;
                this.tooltipFixedPos = initialMousePos;
                this.app?.graph?.setDirtyCanvas(true);
            }, this.tooltipDelay);
        }
    },

    handleMouseUp(e) {
        const node = this.node;

        if (!node.capture) return false;

        node.capture = false;
        this.canvasDragAspectLock = null;
        this.releaseNodePointer();

        if (this.widthWidget && this.heightWidget) {
            this.widthWidget.value = node.properties.valueX;
            this.heightWidget.value = node.properties.valueY;
        }

        this.updateRescaleValue();
        this.requestCanvasUpdate();

        return true;
    },

    handlePropertyChange(property) {
        const node = this.node;
        if (property?.startsWith('section_') && property.endsWith('_collapsed')) {
            const sectionKey = property.replace(/^section_/, '').replace(/_collapsed$/, '');
            this.collapsedSections[sectionKey] = node.properties[property];
            if (sectionKey === 'extraControls') {
                this.userPreferredHeight = this.getStoredPreferredHeight(this.collapsedSections.extraControls);
                this.applyCompactSlotLabels();
            }
        }
        if (!node.configured) return;

        node.intpos.x = (node.properties.valueX - node.properties.canvas_min_x) /
                       (node.properties.canvas_max_x - node.properties.canvas_min_x);
        node.intpos.y = (node.properties.valueY - node.properties.canvas_min_y) /
                       (node.properties.canvas_max_y - node.properties.canvas_min_y);

        node.intpos.x = Math.max(0, Math.min(1, node.intpos.x));
        node.intpos.y = Math.max(0, Math.min(1, node.intpos.y));

        this.requestCanvasUpdate();
    },

    handleButtonClick(buttonName) {
        const actions = {
            swapBtn: () => this.handleSwap(),
            snapBtn: () => this.handleSnap(),
            scaleBtn: () => this.handleScale(),
            resolutionBtn: () => this.handleResolutionScale(),
            megapixelsBtn: () => this.handleMegapixelsScale(),
            autoFitBtn: () => this.handleAutoFit(),
            autoResizeBtn: () => this.handleAutoResize(),
            autoSnapBtn: () => this.handleSnap(),
            autoCalcBtn: () => this.handleAutoCalc(),
            detectedInfo: () => this.handleDetectedClick(),
            managePresetsBtn: () => this.handleManagePresets(),
            compactHelpBtn: () => this.showHelpDialog()
        };
        actions[buttonName]?.();
    },

    showHelpDialog() {
        this.closeHelpDialog();

        const overlay = document.createElement('div');
        this.helpDialogOverlay = overlay;
        overlay.style.cssText = `
            position: fixed; inset: 0; background: rgba(0,0,0,0.62);
            z-index: 9999; display: flex; align-items: center; justify-content: center;
            padding: 24px; box-sizing: border-box; backdrop-filter: blur(2px);
        `;
        overlay.addEventListener('mousedown', (e) => {
            if (e.target === overlay) this.closeHelpDialog();
        });

        const dialog = document.createElement('div');
        this.helpDialog = dialog;
        dialog.addEventListener('mousedown', (e) => e.stopPropagation());
        dialog.style.cssText = `
            width: min(860px, calc(100vw - 32px)); max-height: calc(100vh - 40px);
            overflow: auto; box-sizing: border-box;
            background: linear-gradient(135deg, rgba(37,37,37,0.98) 0%, rgba(20,20,20,0.98) 100%);
            border: 1px solid rgba(210, 220, 235, 0.28);
            border-radius: 14px; box-shadow: 0 24px 70px rgba(0,0,0,0.82), inset 0 1px 0 rgba(255,255,255,0.05);
            color: #ddd; font-family: Arial, sans-serif; padding: 0;
            transform: scale(${HELP_DIALOG_SCALE}); transform-origin: center center;
        `;

        dialog.innerHTML = `
            <div style="padding:28px 40px 22px;">
                <div style="display:flex; align-items:center; justify-content:space-between; gap:18px; margin-bottom:30px;">
                    <div style="font-size:36px; line-height:1.1; font-weight:800; color:#e9e9e9; letter-spacing:0; text-shadow:0 2px 18px rgba(255,255,255,0.13);">Resolution Master Help</div>
                    <button type="button" data-close aria-label="Close" style="width:50px; height:50px; border-radius:9px; border:1px solid rgba(210,220,235,0.25); background:linear-gradient(180deg, rgba(80,80,80,0.85), rgba(45,45,45,0.9)); color:#eee; cursor:pointer; font-size:28px; line-height:1; box-shadow:inset 0 1px 0 rgba(255,255,255,0.08), 0 8px 18px rgba(0,0,0,0.35);">&times;</button>
                </div>

                <section style="margin-bottom:30px;">
                    <div style="display:grid; grid-template-columns:26px minmax(0, 1fr); align-items:center; column-gap:10px; margin-bottom:14px; color:#d9d9d9;">
                        <span style="display:flex; align-items:center; justify-content:center; width:26px; color:#bfc3c7;">${inlineSvgIcons.keyboard}</span>
                        <div style="font-size:24px; line-height:1.2; font-weight:800; color:#e4e4e4;">2D Canvas Shortcuts</div>
                    </div>
                    <div style="border:1px solid rgba(210,220,235,0.16); border-radius:8px; overflow:hidden; background:rgba(10,10,10,0.17);">
                        <div style="display:grid; grid-template-columns:minmax(0, 1fr) minmax(0, 1.15fr); align-items:center; min-height:60px; border-bottom:1px solid rgba(210,220,235,0.12);">
                            <div style="display:flex; align-items:center; flex-wrap:wrap; gap:8px; min-width:0; padding:10px 24px;">
                                <span style="display:inline-flex; align-items:center; gap:8px; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">${inlineSvgIcons.mouse}<span>Drag</span></span>
                            </div>
                            <div style="padding:10px 22px; color:#e2e2e2; font-size:18px; line-height:1.35; border-left:1px solid rgba(210,220,235,0.08);">Set width and height</div>
                        </div>
                        <div style="display:grid; grid-template-columns:minmax(0, 1fr) minmax(0, 1.15fr); align-items:center; min-height:60px; border-bottom:1px solid rgba(210,220,235,0.12);">
                            <div style="display:flex; align-items:center; flex-wrap:wrap; gap:8px; min-width:0; padding:10px 24px;">
                                <span style="display:inline-flex; align-items:center; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">Shift</span>
                                <span style="color:#f0f0f0; font-weight:700;">+</span>
                                <span style="display:inline-flex; align-items:center; gap:8px; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">${inlineSvgIcons.mouse}<span>Drag</span></span>
                            </div>
                            <div style="padding:10px 22px; color:#e2e2e2; font-size:18px; line-height:1.35; border-left:1px solid rgba(210,220,235,0.08);">Keep aspect ratio</div>
                        </div>
                        <div style="display:grid; grid-template-columns:minmax(0, 1fr) minmax(0, 1.15fr); align-items:center; min-height:60px; border-bottom:1px solid rgba(210,220,235,0.12);">
                            <div style="display:flex; align-items:center; flex-wrap:wrap; gap:8px; min-width:0; padding:10px 24px;">
                                <span style="display:inline-flex; align-items:center; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">Ctrl</span>
                                <span style="color:#f0f0f0; font-weight:700;">+</span>
                                <span style="display:inline-flex; align-items:center; gap:8px; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">${inlineSvgIcons.mouse}<span>Drag</span></span>
                            </div>
                            <div style="padding:10px 22px; color:#e2e2e2; font-size:18px; line-height:1.35; border-left:1px solid rgba(210,220,235,0.08);">Disable canvas snap</div>
                        </div>
                        <div style="display:grid; grid-template-columns:minmax(0, 1fr) minmax(0, 1.15fr); align-items:center; min-height:60px;">
                            <div style="display:flex; align-items:center; flex-wrap:wrap; gap:8px; min-width:0; padding:10px 24px;">
                                <span style="display:inline-flex; align-items:center; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">Ctrl</span>
                                <span style="color:#f0f0f0; font-weight:700;">+</span>
                                <span style="display:inline-flex; align-items:center; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">Shift</span>
                                <span style="color:#f0f0f0; font-weight:700;">+</span>
                                <span style="display:inline-flex; align-items:center; gap:8px; min-height:36px; padding:0 13px; border:1px solid rgba(210,220,235,0.17); border-radius:6px; background:linear-gradient(180deg, rgba(78,78,78,0.78), rgba(40,40,40,0.8)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.08); color:#f0f0f0; font-size:18px; white-space:nowrap;">${inlineSvgIcons.mouse}<span>Drag</span></span>
                            </div>
                            <div style="padding:10px 22px; color:#e2e2e2; font-size:18px; line-height:1.35; border-left:1px solid rgba(210,220,235,0.08);">Keep aspect ratio with canvas snap disabled</div>
                        </div>
                    </div>
                </section>

                <section>
                    <div style="display:grid; grid-template-columns:26px minmax(0, 1fr); align-items:center; column-gap:10px; color:#d9d9d9;">
                        <span style="display:flex; align-items:center; justify-content:center; width:26px; color:#bfc3c7;">${inlineSvgIcons.tip}</span>
                        <div style="font-size:24px; line-height:1.2; font-weight:800; color:#e4e4e4;">Tip</div>
                    </div>
                    <div style="margin:13px 0 0 36px; color:#b9b9b9; font-size:18px; line-height:1.45;">Click most numeric values to enter a custom value.</div>
                </section>
            </div>
            <div style="display:flex; align-items:center; justify-content:space-between; gap:18px; flex-wrap:wrap; padding:20px 40px 24px; border-top:1px solid rgba(210,220,235,0.18); background:rgba(255,255,255,0.02);">
                <div style="display:flex; align-items:center; gap:14px; min-width:0; color:#bdbdbd; font-size:18px; line-height:1.4;">
                    <span style="display:inline-flex; align-items:center; justify-content:center; width:40px; height:40px; border-radius:50%; color:#f2cc60; background:rgba(242,204,96,0.14); border:1px solid rgba(242,204,96,0.42); box-shadow:0 0 20px rgba(242,204,96,0.12);">${inlineSvgIcons.star}</span>
                    <span>If this node helps you, please consider <span style="color:#f2cc60; font-weight:700;">starring</span> the repository.</span>
                </div>
                <a href="https://github.com/Azornes/Comfyui-Resolution-Master" target="_blank" rel="noopener noreferrer" style="display:inline-flex; align-items:center; justify-content:center; gap:10px; min-height:44px; padding:0 18px; border:1px solid rgba(210,220,235,0.18); border-radius:7px; color:#f2f2f2; background:linear-gradient(180deg, rgba(48,48,48,0.72), rgba(26,26,26,0.88)); box-shadow:inset 0 1px 0 rgba(255,255,255,0.06), 0 6px 16px rgba(0,0,0,0.25); text-decoration:none; font-size:18px; white-space:nowrap;">
                    <span style="color:#f2f2f2;">${inlineSvgIcons.github}</span>
                    <span>Go to GitHub</span>
                </a>
            </div>
        `;

        dialog.querySelector('[data-close]')?.addEventListener('click', () => this.closeHelpDialog());
        overlay.appendChild(dialog);
        document.body.appendChild(overlay);
    },

    closeHelpDialog() {
        if (this.helpDialogOverlay?.parentNode) {
            this.helpDialogOverlay.parentNode.removeChild(this.helpDialogOverlay);
        }
        this.helpDialogOverlay = null;
        this.helpDialog = null;
    },

    handleToggleClick(toggleName) {
        const props = this.node.properties;
        if (toggleName === 'autoDetectToggle') {
            props.autoDetect = !props.autoDetect;
            this.setAutoDetectSource('backend');
            if (props.autoDetect) this.startAutoDetect();
            else this.stopAutoDetect();
            const widget = this.node.widgets?.find(w => w.name === 'auto_detect');
            if (widget) widget.value = props.autoDetect;
            this.syncBackendFallbackWidgets();
            this.app?.graph?.setDirtyCanvas(true);
        } else if (toggleName === 'smartFitToggle' && props.selectedCategory) {
            props.smartFit = !props.smartFit;
            this.syncBackendFallbackWidgets();
            this.app?.graph?.setDirtyCanvas(true);
        } else if (toggleName === 'calcInfoToggle' && props.selectedCategory) {
            props.showCalcInfo = !props.showCalcInfo;
            this.app?.graph?.setDirtyCanvas(true);
        }
    },

    handleCheckboxClick(checkboxName) {
        const props = this.node.properties;
        if (checkboxName === 'autoFitCheckbox' && props.selectedCategory) {
            props.autoFitOnChange = !props.autoFitOnChange;
        } else if (checkboxName === 'autoResizeCheckbox') {
            props.autoResizeOnChange = !props.autoResizeOnChange;
        } else if (checkboxName === 'autoSnapCheckbox') {
            props.autoSnapOnChange = !props.autoSnapOnChange;
        } else if (checkboxName === 'customCalcCheckbox') {
            props.useCustomCalc = !props.useCustomCalc;
        } else if (checkboxName === 'preserveScalingRatioCheckbox') {
            props.preserveScalingRatio = !props.preserveScalingRatio;
        }
        this.syncBackendFallbackWidgets();
        this.updateRescaleValue();
        this.app?.graph?.setDirtyCanvas(true);
    },

    handleRadioClick(radioName) {
        const props = this.node.properties;
        const radioMap = {
            upscaleRadio: 'manual',
            resolutionRadio: 'resolution',
            megapixelsRadio: 'megapixels'
        };
        props.rescaleMode = radioMap[radioName];
        this.updateRescaleValue();
        this.app?.graph?.setDirtyCanvas(true);
    },

    handleSectionHeaderClick(headerKey) {
        const sectionKey = headerKey.replace('Header', '');
        if (sectionKey === 'extraControls') {
            this.storePreferredHeight(this.node.size[1], this.collapsedSections.extraControls);
        }
        this.collapsedSections[sectionKey] = !this.collapsedSections[sectionKey];
        const propertyKey = `section_${sectionKey}_collapsed`;
        this.node.properties[propertyKey] = this.collapsedSections[sectionKey];
        if (sectionKey === 'extraControls') {
            this.userPreferredHeight = this.getStoredPreferredHeight(this.collapsedSections.extraControls);
            this.applyCompactSlotLabels();
        }
        this.app?.graph?.setDirtyCanvas(true, true);

        log.debug(`Section ${sectionKey} ${this.collapsedSections[sectionKey] ? 'collapsed' : 'expanded'}`);
    },

    updateSliderValue(sliderName, x, w) {
        const props = this.node.properties;
        let value = Math.max(0, Math.min(1, x / w));

        const sliderConfig = {
            snapSlider: { prop: 'snapValue', min: props.action_slider_snap_min, max: props.action_slider_snap_max, step: props.action_slider_snap_step },
            scaleSlider: { prop: 'upscaleValue', min: props.scaling_slider_min, max: props.scaling_slider_max, step: props.scaling_slider_step, updateOn: 'manual' },
            megapixelsSlider: { prop: 'targetMegapixels', min: props.megapixels_slider_min, max: props.megapixels_slider_max, step: props.megapixels_slider_step, updateOn: 'megapixels' },
            widthSlider: { prop: 'valueX', min: props.manual_slider_min_w, max: props.manual_slider_max_w, step: props.manual_slider_step_w },
            heightSlider: { prop: 'valueY', min: props.manual_slider_min_h, max: props.manual_slider_max_h, step: props.manual_slider_step_h }
        };

        const config = sliderConfig[sliderName];
        if (config) {
            let newValue = config.min + value * (config.max - config.min);
            props[config.prop] = Math.round(newValue / config.step) * config.step;

            if (sliderName === 'scaleSlider' || sliderName === 'megapixelsSlider') {
                 props[config.prop] = parseFloat(props[config.prop].toFixed(1));
            }

            if (config.updateOn) {
                this.updateRescaleValue();
            }

            if (sliderName === 'widthSlider') {
                this.setDimensions(props.valueX, this.heightWidget.value);
            } else if (sliderName === 'heightSlider') {
                this.setDimensions(this.widthWidget.value, props.valueY);
            } else if (sliderName.includes('Slider')) {
                this.handlePropertyChange();
            }
        }

        this.app?.graph?.setDirtyCanvas(true);
    },

    showPresetSelector(e, mode) {
        const props = this.node.properties;
        const allPresets = this.getAllPresets();
        const presets = allPresets[props.selectedCategory];
        if (!presets) return;

        const commonCallback = (presetName) => {
            this.applyPreset(props.selectedCategory, presetName);
        };

        const commonModeChange = (newMode) => {
            props.preset_selector_mode = newMode;
            this.showPresetSelector(e, newMode);
        };

        if (mode === 'list') {
            const presetItems = Object.entries(presets)
                .filter(([name, dims]) => !dims.isHidden)
                .map(([name, dims]) => {
                    const isCustom = this.customPresetsManager.isCustomPreset(props.selectedCategory, name);
                    return {
                        text: `${name} (${dims.width}\u00d7${dims.height})`,
                        isCustom: isCustom
                    };
                });

            this.searchableDropdown.show(presetItems, {
                event: e,
                title: 'Select Preset',
                currentMode: 'list',
                initialExpanded: props.dropdown_preset_expanded || false,
                onExpandedChange: (isExpanded) => {
                    props.dropdown_preset_expanded = isExpanded;
                },
                callback: (selectedItem) => {
                    const presetName = selectedItem.replace(/\s*\([^)]*\)$/, '');
                    commonCallback(presetName);
                },
                onModeChange: () => commonModeChange('visual')
            });
        } else {
            this.aspectRatioSelector.show(presets, {
                event: e,
                selectedPreset: props.selectedPreset,
                currentMode: 'visual',
                callback: commonCallback,
                onModeChange: () => commonModeChange('list')
            });
        }
    },

    showLatentTypeSelector(e) {
        if (!this.latentTypeWidget) {
            log.debug("Latent type selector: latent_type widget not found");
            return;
        }

        const currentValue = this.latentTypeWidget.value || 'latent_4x8';

        const latentTypes = [
            { text: '4x8 (Standard SD/SDXL/Flux)', value: 'latent_4x8' },
            { text: '128x16 (Flux.2)', value: 'latent_128x16' }
        ];

        const items = latentTypes.map(type => ({
            text: type.text,
            value: type.value,
            isCustom: type.value === currentValue
        }));

        this.searchableDropdown.show(items, {
            event: e,
            title: 'Select Latent Type',
            callback: (selectedText) => {
                const selectedType = latentTypes.find(t => t.text === selectedText);
                if (selectedType && this.latentTypeWidget) {
                    this.latentTypeWidget.value = selectedType.value;
                    log.debug(`Latent type manually changed to: ${selectedType.value}`);
                    this.app?.graph?.setDirtyCanvas(true);
                }
            }
        });
    },

    showDropdownMenu(dropdownName, e) {
        const props = this.node.properties;
        let items, callback, title, propertyKey;

        if (dropdownName === 'categoryDropdown') {
            const allPresets = this.getAllPresets();
            items = Object.keys(allPresets)
                .filter(categoryName => {
                    const categoryPresets = allPresets[categoryName];
                    const hasVisiblePresets = Object.values(categoryPresets).some(preset => !preset.isHidden);

                    return hasVisiblePresets;
                })
                .map(categoryName => {
                    const isCustomCategory = this.customPresetsManager.categoryExists(categoryName);
                    return {
                        text: categoryName,
                        isCustom: isCustomCategory
                    };
                });

            title = 'Select Category';
            propertyKey = 'dropdown_category_expanded';
            callback = (value) => {
                props.selectedCategory = value;
                props.selectedPreset = null;
                this.syncBackendFallbackWidgets();
                this.updateRescaleValue();
                this.app?.graph?.setDirtyCanvas(true);
            };
        } else if (dropdownName === 'presetDropdown' && props.selectedCategory) {
            const selectorMode = props.preset_selector_mode || 'visual';
            this.showPresetSelector(e, selectorMode);
            return;
        } else if (dropdownName === 'resolutionDropdown') {
            items = this.resolutions;
            title = 'Select Resolution';
            propertyKey = 'dropdown_resolution_expanded';
            callback = (value) => {
                let resolutionValue = value.trim();
                if (!resolutionValue.endsWith('p')) {
                    resolutionValue = resolutionValue + 'p';
                }
                props.targetResolution = parseInt(resolutionValue);
                this.updateRescaleValue();
                this.app?.graph?.setDirtyCanvas(true);
            };
        }

        if (items?.length && propertyKey) {
            this.searchableDropdown.show(items, {
                event: e,
                callback,
                title,
                allowCustomValues: dropdownName === 'resolutionDropdown',
                initialExpanded: props[propertyKey] || false,
                onExpandedChange: (isExpanded) => {
                    props[propertyKey] = isExpanded;
                }
            });
        }
    },

    handleSwap() {
        if (!this.validateWidgets()) return;

        const newWidth = this.heightWidget.value;
        const newHeight = this.widthWidget.value;
        this.setDimensions(newWidth, newHeight);
    },

    handleDetectedClick() {
        if (!this.detectedDimensions) {
            log.debug("Detected click: No detected dimensions available");
            return;
        }

        if (!this.widthWidget || !this.heightWidget) {
            log.debug("Detected click: Width or height widget not found");
            return;
        }
        this.setDimensions(this.detectedDimensions.width, this.detectedDimensions.height);

        log.debug(`Detected click applied: Set dimensions to ${this.detectedDimensions.width}x${this.detectedDimensions.height}`);
    },

    handleManagePresets() {
        log.debug("Manage Presets button clicked - opening dialog");
        this.presetManagerDialog.show();
    }
};