// The MIT License (MIT)
//
// Copyright (C) 2026 Scott Duensing
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

// ideDesigner.c -- DVX BASIC form designer implementation
//
// WYSIWYG design surface using real DVX widgets positioned
// identically to how the form runtime lays them out. Selection
// handles and grid dots are drawn in the window's onPaint callback.

#include "ideDesigner.h"
#include "../formrt/formrt.h"
#include "../formrt/frmParser.h"
#include "dvxDraw.h"
#include "dvxVideo.h"
#include "dvxWm.h"
#include "stb_ds_wrap.h"

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

// ============================================================
// Constants
// ============================================================

#define DEFAULT_FORM_W   400
#define DEFAULT_FORM_H   300
#define DEFAULT_CTRL_W   100
#define DEFAULT_CTRL_H   30
#define MIN_CTRL_SIZE    8


// ============================================================
// Default event for the Form type (not a widget, so not in iface)
// ============================================================

static const char *FORM_DEFAULT_EVENT = "Load";

// ============================================================
// Prototypes
// ============================================================

// dsgnCreateDesignWidget is declared in ideDesigner.h (non-static)
static void         dsgnLoad_onCtrlBegin(void *userData, const char *typeName, const char *name);
static void         dsgnLoad_onCtrlEnd(void *userData);
static void         dsgnLoad_onCtrlProp(void *userData, const char *key, const char *value);
static bool         dsgnLoad_onFormBegin(void *userData, const char *name);
static void         dsgnLoad_onFormEnd(void *userData, const char *trailingSrc, int32_t trailingLen);
static void         dsgnLoad_onFormProp(void *userData, const char *key, const char *value);
static void         dsgnLoad_onMenuBegin(void *userData, const char *name, int32_t level);
static void         dsgnLoad_onMenuEnd(void *userData);
static void         dsgnLoad_onMenuProp(void *userData, const char *key, const char *value);
static const char  *getPropValue(const DsgnControlT *ctrl, const char *name);
static int32_t      hitTestControl(const DsgnStateT *ds, int32_t x, int32_t y);
static DsgnHandleE  hitTestHandles(const DsgnControlT *ctrl, int32_t x, int32_t y);
static void         rebuildWidgets(DsgnStateT *ds);
static int32_t      saveControls(const DsgnFormT *form, char *buf, int32_t bufSize, int32_t pos, const char *parentName, int32_t indent);
static void         setPropValue(DsgnControlT *ctrl, const char *name, const char *value);
static void         syncWidgetGeom(DsgnControlT *ctrl);


// ============================================================
// .frm parsing context (used by dsgnLoad_* callbacks)
// ============================================================

typedef struct {
    DsgnFormT     *form;
    DsgnControlT  *current;
    int32_t        curMenuItemIdx;
    char           parentStack[8][DSGN_MAX_NAME];
    int32_t        nestDepth;
    bool           containerStack[BAS_MAX_FRM_NESTING];
    int32_t        containerDepth;
} DsgnFrmLoadCtxT;


void dsgnAutoName(const DsgnStateT *ds, const char *typeName, char *buf, int32_t bufSize) {
    // Look up the name prefix from the widget interface descriptor.
    // Falls back to the type name itself if no prefix is registered.
    const char *prefix  = typeName;
    const char *wgtName = wgtFindByBasName(typeName);

    if (wgtName) {
        const WgtIfaceT *iface = wgtGetIface(wgtName);

        if (iface && iface->namePrefix) {
            prefix = iface->namePrefix;
        }
    }

    int32_t highest   = 0;
    int32_t prefixLen = (int32_t)strlen(prefix);
    int32_t count     = ds->form ? (int32_t)arrlen(ds->form->controls) : 0;

    for (int32_t i = 0; i < count; i++) {
        if (strncasecmp(ds->form->controls[i]->name, prefix, prefixLen) == 0) {
            int32_t num = atoi(ds->form->controls[i]->name + prefixLen);

            if (num > highest) {
                highest = num;
            }
        }
    }

    snprintf(buf, bufSize, "%s%d", prefix, (int)(highest + 1));
}


void dsgnBuildPreviewMenuBar(WindowT *win, const DsgnFormT *form) {
    if (!win || !form) {
        return;
    }

    int32_t menuCount = (int32_t)arrlen(form->menuItems);

    if (menuCount <= 0) {
        return;
    }

    MenuBarT *bar = wmAddMenuBar(win);

    if (!bar) {
        return;
    }

    MenuT *menuStack[8];
    memset(menuStack, 0, sizeof(menuStack));

    for (int32_t i = 0; i < menuCount; i++) {
        const DsgnMenuItemT *mi = &form->menuItems[i];
        bool isSep      = (mi->caption[0] == '-');
        bool isSubParent = (i + 1 < menuCount && form->menuItems[i + 1].level > mi->level);

        if (mi->level == 0) {
            menuStack[0] = wmAddMenu(bar, mi->caption);
        } else if (isSep && mi->level > 0 && mi->level < 8 && menuStack[mi->level - 1]) {
            wmAddMenuSeparator(menuStack[mi->level - 1]);
        } else if (isSubParent && mi->level > 0 && mi->level < 8 && menuStack[mi->level - 1]) {
            menuStack[mi->level] = wmAddSubMenu(menuStack[mi->level - 1], mi->caption);
        } else if (mi->level > 0 && mi->level < 8 && menuStack[mi->level - 1]) {
            int32_t id = DSGN_MENU_ID_BASE + i;

            if (mi->radioCheck) {
                wmAddMenuRadioItem(menuStack[mi->level - 1], mi->caption, id, mi->checked);
            } else if (mi->checked) {
                wmAddMenuCheckItem(menuStack[mi->level - 1], mi->caption, id, true);
            } else {
                wmAddMenuItem(menuStack[mi->level - 1], mi->caption, id);
            }
        }
    }
}


