@sapui5/sap.suite.ui.generic.template 1.148.0 → 1.148.2

package/src/sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillHandler.js

@@ -1,1205 +1,786 @@
 sap.ui.define([
     "sap/ui/base/Object",
     "sap/base/util/extend",
-    "sap/ui/comp/smartform/GroupElement",
-    "sap/ui/comp/smartfield/SmartField",
-    "sap/m/MessageToast",
-    "sap/ui/model/json/JSONModel",
-	"sap/ui/model/odata/AnnotationHelper",
-    "sap/suite/ui/generic/template/lib/ai/EasyFill/ObjectPageSectionHandler",
-    "sap/m/VBox",
-    "sap/m/Text",
     "sap/suite/ui/generic/template/library",
-    "sap/m/HBox",
-    "sap/ui/layout/form/ColumnElementData",
-    "sap/suite/ui/generic/template/js/AnnotationHelper",
-	"sap/suite/ui/generic/template/genericUtilities/controlHelper",
-    "sap/ui/model/Filter",
-    "sap/ui/model/FilterOperator",
-    "sap/m/Title",
-    "sap/m/SegmentedButton",
-    "sap/m/SegmentedButtonItem",
-    "sap/m/Table",
-    "sap/m/Column",
-    "sap/m/ColumnListItem"
-], function(BaseObject, extend, GroupElement, SmartField,MessageToast,JSONModel,AnnotationHelperModel,ObjectPageSectionHandler,VBox,Text,Library,HBox,ColumnElementData,GenericAnnotationHelper,controlHelper,Filter,FilterOperator,Title,SegmentedButton,SegmentedButtonItem,Table,Column,ColumnListItem) {
-    'use strict';
-    const EasyFillLayoutMode = Library.EasyFillLayoutMode;
-    /*
-     * This is a handler class for EasyFill.
-     * It gets initialized when the Fiori AI EasyFill  is enabled
-     * Below things are handled in this class:
-     * 1. Prepare Field metadata
-     * 2. Prepare EasyFill Dialog
+    "sap/suite/ui/generic/template/genericUtilities/FeError",
+    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillFieldCollector",
+    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillAIOrchestrator",
+    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillFormRenderer",
+    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillTableRenderer",
+    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillApplyHandler",
+    "sap/suite/ui/generic/template/lib/ai/EasyFill/EasyFillDialogController"
+], function(
+    BaseObject,
+    extend,
+    Library,
+    FeError,
+    EasyFillFieldCollector,
+    EasyFillAIOrchestrator,
+    EasyFillFormRenderer,
+    EasyFillTableRenderer,
+    EasyFillApplyHandler,
+    EasyFillDialogController
+) {
+    "use strict";
+
+    /**
+     * EasyFillHandler
      *
+     * Thin orchestrator for the EasyFill AI feature on the ObjectPage.
+     *
+     * This class wires all EasyFill sub-modules together and exposes a single public
+     * entry point (onEasyFillButtonClick) to the ObjectPage ControllerImplementation.
+     *
+     * Sub-module responsibilities:
+     *   EasyFillFieldCollector   — OData metadata field/section extraction
+     *   EasyFillAIOrchestrator   — AI service call and response post-processing
+     *   EasyFillFormRenderer     — SmartForm/GroupElement/SmartField population
+     *   EasyFillTableRenderer    — SmartTable collection preview rendering
+     *   EasyFillApplyHandler     — Confirm/save, validation, reset logic
+     *   EasyFillDialogController — Dialog lifecycle, formatters, UI event handlers
+     *
+     * Shared mutable state lives here and is passed by reference into sub-modules.
+     * Sub-modules are stateless — they never store state themselves.
      */
     function getMethods(oState, oController, oTemplateUtils, oObjectPage) {
-        let oTransientContextForEasyFill;
-        let oObjectPageContext;
-        let oObjectPageModel;
-        let mUpdatableLookupMap;
-        let oRb;
-        let oAIPopover;
-        let aEditableFields = [];
-        let mCollectionUpdates = Object.create(null);
-        let mCollectionRowContexts = Object.create(null);
-        let mCollectionRowContextsByPath = Object.create(null);
-        let mCollectionProperties = Object.create(null);
-        let mCollectionEntityTypes = Object.create(null);
-        let mStagedRowValues = Object.create(null);
-        const MAX_TABLE_PREVIEW_ROWS = 20;
-
-        async function openEasyFillDialog(oEvent,oContext) {
-            let oEasyFillDialog;
+        var EasyFillLayoutMode = Library.EasyFillLayoutMode;
+
+        // ─── Shared Mutable State ────────────────────────────────────────────────
+        // All state is declared here and passed into sub-modules as needed.
+        // Sub-modules must not cache these values — always use the latest reference.
+
+        var oTransientContextForEasyFill = null; // Transient OData context for staged AI scalar values
+        var oObjectPageContext = null;            // Live ObjectPage binding context
+        var oObjectPageModel = null;              // OData model of the ObjectPage
+        var mUpdatableLookupMap = {};             // { fieldName: value } for updatable fields only
+        var oRb = null;                           // i18n resource bundle
+        var oAIPopoverRef = { popover: null };    // Mutable ref for lazy-loaded AINotice popover
+
+        // Collection state — tracks OData row contexts and property metadata for SmartTable collections
+        var mCollectionState = {
+            mCollectionRowContexts: Object.create(null),
+            mCollectionRowContextsByPath: Object.create(null),
+            mCollectionProperties: Object.create(null),
+            mCollectionEntityTypes: Object.create(null),
+            mCollectionEntitySets: Object.create(null),
+            mCollectionAllowsCreation: Object.create(null)
+        };
+
+        var mCollectionUpdates = Object.create(null); // { navProperty: [ rowUpdate ] } from AI response
+        var mLastFieldMapping = null;                  // retained so table sections can be re-rendered on mode switch
+        var oTableStagingState = {
+            mStagedRows: Object.create(null),
+            mPendingNewRowContexts: Object.create(null)
+        };
+
+        // ─── Internal Helpers ────────────────────────────────────────────────────
+
+        /**
+         * Opens the EasyFill dialog for the given ObjectPage context.
+         * Initializes the dialog model on first open, then loads and opens the dialog fragment
+         * with all event handlers and formatters bound.
+         *
+         * @param {sap.ui.base.Event} oEvent - the button click event
+         * @param {sap.ui.model.Context} [oContext] - optional context override (used when OP just entered edit mode)
+         */
+        async function openEasyFillDialog(oEvent, oContext) {
             oRb = oController.getView().getModel("i18n").getResourceBundle();
-            const bIsModelCreated = !!oController.getView().getModel("easyFillDialogModel");
             oObjectPageModel = oObjectPage.getModel();
-            if (!bIsModelCreated) {
-                const aDeferredGroups = oObjectPageModel.getDeferredGroups();
-                //Adding a defferred group will make sure that no batch call would get triggered to backend until submitChanges() is invoked
-                aDeferredGroups.push("EasyFillFETransientChanges");
-                oObjectPageModel.setDeferredGroups(aDeferredGroups);
-
-                //Creating a JSON model for the dialog
-
-                const oData = {
-                    isBusy: false,
-                    isFormVisible: false,
-                    isIllustrationVisible: true,
-                    isSaveEnabled: false,
-                    stateType: "Initial",
-                    feedbackEnabled: true,
-                    feedbackPressedUp: false,
-                    feedbackPressedDown: false,
-                    isEasyFillButtonEnabled: false,
-                    llmData: {},
-                    easyFillMode: EasyFillLayoutMode.CondensedMode,
-                    sections:[],
-                    isFullScreen: true,
-                    hasTableUpdates: false,
-                    hasTableValidationErrors: false,
-                    tableValidationMessage: ""
-                  };
-
-                  let oModel = new JSONModel(oData);
-                  oController.getView().setModel(oModel, "easyFillDialogModel");
-            }
 
-            oObjectPageContext = (oContext) ? oContext : oObjectPage.getBindingContext();
+            // Initialize dialog model and deferred group once per view lifetime
+            EasyFillDialogController.initDialogModel(oController, oObjectPageModel, EasyFillLayoutMode);
+
+            // Use the provided context override or fall back to the current OP binding context
+            oObjectPageContext = oContext || oObjectPage.getBindingContext();
+
+            // Build the handler/formatter map that the dialog fragment binds to
+            var oHandlers = _buildDialogHandlers();
+
+            await EasyFillDialogController.openDialog(oController, oTemplateUtils, oHandlers);
+        }
 
-            // cannot use OP path to create a list binding as it is a individual entry
-            var sFragmentname = "sap.suite.ui.generic.template.lib.ai.EasyFill.fragments.EasyFillDialog";
-			oTemplateUtils.oCommonUtils.getDialogFragmentAsync(sFragmentname, {
+        /**
+         * Builds the event handler and formatter map passed to the EasyFillDialog fragment.
+         * Each entry corresponds to a function called from the fragment via event binding or formatter.
+         *
+         * @returns {object} handler/formatter map
+         */
+        function _buildDialogHandlers() {
+            return {
+                // ── Layout mode toggle (Condensed ↔ ObjectPage view) ──────────────
+                // After the sections binding is refreshed, SmartForms for the new mode
+                // are repopulated asynchronously (setTimeout in populateSmartFields).
+                // _validateFieldsAndUpdateConfirmState is called here so that validation runs
+                // immediately on whatever SmartForms are currently in the DOM, and then
+                // again via fnOnFieldChange once the new SmartFields are rendered.
                 onSelectionChange: function(oEvent) {
-                    const sSelectedKey = oEvent.getSource().getSelectedKey();
-                    const easyFillDialogModel = oController.getView().getModel("easyFillDialogModel");
-                    const oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(oController.getOwnerComponent().getEntitySet());
-                    easyFillDialogModel.setProperty("/easyFillMode",sSelectedKey);
-                    const oLLMResult = easyFillDialogModel.getProperty("/llmData");
-                    const aData = (sSelectedKey === EasyFillLayoutMode.CondensedMode) ? ObjectPageSectionHandler.getSectionsForCondensedView(oLLMResult) : ObjectPageSectionHandler.getSectionsForObjectPageView(oEntityType,oLLMResult,oRb);
-                    easyFillDialogModel.setProperty("/sections",aData);
+                    // Step 1: clean up table content injected for the CURRENT mode BEFORE the
+                    // model update. This ensures the OPL aggregation is free of manually-added
+                    // sections when the sections binding recreates controls for the new mode,
+                    // so getSections() in renderCollectionPreviews returns only bound sections.
+                    var oOpl = oController.byId("EasyFillObjectPageLayout");
+                    if (oOpl && mLastFieldMapping && Object.keys(mCollectionUpdates).length > 0) {
+                        EasyFillTableRenderer.removeTableSections(oOpl);
+                    }
+
+                    // Step 2: update model — this triggers the OPL sections binding to recreate
+                    // bound section controls for the new mode.
+                    EasyFillDialogController.onSelectionChange(
+                        oEvent, oController, oTemplateUtils, oRb,
+                        EasyFillFieldCollector, EasyFillLayoutMode
+                    );
+
+                    // Step 3: re-render table previews for the new mode.
+                    // _removeTableSections is skipped inside renderCollectionPreviews because
+                    // bReuseStaging=true, since cleanup was already done in step 1 above.
+                    if (mLastFieldMapping && Object.keys(mCollectionUpdates).length > 0) {
+                        EasyFillTableRenderer.renderCollectionPreviews(
+                            mCollectionUpdates,
+                            mLastFieldMapping,
+                            [],
+                            oController,
+                            oRb,
+                            mCollectionState,
+                            oTableStagingState,
+                            oObjectPageModel,
+                            _validateFieldsAndUpdateConfirmState,
+                            true  // bReuseStaging — also skips re-cleanup (already done above)
+                        );
+                    }
+                    _validateFieldsAndUpdateConfirmState();
                 },
+
+                // ── Feedback thumbs-up/down ───────────────────────────────────────
                 onFeedbackPress: function() {
-                    const easyFillDialogModel = oController.getView().getModel("easyFillDialogModel");
-                    easyFillDialogModel.setProperty("/feedbackEnabled",false);
-                    MessageToast.show(oRb.getText("EASYFILL_RESULT_FEEDBACK"));
+                    EasyFillDialogController.onFeedbackPress(oController, oRb);
                 },
+
+                // ── Section title formatter (resolves i18n patterns) ──────────────
                 formatSectionTitle: function(sTitle) {
-                    if (!sTitle) {return "";}
-                    // Matches {@i18n>SomeKey} or {i18n>SomeKey}
-                    const oMatch = sTitle.match(/\{@?i18n>([^}]+)\}/);
-                    if (oMatch) {
-                        const sKey = oMatch[1];
-                        const oResourceBundle = oController.getView().getModel("i18n").getResourceBundle();
-                        return oResourceBundle.getText(sKey);
-                    }
-                    // No i18n pattern → return as-is
-                    return sTitle;
+                    return EasyFillDialogController.formatSectionTitle(sTitle, oController);
                 },
-                formatIllustrationType: function (sState) {
-                    switch (sState) {
-                        case "Initial":
-                            return "sapIllus-NoSearchResults";
-                        case "NoEntries":
-                            return "sapIllus-NoEntries";
-                        case "Error":
-                            return "sapIllus-UnableToLoad";
-                        default:
-                            return "sapIllus-NoSearchResults";
-                    }
+
+                // ── IllustratedMessage state formatters ───────────────────────────
+                formatIllustrationType: function(sState) {
+                    return EasyFillDialogController.formatIllustrationType(sState);
                 },
-                formatIllustrationTitle: function (sState) {
-                    switch (sState) {
-                        case "Initial":
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_TITLE_INITIAL");
-                        case "NoEntries":
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_TITLE_NO_ENTRIES");
-                        case "Error":
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_TITLE_ERROR");
-                        default:
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_TITLE_INITIAL");
-                    }
+                formatIllustrationTitle: function(sState) {
+                    return EasyFillDialogController.formatIllustrationTitle(sState, oRb);
                 },
-                formatIllustrationDescription: function (sState) {
-                    switch (sState) {
-                        case "Initial":
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_DESCRIPTION_INITIAL");
-                        case "NoEntries":
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_DESCRIPTION_NO_ENTRIES");
-                        case "Error":
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_DESCRIPTION_ERROR");
-                        default:
-                            return oRb.getText("EASY_FILL_ILLUSTRATION_DESCRIPTION_INITIAL");
-                    }
+                formatIllustrationDescription: function(sState) {
+                    return EasyFillDialogController.formatIllustrationDescription(sState, oRb);
                 },
-                onSaveFromEasyFillDialog : async function (oEvent) {
-                    var oTransientObject = oTransientContextForEasyFill.getObject();
-                    for (const oProp in oTransientObject) {
-                        if (oProp !== "__metadata" && mUpdatableLookupMap[oProp]) {
-                            oObjectPageContext.setProperty(oProp, oTransientObject[oProp]);
-                        }
-                    }
-                    // Collection row values are already staged onto OData contexts via the editable New table;
-                    // clear staged tracking without reverting, then activate side effects.
-                    mStagedRowValues = Object.create(null);
-                    //Temporarily deactivating, Yet to be added again
-                    // activateSideEffects();
-                    resetEasyFill(true);
-                    oEasyFillDialog?.close();
+
+                // ── Confirm: apply AI values to the live OP context ───────────────
+                // The Confirm button is disabled reactively by _validateFieldsAndUpdateConfirmState
+                // whenever a SmartField value is invalid — no click-time check needed.
+                onSaveFromEasyFillDialog: async function() {
+                    // Capture staged collection updates BEFORE applyAndSave writes them to the live
+                    // contexts — after applyAndSave the staged values equal the live values and the map would be empty.
+                    var mStagedUpdates = EasyFillApplyHandler.buildStagedCollectionUpdates(oTableStagingState, mCollectionState);
+
+                    // Extract reviewed new-row values from staging contexts BEFORE reset discards them.
+                    var mNewRowValues = EasyFillApplyHandler.extractPendingNewRowValues(oTableStagingState, mCollectionState);
+
+                    EasyFillApplyHandler.applyAndSave(
+                        oTransientContextForEasyFill,
+                        oObjectPageContext,
+                        mUpdatableLookupMap,
+                        oTableStagingState,
+                        mCollectionState
+                    );
+                    // Trigger side effects on the OP context for all changed SmartForm fields
+                    // before resetting the dialog (SmartFields must still be present)
+                    _activateSideEffects();
+                    // Trigger side effects for all modified table rows
+                    _activateSideEffectsForTable(mStagedUpdates);
+                    _resetEasyFill(true);
+                    EasyFillDialogController.closeDialog(oController);
+
+                    // Create the new rows via the standard CRUDManager (draft-aware, handles side effects)
+                    // This is done after dialog close so the user sees the OP immediately.
+                    await _createNewRows(mNewRowValues);
                 },
+
+                // ── Text area live change: enable/disable submit button ───────────
                 onLiveChange: function(oEvent) {
-                    const easyFillDialogModel = oController.getView().getModel("easyFillDialogModel");
-                    easyFillDialogModel.setProperty("/isEasyFillButtonEnabled",!!oEvent.getSource().getValue());
+                    EasyFillDialogController.onLiveChange(oEvent, oController);
                 },
-                onCancelEasyFillDialog : function () {
-                    resetEasyFill(true);
-                    oEasyFillDialog.close();
+
+                // ── Cancel: revert staged values and close dialog ─────────────────
+                onCancelEasyFillDialog: function() {
+                    _resetEasyFill(true);
+                    EasyFillDialogController.closeDialog(oController);
                 },
-                formatFieldValue: function(sFieldName,oData) {
-                    return `{${sFieldName}}`;
+
+                // ── Field value formatter (binding expression builder) ────────────
+                formatFieldValue: function(sFieldName) {
+                    return "{" + sFieldName + "}";
                 },
-                onEasyFillSubmitInputToAI : async function (oEvent) {
-                    const easyFillDialogModel = oController.getView().getModel("easyFillDialogModel");
-                    easyFillDialogModel.setProperty("/isBusy",true);
-                    let mFieldMapping = getEntitySetMapForLLM();
-                    let aiCallResult = await  oTemplateUtils.oServices.oFioriAIHandler.fioriaiLib.EasyFill.extractFieldValuesFromText(oController.byId("EasyFillInputTextArea").getValue(), mFieldMapping);
-                    aEditableFields = [];
-                    easyFillDialogModel.setProperty("/isBusy",false);
-                    formatDateValues(aiCallResult,mFieldMapping);
-                    const oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(oController.getOwnerComponent().getEntitySet());
-                    const sSelectedKey = easyFillDialogModel.getProperty("/easyFillMode") || EasyFillLayoutMode.CondensedMode;
-                    easyFillDialogModel.setProperty("/easyFillMode",sSelectedKey);
-                    if (aiCallResult.success) {
-                        const {simpleFields,collectionFields} = splitAIResultByCollection(aiCallResult.data, mFieldMapping);
-                        const {updatableFields,nonUpdatableFields} = getUpdatableAndNonUpdatableFields(simpleFields);
-                        mUpdatableLookupMap = updatableFields;
-                        //Setting up Sections for both condensed view and Object page view
-                        const aData = (sSelectedKey === EasyFillLayoutMode.CondensedMode) ? ObjectPageSectionHandler.getSectionsForCondensedView(simpleFields) : ObjectPageSectionHandler.getSectionsForObjectPageView(oEntityType,simpleFields,oRb);
-                        resetEasyFill();
-                        makeTransientContext();
-                        easyFillDialogModel.setProperty("/sections",aData);
-                        easyFillDialogModel.setProperty("/llmData",simpleFields);
-                        //Setting and rendering of SmartTables
-                        mCollectionUpdates = collectionFields;
-                        const bHasTableUpdates = Object.keys(mCollectionUpdates).length > 0;
-                        easyFillDialogModel.setProperty("/hasTableUpdates", bHasTableUpdates);
-                        const aTableValidationErrors = await validateCollectionUpdatesAgainstValueHelp(mFieldMapping);
-                        applyTableValidationState(aTableValidationErrors);
-                        renderCollectionPreviews(mFieldMapping, aTableValidationErrors);
-
-                        if (Object.keys(updatableFields).length + Object.keys(nonUpdatableFields).length === 0 && !bHasTableUpdates) {
-                            easyFillDialogModel.setProperty("/stateType","NoEntries");
-                            return;
-                        }
-                        easyFillDialogModel.setProperty("/isIllustrationVisible",false);
-                        //Fillable Fields
-                        easyFillDialogModel.setProperty("/isFormVisible",Object.keys(updatableFields).length + Object.keys(nonUpdatableFields).length > 0);
 
-                        if (bHasTableUpdates) {
-                            easyFillDialogModel.setProperty("/isSaveEnabled", aTableValidationErrors.length === 0);
-                        }
-                    } else {
-                        applyTableValidationState([]);
-                        easyFillDialogModel.setProperty("/stateType","Error");
-                    }
+                // ── Submit user text to AI ────────────────────────────────────────
+                onEasyFillSubmitInputToAI: async function() {
+                    await _handleAISubmit();
                 },
 
+                // ── Clear all (reset without closing) ────────────────────────────
                 onEasyFillClearAll: function() {
-                    resetEasyFill(true);
+                    _resetEasyFill(true);
                 },
 
+                // ── SmartForm group population formatter ──────────────────────────
                 populateSmartFields: function(sId, aFields, sEasyFillMode) {
-                    const oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
-                    if (!oObjectPageLayout || !Array.isArray(aFields) || aFields.length === 0) {
+                    return EasyFillFormRenderer.populateSmartFields(
+                        sId, aFields, sEasyFillMode,
+                        oController,
+                        oTransientContextForEasyFill,
+                        oObjectPageContext,
+                        mUpdatableLookupMap,
+                        oDialogModel().getProperty("/llmData"),
+                        _validateFieldsAndUpdateConfirmState
+                    );
+                },
+
+                // ── Section visibility: hide SmartForm sections with no fields ──────────────
+                hasSectionFields: function(aFields, aChildren) {
+                    if (Array.isArray(aFields) && aFields.length > 0) {
                         return true;
                     }
 
-                    const easyFillDialogModel = oController.getView().getModel("easyFillDialogModel");
-
-                    setTimeout(() => {
-                        const oLLMData = easyFillDialogModel.getProperty("/llmData");
-                        let oTargetGroup = null;
-
-                        // sections -> ObjectPageSection
-                        oObjectPageLayout.getSections().forEach((oSection) => {
-                            // subSections -> ObjectPageSubSection
-                            oSection.getSubSections().forEach((oSubSection) => {
-                                // blocks -> SmartForm
-                                oSubSection.getBlocks().forEach((oBlock) => {
-                                    if (oBlock.isA("sap.ui.comp.smartform.SmartForm")) {
-                                        // ✅ Search inside Groups, not SmartForm
-                                        oBlock.getGroups().forEach((oGroup) => {
-                                            const oMatchedCustomData = oGroup.getCustomData().find(
-                                                (oData) => oData.getKey() === "id" && oData.getValue() === sId
-                                            );
-                                            if (oMatchedCustomData) {
-                                                oTargetGroup = oGroup;
-                                            }
-                                        });
-                                    }
-                                });
-                            });
-                        });
-
-                        if (!oTargetGroup) {
-                            return;
+                    function hasFieldsInNode(oNode) {
+                        if (!oNode) {
+                            return false;
                         }
+                        if (Array.isArray(oNode.fields) && oNode.fields.length > 0) {
+                            return true;
+                        }
+                        if (Array.isArray(oNode.children)) {
+                            return oNode.children.some(hasFieldsInNode);
+                        }
+                        return false;
+                    }
 
-                        // Destroy old GroupElements before adding new
-                        oTargetGroup.destroyGroupElements();
-
-                        aFields.forEach((sKey) => {
-                            // const bFieldEditable = true;
-                            const oGroupElement = new GroupElement({
-                                useHorizontalLayout: false
-                              });
-
-                              const isEditable = mUpdatableLookupMap && !!mUpdatableLookupMap[sKey];
-
-                            const oSmartField = new SmartField({
-                                value: "{" + sKey + "}",
-                                editable: isEditable,
-                                enabled: isEditable,
-                                contextEditable: isEditable,
-                                //Yet to be added, Temporarily disabled
-                                // change: onSmartFieldChange.bind(this),
-                                layoutData: new ColumnElementData({
-                                    cellsSmall: 12,
-                                    cellsLarge: 12
-                                }),
-                                editableChanged: (oEvent) => {
-                                    if (oEvent.getParameter("editable") !== isEditable) {
-                                        oEvent.getSource().setEditable(isEditable);
-                                    }
-                                }
-                            });
-
-                            const oSmartFieldPrev = new SmartField({
-                                value: "{" + sKey + "}",
-                                editable: false,
-                                enabled: false,
-                                contextEditable: false,
-                                showLabel: false,
-                                visible: isEditable,
-                                layoutData: new ColumnElementData({
-                                    cellsSmall: 9,
-                                    cellsLarge: 10
-                                }),
-                                editableChanged: (oEvent) => {
-                                    if (oEvent.getParameter("editable") !== false) {
-                                        oEvent.getSource().setEditable(false);
-                                    }
-                                }
-                            });
-
-
-                            if (isEditable) {
-                                oSmartField.setBindingContext(oTransientContextForEasyFill);
-                                oSmartFieldPrev.setBindingContext(oObjectPageContext);
-                                // aEditableFields.push(oSmartField);
-                                oTransientContextForEasyFill.setProperty(sKey, oLLMData[sKey]);
-                            } else {
-                                oSmartField.setBindingContext(oObjectPageContext);
-                            }
-                            oGroupElement.addElement(oSmartField);   // label source
-                            oGroupElement.addElement( new Text({
-                                text: "Previously:",
-                                visible: isEditable,
-                                layoutData: new ColumnElementData({
-                                    cellsSmall: 3,
-                                    cellsLarge: 2
-                                })
-                            }));
-                            oGroupElement.addElement(oSmartFieldPrev);
-                            oTargetGroup.addGroupElement(oGroupElement);
-                        });
-
-                    }, 0);
-
-                    return true;
+                    return Array.isArray(aChildren) && aChildren.some(hasFieldsInNode);
                 },
 
+                // ── Fullscreen toggle ─────────────────────────────────────────────
                 onToggleFullScreen: function() {
-                    const oEasyFillDialogModel = oController.getView().getModel("easyFillDialogModel");
-                    const bIsFullScreen = oEasyFillDialogModel.getProperty("/isFullScreen");
-                    // ✅ Toggle fullscreen state
-                    oEasyFillDialogModel.setProperty("/isFullScreen", !bIsFullScreen);
-                    if (bIsFullScreen) {
-                        oController.byId("inputAreaSplitPane").getLayoutData().setSize("0%");
-                        oController.byId("reviewAreaSplitPane").getLayoutData().setSize("100%");
-                    } else {
-                        oController.byId("inputAreaSplitPane").getLayoutData().setSize("40%");
-                        oController.byId("reviewAreaSplitPane").getLayoutData().setSize("60%");
-                    }
+                    EasyFillDialogController.onToggleFullScreen(oController);
                 },
 
-
+                // ── AI Notice popover ─────────────────────────────────────────────
                 onLinkPress: async function(oEvent) {
-                    if (!oAIPopover) {
-                        oAIPopover = await getAIPopover();
-                    }
-                    oAIPopover.openBy(oEvent.getSource());
+                    await EasyFillDialogController.onLinkPress(oEvent, oTemplateUtils, oAIPopoverRef);
                 }
-			}, "easyFillPopup",undefined,true,true).then(function (oPopup) {
-                oEasyFillDialog = oPopup;
-                oPopup?.open();
-			});
-        }
-
-        //Yet to implement, temporarily disabled
-        // function activateSideEffects() {
-        //     //Making a set so that , duplicate field group ids are not passed
-        //     const aFieldGroupIdSet = new Set();
-        //     aEditableFields.forEach((oSmartField)=>{
-        //         //SideEffect would be invoked only for the editable controls inside the SmartField
-        //         const aEditableInnerFields = oSmartField.getInnerControls().filter((oControl)=>oControl.getEditable());
-        //         aEditableInnerFields.forEach((oControl)=>{
-        //             const aControlFieldGroupId = oControl.getFieldGroupIds();
-        //             if (aControlFieldGroupId.length > 0) {
-        //                 aControlFieldGroupId.forEach((sFieldGroupId)=>{
-        //                     aFieldGroupIdSet.add(sFieldGroupId);
-        //                 });
-        //             }
-        //         });
-
-        //     });
-
-        //     const oView = oController.getView();
-
-        //     aFieldGroupIdSet.forEach((sFieldGroupId)=>{
-        //         const oID = oView.data(sFieldGroupId);
-
-        //         /**
-        //          * Currently, the SmartFields are created using the TransientContext, which means both
-        //          * "context" and "contextObject" refer to the TransientContext instance.
-        //          *
-        //          * However, we need to use the original OP context so that side effects are triggered
-        //          * on the original OP context when the user saves data from the EasyFill dialog back to OP.
-        //          *
-        //          * Therefore, we update the "context" and "contextObject" to reference the original OP context.
-        //          */
-
-        //         if (oID) {
-        //             oID["context"] = oObjectPageContext.getPath();
-        //             oID["contextObject"] = oObjectPageContext;
-        //             oView.data(sFieldGroupId,oID);
-        //         }
-        //         //To make sure that all the fields sideeffect would be triggered
-        //         const sSideEffectQualifier = oTemplateUtils.oServices.oApplicationController._getSideEffectsQualifier(oID.name);
-        //         oTemplateUtils.oServices.oApplicationController.registerGroupChange(sSideEffectQualifier);
-        //     });
-
-
-        //     oView.triggerValidateFieldGroup([...aFieldGroupIdSet]);
-        // }
-
-        function getAIPopover() {
-            return new Promise(async(resolve,reject) => {
-                const sFragmentname = "sap.suite.ui.generic.template.fragments.AINotice";
-                const oPopover = await oTemplateUtils.oCommonUtils.getDialogFragmentAsync(sFragmentname,{
-                    onCloseAiPopover: function() {
-                        oAIPopover.close();
-                    }
-                },"aiPopover",undefined,true);
-                resolve(oPopover);
-            });
-        }
-
-        function getEntitySetMapForLLM(oLLMResult) {
-            const mPropertyMap = {};
-            const oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(oController.getOwnerComponent().getEntitySet());
-            oEntityType.property.forEach((oProperty)=>{
-                if (isVisible(oProperty)) {
-                    mPropertyMap[oProperty.name] = {
-                        description: getLabel(oProperty),
-                        dataType: oProperty.type
-                    };
-                }
-            });
-            appendCollectionMapForLLM(mPropertyMap);
-            return mPropertyMap;
-        }
-
-        function getLabel(oProperty) {
-            return oProperty["com.sap.vocabularies.Common.v1.Label"] ? AnnotationHelperModel.format(oObjectPageContext,oProperty["com.sap.vocabularies.Common.v1.Label"]) : oProperty["sap:label"];
+            };
         }
 
-        function formatDateValues(aiCallResult,mFieldMapping) {
-            if (aiCallResult.success) {
-                for (const key of Object.keys(aiCallResult.data)) {
-                    const sDataType = mFieldMapping[key].dataType;
-                    if (sDataType === "Edm.DateTimeOffset" || sDataType === "Edm.DateTime") {
-                        aiCallResult.data[key] = new Date(aiCallResult.data[key]);
-                    }
-                }
-            }
-        }
+        /**
+         * Handles the full AI submission flow:
+         * 1. Build field mapping
+         * 2. Call AI service
+         * 3. Post-process response (dates, split)
+         * 4. Update dialog model
+         * 5. Populate SmartForms and table previews
+         */
+        async function _handleAISubmit() {
+            var oModel = oDialogModel();
+            oModel.setProperty("/isBusy", true);
+
+            // Build complete LLM field mapping (entity fields + collection fields)
+            var mFieldMapping = EasyFillAIOrchestrator.buildFieldMapping(
+                oTemplateUtils, oController, oObjectPage, oObjectPageModel,
+                oObjectPageContext, EasyFillFieldCollector, mCollectionState
+            );
 
-        //Yet to be implemented, temporarily disabled
-        // function validateSmartForm() {
-        //     setTimeout(async() => {
-        //         const easyFillDialogModel = oController.getView().getModel("easyFillDialogModel");
-        //         try {
-        //             const oAIResponseReviewRegionSmartFormForUpdatableFields = oController.byId("EasyFillUpdatebleForm");
-        //             const aIds = await oAIResponseReviewRegionSmartFormForUpdatableFields.check();
-        //             const bHasTableValidationErrors = !!easyFillDialogModel.getProperty("/hasTableValidationErrors");
-        //             easyFillDialogModel.setProperty("/isSaveEnabled",aIds.length === 0 && !bHasTableValidationErrors);
-        //         } catch (error) {
-        //             easyFillDialogModel.setProperty("/isSaveEnabled",false);
-        //         }
-        //     }, 0);
-        // }
-
-        function applyTableValidationState(aValidationErrors) {
-            const easyFillDialogModel =  oController.getView().getModel("easyFillDialogModel");
-            if (!aValidationErrors || aValidationErrors.length === 0) {
-                easyFillDialogModel.setProperty("/hasTableValidationErrors", false);
-                easyFillDialogModel.setProperty("/tableValidationMessage", "");
-                return;
-            }
-            const sSummary = aValidationErrors.slice(0, 3).map(function(oError) {
-                return oError.collectionLabel + " / " + oError.rowLabel + " / " + oError.propertyLabel;
-            }).join(", ");
-            easyFillDialogModel.setProperty("/hasTableValidationErrors", true);
-            easyFillDialogModel.setProperty(
-                "/tableValidationMessage",
-                oRb.getText("EASY_FILL_TABLE_VALIDATION_MESSAGE", [sSummary])
+            // Submit to AI
+            var aiCallResult = await EasyFillAIOrchestrator.submitToAI(
+                oController.byId("EasyFillInputTextArea").getValue(),
+                mFieldMapping,
+                oTemplateUtils
             );
-        }
 
-        function resetEasyFill(bRemoveTextAreaValue) {
-            const easyFillDialogModel =  oController.getView().getModel("easyFillDialogModel");
-            const oTablePreviewContainer = oController.byId("EasyFillTablePreviewContainer");
-            if (oTablePreviewContainer) {
-                oTablePreviewContainer.destroyItems();
-            }
-            revertStagedCollectionUpdates();
-            resetTransientContext();
-            easyFillDialogModel.setProperty("/isFormVisible",false);
-            easyFillDialogModel.setProperty("/isIllustrationVisible",true);
-            easyFillDialogModel.setProperty("/isSaveEnabled",false);
-            easyFillDialogModel.setProperty("/stateType","Initial");
-            easyFillDialogModel.setProperty("/feedbackEnabled",true);
-            easyFillDialogModel.setProperty("/feedbackPressedUp",false);
-            easyFillDialogModel.setProperty("/feedbackPressedDown",false);
-            easyFillDialogModel.setProperty("/isFullScreen",true);
-            easyFillDialogModel.setProperty("/hasTableUpdates",false);
-            easyFillDialogModel.setProperty("/hasTableValidationErrors",false);
-            easyFillDialogModel.setProperty("/tableValidationMessage","");
-            easyFillDialogModel.setProperty("/easyFillMode",EasyFillLayoutMode.CondensedMode);
-            mCollectionUpdates = Object.create(null);
-            if (bRemoveTextAreaValue) {
-                oController.byId("EasyFillInputTextArea").setValue("");
-                easyFillDialogModel.setProperty("/isEasyFillButtonEnabled",false);
-            }
-            easyFillDialogModel.setProperty("/llmData",{});
-            easyFillDialogModel.setProperty("/sections",[]);
+            // Reset editable fields tracker for fresh population
+            oModel.setProperty("/isBusy", false);
 
-        }
+            // Convert date strings in AI response to JS Date objects
+            EasyFillAIOrchestrator.formatDateValues(aiCallResult, mFieldMapping);
 
-        function getUpdatableAndNonUpdatableFields(oAiCallResult) {
-            const oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(oController.getOwnerComponent().getEntitySet());
-            const updatableFields = {};
-            const nonUpdatableFields = {};
+            var sSelectedKey = oModel.getProperty("/easyFillMode") || EasyFillLayoutMode.CondensedMode;
+            oModel.setProperty("/easyFillMode", sSelectedKey);
 
-            Object.keys(oAiCallResult).forEach((sKey)=>{
-                const oProperty = oEntityType.property.find((oProperty)=>oProperty.name === sKey);
-                if (!oProperty) {
-                    nonUpdatableFields[sKey] = oAiCallResult[sKey];
+            if (aiCallResult.success) {
+                // Split AI response into simple fields (SmartForm) and collection rows (SmartTable)
+                // Pass mCollectionState so the splitter can check which tables allow creation
+                var oSplitResult = EasyFillAIOrchestrator.splitAIResultByCollection(
+                    aiCallResult.data, mFieldMapping, EasyFillFieldCollector, oObjectPage, mCollectionState
+                );
+                var simpleFields = oSplitResult.simpleFields;
+                var collectionFields = oSplitResult.collectionFields;
+
+                // Separate updatable from non-updatable fields
+                var sEntitySetName = oController.getOwnerComponent().getEntitySet();
+                var oEntityType = oTemplateUtils.oCommonUtils.getMetaModelEntityType(sEntitySetName);
+                var oMetaModel = oObjectPageModel.getMetaModel();
+                var oEntitySet = oMetaModel.getODataEntitySet(sEntitySetName);
+                var oSplit = EasyFillFieldCollector.getUpdatableAndNonUpdatableFields(
+                    simpleFields, oEntityType, oObjectPageContext, oEntitySet
+                );
+                mUpdatableLookupMap = oSplit.updatableFields;
+                var mNonUpdatableFields = oSplit.nonUpdatableFields;
+
+                // Build section tree for selected view mode
+                var aData = (sSelectedKey === EasyFillLayoutMode.CondensedMode)
+                    ? EasyFillFieldCollector.getSectionsForCondensedView(simpleFields, mUpdatableLookupMap, mNonUpdatableFields)
+                    : EasyFillFieldCollector.getSectionsForObjectPageView(oEntityType, simpleFields, oRb, mNonUpdatableFields);
+
+                // Reset form (destroy previous SmartForm content + revert table staging)
+                // then create a fresh transient context for the new AI result.
+                // Restore the user's chosen layout mode afterwards because _resetEasyFill
+                // unconditionally resets it to CondensedMode — without this, renderCollectionPreviews
+                // would see the wrong mode and embed table sections inside the SmartForm SubSection
+                // instead of adding them as standalone OPL sections (OP mode) or vice-versa.
+                _resetEasyFill();
+                oModel.setProperty("/easyFillMode", sSelectedKey);
+                oTransientContextForEasyFill = EasyFillFormRenderer.makeTransientContext(
+                    null, oObjectPageModel, oController
+                );
+
+                // Update dialog model with section data and AI result.
+                // llmData must be set BEFORE sections so that when the sections binding fires
+                // and triggers the populateSmartFields formatter synchronously, the AI-suggested
+                // values are already available and can be written to the transient context.
+                oModel.setProperty("/llmData", simpleFields);
+                oModel.setProperty("/updatableFields", mUpdatableLookupMap);
+                oModel.setProperty("/nonUpdatableFields", mNonUpdatableFields);
+                oModel.setProperty("/sections", aData);
+                oModel.setProperty("/hasNonUpdatableFields", Object.keys(mNonUpdatableFields).length > 0);
+
+                // Show warning if AI attempted to add multiple new rows but only one was accepted
+                oModel.setProperty("/attemptedMultipleNewRows", oSplitResult.attemptedMultipleNewRows === true);
+
+                // Process collection/table updates
+                mCollectionUpdates = collectionFields;
+                mLastFieldMapping = mFieldMapping;
+                var mRejectedNewRows = oSplitResult.collectionsWithRejectedNewRows || {};
+                // hasTableUpdates is true when there are accepted updates OR rejected-only tables to show
+                var bHasTableUpdates = Object.keys(mCollectionUpdates).length > 0 ||
+                    Object.keys(mRejectedNewRows).length > 0;
+                oModel.setProperty("/hasTableUpdates", bHasTableUpdates);
+
+                // Render collection previews into the table preview container
+                EasyFillTableRenderer.renderCollectionPreviews(
+                    mCollectionUpdates,
+                    mFieldMapping,
+                    [],
+                    oController,
+                    oRb,
+                    mCollectionState,
+                    oTableStagingState,
+                    oObjectPageModel,
+                    _validateFieldsAndUpdateConfirmState,
+                    false,
+                    mRejectedNewRows
+                );
+
+                _validateFieldsAndUpdateConfirmState();
+
+                var iTotalFields = Object.keys(oSplit.updatableFields).length + Object.keys(oSplit.nonUpdatableFields).length;
+                if (iTotalFields === 0 && !bHasTableUpdates) {
+                    oModel.setProperty("/stateType", "NoEntries");
                     return;
                 }
-                    if (isEditable(oProperty)) {
-                        updatableFields[sKey] = oAiCallResult[sKey];
-                    } else {
-                        nonUpdatableFields[sKey] = oAiCallResult[sKey];
-                    }
 
-            });
-            return {updatableFields,nonUpdatableFields};
+                oModel.setProperty("/isIllustrationVisible", false);
+                oModel.setProperty("/isFormVisible", iTotalFields > 0 || bHasTableUpdates);
+            } else {
+                // AI call failed — show error illustration
+                oModel.setProperty("/stateType", "Error");
+            }
         }
 
-        //Checks if the field is editable or not
-
-        // It can be set in 2 ways using field-control, it would be present when sap:updatable attribute is not present
-        // 1. By attaching to an existing metadata property, sap:field-control-> path for the property
-        //Below are the values by which the editable state would be defined
-
         /**
-         * Value	Meaning
-         -----------------------------------------------
-            0	    Hidden (field not shown at all)
-            1	    Read-only (display only)
-            3	    Editable
-            7	    Mandatory (Still Editable)
-            */
-
-        // 2. By Adding to an annotation "com.sap.vocabularies.Common.v1.FieldControl"
-        
-        //Since "com.sap.vocabularies.Common.v1.FieldControl" is an V4 annotation, it would be given the first priority
-
-        function isEditable(oProperty) {
-            return isEditableByContextObject(oProperty, oObjectPageContext && oObjectPageContext.getObject && oObjectPageContext.getObject());
-        }
-
-        function isEditableByContextObject(oProperty, oContextObject) {
-            if (!oProperty) {
-                return false;
-            }
-
-            //Check for sap:updatable
-            const sUpdatable = oProperty["sap:updatable"];
-            if (sUpdatable) {
-               return sUpdatable === "false" ? false : true;
-            }
-
-            //Check for "com.sap.vocabularies.Common.v1.FieldControl"
-            const oAnnotation = oProperty["com.sap.vocabularies.Common.v1.FieldControl"];
-
-            if (oAnnotation && oAnnotation["EnumMember"]) {
-                const enumNumberType = oAnnotation["EnumMember"];
-                return enumNumberType === 'com.sap.vocabularies.Common.v1.FieldControlType/ReadOnly' ? false : true;
-            }
-
-
-            //Check for "sap:field-control"
-            const sFieldControl = oProperty["sap:field-control"];
-
-            if (sFieldControl) {
-                const iFieldControlValue = oContextObject && oContextObject[sFieldControl];
-                return iFieldControlValue === 1 ? false : true;
+         * Runs SmartForm.check() on every SmartForm in the EasyFill ObjectPageLayout.
+         * Returns true if all SmartForms pass validation (or none exist yet).
+         * As a side effect, check() visually marks invalid fields in the dialog.
+         *
+         * SmartForm.check() returns either:
+         *   - string[]          (synchronous validationMode) — field IDs with errors
+         *   - Promise<Object[]> (asynchronous validationMode) — resolves with field objects with errors
+         * Both are normalised via Promise.resolve() so the caller can always await the result.
+         *
+         * @returns {Promise<boolean>} resolves to true when all SmartForms have zero errors
+         */
+        async function _checkSmartFormsValidity() {
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (!oObjectPageLayout) {
+                return true;
             }
 
-            //If no restriction is present then by default all fields are editable
-            return true;
-        }
-
-        function splitAIResultByCollection(oAiData, mFieldMapping) {
-            var oSplitResult = {
-                simpleFields: {},
-                collectionFields: {}
-            };
-            Object.keys(oAiData || {}).forEach(function(sFieldName) {
-                var oFieldMeta = mFieldMapping[sFieldName];
-                var vFieldValue = oAiData[sFieldName];
-                var aCollectionRows = null;
-                if (Array.isArray(vFieldValue)) {
-                    aCollectionRows = vFieldValue;
-                } else if (vFieldValue && Array.isArray(vFieldValue.rows)) {
-                    aCollectionRows = vFieldValue.rows;
-                }
-                if (oFieldMeta && oFieldMeta.isCollection === true && aCollectionRows) {
-                    var aRowUpdates = aCollectionRows.filter(function(oRow) {
-                        return oRow && typeof oRow === "object" && (typeof oRow._contextPath === "string" || typeof oRow._rowIndex === "number");
+            // Collect one Promise<errorArray> per SmartForm found in the layout
+            var aCheckPromises = [];
+            oObjectPageLayout.getSections().forEach(function(oSection) {
+                oSection.getSubSections().forEach(function(oSubSection) {
+                    oSubSection.getBlocks().forEach(function(oBlock) {
+                        var aSmartFormCandidates = [];
+                        if (oBlock.isA("sap.ui.comp.smartform.SmartForm")) {
+                            aSmartFormCandidates.push(oBlock);
+                        } else if (typeof oBlock.getItems === "function") {
+                            // In condensed mode the SmartForm is nested inside a wrapper VBox;
+                            // look one level deeper to find it (mirrors EasyFillFormRenderer).
+                            oBlock.getItems().forEach(function(oItem) {
+                                if (oItem.isA("sap.ui.comp.smartform.SmartForm")) {
+                                    aSmartFormCandidates.push(oItem);
+                                }
+                            });
+                        }
+                        aSmartFormCandidates.forEach(function(oSmartForm) {
+                            // .catch(() => []) absorbs internal SmartField metadata-promise rejections
+                            // that fire when SmartFields are destroyed during a mode switch.
+                            aCheckPromises.push(
+                                Promise.resolve(oSmartForm.check()).catch(function() { return []; })
+                            );
+                        });
                     });
-
-                    // For current development, we are only supporting one SmartTable
-                    //  in future if we support multiple SmartTable in the same OP, then we can change the structure of collectionFields to support multiple tables
-                    const {isValid} = isValidSmartTable(oFieldMeta.entitySet);
-                    if (aRowUpdates.length > 0 &&  Object.keys(oSplitResult.collectionFields).length === 0 && isValid) {
-                        oSplitResult.collectionFields[sFieldName] = aRowUpdates;
-                    }
-                } else {
-                    oSplitResult.simpleFields[sFieldName] = vFieldValue;
-                }
+                });
             });
-            return oSplitResult;
-        }
 
-        function isValidSmartTable(sEntitySet) {
-            var aSmartTables = getObjectPageSmartTables();
-            const oSmartTable = aSmartTables.find(function(oSmartTable) {
-                return oSmartTable.getEntitySet() === sEntitySet;
+            // Resolve all checks in parallel; valid only when every SmartForm has no errors
+            var aResults = await Promise.all(aCheckPromises);
+            return aResults.every(function(aErrors) {
+                return Array.isArray(aErrors) && aErrors.length === 0;
             });
-            return {
-                isValid: !!oSmartTable,
-                smartTable: oSmartTable
-            };
         }
 
-        function getObjectPageSmartTables() {
-            if (!oObjectPage || !oObjectPage.findAggregatedObjects) {
-                return [];
-            }
-            //Currently we are looping all the tables in the ObjectPage, but it might contain custom smarttables
-            //In future we have to read the table data from annotations/manifest so that we dont confuse with custom smart tables
-            return oObjectPage.findAggregatedObjects(true, function(oControl) {
-                const isSmartTable = controlHelper.isSmartTable(oControl);
-                //Currently restricting it to Responsive Table and UITable, in future we have to extend it for other table types as well
-                return  isSmartTable && (oControl.getTable().isA("sap.m.Table") || oControl.getTable().isA("sap.ui.table.Table"));
-            }) || [];
+        /**
+         * Re-computes isSaveEnabled from the combined SmartForm and table SmartField validity
+         * flag. Called as the single source of truth for the Confirm button state.
+         *
+         * @param {boolean} bAllFieldsValid - true when both SmartForm and table SmartField checks pass
+         */
+        function _computeSaveEnabled(bAllFieldsValid) {
+            var bHasScalarChanges = Object.keys(mUpdatableLookupMap || {}).length > 0;
+            var bHasTableChanges = EasyFillApplyHandler.hasStagedCollectionChanges(oTableStagingState, mCollectionState);
+            var bHasChanges = bHasScalarChanges || bHasTableChanges;
+            oDialogModel().setProperty("/isSaveEnabled", bAllFieldsValid && bHasChanges);
         }
 
-        function appendCollectionMapForLLM(mPropertyMap) {
-            mCollectionRowContexts = Object.create(null);
-            mCollectionRowContextsByPath = Object.create(null);
-            mCollectionProperties = Object.create(null);
-            mCollectionEntityTypes = Object.create(null);
-            var aSmartTables = getObjectPageSmartTables();
-            if (!aSmartTables.length) {
-                return;
+        /**
+         * Runs SmartField.checkValuesValidity() on every editable table SmartField.
+         * Returns true if all fields pass (or no table exists yet).
+         *
+         * checkValuesValidity() returns a Promise<boolean> (true = valid).
+         *
+         * @returns {Promise<boolean>} resolves to true when all table SmartFields are valid
+         */
+        async function _checkTableSmartFieldsValidity() {
+            var sMarker = "easyfillTableSection";
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (!oObjectPageLayout) {
+                return true;
             }
-            var oMetaModel = oObjectPageModel && oObjectPageModel.getMetaModel();
-            aSmartTables.forEach(function(oSmartTable) {
-                var oHandler = oTemplateUtils.oServices.oPresentationControlHandlerFactory.getPresentationControlHandler(oSmartTable);
-                if (!oHandler) {
-                    return;
-                }
-                var sNavProperty = extractNavigationPropertyName(oHandler.getBindingPath());
-                if (!sNavProperty) {
-                    return;
-                }
-                var aVisibleProps = (oHandler.findVisibleColumnProperties && oHandler.findVisibleColumnProperties()) || [];
-                if (!aVisibleProps.length) {
-                    return;
-                }
-                var aRowContexts = (oHandler.getCurrentContexts && oHandler.getCurrentContexts()) || [];
-                var sEntitySetName = oSmartTable.getEntitySet();
-                var oEntitySet = oMetaModel.getODataEntitySet(oSmartTable.getEntitySet());
-                var oEntityType = oEntitySet && oMetaModel.getODataEntityType(oEntitySet.entityType);
-                if (!oEntityType || !oEntityType.property) {
-                    return;
-                }
-                var mPropertyByName = Object.create(null);
-                oEntityType.property.forEach(function(oProperty) {
-                    mPropertyByName[oProperty.name] = oProperty;
-                });
 
-                var oItemProperties = {};
-                aVisibleProps.forEach(function(sPropName) {
-                    var oProperty = mPropertyByName[sPropName];
-                    if (!oProperty) {
-                        return;
-                    }
-                    oItemProperties[sPropName] = {
-                        description: getLabel(oProperty) || sPropName,
-                        dataType: oProperty.type
-                    };
+            var aCheckPromises = [];
+
+            function scanTableForSmartFields(oTable) {
+                if (!oTable.isA("sap.m.Table") || !oTable.getVisible()) { return; }
+                oTable.getItems().forEach(function(oListItem) {
+                    if (!oListItem.isA("sap.m.ColumnListItem")) { return; }
+                    oListItem.getCells().forEach(function(oCell) {
+                        if (!oCell.isA("sap.ui.comp.smartfield.SmartField") || !oCell.getEditable()) { return; }
+                        var bValueStateOk = oCell.getValueState() !== "Error";
+                        aCheckPromises.push(
+                            Promise.resolve(oCell.checkValuesValidity()).then(function(bValid) {
+                                return bValueStateOk && bValid !== false;
+                            })
+                        );
+                    });
                 });
+            }
 
-                if (!Object.keys(oItemProperties).length) {
-                    return;
-                }
+            function scanVBox(oVBox) {
+                oVBox.getItems().forEach(function(oItem) { scanTableForSmartFields(oItem); });
+            }
 
-                var aCurrentItems = [];
-                var mRowsByPath = Object.create(null);
-                aRowContexts.forEach(function(oContext, iIndex) {
-                    if (!oContext || !oContext.getObject) {
-                        return;
-                    }
-                    var sContextPath = oContext.getPath && oContext.getPath();
-                    var oRowData = {_rowIndex: iIndex};
-                    if (typeof sContextPath === "string") {
-                        oRowData._contextPath = sContextPath;
-                        mRowsByPath[sContextPath] = {
-                            context: oContext,
-                            rowIndex: iIndex
-                        };
-                    }
-                    Object.keys(oItemProperties).forEach(function(sPropName) {
-                        var vValue = oContext.getProperty(sPropName);
-                        if (typeof vValue !== "object") {
-                            oRowData[sPropName] = vValue;
+            oObjectPageLayout.getSections().forEach(function(oSection) {
+                var bIsTableSection = oSection.getCustomData().some(function(oData) {
+                    return oData.getKey() === sMarker;
+                });
+
+                oSection.getSubSections().forEach(function(oSubSection) {
+                    oSubSection.getBlocks().forEach(function(oBlock) {
+                        if (!oBlock.isA("sap.m.VBox")) { return; }
+                        var bIsMarkedBlock = oBlock.getCustomData().some(function(oData) {
+                            return oData.getKey() === sMarker;
+                        });
+                        // Scan VBoxes that are either:
+                        // (a) directly marked (condensed mode: injected into Filled Fields SubSection)
+                        // (b) inside a marked standalone section (OP mode)
+                        if (bIsMarkedBlock || bIsTableSection) {
+                            scanVBox(oBlock);
                         }
                     });
-                    aCurrentItems.push(oRowData);
                 });
-
-                mCollectionRowContexts[sNavProperty] = aRowContexts;
-                mCollectionRowContextsByPath[sNavProperty] = mRowsByPath;
-                mCollectionProperties[sNavProperty] = mPropertyByName;
-                mCollectionEntityTypes[sNavProperty] = oEntityType;
-                mPropertyMap[sNavProperty] = {
-                    description: typeof oSmartTable.getHeader() === "string" ? oSmartTable.getHeader() : sNavProperty,
-                    dataType: "Collection",
-                    isCollection: true,
-                    itemProperties: oItemProperties,
-                    currentItems: aCurrentItems,
-                    entitySet: sEntitySetName,
-                    section: typeof oSmartTable.getHeader() === "string" ? oSmartTable.getHeader() : sNavProperty
-                };
             });
-        }
 
-        function extractNavigationPropertyName(sBindingPath) {
-            if (!sBindingPath || typeof sBindingPath !== "string") {
-                return null;
-            }
-            var aParts = sBindingPath.split("/").filter(Boolean);
-            return aParts.length ? aParts[aParts.length - 1] : null;
+            var aResults = await Promise.all(aCheckPromises);
+            return aResults.every(function(bValid) { return bValid === true; });
         }
 
-        function resolveCollectionRowContext(sCollectionName, oRowUpdate) {
-            var mByPath = mCollectionRowContextsByPath[sCollectionName] || Object.create(null);
-            var sContextPath = oRowUpdate && oRowUpdate._contextPath;
-            if (typeof sContextPath === "string" && mByPath[sContextPath]) {
-                return mByPath[sContextPath];
-            }
-            var iRowIndex = oRowUpdate && oRowUpdate._rowIndex;
-            var aRowContexts = mCollectionRowContexts[sCollectionName] || [];
-            if (typeof iRowIndex === "number" && aRowContexts[iRowIndex]) {
-                return {
-                    context: aRowContexts[iRowIndex],
-                    rowIndex: iRowIndex
-                };
-            }
-            return null;
-        }
-
-        function readValueListByEquality(sCollectionPath, sValueListProperty, vValue) {
-            return new Promise(function(resolve) {
-                oObjectPageModel.read("/" + sCollectionPath, {
-                    filters: [
-                        new Filter({
-                            path: sValueListProperty,
-                            operator: FilterOperator.EQ,
-                            value1: vValue
-                        })
-                    ],
-                    success: function(oResponse) {
-                        resolve(!!(oResponse && Array.isArray(oResponse.results) && oResponse.results.length > 0));
-                    },
-                    error: function() {
-                        resolve(true);
-                    }
-                });
-            });
+        /**
+         * Called after every SmartField change event (both form and table) and once after each
+         * group/table is populated. Validates all SmartForms and all table SmartFields and
+         * updates the Confirm button enabled state.
+         */
+        function _validateFieldsAndUpdateConfirmState() {
+            setTimeout(function() {
+                Promise.all([
+                    _checkSmartFormsValidity(),
+                    _checkTableSmartFieldsValidity()
+                ]).then(function(aResults) {
+                    _computeSaveEnabled(aResults[0] && aResults[1]);
+                }).catch(Function.prototype);
+            }, 0);
         }
 
-        async function validateCollectionUpdatesAgainstValueHelp(mFieldMapping) {
-            const oMetaModel = oObjectPageModel && oObjectPageModel.getMetaModel();
-            if (!oMetaModel) {
-                return [];
-            }
-            const aValidationErrors = [];
-            const aCollectionNames = Object.keys(mCollectionUpdates || {});
-            for (const sCollectionName of aCollectionNames) {
-                const aRowUpdates = mCollectionUpdates[sCollectionName] || [];
-                const mCollectionPropertyMap = mCollectionProperties[sCollectionName] || Object.create(null);
-                const oCollectionEntityType = mCollectionEntityTypes[sCollectionName];
-                const sCollectionLabel = (mFieldMapping[sCollectionName] && mFieldMapping[sCollectionName].description) || sCollectionName;
-                if (!oCollectionEntityType) {
-                    continue;
-                }
-                for (const oRowUpdate of aRowUpdates) {
-                    const oResolvedRow = resolveCollectionRowContext(sCollectionName, oRowUpdate);
-                    if (!oResolvedRow || !oResolvedRow.context) {
-                        continue;
-                    }
-                    const oRowContext = oResolvedRow.context;
-                    const oRowObject = oRowContext.getObject && oRowContext.getObject();
-                    const sRowLabel = oRb.getText("EASY_FILL_TABLE_ROW_LABEL", [String((oResolvedRow.rowIndex || 0) + 1)]);
-                    for (const sPropertyName of Object.keys(oRowUpdate)) {
-                        if (sPropertyName === "_rowIndex" || sPropertyName === "_contextPath") {
-                            continue;
-                        }
-                        const oPropertyMeta = mCollectionPropertyMap[sPropertyName];
-                        if (!oPropertyMeta || !isEditableByContextObject(oPropertyMeta, oRowObject)) {
-                            continue;
-                        }
-                        if (!GenericAnnotationHelper.isValueHelpTableAvailable(oPropertyMeta)) {
-                            continue;
-                        }
-                        const vUpdatedValue = oRowUpdate[sPropertyName];
-                        if (vUpdatedValue === null || vUpdatedValue === undefined || typeof vUpdatedValue === "object") {
-                            continue;
-                        }
-                        try {
-                            const sPropertyPath = oMetaModel.getODataProperty(oCollectionEntityType, sPropertyName, true);
-                            if (!sPropertyPath) {
-                                continue;
-                            }
-                            const oPropertyContext = oMetaModel.createBindingContext(sPropertyPath);
-                            const oValueLists = await oMetaModel.getODataValueLists(oPropertyContext);
-                            const oDefaultValueList = oValueLists && oValueLists[""];
-                            if (!oDefaultValueList || !oDefaultValueList.CollectionPath || !oDefaultValueList.CollectionPath.String) {
-                                continue;
-                            }
-                            let sValueListProperty = sPropertyName;
-                            if (Array.isArray(oDefaultValueList.Parameters)) {
-                                const oParameter = oDefaultValueList.Parameters.find(function(oParam) {
-                                    return (
-                                        oParam.RecordType === "com.sap.vocabularies.Common.v1.ValueListParameterInOut" &&
-                                        oParam.LocalDataProperty &&
-                                        oParam.LocalDataProperty.PropertyPath === sPropertyName
-                                    );
-                                });
-                                if (oParameter && oParameter.ValueListProperty && oParameter.ValueListProperty.String) {
-                                    sValueListProperty = oParameter.ValueListProperty.String;
-                                }
-                            }
-                            const bValueFound = await readValueListByEquality(
-                                oDefaultValueList.CollectionPath.String,
-                                sValueListProperty,
-                                vUpdatedValue
-                            );
-                            if (!bValueFound) {
-                                aValidationErrors.push({
-                                    collectionName: sCollectionName,
-                                    collectionLabel: sCollectionLabel,
-                                    rowLabel: sRowLabel,
-                                    rowIndex: oResolvedRow.rowIndex,
-                                    rowPath: oRowContext.getPath && oRowContext.getPath(),
-                                    propertyName: sPropertyName,
-                                    propertyLabel: getLabel(oPropertyMeta) || sPropertyName
-                                });
-                            }
-                        } catch (e) {
-                            // If metadata/value list cannot be resolved, we keep current behavior and do not block save.
-                        }
-                    }
+        /**
+         * Resets the EasyFill dialog to its initial state.
+         * Delegates to EasyFillApplyHandler.resetEasyFill with the current state references.
+         *
+         * @param {boolean} [bRemoveTextAreaValue=false] - if true, also clears the text area input
+         */
+        function _resetEasyFill(bRemoveTextAreaValue) {
+            mLastFieldMapping = null;
+            EasyFillApplyHandler.resetEasyFill(
+                !!bRemoveTextAreaValue,
+                oDialogModel(),
+                oController,
+                mCollectionUpdates,
+                EasyFillLayoutMode,
+                function() {
+                    EasyFillTableRenderer.resetStagedCollectionContexts(oTableStagingState, oObjectPageModel);
+                },
+                function() {
+                    EasyFillFormRenderer.resetTransientContext(oTransientContextForEasyFill, oObjectPageModel);
+                    oTransientContextForEasyFill = null;
                 }
-            }
-            return aValidationErrors;
+            );
         }
 
-        function stringifyCellValue(vValue) {
-            if (vValue === null || vValue === undefined) {
-                return "";
-            }
-            if (vValue instanceof Date) {
-                return vValue.toISOString();
+        /**
+         * Activates side effects for all editable SmartFields in the EasyFill SmartForm.
+         * Called after applyAndSave so that side effects are triggered on the original
+         * ObjectPage context (not the transient context used while the dialog was open).
+         *
+         * Collects field group IDs from the inner controls of every editable SmartField,
+         * updates the view's CustomData for each field group to reference the OP context,
+         * then registers the group change and triggers field-group validation on the view.
+         */
+        function _activateSideEffects() {
+            var oObjectPageLayout = oController.byId("EasyFillObjectPageLayout");
+            if (!oObjectPageLayout) {
+                return;
             }
-            return String(vValue);
-        }
-
-        function createPreviewTable(aPropertyNames, oItemProperties, aRows, fnCellFormatter) {
-            var aColumns = aPropertyNames.map(function(sPropertyName) {
-                return new Column({
-                    header: new Text({ text: (oItemProperties[sPropertyName] && oItemProperties[sPropertyName].description) || sPropertyName })
-                });
-            });
 
-            var aItems = aRows.map(function(oRow) {
-                return new ColumnListItem({
-                    cells: aPropertyNames.map(function(sPropertyName) {
-                        var sText = fnCellFormatter
-                            ? fnCellFormatter(oRow, sPropertyName, stringifyCellValue(oRow[sPropertyName]))
-                            : stringifyCellValue(oRow[sPropertyName]);
-                        return new Text({ text: sText });
-                    })
-                });
-            });
-
-            return new Table({
-                columns: aColumns,
-                items: aItems,
-                fixedLayout: false,
-                autoPopinMode: true
-            }).addStyleClass("sapSmartTemplatesObjectPageEasyFillTablePreview");
-        }
-
-        function stageCollectionUpdatesForPreview() {
-            mStagedRowValues = Object.create(null);
-            Object.keys(mCollectionUpdates).forEach(function(sCollectionName) {
-                var mCollectionPropertyMap = mCollectionProperties[sCollectionName] || Object.create(null);
-                var aRowUpdates = mCollectionUpdates[sCollectionName] || [];
-                aRowUpdates.forEach(function(oRowUpdate) {
-                    var oResolved = resolveCollectionRowContext(sCollectionName, oRowUpdate);
-                    if (!oResolved || !oResolved.context) { return; }
-                    var oContext = oResolved.context;
-                    var sPath = oContext.getPath && oContext.getPath();
-                    if (!sPath) { return; }
-                    if (!mStagedRowValues[sPath]) {
-                        mStagedRowValues[sPath] = { context: oContext, originalValues: {} };
-                    }
-                    var oRowObject = oContext.getObject && oContext.getObject();
-                    Object.keys(oRowUpdate).forEach(function(sPropName) {
-                        if (sPropName === "_rowIndex" || sPropName === "_contextPath") { return; }
-                        var oPropertyMeta = mCollectionPropertyMap[sPropName];
-                        if (!isEditableByContextObject(oPropertyMeta, oRowObject)) { return; }
-                        if (!Object.prototype.hasOwnProperty.call(mStagedRowValues[sPath].originalValues, sPropName)) {
-                            mStagedRowValues[sPath].originalValues[sPropName] = oContext.getProperty(sPropName);
+            // Collect all editable SmartFields from the EasyFill dialog SmartForms
+            var aEditableFields = [];
+            oObjectPageLayout.getSections().forEach(function(oSection) {
+                oSection.getSubSections().forEach(function(oSubSection) {
+                    oSubSection.getBlocks().forEach(function(oBlock) {
+                        if (oBlock.isA("sap.ui.comp.smartform.SmartForm")) {
+                            oBlock.getGroups().forEach(function(oGroup) {
+                                oGroup.getGroupElements().forEach(function(oGroupElement) {
+                                    oGroupElement.getElements().forEach(function(oElement) {
+                                        if (oElement.isA && oElement.isA("sap.ui.comp.smartfield.SmartField") && oElement.getEditable()) {
+                                            aEditableFields.push(oElement);
+                                        }
+                                    });
+                                });
+                            });
                         }
-                        oContext.setProperty(sPropName, oRowUpdate[sPropName]);
                     });
                 });
             });
-        }
 
-        function revertStagedCollectionUpdates() {
-            Object.keys(mStagedRowValues).forEach(function(sPath) {
-                var oEntry = mStagedRowValues[sPath];
-                var oContext = oEntry.context;
-                Object.keys(oEntry.originalValues).forEach(function(sPropName) {
-                    oContext.setProperty(sPropName, oEntry.originalValues[sPropName]);
+            // Making a Set so that duplicate field group IDs are not passed
+            var aFieldGroupIdSet = new Set();
+            aEditableFields.forEach(function(oSmartField) {
+                // SideEffect would be invoked only for the editable controls inside the SmartField
+                var aEditableInnerFields = oSmartField.getInnerControls().filter(function(oControl) {
+                    return oControl.getEditable();
+                });
+                aEditableInnerFields.forEach(function(oControl) {
+                    var aControlFieldGroupId = oControl.getFieldGroupIds();
+                    if (aControlFieldGroupId.length > 0) {
+                        aControlFieldGroupId.forEach(function(sFieldGroupId) {
+                            aFieldGroupIdSet.add(sFieldGroupId);
+                        });
+                    }
                 });
             });
-            mStagedRowValues = Object.create(null);
-        }
 
-        function buildCollectionPreviewRow(aPropertyNames, oResolvedRow, oRowUpdate, bUseUpdatedValues) {
-            var oPreviewRow = {};
-            var oContext = oResolvedRow && oResolvedRow.context;
-            var sPath = oContext && oContext.getPath && oContext.getPath();
-            var oStagedEntry = sPath && mStagedRowValues[sPath];
-            aPropertyNames.forEach(function(sPropertyName) {
-                if (bUseUpdatedValues && oRowUpdate && Object.prototype.hasOwnProperty.call(oRowUpdate, sPropertyName)) {
-                    oPreviewRow[sPropertyName] = oRowUpdate[sPropertyName];
-                    return;
-                }
-                if (!bUseUpdatedValues && oStagedEntry && Object.prototype.hasOwnProperty.call(oStagedEntry.originalValues, sPropertyName)) {
-                    oPreviewRow[sPropertyName] = oStagedEntry.originalValues[sPropertyName];
-                    return;
+            var oView = oController.getView();
+
+            aFieldGroupIdSet.forEach(function(sFieldGroupId) {
+                var oID = oView.data(sFieldGroupId);
+
+                /**
+                 * Currently, the SmartFields are created using the TransientContext, which means both
+                 * "context" and "contextObject" refer to the TransientContext instance.
+                 *
+                 * However, we need to use the original OP context so that side effects are triggered
+                 * on the original OP context when the user saves data from the EasyFill dialog back to OP.
+                 *
+                 * Therefore, we update the "context" and "contextObject" to reference the original OP context.
+                 */
+                if (oID) {
+                    oID["context"] = oObjectPageContext.getPath();
+                    oID["contextObject"] = oObjectPageContext;
+                    oView.data(sFieldGroupId, oID);
+
+                    // To make sure that all the fields side effect would be triggered
+                    var sSideEffectQualifier = oTemplateUtils.oServices.oApplicationController._getSideEffectsQualifier(oID.name);
+                    oTemplateUtils.oServices.oApplicationController.registerGroupChange(sSideEffectQualifier);
                 }
-                oPreviewRow[sPropertyName] = oContext ? oContext.getProperty(sPropertyName) : "";
             });
-            return oPreviewRow;
+
+            oView.triggerValidateFieldGroup([...aFieldGroupIdSet]);
         }
 
-        function getCollectionRowIdentity(oResolvedRow, oRowUpdate, iFallbackIndex) {
-            if (oResolvedRow && oResolvedRow.context && oResolvedRow.context.getPath) {
-                return oResolvedRow.context.getPath();
-            }
-            if (oRowUpdate && typeof oRowUpdate._contextPath === "string") {
-                return oRowUpdate._contextPath;
-            }
-            if (oRowUpdate && typeof oRowUpdate._rowIndex === "number") {
-                return "index:" + String(oRowUpdate._rowIndex);
+        /**
+         * Activates side effects for all modified table (collection) rows after applyAndSave.
+         * For each collection row that had AI-suggested value changes applied, triggers
+         * executeSideEffects on the real row context with the list of changed property names.
+         *
+         * Must be called with mStagedUpdates captured BEFORE applyAndSave, because after
+         * applyAndSave the staged values equal the live values so buildStagedCollectionUpdates
+         * would return an empty map.
+         *
+         * @param {object} mStagedUpdates - pre-computed collection updates: { navProperty: [ rowUpdate ] }
+         */
+        function _activateSideEffectsForTable(mStagedUpdates) {
+            if (!mStagedUpdates || !Object.keys(mStagedUpdates).length) {
+                return;
             }
-            return "row:" + String(iFallbackIndex);
-        }
 
-        function createEditableNewTable(aPropertyNames, oItemProperties, aPreviewRows, sCollectionName) {
-            var aColumns = aPropertyNames.map(function(sPropName) {
-                return new Column({
-                    header: new Text({ text: (oItemProperties[sPropName] && oItemProperties[sPropName].description) || sPropName })
-                });
-            });
-            var mCollectionPropertyMap = mCollectionProperties[sCollectionName] || Object.create(null);
-            var aItems = aPreviewRows.map(function(oPreviewRow) {
-                var oContext = oPreviewRow.context;
-                var oRowObject = oContext && oContext.getObject && oContext.getObject();
-                var aCells = aPropertyNames.map(function(sPropName) {
-                    if (!oContext) {
-                        return new Text({ text: stringifyCellValue(oPreviewRow.newValues[sPropName]) });
+            Object.keys(mStagedUpdates).forEach(function(sCollectionName) {
+                var aRowUpdates = mStagedUpdates[sCollectionName] || [];
+                aRowUpdates.forEach(function(oRowUpdate) {
+                    var oResolvedRow = EasyFillApplyHandler._resolveCollectionRowContext(sCollectionName, oRowUpdate, mCollectionState);
+                    if (!oResolvedRow || !oResolvedRow.context) {
+                        return;
                     }
-                    var oPropertyMeta = mCollectionPropertyMap[sPropName];
-                    var bEditable = isEditableByContextObject(oPropertyMeta, oRowObject);
-                    var oSmartField = new SmartField({
-                        value: "{" + sPropName + "}",
-                        editable: bEditable,
-                        enabled: bEditable,
-                        contextEditable: bEditable,
-                        // change: onSmartFieldChange.bind(this),
-                        editableChanged: function(oEvent) {
-                            // Keep table SmartField editability deterministic in preview mode.
-                            if (oEvent.getParameter("editable") !== bEditable) {
-                                oEvent.getSource().setEditable(bEditable);
-                            }
-                        }
+
+                    // Collect the names of changed properties (exclude internal metadata fields)
+                    var aChangedProperties = Object.keys(oRowUpdate).filter(function(sKey) {
+                        return sKey !== "_rowIndex" && sKey !== "_contextPath";
                     });
 
-                    if (bEditable) {
-                        aEditableFields.push(oSmartField);
+                    if (!aChangedProperties.length) {
+                        return;
                     }
-                    return oSmartField;
+
+                    oTemplateUtils.oServices.oApplicationController.executeSideEffects(
+                        oResolvedRow.context,
+                        aChangedProperties
+                    );
                 });
-                var oItem = new ColumnListItem({ cells: aCells });
-                if (oContext) {
-                    oItem.setBindingContext(oContext);
-                }
-                return oItem;
             });
-            return new Table({
-                columns: aColumns,
-                items: aItems,
-                fixedLayout: false,
-                autoPopinMode: true
-            }).addStyleClass("sapSmartTemplatesObjectPageEasyFillTablePreview");
         }
 
-        function renderCollectionPreviews(mFieldMapping, aTableValidationErrors) {
-            var oTablePreviewContainer = oController.byId("EasyFillTablePreviewContainer");
-            if (!oTablePreviewContainer) {
-                return;
-            }
-            oTablePreviewContainer.destroyItems();
-            // Stage LLM values onto OData row contexts; saves originals for revert on cancel
-            stageCollectionUpdatesForPreview();
-            var mInvalidCellByPath = Object.create(null);
-            (aTableValidationErrors || []).forEach(function(oError) {
-                if (!oError || !oError.rowPath) {
-                    return;
-                }
-                mInvalidCellByPath[oError.rowPath + "|" + oError.propertyName] = true;
-            });
-
-            Object.keys(mCollectionUpdates).forEach(function(sCollectionName) {
-                var oCollectionMeta = mFieldMapping[sCollectionName];
-                if (!oCollectionMeta || !oCollectionMeta.itemProperties) {
-                    return;
-                }
-                var aRowUpdates = mCollectionUpdates[sCollectionName] || [];
-                var aPropertyNames = Object.keys(oCollectionMeta.itemProperties || {});
-                if (!aPropertyNames.length) {
-                    return;
-                }
-                var mUpdatesByIdentity = Object.create(null);
-                aRowUpdates.forEach(function(oRowUpdate, iUpdateIndex) {
-                    var oResolvedUpdate = resolveCollectionRowContext(sCollectionName, oRowUpdate);
-                    mUpdatesByIdentity[getCollectionRowIdentity(oResolvedUpdate, oRowUpdate, iUpdateIndex)] = oRowUpdate;
-                });
-                var aPreviewRows = [];
-                var aCollectionRowContexts = mCollectionRowContexts[sCollectionName] || [];
-                aCollectionRowContexts.forEach(function(oContext, iRowIndex) {
-                    var oResolved = {
-                        context: oContext,
-                        rowIndex: iRowIndex
-                    };
-                    var sIdentity = getCollectionRowIdentity(oResolved, null, iRowIndex);
-                    var oRowUpdate = mUpdatesByIdentity[sIdentity];
-                    aPreviewRows.push({
-                        context: oContext,
-                        rowIndex: iRowIndex,
-                        update: oRowUpdate,
-                        previousValues: buildCollectionPreviewRow(aPropertyNames, oResolved, oRowUpdate, false),
-                        newValues: buildCollectionPreviewRow(aPropertyNames, oResolved, oRowUpdate, true)
-                    });
-                });
-                aPreviewRows = aPreviewRows.slice(0, MAX_TABLE_PREVIEW_ROWS);
-
-                var aPreviousRows = aPreviewRows.map(function(oPreviewRow) {
-                    return oPreviewRow.previousValues;
-                });
-
-                if (!aPreviewRows.length) {
-                    return;
-                }
-
-                var oPreviousTable = createPreviewTable(aPropertyNames, oCollectionMeta.itemProperties, aPreviousRows);
-                var oNewTable = createEditableNewTable(aPropertyNames, oCollectionMeta.itemProperties, aPreviewRows, sCollectionName);
-                oPreviousTable.setVisible(false);
-
-                var oSectionTitle = new Title({
-                    level: "H5",
-                    text: (oCollectionMeta.description || sCollectionName) + " (" + aPreviewRows.length + ")"
-                });
-
-                var oSegmentedButton = new SegmentedButton({
-                    selectedKey: "new",
-                    width:"auto",
-                    items: [
-                        new SegmentedButtonItem({ key: "previous", text: oRb.getText("EASY_FILL_TABLE_VIEW_PREVIOUS"), width:"auto" }),
-                        new SegmentedButtonItem({ key: "new", text: oRb.getText("EASY_FILL_TABLE_VIEW_NEW"), width:"auto" })
-                    ],
-                    selectionChange: function() {
-                        var sKey = oSegmentedButton.getSelectedKey();
-                        oPreviousTable.setVisible(sKey === "previous");
-                        oNewTable.setVisible(sKey === "new");
-                    }
-                });
-
-                var oHeader = new HBox({
-                    justifyContent: "SpaceBetween",
-                    items: [oSectionTitle, oSegmentedButton]
-                }).addStyleClass("sapUiSmallMarginTop");
-
-                var oSection = new VBox({
-                    items: [oHeader, oPreviousTable, oNewTable]
-                }).addStyleClass("sapSmartTemplatesObjectPageEasyFillTableSection");
+        /**
+         * Convenience accessor for the easyFillDialogModel JSONModel.
+         * @returns {sap.ui.model.json.JSONModel}
+         */
+        function oDialogModel() {
+            return oController.getView().getModel("easyFillDialogModel");
+        }
 
-                oTablePreviewContainer.addItem(oSection);
+        function _findSmartTableForNavProperty(aSmartTables, sNavProperty) {
+            return aSmartTables.find(function(oTable) {
+                var oHandler = oTemplateUtils.oServices.oPresentationControlHandlerFactory.getPresentationControlHandler(oTable);
+                if (!oHandler) { return false; }
+                var sPath = oHandler.getBindingPath && oHandler.getBindingPath();
+                return sPath && sPath.split("/").pop() === sNavProperty;
             });
         }
 
-        function isVisible(oProperty) {
-
-            //Check for "com.sap.vocabularies.Common.v1.FieldControl"
-            const oAnnotation = oProperty["com.sap.vocabularies.Common.v1.FieldControl"];
-
-            if (oAnnotation && oAnnotation["EnumMember"]) {
-                const enumNumberType = oAnnotation["EnumMember"];
-                return enumNumberType === 'com.sap.vocabularies.Common.v1.FieldControlType/Hidden' ? false : true;
+        /**
+         * Creates new table rows via CommonEventHandlers.addEntry (draft-aware) with navigation
+         * suppressed so the user stays on the ObjectPage.
+         * Using CommonEventHandlers.addEntry (bSuppressNavigation=true) instead of calling
+         * CRUDManager.addEntry directly ensures the SmartTable binding is refreshed and side
+         * effects are executed after the row is created — without that refresh the ObjectPage
+         * table would not show the newly created row.
+         *
+         * @param {object} mNewRowValues - map of { navProperty: plainValuesObject }
+         * @returns {Promise<void>}
+         */
+        async function _createNewRows(mNewRowValues) {
+            if (!mNewRowValues || !Object.keys(mNewRowValues).length) {
+                return;
             }
+            var aSmartTables = EasyFillFieldCollector.getObjectPageSmartTables(oObjectPage);
+            var aNavProperties = Object.keys(mNewRowValues);
 
-            //Check for Hidden annotation i.e com.sap.vocabularies.UI.v1.Hidden
-            const oHiddenAnnotation = oProperty["com.sap.vocabularies.UI.v1.Hidden"];
-            if (oHiddenAnnotation) {
-                let bIsVisible = false;    // <Annotation Term="UI.Hidden"/>
-                if (oHiddenAnnotation["Bool"]) {
-                    bIsVisible = (oHiddenAnnotation["Bool"] === "true") ? false : true;
-                } else if (oHiddenAnnotation["Path"]) {
-                    bIsVisible = !oObjectPageContext.getObject()[oHiddenAnnotation["Path"]];
+            for (var i = 0; i < aNavProperties.length; i++) {
+                var sNavProp = aNavProperties[i];
+                var oSmartTable = _findSmartTableForNavProperty(aSmartTables, sNavProp);
+                if (!oSmartTable) {
+                    continue;
+                }
+                try {
+                    // bSuppressNavigation=true: stay on the OP (don't navigate to the new sub-item).
+                    // bIgnoreTableRefresh not passed (undefined/falsy): the SmartTable binding is
+                    // refreshed and side effects are executed so the new row becomes visible.
+                    await oTemplateUtils.oCommonEventHandlers.addEntry(oSmartTable, true, undefined, mNewRowValues[sNavProp]);
+                } catch (e) {
+                    // addEntry handles its own error messaging via CommonEventHandlers/CRUDManager
                 }
-                return bIsVisible;
-            }
-
-            //Check for "sap:field-control"
-            const sFieldControl = oProperty["sap:field-control"];
-
-            if (sFieldControl) {
-                const iFieldControlValue = oObjectPageContext.getObject()[sFieldControl];
-                return iFieldControlValue === 0 ? false : true;
-            }
-
-            //If no restriction is present then by default all fields are visible
-            return true;
-        }
-
-        function resetTransientContext() {
-            if (oTransientContextForEasyFill) {
-                oObjectPageModel.resetChanges([oTransientContextForEasyFill.getPath()],false,true);
-                oTransientContextForEasyFill = null;
-            }
-        }
-
-        function makeTransientContext() {
-            if (oTransientContextForEasyFill) {
-                resetTransientContext();
             }
-            oTransientContextForEasyFill = oObjectPageModel.createEntry("/" + oController.getOwnerComponent().getEntitySet(), {
-                "groupId" : "EasyFillFETransientChanges",
-                "changeSetId":"EasyFillFETransientChanges"
-            });
         }
 
-        //Yet to implement, temporarily disabled
-        //  function onSmartFieldChange() {
-        //     validateSmartForm();
-        // }
-
+        // ─── Public API ──────────────────────────────────────────────────────────
 
         return {
+            /**
+             * Entry point called by the ObjectPage ControllerImplementation when the
+             * EasyFill button is pressed.
+             *
+             * If the ObjectPage is already in edit mode, the dialog opens immediately.
+             * If not, the page is transitioned to edit mode first and the resulting
+             * edit context is passed into the dialog.
+             *
+             * @param {sap.ui.base.Event} oEvent - the button click event
+             */
             onEasyFillButtonClick: function(oEvent) {
-                // Once you click on the easyFill button the OP should be going to editable state, if its already in editState then directly open the dialog
-                //If its in non-editable state we should wait until the context switch, We need that context to finally save the data from the AI into the newly came editable context of the OP
-                const isEditable = oController.getView().getModel("ui").getProperty("/editable");
-                if (isEditable) {
+                var bIsEditable = oController.getView().getModel("ui").getProperty("/editable");
+                if (bIsEditable) {
                     openEasyFillDialog(oEvent);
                 } else {
-                    oController._templateEventHandlers.onEditByEasyFill().then((oContext)=>{
-                        oObjectPageContext = oContext;
-                        openEasyFillDialog(oEvent,oContext);
-                    }).catch(Function.prototype);
+                    // Trigger the OP edit flow and wait for the new edit context before opening
+                    oController._templateEventHandlers.onEditByEasyFill()
+                        .then(function(oContext) {
+                            oObjectPageContext = oContext;
+                            openEasyFillDialog(oEvent, oContext);
+                        })
+                        .catch(Function.prototype);
                 }
             }
         };
     }
 
     return BaseObject.extend("sap.suite.ui.generic.template.lib.ai.EasyFill.EasyFillHandler", {
-        constructor: function (oState, oController, oTemplateUtils, oObjectPage) {
+        /**
+         * Constructor — wires all helpers and exposes the public API via getMethods.
+         *
+         * @param {object} oState - shared template state (passed from ControllerImplementation)
+         * @param {object} oController - MVC controller instance
+         * @param {object} oTemplateUtils - FE template utilities (services, common utils, etc.)
+         * @param {object} oObjectPage - the ObjectPage control instance
+         */
+        constructor: function(oState, oController, oTemplateUtils, oObjectPage) {
             extend(this, getMethods(oState, oController, oTemplateUtils, oObjectPage));
         }
     });
-    
 });