// dsgnCreateFormWindow / dsgnCreateContentBox
// Thin wrappers around formrt functions for backward compatibility.
WidgetT *dsgnCreateContentBox(WidgetT *root, const char *layout) {
    return basFormRtCreateContentBox(root, layout);
}


// Create a real DVX widget for design-time display.  Uses the shared
// createWidgetByIface switch from formrt; design-time refuses
// WGT_CREATE_PARENT_DATA widgets (Image/ImageButton) since we have no
// pixel data.
WidgetT *dsgnCreateDesignWidget(const char *vbTypeName, WidgetT *parent) {
    const char *wgtName = resolveTypeName(vbTypeName);

    if (!wgtName) {
        return NULL;
    }

    const void *api = wgtGetApi(wgtName);

    if (!api) {
        return NULL;
    }

    return createWidgetByIface(wgtGetIface(wgtName), api, parent, false);
}


WindowT *dsgnCreateFormWindow(AppContextT *ctx, const char *title, const char *layout, bool resizable, bool centered, bool autoSize, int32_t width, int32_t height, int32_t left, int32_t top, WidgetT **outRoot, WidgetT **outContentBox) {
    return basFormRtCreateFormWindow(ctx, title, layout, resizable, centered, autoSize, width, height, left, top, outRoot, outContentBox);
}


void dsgnCreateWidgets(DsgnStateT *ds, WidgetT *contentBox) {
    if (!ds->form || !contentBox) {
        return;
    }

    ds->form->contentBox = contentBox;
    int32_t count = (int32_t)arrlen(ds->form->controls);

    // Two passes: first create all controls (so containers exist),
    // then parent children inside their containers.
    // Pass 1: create all widgets as top-level children
    for (int32_t i = 0; i < count; i++) {
        DsgnControlT *ctrl = ds->form->controls[i];

        if (ctrl->widget) {
            continue;
        }

        // Find the parent widget. For containers with a non-VBox Layout
        // property, create a content box inside so children use the
        // correct layout direction.
        WidgetT *parent = contentBox;

        if (ctrl->parentName[0]) {
            for (int32_t j = 0; j < count; j++) {
                if (j != i && ds->form->controls[j]->widget &&
                    strcasecmp(ds->form->controls[j]->name, ctrl->parentName) == 0) {
                    DsgnControlT *pc = ds->form->controls[j];
                    parent = pc->widget;
                    const char *layout = getPropValue(pc, "Layout");

                    if (layout && layout[0] && strcasecmp(layout, "VBox") != 0) {
                        // Check if we already created a content box inside
                        if (!parent->firstChild || !parent->firstChild->userData ||
                            parent->firstChild->userData != (void *)pc) {
                            WidgetT *box = dsgnCreateContentBox(parent, layout);
                            box->userData = (void *)pc;
                        }

                        parent = parent->firstChild;
                    }

                    break;
                }
            }
        }

        WidgetT *w = dsgnCreateDesignWidget(ctrl->typeName, parent);

        if (!w) {
            continue;
        }

        ctrl->widget = w;
        wgtSetName(w, ctrl->name);

        // Set Caption/Text
        const char *caption = getPropValue(ctrl, "Caption");
        const char *text    = getPropValue(ctrl, "Text");

        if (caption) { wgtSetText(w, caption); }
        if (text)    { wgtSetText(w, text); }

        // Set size hints for the layout engine.
        // minW/minH set the floor; maxW/maxH cap the size.
        if (ctrl->width > 0) {
            w->minW = wgtPixels(ctrl->width);
        }

        if (ctrl->height > 0) {
            w->minH = wgtPixels(ctrl->height);
        }

        if (ctrl->maxWidth > 0) {
            w->maxW = wgtPixels(ctrl->maxWidth);
        }

        if (ctrl->maxHeight > 0) {
            w->maxH = wgtPixels(ctrl->maxHeight);
        }

        w->weight = ctrl->weight;

        // Apply interface properties (Alignment, etc.) from FRM data
        const char *wgtName = wgtFindByBasName(ctrl->typeName);
        const WgtIfaceT *iface = wgtName ? wgtGetIface(wgtName) : NULL;

        if (iface) {
            for (int32_t pi = 0; pi < iface->propCount; pi++) {
                const WgtPropDescT *p = &iface->props[pi];

                if (!p->setFn) {
                    continue;
                }

                const char *val = getPropValue(ctrl, p->name);

                if (val) {
                    wgtApplyPropFromString(w, p, val);
                }
            }
        }
    }
}


const char *dsgnDefaultEvent(const char *typeName) {
    if (strcasecmp(typeName, "Form") == 0) {
        return FORM_DEFAULT_EVENT;
    }

    const char *wgtName = wgtFindByBasName(typeName);

    if (wgtName) {
        const WgtIfaceT *iface = wgtGetIface(wgtName);

        if (iface && iface->defaultEvent) {
            return iface->defaultEvent;
        }
    }

    return "Click";
}


void dsgnFree(DsgnStateT *ds) {
    if (ds->form) {
        for (int32_t i = 0; i < arrlen(ds->form->controls); i++) {
            free(ds->form->controls[i]);
        }
        arrfree(ds->form->controls);
        arrfree(ds->form->menuItems);
        free(ds->form->code);
        free(ds->form);
        ds->form = NULL;
    }
}


void dsgnInit(DsgnStateT *ds, AppContextT *ctx) {
    memset(ds, 0, sizeof(*ds));
    ds->selectedIdx     = -1;
    ds->activeTool[0]   = '\0';
    ds->mode            = DSGN_IDLE;
    ds->activeHandle = HANDLE_NONE;
    ds->ctx          = ctx;
}


bool dsgnIsContainer(const char *typeName) {
    const char *wgtName = wgtFindByBasName(typeName);

    if (wgtName) {
        const WgtIfaceT *iface = wgtGetIface(wgtName);

        if (iface) {
            return iface->isContainer;
        }
    }

    return false;
}


bool dsgnLoadFrm(DsgnStateT *ds, const char *source, int32_t sourceLen) {
    if (!source || sourceLen <= 0) {
        return false;
    }

    dsgnFree(ds);

    DsgnFormT *form = (DsgnFormT *)calloc(1, sizeof(DsgnFormT));

    if (!form) {
        return false;
    }

    form->controls  = NULL;
    form->width     = DEFAULT_FORM_W;
    form->height    = DEFAULT_FORM_H;
    form->left      = 0;
    form->top       = 0;
    snprintf(form->layout, DSGN_MAX_NAME, "VBox");
    form->centered  = true;
    form->autoSize  = true;
    form->resizable = true;
    snprintf(form->name, DSGN_MAX_NAME, "Form1");
    snprintf(form->caption, DSGN_MAX_TEXT, "Form1");

    DsgnFrmLoadCtxT ctx;
    memset(&ctx, 0, sizeof(ctx));
    ctx.form           = form;
    ctx.curMenuItemIdx = -1;

    FrmParserCbsT cbs;
    memset(&cbs, 0, sizeof(cbs));
    cbs.userData    = &ctx;
    cbs.onFormBegin = dsgnLoad_onFormBegin;
    cbs.onFormProp  = dsgnLoad_onFormProp;
    cbs.onFormEnd   = dsgnLoad_onFormEnd;
    cbs.onMenuBegin = dsgnLoad_onMenuBegin;
    cbs.onMenuEnd   = dsgnLoad_onMenuEnd;
    cbs.onMenuProp  = dsgnLoad_onMenuProp;
    cbs.onCtrlBegin = dsgnLoad_onCtrlBegin;
    cbs.onCtrlEnd   = dsgnLoad_onCtrlEnd;
    cbs.onCtrlProp  = dsgnLoad_onCtrlProp;

    if (!frmParse(source, sourceLen, &cbs)) {
        free(form);
        return false;
    }

    ds->form        = form;
    ds->selectedIdx = -1;
    return true;
}


static void dsgnLoad_onCtrlBegin(void *userData, const char *typeName, const char *name) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (!ctx->form) {
        return;
    }

    DsgnControlT *cp = (DsgnControlT *)calloc(1, sizeof(DsgnControlT));

    if (!cp) {
        if (ctx->containerDepth < BAS_MAX_FRM_NESTING) {
            ctx->containerStack[ctx->containerDepth++] = false;
        }
        return;
    }

    cp->index = -1;
    snprintf(cp->name, DSGN_MAX_NAME, "%s", name);
    snprintf(cp->typeName, DSGN_MAX_NAME, "%s", typeName);

    if (ctx->nestDepth > 0) {
        snprintf(cp->parentName, DSGN_MAX_NAME, "%s", ctx->parentStack[ctx->nestDepth - 1]);
    }

    cp->width  = DEFAULT_CTRL_W;
    cp->height = DEFAULT_CTRL_H;
    arrput(ctx->form->controls, cp);
    ctx->current = ctx->form->controls[arrlen(ctx->form->controls) - 1];

    bool isCtrl = dsgnIsContainer(typeName);

    if (ctx->containerDepth < BAS_MAX_FRM_NESTING) {
        ctx->containerStack[ctx->containerDepth++] = isCtrl;
    }

    if (isCtrl && ctx->nestDepth < 7) {
        snprintf(ctx->parentStack[ctx->nestDepth], DSGN_MAX_NAME, "%s", name);
        ctx->nestDepth++;
    }
}


static void dsgnLoad_onCtrlEnd(void *userData) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (ctx->containerDepth > 0) {
        ctx->containerDepth--;

        if (ctx->containerStack[ctx->containerDepth] && ctx->nestDepth > 0) {
            ctx->nestDepth--;
        }
    }

    ctx->current = NULL;
}


static void dsgnLoad_onCtrlProp(void *userData, const char *key, const char *value) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (!ctx->current) {
        return;
    }

    char val[DSGN_MAX_TEXT];
    snprintf(val, sizeof(val), "%s", value);
    frmStripQuotes(val);

    DsgnControlT *cc = ctx->current;

    if (strcasecmp(key, "Left") == 0) {
        cc->left = atoi(val);
    } else if (strcasecmp(key, "Top") == 0) {
        cc->top = atoi(val);
    } else if (strcasecmp(key, "MinWidth") == 0 || strcasecmp(key, "Width") == 0) {
        cc->width = atoi(val);
    } else if (strcasecmp(key, "MinHeight") == 0 || strcasecmp(key, "Height") == 0) {
        cc->height = atoi(val);
    } else if (strcasecmp(key, "MaxWidth") == 0) {
        cc->maxWidth = atoi(val);
    } else if (strcasecmp(key, "MaxHeight") == 0) {
        cc->maxHeight = atoi(val);
    } else if (strcasecmp(key, "Weight") == 0) {
        cc->weight = atoi(val);
    } else if (strcasecmp(key, "Index") == 0) {
        cc->index = atoi(val);
    } else if (strcasecmp(key, "HelpTopic") == 0) {
        snprintf(cc->helpTopic, DSGN_MAX_NAME, "%s", val);
    } else if (strcasecmp(key, "TabIndex") == 0) {
        // ignored -- DVX has no tab order
    } else {
        setPropValue(cc, key, val);
    }
}


static bool dsgnLoad_onFormBegin(void *userData, const char *name) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (!ctx->form) {
        return false;
    }

    snprintf(ctx->form->name, DSGN_MAX_NAME, "%s", name);
    snprintf(ctx->form->caption, DSGN_MAX_TEXT, "%s", name);
    ctx->current   = NULL;
    ctx->nestDepth = 0;
    return true;
}


static void dsgnLoad_onFormEnd(void *userData, const char *trailingSrc, int32_t trailingLen) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (!ctx->form || trailingLen <= 0) {
        return;
    }

    // Skip leading whitespace/blank lines
    const char *codeStart = trailingSrc;
    const char *codeEnd   = trailingSrc + trailingLen;

    while (codeStart < codeEnd && (*codeStart == '\r' || *codeStart == '\n' || *codeStart == ' ' || *codeStart == '\t')) {
        codeStart++;
    }

    if (codeStart >= codeEnd) {
        return;
    }

    int32_t codeLen = (int32_t)(codeEnd - codeStart);
    ctx->form->code = (char *)malloc(codeLen + 1);

    if (ctx->form->code) {
        memcpy(ctx->form->code, codeStart, codeLen);
        ctx->form->code[codeLen] = '\0';
    }
}


static void dsgnLoad_onFormProp(void *userData, const char *key, const char *value) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (!ctx->form) {
        return;
    }

    char val[DSGN_MAX_TEXT];
    snprintf(val, sizeof(val), "%s", value);
    frmStripQuotes(val);

    DsgnFormT *ff = ctx->form;

    if (strcasecmp(key, "Caption") == 0) {
        snprintf(ff->caption, DSGN_MAX_TEXT, "%s", val);
    } else if (strcasecmp(key, "Layout") == 0) {
        strncpy(ff->layout, val, DSGN_MAX_NAME - 1);
        ff->layout[DSGN_MAX_NAME - 1] = '\0';
    } else if (strcasecmp(key, "AutoSize") == 0) {
        ff->autoSize = frmParseBool(val);
    } else if (strcasecmp(key, "Resizable") == 0) {
        ff->resizable = frmParseBool(val);
    } else if (strcasecmp(key, "Centered") == 0) {
        ff->centered = frmParseBool(val);
    } else if (strcasecmp(key, "Left") == 0) {
        ff->left = atoi(val);
    } else if (strcasecmp(key, "Top") == 0) {
        ff->top = atoi(val);
    } else if (strcasecmp(key, "Width") == 0) {
        ff->width    = atoi(val);
        ff->autoSize = false;
    } else if (strcasecmp(key, "Height") == 0) {
        ff->height   = atoi(val);
        ff->autoSize = false;
    } else if (strcasecmp(key, "HelpTopic") == 0) {
        snprintf(ff->helpTopic, DSGN_MAX_NAME, "%s", val);
    }
}


static void dsgnLoad_onMenuBegin(void *userData, const char *name, int32_t level) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (!ctx->form) {
        return;
    }

    DsgnMenuItemT mi;
    memset(&mi, 0, sizeof(mi));
    snprintf(mi.name, DSGN_MAX_NAME, "%s", name);
    mi.level   = level;
    mi.enabled = true;
    arrput(ctx->form->menuItems, mi);
    ctx->curMenuItemIdx = (int32_t)arrlen(ctx->form->menuItems) - 1;
    ctx->current        = NULL;
}


static void dsgnLoad_onMenuEnd(void *userData) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    ctx->curMenuItemIdx = -1;
}


static void dsgnLoad_onMenuProp(void *userData, const char *key, const char *value) {
    DsgnFrmLoadCtxT *ctx = (DsgnFrmLoadCtxT *)userData;

    if (!ctx->form ||
        ctx->curMenuItemIdx < 0 ||
        ctx->curMenuItemIdx >= (int32_t)arrlen(ctx->form->menuItems)) {
        return;
    }

    // Resolve pointer fresh each write -- arrput on nested menus may
    // have reallocated the array.
    DsgnMenuItemT *mip = &ctx->form->menuItems[ctx->curMenuItemIdx];
    char           val[DSGN_MAX_TEXT];
    snprintf(val, sizeof(val), "%s", value);
    frmStripQuotes(val);

    if (strcasecmp(key, "Caption") == 0) {
        snprintf(mip->caption, DSGN_MAX_TEXT, "%s", val);
    } else if (strcasecmp(key, "Checked") == 0) {
        mip->checked = frmParseBool(val);
    } else if (strcasecmp(key, "RadioCheck") == 0) {
        mip->radioCheck = frmParseBool(val);
    } else if (strcasecmp(key, "Enabled") == 0) {
        mip->enabled = frmParseBool(val);
    }
}


void dsgnNewForm(DsgnStateT *ds, const char *name) {
    dsgnFree(ds);

    DsgnFormT *form = (DsgnFormT *)calloc(1, sizeof(DsgnFormT));
    form->controls  = NULL;
    form->width     = DEFAULT_FORM_W;
    form->height    = DEFAULT_FORM_H;
    form->left      = 0;
    form->top       = 0;
    snprintf(form->layout, DSGN_MAX_NAME, "VBox");
    form->centered  = true;
    form->autoSize  = false;
    form->resizable = true;
    snprintf(form->name, DSGN_MAX_NAME, "%s", name);
    snprintf(form->caption, DSGN_MAX_TEXT, "%s", name);

    ds->form        = form;
    ds->selectedIdx = -1;
}


void dsgnOnKey(DsgnStateT *ds, int32_t key) {
    if (!ds->form) {
        return;
    }

    int32_t count = (int32_t)arrlen(ds->form->controls);

    // Delete key -- remove the selected control and any children
    if (key == 0x153 && ds->selectedIdx >= 0 && ds->selectedIdx < count) {
        const char *delName = ds->form->controls[ds->selectedIdx]->name;

        // Remove children first (controls whose parentName matches)
        for (int32_t i = count - 1; i >= 0; i--) {
            if (i != ds->selectedIdx && strcasecmp(ds->form->controls[i]->parentName, delName) == 0) {
                free(ds->form->controls[i]);
                arrdel(ds->form->controls, i);

                if (i < ds->selectedIdx) {
                    ds->selectedIdx--;
                }
            }
        }

        free(ds->form->controls[ds->selectedIdx]);
        arrdel(ds->form->controls, ds->selectedIdx);
        ds->selectedIdx = -1;
        ds->form->dirty = true;

        rebuildWidgets(ds);
    }
}


void dsgnOnMouse(DsgnStateT *ds, int32_t x, int32_t y, bool drag) {
    if (!ds->form) {
        return;
    }

    int32_t ctrlCount = (int32_t)arrlen(ds->form->controls);

    if (drag) {
        if (ds->mode == DSGN_RESIZING && ds->selectedIdx >= 0 && ds->selectedIdx < ctrlCount) {
            DsgnControlT *ctrl = ds->form->controls[ds->selectedIdx];
            int32_t dx = x - ds->dragStartX;
            int32_t dy = y - ds->dragStartY;

            switch (ds->activeHandle) {
                case HANDLE_E:
                    ctrl->width = ds->dragOrigWidth + dx;
                    break;
                case HANDLE_S:
                    ctrl->height = ds->dragOrigHeight + dy;
                    break;
                case HANDLE_SE:
                    ctrl->width  = ds->dragOrigWidth + dx;
                    ctrl->height = ds->dragOrigHeight + dy;
                    break;
                default:
                    break;
            }

            if (ctrl->width < MIN_CTRL_SIZE)  { ctrl->width = MIN_CTRL_SIZE; }
            if (ctrl->height < MIN_CTRL_SIZE) { ctrl->height = MIN_CTRL_SIZE; }

            syncWidgetGeom(ctrl);
            ds->form->dirty = true;
        } else if (ds->mode == DSGN_REORDERING && ds->selectedIdx >= 0 && ds->selectedIdx < ctrlCount) {
            // Determine if we should swap with a neighbor based on drag direction
            int32_t dy = y - ds->dragStartY;
            DsgnControlT *ctrl = ds->form->controls[ds->selectedIdx];

            if (dy > 0 && ctrl->widget) {
                // Dragging down -- swap with next control if past its midpoint
                if (ds->selectedIdx < ctrlCount - 1) {
                    DsgnControlT *next = ds->form->controls[ds->selectedIdx + 1];

                    if (next->widget && y > next->widget->y + next->widget->h / 2) {
                        DsgnControlT *tmp = ds->form->controls[ds->selectedIdx];
                        ds->form->controls[ds->selectedIdx] = ds->form->controls[ds->selectedIdx + 1];
                        ds->form->controls[ds->selectedIdx + 1] = tmp;
                        rebuildWidgets(ds);
                        ds->selectedIdx++;
                        ds->dragStartY = y;
                        ds->form->dirty = true;
                    }
                }
            } else if (dy < 0 && ctrl->widget) {
                // Dragging up -- swap with previous control if past its midpoint
                if (ds->selectedIdx > 0) {
                    DsgnControlT *prev = ds->form->controls[ds->selectedIdx - 1];

                    if (prev->widget && y < prev->widget->y + prev->widget->h / 2) {
                        DsgnControlT *tmp = ds->form->controls[ds->selectedIdx];
                        ds->form->controls[ds->selectedIdx] = ds->form->controls[ds->selectedIdx - 1];
                        ds->form->controls[ds->selectedIdx - 1] = tmp;
                        rebuildWidgets(ds);
                        ds->selectedIdx--;
                        ds->dragStartY = y;
                        ds->form->dirty = true;
                    }
                }
            }
        }

        return;
    }

    // Mouse click (not drag) -- end any ongoing operation
    if (ds->mode == DSGN_REORDERING || ds->mode == DSGN_RESIZING) {
        ds->mode = DSGN_IDLE;
        return;
    }

    // Pointer tool: select, start resize or reorder
    if (ds->activeTool[0] == '\0') {
        // Check grab handles of selected control first
        if (ds->selectedIdx >= 0 && ds->selectedIdx < ctrlCount) {
            DsgnHandleE handle = hitTestHandles(ds->form->controls[ds->selectedIdx], x, y);

            if (handle != HANDLE_NONE) {
                DsgnControlT *ctrl = ds->form->controls[ds->selectedIdx];
                ds->mode           = DSGN_RESIZING;
                ds->activeHandle   = handle;
                ds->dragStartX     = x;
                ds->dragStartY     = y;
                ds->dragOrigWidth  = ctrl->widget ? ctrl->widget->w : ctrl->width;
                ds->dragOrigHeight = ctrl->widget ? ctrl->widget->h : ctrl->height;
                return;
            }
        }

        // Hit test controls -- click to select, drag to reorder
        int32_t hit = hitTestControl(ds, x, y);

        if (hit >= 0) {
            ds->selectedIdx = hit;
            ds->mode        = DSGN_REORDERING;
            ds->dragStartY  = y;
        } else {
            ds->selectedIdx = -1;
        }

        return;
    }

    // Non-pointer tool: place a new control
    const char *typeName = ds->activeTool;
    DsgnControlT *cp = (DsgnControlT *)calloc(1, sizeof(DsgnControlT));
    cp->index = -1;
    dsgnAutoName(ds, typeName, cp->name, DSGN_MAX_NAME);
    snprintf(cp->typeName, DSGN_MAX_NAME, "%s", typeName);
    cp->width  = DEFAULT_CTRL_W;
    cp->height = DEFAULT_CTRL_H;
    setPropValue(cp, "Caption", cp->name);

    // Determine parent: if click is inside a container, nest there
    WidgetT *parentWidget = ds->form->contentBox;

    for (int32_t i = ctrlCount - 1; i >= 0; i--) {
        DsgnControlT *pc = ds->form->controls[i];

        if (pc->widget && dsgnIsContainer(pc->typeName)) {
            int32_t wx = pc->widget->x;
            int32_t wy = pc->widget->y;
            int32_t ww = pc->widget->w;
            int32_t wh = pc->widget->h;

            if (x >= wx && x < wx + ww && y >= wy && y < wy + wh) {
                snprintf(cp->parentName, DSGN_MAX_NAME, "%s", pc->name);
                parentWidget = pc->widget;
                break;
            }
        }
    }

    // Create the live widget
    if (parentWidget) {
        cp->widget = dsgnCreateDesignWidget(typeName, parentWidget);

        if (cp->widget) {
            cp->widget->minW = wgtPixels(cp->width);
            cp->widget->minH = wgtPixels(cp->height);
        }
    }

    arrput(ds->form->controls, cp);
    ds->selectedIdx = (int32_t)arrlen(ds->form->controls) - 1;

    // Set text AFTER arrput so pointers are stable (heap-allocated, so always stable)
    DsgnControlT *stable = ds->form->controls[ds->selectedIdx];

    if (stable->widget) {
        const char *caption = getPropValue(stable, "Caption");
        wgtSetName(stable->widget, stable->name);
        wgtSetText(stable->widget, caption ? caption : stable->name);
    }
    ds->activeTool[0] = '\0';
    ds->mode        = DSGN_IDLE;
    ds->form->dirty = true;
}


// Draw grid dots and selection handles over the live widgets.
// Called from the form window's onPaint callback.
void dsgnPaint(DsgnStateT *ds) {
    if (!ds->form || !ds->ctx) {
        return;
    }

    // Grid dots and selection handles are drawn directly onto
    // the window via the display backbuffer. The live widgets
    // handle their own rendering.

    // Nothing to do here for now -- the onPaint hook in ideMain
    // calls dsgnPaintOverlay with the display pointer.
}


// Draw selection handles on the window's painted surface.
// Called after widgets have painted, using direct display drawing.
void dsgnPaintOverlay(DsgnStateT *ds, int32_t winX, int32_t winY) {
    (void)winX;
    (void)winY;

    if (!ds->form || !ds->form->controls || !ds->ctx || !ds->formWin || !ds->formWin->contentBuf) {
        return;
    }

    int32_t count = (int32_t)arrlen(ds->form->controls);

    if (ds->selectedIdx < 0 || ds->selectedIdx >= count) {
        return;
    }

    DsgnControlT *ctrl = ds->form->controls[ds->selectedIdx];

    if (!ctrl->widget || !ctrl->widget->visible || ctrl->widget->w <= 0 || ctrl->widget->h <= 0) {
        return;
    }

    // Draw into the window's content buffer (same coordinate space as widgets)
    DisplayT cd = ds->ctx->display;
    cd.backBuf  = ds->formWin->contentBuf;
    cd.width    = ds->formWin->contentW;
    cd.height   = ds->formWin->contentH;
    cd.pitch    = ds->formWin->contentPitch;
    cd.clipX    = 0;
    cd.clipY    = 0;
    cd.clipW    = ds->formWin->contentW;
    cd.clipH    = ds->formWin->contentH;

    const BlitOpsT *ops = &ds->ctx->blitOps;
    uint32_t black      = packColor(&cd, 0, 0, 0);
    uint32_t gray       = packColor(&cd, 128, 128, 128);

    int32_t cx = ctrl->widget->x;
    int32_t cy = ctrl->widget->y;
    int32_t cw = ctrl->widget->w;
    int32_t ch = ctrl->widget->h;
    int32_t hs = DSGN_HANDLE_SIZE;

    // All 8 handles: NW, N, NE, E, SE, S, SW, W
    int32_t hx[8] = { cx - hs/2, cx + cw/2 - hs/2, cx + cw - hs/2, cx + cw - hs/2, cx + cw - hs/2, cx + cw/2 - hs/2, cx - hs/2, cx - hs/2 };
    int32_t hy[8] = { cy - hs/2, cy - hs/2, cy - hs/2, cy + ch/2 - hs/2, cy + ch - hs/2, cy + ch - hs/2, cy + ch - hs/2, cy + ch/2 - hs/2 };

    // E (idx 3), S (idx 5), SE (idx 4) are active (black); rest are inactive (gray)
    for (int32_t i = 0; i < 8; i++) {
        bool active = (i == 3 || i == 4 || i == 5);
        rectFill(&cd, ops, hx[i], hy[i], hs, hs, active ? black : gray);
    }
}


int32_t dsgnSaveFrm(const DsgnStateT *ds, char *buf, int32_t bufSize) {
    if (!ds->form || !buf || bufSize <= 0) {
        return -1;
    }

    int32_t pos = 0;

    pos += snprintf(buf + pos, bufSize - pos, "VERSION DVX 1.00\n");
    pos += snprintf(buf + pos, bufSize - pos, "Begin Form %s\n", ds->form->name);
    pos += snprintf(buf + pos, bufSize - pos, "    Caption   = \"%s\"\n", ds->form->caption);
    pos += snprintf(buf + pos, bufSize - pos, "    Layout    = %s\n", ds->form->layout);
    pos += snprintf(buf + pos, bufSize - pos, "    AutoSize  = %s\n", ds->form->autoSize ? "True" : "False");
    pos += snprintf(buf + pos, bufSize - pos, "    Resizable = %s\n", ds->form->resizable ? "True" : "False");
    pos += snprintf(buf + pos, bufSize - pos, "    Centered  = %s\n", ds->form->centered ? "True" : "False");

    if (!ds->form->centered) {
        pos += snprintf(buf + pos, bufSize - pos, "    Left      = %d\n", (int)ds->form->left);
        pos += snprintf(buf + pos, bufSize - pos, "    Top       = %d\n", (int)ds->form->top);
    }

    if (!ds->form->autoSize) {
        pos += snprintf(buf + pos, bufSize - pos, "    Width     = %d\n", (int)ds->form->width);
        pos += snprintf(buf + pos, bufSize - pos, "    Height    = %d\n", (int)ds->form->height);
    }

    if (ds->form->helpTopic[0]) {
        pos += snprintf(buf + pos, bufSize - pos, "    HelpTopic = \"%s\"\n", ds->form->helpTopic);
    }

    // Output menu items as nested Begin Menu blocks
    {
        int32_t menuCount = (int32_t)arrlen(ds->form->menuItems);
        int32_t curLevel  = 0;

        for (int32_t i = 0; i < menuCount; i++) {
            DsgnMenuItemT *mi = &ds->form->menuItems[i];

            // Close blocks back to this item's level
            while (curLevel > mi->level) {
                curLevel--;

                for (int32_t p = 0; p < (curLevel + 1) * 4; p++) {
                    buf[pos++] = ' ';
                }

                pos += snprintf(buf + pos, bufSize - pos, "End\n");
            }

            // Indent: (level + 1) * 4 spaces (one extra for being inside Form block)
            for (int32_t p = 0; p < (mi->level + 1) * 4; p++) {
                buf[pos++] = ' ';
            }

            pos += snprintf(buf + pos, bufSize - pos, "Begin Menu %s\n", mi->name);

            // Caption
            for (int32_t p = 0; p < (mi->level + 2) * 4; p++) {
                buf[pos++] = ' ';
            }

            pos += snprintf(buf + pos, bufSize - pos, "Caption = \"%s\"\n", mi->caption);

            // Optional properties
            if (mi->checked) {
                for (int32_t p = 0; p < (mi->level + 2) * 4; p++) {
                    buf[pos++] = ' ';
                }

                pos += snprintf(buf + pos, bufSize - pos, "Checked = True\n");
            }

            if (mi->radioCheck) {
                for (int32_t p = 0; p < (mi->level + 2) * 4; p++) {
                    buf[pos++] = ' ';
                }

                pos += snprintf(buf + pos, bufSize - pos, "RadioCheck = True\n");
            }

            if (!mi->enabled) {
                for (int32_t p = 0; p < (mi->level + 2) * 4; p++) {
                    buf[pos++] = ' ';
                }

                pos += snprintf(buf + pos, bufSize - pos, "Enabled = False\n");
            }

            curLevel = mi->level + 1;
        }

        // Close any remaining open menu blocks
        while (curLevel > 0) {
            curLevel--;

            for (int32_t p = 0; p < (curLevel + 1) * 4; p++) {
                buf[pos++] = ' ';
            }

            pos += snprintf(buf + pos, bufSize - pos, "End\n");
        }
    }

    // Output top-level controls (and recurse into containers)
    pos = saveControls(ds->form, buf, bufSize, pos, "", 1);

    pos += snprintf(buf + pos, bufSize - pos, "End\n");

    // Append code section if present
    if (ds->form->code && ds->form->code[0]) {
        int32_t codeLen = (int32_t)strlen(ds->form->code);
        int32_t avail   = bufSize - pos - 2; // room for \n prefix and \n suffix

        if (avail > 0) {
            buf[pos++] = '\n';

            if (codeLen > avail) {
                codeLen = avail;
            }

            memcpy(buf + pos, ds->form->code, codeLen);
            pos += codeLen;

            // Ensure trailing newline
            if (pos > 0 && buf[pos - 1] != '\n' && pos < bufSize - 1) {
                buf[pos++] = '\n';
            }

            buf[pos] = '\0';
        }
    }

    return pos;
}


const char *dsgnSelectedName(const DsgnStateT *ds) {
    if (!ds->form) {
        return "";
    }

    if (ds->selectedIdx >= 0 && ds->selectedIdx < (int32_t)arrlen(ds->form->controls)) {
        return ds->form->controls[ds->selectedIdx]->name;
    }

    return ds->form->name;
}


static const char *getPropValue(const DsgnControlT *ctrl, const char *name) {
    for (int32_t i = 0; i < ctrl->propCount; i++) {
        if (strcasecmp(ctrl->props[i].name, name) == 0) {
            return ctrl->props[i].value;
        }
    }

    return NULL;
}


static int32_t hitTestControl(const DsgnStateT *ds, int32_t x, int32_t y) {
    int32_t count = (int32_t)arrlen(ds->form->controls);

    for (int32_t i = count - 1; i >= 0; i--) {
        const DsgnControlT *ctrl = ds->form->controls[i];

        if (!ctrl->widget || !ctrl->widget->visible) {
            continue;
        }

        // Use the widget's actual laid-out position
        int32_t wx = ctrl->widget->x;
        int32_t wy = ctrl->widget->y;
        int32_t ww = ctrl->widget->w;
        int32_t wh = ctrl->widget->h;

        if (x >= wx && x < wx + ww && y >= wy && y < wy + wh) {
            return i;
        }
    }

    return -1;
}


static DsgnHandleE hitTestHandles(const DsgnControlT *ctrl, int32_t x, int32_t y) {
    if (!ctrl->widget) {
        return HANDLE_NONE;
    }

    int32_t cx = ctrl->widget->x;
    int32_t cy = ctrl->widget->y;
    int32_t cw = ctrl->widget->w;
    int32_t ch = ctrl->widget->h;
    int32_t hs = DSGN_HANDLE_SIZE;

    // 3 handles: E (right edge), S (bottom edge), SE (corner)
    int32_t hx[HANDLE_COUNT] = { cx + cw - hs/2, cx + cw/2 - hs/2, cx + cw - hs/2 };
    int32_t hy[HANDLE_COUNT] = { cy + ch/2 - hs/2, cy + ch - hs/2, cy + ch - hs/2 };

    for (int32_t i = 0; i < HANDLE_COUNT; i++) {
        if (x >= hx[i] && x < hx[i] + hs && y >= hy[i] && y < hy[i] + hs) {
            return (DsgnHandleE)i;
        }
    }

    return HANDLE_NONE;
}


// Destroy all live widgets and recreate them in the current
// array order. This is the safest way to reorder since the
// widget tree child list matches the creation order.
static void rebuildWidgets(DsgnStateT *ds) {
    WidgetT *parent = ds->form ? ds->form->contentBox : NULL;

    if (!parent) {
        return;
    }

    // Destroy all existing widget children
    // (wgtDestroy not available, so just unlink and let the window own them)
    parent->firstChild = NULL;
    parent->lastChild  = NULL;

    // Clear widget pointers
    int32_t count = (int32_t)arrlen(ds->form->controls);

    for (int32_t i = 0; i < count; i++) {
        ds->form->controls[i]->widget = NULL;
    }

    // Recreate all widgets in current array order
    dsgnCreateWidgets(ds, parent);
}


// Write controls at a given nesting level with the specified parent name.
static int32_t saveControls(const DsgnFormT *form, char *buf, int32_t bufSize, int32_t pos, const char *parentName, int32_t indent) {
    int32_t count = (int32_t)arrlen(form->controls);

    for (int32_t i = 0; i < count; i++) {
        const DsgnControlT *ctrl = form->controls[i];

        // Only output controls whose parent matches
        if (parentName[0] == '\0' && ctrl->parentName[0] != '\0') { continue; }
        if (parentName[0] != '\0' && strcasecmp(ctrl->parentName, parentName) != 0) { continue; }

        // Indent
        char pad[32];
        int32_t padLen = indent * 4;
        if (padLen > 31) { padLen = 31; }
        memset(pad, ' ', padLen);
        pad[padLen] = '\0';

        pos += snprintf(buf + pos, bufSize - pos, "%sBegin %s %s\n", pad, ctrl->typeName, ctrl->name);

        if (ctrl->index >= 0) {
            pos += snprintf(buf + pos, bufSize - pos, "%s    Index    = %d\n", pad, (int)ctrl->index);
        }

        const char *caption = getPropValue(ctrl, "Caption");
        const char *text    = getPropValue(ctrl, "Text");

        if (caption) { pos += snprintf(buf + pos, bufSize - pos, "%s    Caption  = \"%s\"\n", pad, caption); }
        if (text)    { pos += snprintf(buf + pos, bufSize - pos, "%s    Text     = \"%s\"\n", pad, text); }

        pos += snprintf(buf + pos, bufSize - pos, "%s    Left     = %d\n", pad, (int)ctrl->left);
        pos += snprintf(buf + pos, bufSize - pos, "%s    Top      = %d\n", pad, (int)ctrl->top);
        pos += snprintf(buf + pos, bufSize - pos, "%s    MinWidth = %d\n", pad, (int)ctrl->width);
        pos += snprintf(buf + pos, bufSize - pos, "%s    MinHeight = %d\n", pad, (int)ctrl->height);

        if (ctrl->maxWidth > 0) {
            pos += snprintf(buf + pos, bufSize - pos, "%s    MaxWidth = %d\n", pad, (int)ctrl->maxWidth);
        }

        if (ctrl->maxHeight > 0) {
            pos += snprintf(buf + pos, bufSize - pos, "%s    MaxHeight = %d\n", pad, (int)ctrl->maxHeight);
        }

        if (ctrl->weight > 0) {
            pos += snprintf(buf + pos, bufSize - pos, "%s    Weight   = %d\n", pad, (int)ctrl->weight);
        }

        if (ctrl->helpTopic[0]) {
            pos += snprintf(buf + pos, bufSize - pos, "%s    HelpTopic = \"%s\"\n", pad, ctrl->helpTopic);
        }

        for (int32_t j = 0; j < ctrl->propCount; j++) {
            if (strcasecmp(ctrl->props[j].name, "Caption") == 0) { continue; }
            if (strcasecmp(ctrl->props[j].name, "Text") == 0)    { continue; }

            pos += snprintf(buf + pos, bufSize - pos, "%s    %s = \"%s\"\n", pad, ctrl->props[j].name, ctrl->props[j].value);
        }

        // Save interface properties (Alignment, etc.) read from the live widget
        if (ctrl->widget) {
            const char *wgtName = wgtFindByBasName(ctrl->typeName);
            const WgtIfaceT *iface = wgtName ? wgtGetIface(wgtName) : NULL;

            if (iface) {
                for (int32_t j = 0; j < iface->propCount; j++) {
                    const WgtPropDescT *p = &iface->props[j];

                    if (!p->getFn || !p->setFn) {
                        continue;
                    }

                    // Skip if already saved as a custom prop
                    bool already = false;

                    for (int32_t k = 0; k < ctrl->propCount; k++) {
                        if (strcasecmp(ctrl->props[k].name, p->name) == 0) {
                            already = true;
                            break;
                        }
                    }

                    if (already) {
                        continue;
                    }

                    // Skip STRING props here: saveControls only emits
                    // the iface-known scalar types.  String values come
                    // through ctrl->props[] (custom props).
                    if (p->type == WGT_IFACE_STRING) {
                        continue;
                    }

                    char valBuf[DSGN_MAX_TEXT];

                    if (wgtPropValueToString(ctrl->widget, p, valBuf, sizeof(valBuf))) {
                        pos += snprintf(buf + pos, bufSize - pos, "%s    %s = %s\n", pad, p->name, valBuf);
                    }
                }
            }
        }

        // Recursively output children of this container
        if (dsgnIsContainer(ctrl->typeName)) {
            pos = saveControls(form, buf, bufSize, pos, ctrl->name, indent + 1);
        }

        pos += snprintf(buf + pos, bufSize - pos, "%sEnd\n", pad);
    }

    return pos;
}


static void setPropValue(DsgnControlT *ctrl, const char *name, const char *value) {
    for (int32_t i = 0; i < ctrl->propCount; i++) {
        if (strcasecmp(ctrl->props[i].name, name) == 0) {
            snprintf(ctrl->props[i].value, DSGN_MAX_TEXT, "%s", value);
            return;
        }
    }

    if (ctrl->propCount < DSGN_MAX_PROPS) {
        snprintf(ctrl->props[ctrl->propCount].name, DSGN_MAX_NAME, "%s", name);
        snprintf(ctrl->props[ctrl->propCount].value, DSGN_MAX_TEXT, "%s", value);
        ctrl->propCount++;
    }
}


// Update the live widget's position and size from the design data.
static void syncWidgetGeom(DsgnControlT *ctrl) {
    if (!ctrl->widget) {
        return;
    }

    ctrl->widget->minW = wgtPixels(ctrl->width);
    ctrl->widget->minH = wgtPixels(ctrl->height);
    ctrl->widget->maxW = ctrl->maxWidth  > 0 ? wgtPixels(ctrl->maxWidth)  : 0;
    ctrl->widget->maxH = ctrl->maxHeight > 0 ? wgtPixels(ctrl->maxHeight) : 0;
}
