tango-app-ui-store-builder 1.0.46 → 1.0.48

package/esm2022/lib/components/collection-update-ai/find-replace-layout/prepare-template/prepare-template.component.mjs

@@ -0,0 +1,2524 @@
+import { Component, ViewChild } from '@angular/core';
+import { ReactiveFormsModule, FormsModule } from '@angular/forms';
+import { CommonModule, TitleCasePipe } from '@angular/common';
+import { ReactiveSelectComponent } from '../../../reactive-select/reactive-select.component';
+import { StoreSelectComponent } from '../../components/store-select/store-select.component';
+import { StoreDropdownComponent } from '../../components/store-dropdown/store-dropdown.component';
+import { FormControl } from '@angular/forms';
+import { Subject, takeUntil } from 'rxjs';
+import * as fabric from "fabric";
+import { StoreFixtureComponent } from '../../components/store-fixture/store-fixture.component';
+import { BatchConfirmationModalComponent } from './batch-confirmation-modal/batch-confirmation-modal.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../services/store-builder.service";
+import * as i2 from "../../services/data.service";
+import * as i3 from "@angular/common";
+import * as i4 from "tango-app-ui-global";
+import * as i5 from "@angular/router";
+import * as i6 from "tango-app-ui-shared";
+import * as i7 from "@ng-bootstrap/ng-bootstrap";
+import * as i8 from "@angular/forms";
+export class PrepareTemplateComponent {
+    storeBuilderService;
+    dataService;
+    titleCase;
+    cdr;
+    gs;
+    router;
+    route;
+    toastService;
+    modalService;
+    searchModes = [
+        { value: 'store', label: 'Stores' },
+        { value: 'cluster', label: 'Clusters' },
+    ];
+    selectedMode = new FormControl('store');
+    target = new FormControl('both');
+    findPrompt = new FormControl('');
+    replacePrompt = new FormControl('');
+    storeOptions = [];
+    clusterData = []; // Store full cluster data with stores
+    loading = false;
+    savingDraft = false;
+    batchProcessing = false;
+    destroy$ = new Subject();
+    selectedStores = [];
+    findReplaceData = null;
+    selectedStoreForPreview = null;
+    storeListForDropdown = [];
+    storeDropdownItems = [];
+    selectedStoreValues = [];
+    // Canvas properties
+    previewCanvasRef;
+    previewCanvasContainerRef;
+    previewCanvas;
+    planoData;
+    floorData;
+    wallThickness = 30;
+    verticalMargin = (1.25 / 100) * this.toPixels(1524, "mm");
+    cdnUrl = '';
+    activeHighlight = null;
+    cancelHighlightBlink = false;
+    selectedFixture;
+    selectedFixtureData = null;
+    originalFixtureData = null; // Original fixture before replace (for before/after comparison)
+    originalFixturesMap = new Map(); // Store original fixtures by fixtureId
+    isRightPanelCollapsed = false;
+    canvasLoading = false;
+    findLoading = false;
+    replaceLoading = false;
+    allFixtureInstances = [];
+    vmList = [];
+    clientId = '';
+    hideMetadata = false;
+    get hasStores() {
+        return !!(this.findReplaceData?.stores && this.findReplaceData.stores.length > 0);
+    }
+    getStoreCount() {
+        return this.findReplaceData?.storeCount || this.findReplaceData?.stores?.length || 0;
+    }
+    getCurrentFixtureData() {
+        return this.selectedFixtureData || this.originalFixtureData;
+    }
+    getFixtureLabel() {
+        const fixture = this.getCurrentFixtureData();
+        return fixture?.header?.label || '';
+    }
+    getFixtureCategory() {
+        const fixture = this.getCurrentFixtureData();
+        return fixture?.fixtureCategory || '';
+    }
+    getFixtureWidth() {
+        const fixture = this.getCurrentFixtureData();
+        if (!fixture?.fixtureWidth)
+            return '';
+        const width = fixture.fixtureWidth.value;
+        const unit = fixture.fixtureWidth.unit || 'mm';
+        let dimensionStr = `${width}${unit}`;
+        // Convert to feet if needed (1200mm = 4ft)
+        if (unit === 'mm' && width === 1200) {
+            dimensionStr = `${width}${unit}/4ft`;
+        }
+        else if (unit === 'mm' && width > 0) {
+            const feet = Math.round(width / 300);
+            if (feet > 0) {
+                dimensionStr = `${width}${unit}/${feet}ft`;
+            }
+        }
+        return dimensionStr;
+    }
+    getShelfCount() {
+        const fixture = this.getCurrentFixtureData();
+        return fixture?.shelfConfig?.length || 0;
+    }
+    getFixtureCapacity() {
+        const fixture = this.getCurrentFixtureData();
+        return fixture?.fixtureCapacity || 0;
+    }
+    constructor(storeBuilderService, dataService, titleCase, cdr, gs, router, route, toastService, modalService) {
+        this.storeBuilderService = storeBuilderService;
+        this.dataService = dataService;
+        this.titleCase = titleCase;
+        this.cdr = cdr;
+        this.gs = gs;
+        this.router = router;
+        this.route = route;
+        this.toastService = toastService;
+        this.modalService = modalService;
+    }
+    previousSearchMode = null;
+    isInitialLoad = true;
+    hasRestoredData = false;
+    isUpdatingFromService = false;
+    ngOnInit() {
+        // Get client ID and CDN URL
+        this.gs.environment
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((env) => {
+            this.cdnUrl = env.planogramCDN || '';
+        });
+        this.gs.dataRangeValue
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((data) => {
+            if (data?.client) {
+                this.clientId = data.client;
+            }
+            else {
+                const headerData = JSON.parse(localStorage.getItem("header-filters"));
+                if (headerData?.client) {
+                    this.clientId = headerData.client;
+                }
+            }
+        });
+        // Subscribe to data service to restore saved data
+        this.dataService.getFindReplaceData()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((data) => {
+            // Prevent infinite loops by skipping updates when we're updating from form changes
+            if (this.isUpdatingFromService) {
+                return;
+            }
+            this.findReplaceData = data;
+            // Update store dropdown items when stores change
+            this.updateStoreDropdownItems();
+            if (data && !this.hasRestoredData) {
+                // Restore all form values on first data load
+                this.restoreFormValues(data);
+                this.hasRestoredData = true;
+            }
+            else if (data && this.hasRestoredData) {
+                // If data already restored, only handle searchMode changes
+                if (data.searchMode && data.searchMode !== this.previousSearchMode) {
+                    this.selectedMode.setValue(data.searchMode, { emitEvent: false });
+                    this.previousSearchMode = data.searchMode;
+                    this.loadStoresOrClusters(data);
+                }
+                // Update selected store for preview if stores exist
+                if (data.stores && data.stores.length > 0 && !this.selectedStoreForPreview) {
+                    const newStore = this.storeDropdownItems[0];
+                    if (newStore && (!this.selectedStoreForPreview || this.selectedStoreForPreview.storeId !== newStore.storeId)) {
+                        this.selectedStoreForPreview = newStore;
+                        this.updateSelectedStoreValues();
+                        // Restore findResponseData and replaceResponseData for the selected store if available
+                        this.restoreStoreResponseData(newStore.storeName);
+                        // Load planogram for the selected store
+                        this.cdr.detectChanges();
+                        setTimeout(() => {
+                            if (this.initializeCanvas()) {
+                                this.loadPlanogramForStore(newStore.storeName);
+                            }
+                        }, 50);
+                    }
+                }
+            }
+            else if (!data && this.isInitialLoad) {
+                // Load initial data if no saved data
+                this.loadStoresOrClusters();
+                this.isInitialLoad = false;
+            }
+        });
+        // Subscribe to save draft loading state
+        this.dataService.getLoadingState()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((isLoading) => {
+            this.savingDraft = isLoading;
+        });
+        // Watch for mode changes
+        this.selectedMode.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((newMode) => {
+            if (newMode !== this.previousSearchMode && !this.isUpdatingFromService) {
+                this.previousSearchMode = newMode;
+                this.loadStoresOrClusters();
+                // Clear selected stores when mode changes manually
+                this.selectedStores = [];
+                // Clear selectedClusters when switching to store mode
+                if (newMode === 'store') {
+                    this.dataService.updateData({ selectedClusters: undefined });
+                }
+            }
+        });
+        // Watch for target changes - debounce to prevent excessive updates
+        this.target.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((value) => {
+            if (value && !this.isUpdatingFromService) {
+                this.isUpdatingFromService = true;
+                this.dataService.updateData({ target: value });
+                setTimeout(() => {
+                    this.isUpdatingFromService = false;
+                }, 0);
+            }
+        });
+        // Watch for find prompt changes - debounce to prevent excessive updates
+        this.findPrompt.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((value) => {
+            if (!this.isUpdatingFromService) {
+                this.isUpdatingFromService = true;
+                this.dataService.updateData({ findPrompt: value || '' });
+                setTimeout(() => {
+                    this.isUpdatingFromService = false;
+                }, 0);
+            }
+        });
+        // Watch for replace prompt changes - debounce to prevent excessive updates
+        this.replacePrompt.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((value) => {
+            if (!this.isUpdatingFromService) {
+                this.isUpdatingFromService = true;
+                this.dataService.updateData({ replacePrompt: value || '' });
+                setTimeout(() => {
+                    this.isUpdatingFromService = false;
+                }, 0);
+            }
+        });
+    }
+    restoreFormValues(data) {
+        // Restore searchMode
+        if (data.searchMode) {
+            this.selectedMode.setValue(data.searchMode, { emitEvent: false });
+            this.previousSearchMode = data.searchMode;
+        }
+        // Restore target
+        if (data.target) {
+            this.target.setValue(data.target, { emitEvent: false });
+        }
+        // Restore findPrompt
+        if (data.findPrompt) {
+            this.findPrompt.setValue(data.findPrompt, { emitEvent: false });
+        }
+        // Restore replacePrompt
+        if (data.replacePrompt) {
+            this.replacePrompt.setValue(data.replacePrompt, { emitEvent: false });
+        }
+        // Load stores/clusters and restore selections
+        if (data.searchMode) {
+            this.loadStoresOrClusters(data);
+        }
+        else {
+            this.loadStoresOrClusters();
+        }
+        // Set initial selected store for preview
+        if (data.stores && data.stores.length > 0) {
+            this.updateStoreDropdownItems();
+            if (this.storeDropdownItems.length > 0) {
+                this.selectedStoreForPreview = this.storeDropdownItems[0];
+                this.updateSelectedStoreValues();
+                // Load planogram after view is initialized
+                this.cdr.detectChanges();
+                setTimeout(() => {
+                    if (this.initializeCanvas() && this.selectedStoreForPreview) {
+                        this.loadPlanogramForStore(this.selectedStoreForPreview.storeName);
+                    }
+                    else {
+                        // Retry if canvas not ready
+                        setTimeout(() => {
+                            if (this.initializeCanvas() && this.selectedStoreForPreview) {
+                                this.loadPlanogramForStore(this.selectedStoreForPreview.storeName);
+                            }
+                        }, 200);
+                    }
+                }, 100);
+            }
+        }
+        this.isInitialLoad = false;
+    }
+    updateStoreDropdownItems() {
+        if (!this.findReplaceData?.stores) {
+            this.storeDropdownItems = [];
+            this.selectedStoreValues = [];
+            return;
+        }
+        const newItems = this.findReplaceData.stores.map((store) => ({
+            storeId: store.storeId || store.storeName,
+            storeName: store.storeName,
+            _id: store.storeId || store.storeName
+        }));
+        // Only update if items actually changed
+        const itemsChanged = JSON.stringify(newItems) !== JSON.stringify(this.storeDropdownItems);
+        if (itemsChanged) {
+            this.storeDropdownItems = newItems;
+            this.updateSelectedStoreValues();
+        }
+    }
+    updateSelectedStoreValues() {
+        if (this.selectedStoreForPreview) {
+            this.selectedStoreValues = [this.selectedStoreForPreview];
+        }
+        else {
+            this.selectedStoreValues = [];
+        }
+    }
+    ngAfterViewInit() {
+        // Canvas will be initialized when store is selected and canvas element is available
+    }
+    initializeCanvas() {
+        if (this.previewCanvas) {
+            return true; // Already initialized
+        }
+        if (this.previewCanvasRef?.nativeElement) {
+            try {
+                this.previewCanvas = new fabric.Canvas(this.previewCanvasRef.nativeElement, {
+                    selectionFullyContained: true,
+                    perPixelTargetFind: true,
+                    targetFindTolerance: 5,
+                });
+                this.setupZoomHandlers(this.previewCanvas);
+                return true;
+            }
+            catch (error) {
+                console.error('Error initializing canvas:', error);
+                return false;
+            }
+        }
+        return false;
+    }
+    onStoreSelectedForPreview(store) {
+        if (store && (!this.selectedStoreForPreview || this.selectedStoreForPreview.storeId !== store.storeId)) {
+            this.selectedStoreForPreview = store;
+            this.updateSelectedStoreValues();
+            // Clear selected fixture when switching stores
+            this.selectedFixture = null;
+            this.selectedFixtureData = null;
+            this.originalFixtureData = null;
+            this.originalFixturesMap.clear(); // Clear the map when switching stores
+            // Restore findResponseData and replaceResponseData for the selected store if available
+            this.restoreStoreResponseData(store.storeName);
+            // Force change detection to ensure canvas element is in DOM
+            this.cdr.detectChanges();
+            // Initialize canvas if not already done, then load planogram
+            setTimeout(() => {
+                if (this.initializeCanvas()) {
+                    this.loadPlanogramForStore(store.storeName);
+                }
+                else {
+                    // Retry after a short delay if canvas element not ready
+                    setTimeout(() => {
+                        if (this.initializeCanvas()) {
+                            this.loadPlanogramForStore(store.storeName);
+                        }
+                    }, 100);
+                }
+            }, 50);
+        }
+    }
+    // Restore findResponseData and replaceResponseData for a specific store
+    restoreStoreResponseData(storeName) {
+        if (!this.findReplaceData?.stores) {
+            return;
+        }
+        const store = this.findReplaceData.stores.find((s) => s.storeName === storeName);
+        if (!store) {
+            return;
+        }
+        // findResponseData is a string (fixture _id)
+        // replaceResponseData is an object with vmConfig and/or shelfConfig
+        const fixtureId = store.findResponseData;
+        if (!fixtureId)
+            return;
+        this.selectedFixture = { fixtureId, fixtureType: undefined };
+        // We'll re-hydrate selectedFixtureData from the loaded planogram (floorData) after load.
+        this.selectedFixtureData = null;
+    }
+    // Apply stored findResponseData and replaceResponseData to floor data
+    applyStoredResponseData() {
+        if (!this.findReplaceData?.stores || !this.selectedStoreForPreview || !this.floorData) {
+            return;
+        }
+        const store = this.findReplaceData.stores.find((s) => s.storeName === this.selectedStoreForPreview.storeName);
+        if (!store) {
+            return;
+        }
+        // findResponseData is a string (fixture _id) - use it to find the fixture
+        const fixtureId = store.findResponseData;
+        if (!fixtureId)
+            return;
+        // Find the fixture in floorData
+        const fixture = this.getFixtureByIdFromFloor(fixtureId);
+        if (!fixture)
+            return;
+        // Apply replaceResponseData configs if available (merge with existing fixture)
+        if (store.replaceResponseData) {
+            // Store the original fixture (before replace) for before/after comparison
+            const originalFixture = structuredClone(fixture);
+            this.originalFixtureData = originalFixture;
+            // Also store it in the map so it persists when clicking other fixtures
+            this.originalFixturesMap.set(fixtureId, originalFixture);
+            const updatedFixture = { ...fixture };
+            // Merge vmConfig if present in replaceResponseData
+            if (store.replaceResponseData.vmConfig) {
+                updatedFixture.vmConfig = store.replaceResponseData.vmConfig;
+            }
+            // Merge shelfConfig if present in replaceResponseData
+            if (store.replaceResponseData.shelfConfig) {
+                updatedFixture.shelfConfig = store.replaceResponseData.shelfConfig;
+            }
+            // Update the fixture in floorData
+            this.updateAiResponseFixture(updatedFixture);
+            // Set selected fixture data (after replace)
+            this.selectedFixture = {
+                fixtureId: updatedFixture._id,
+                fixtureType: updatedFixture.fixtureType,
+            };
+            this.selectedFixtureData = updatedFixture;
+        }
+        else {
+            // No replaceResponseData, clear original fixture and just set the selected fixture from findResponseData
+            this.originalFixtureData = null;
+            this.selectedFixture = {
+                fixtureId: fixture._id,
+                fixtureType: fixture.fixtureType,
+            };
+            this.selectedFixtureData = fixture;
+        }
+    }
+    getFixtureByIdFromFloor(fixtureId) {
+        if (!fixtureId || !this.floorData)
+            return null;
+        for (const element of this.floorData.layoutPolygon || []) {
+            if (element?.elementType === "wall" && Array.isArray(element.fixtures)) {
+                const hit = element.fixtures.find((fx) => fx?._id === fixtureId);
+                if (hit)
+                    return hit;
+            }
+        }
+        for (const fx of this.floorData.centerFixture || []) {
+            if (fx?._id === fixtureId)
+                return fx;
+        }
+        return null;
+    }
+    async loadPlanogramForStore(storeName) {
+        if (!storeName) {
+            console.warn('Cannot load planogram: storeName not available');
+            return;
+        }
+        if (!this.previewCanvas) {
+            console.warn('Canvas not initialized, attempting to initialize...');
+            if (!this.initializeCanvas()) {
+                console.error('Failed to initialize canvas');
+                return;
+            }
+        }
+        this.canvasLoading = true;
+        try {
+            // Get planoId from store name
+            const response = await this.storeBuilderService.getPlanoId({ stores: [storeName.toUpperCase()] }).toPromise();
+            if (response?.code === 200 && response?.data?.length > 0) {
+                const planoId = response.data[0]._id;
+                await this.getStoreFixtures(planoId);
+            }
+            else {
+                console.warn('No planogram found for store:', storeName);
+                this.canvasLoading = false;
+            }
+        }
+        catch (error) {
+            console.error('Error loading planogram:', error);
+            this.canvasLoading = false;
+        }
+    }
+    loadStoresOrClusters(savedData) {
+        const searchMode = this.selectedMode.value;
+        if (!searchMode)
+            return;
+        this.loading = true;
+        this.storeBuilderService.getStoreOrClusterList({ searchMode })
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: (response) => {
+                this.loading = false;
+                if (response?.code === 200 && response?.data && Array.isArray(response.data)) {
+                    if (searchMode === 'store') {
+                        // For store mode, use data directly
+                        this.storeOptions = response.data.map((item) => ({
+                            id: item.id,
+                            label: item.label
+                        }));
+                        this.clusterData = []; // Clear cluster data
+                        // Restore saved selections for store mode
+                        if (savedData?.stores && savedData.stores.length > 0) {
+                            this.restoreStoreSelections(savedData.stores);
+                        }
+                    }
+                    else {
+                        // For cluster mode, show clusters in the dropdown
+                        // Store full cluster data for later use
+                        this.clusterData = response.data;
+                        this.storeOptions = response.data.map((cluster) => ({
+                            id: cluster.id,
+                            label: cluster.label
+                        }));
+                        // Restore saved selections for cluster mode
+                        if (savedData?.stores && savedData.stores.length > 0) {
+                            this.restoreClusterSelections(savedData.stores);
+                        }
+                    }
+                }
+                else {
+                    this.storeOptions = [];
+                    this.clusterData = [];
+                }
+            },
+            error: (error) => {
+                this.loading = false;
+                console.error('Error loading stores/clusters:', error);
+                this.storeOptions = [];
+            }
+        });
+    }
+    restoreStoreSelections(savedStores) {
+        // Match saved stores by storeName
+        const savedStoreNames = new Set(savedStores.map(s => s.storeName));
+        this.selectedStores = this.storeOptions.filter(option => savedStoreNames.has(option.label));
+    }
+    restoreClusterSelections(_savedStores) {
+        // Restore cluster selection ONLY from selectedClusters (no derivation from stores)
+        const savedClusters = this.findReplaceData?.selectedClusters || [];
+        if (!savedClusters.length) {
+            this.selectedStores = [];
+            return;
+        }
+        const savedClusterIds = new Set(savedClusters.map(c => c.id));
+        const selectedClusters = [];
+        this.clusterData.forEach((cluster) => {
+            if (savedClusterIds.has(cluster.id)) {
+                selectedClusters.push({
+                    id: cluster.id,
+                    label: cluster.label
+                });
+            }
+        });
+        this.selectedStores = selectedClusters;
+    }
+    onStoresSelected(stores) {
+        this.selectedStores = stores;
+    }
+    async onReviewAndReplace() {
+        if (!this.findReplaceData?._id) {
+            console.error('No find replace ID available');
+            return;
+        }
+        // Show confirmation modal
+        const modalRef = this.modalService.open(BatchConfirmationModalComponent, {
+            centered: true,
+            size: 'md',
+            backdrop: 'static',
+            windowClass: 'batch-confirmation-modal'
+        });
+        // Pass store count to modal
+        modalRef.componentInstance.storeCount = this.getStoreCount();
+        try {
+            const result = await modalRef.result;
+            if (result) {
+                // User confirmed, proceed with batch process
+                this.proceedWithBatchProcess();
+            }
+        }
+        catch (error) {
+            // User dismissed the modal
+            console.log('Batch confirmation modal dismissed');
+        }
+    }
+    proceedWithBatchProcess() {
+        if (!this.findReplaceData?._id) {
+            console.error('No find replace ID available');
+            return;
+        }
+        this.loading = true;
+        this.batchProcessing = true;
+        const findReplaceId = this.findReplaceData._id;
+        this.storeBuilderService.batchFindReplace({ findReplaceId })
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: (response) => {
+                this.loading = false;
+                this.batchProcessing = false;
+                if (response?.code === 200) {
+                    // Refetch find replace data to update UI
+                    this.dataService.loadAndSetFindReplaceDataById(findReplaceId);
+                }
+                else {
+                    console.error('Failed to start batch find replace:', response?.message);
+                }
+            },
+            error: (error) => {
+                this.loading = false;
+                this.batchProcessing = false;
+                console.error('Error starting batch find replace:', error);
+            }
+        });
+    }
+    onApply() {
+        const searchMode = this.selectedMode.value;
+        let stores = [];
+        let selectedClusters = undefined;
+        if (searchMode === 'store') {
+            // For store mode, convert selected stores directly
+            stores = this.selectedStores.map((storeOption) => ({
+                storeName: storeOption.label,
+            }));
+        }
+        else {
+            // For cluster mode, save selected clusters and extract all stores from selected clusters
+            selectedClusters = this.selectedStores.map((storeOption) => ({
+                id: storeOption.id,
+                label: storeOption.label
+            }));
+            const selectedClusterIds = new Set(this.selectedStores.map(s => s.id));
+            stores = [];
+            // Find selected clusters and extract their stores
+            this.clusterData.forEach((cluster) => {
+                if (selectedClusterIds.has(cluster.id) && cluster.stores && Array.isArray(cluster.stores)) {
+                    cluster.stores.forEach((store) => {
+                        stores.push({
+                            storeName: store.label,
+                        });
+                    });
+                }
+            });
+        }
+        // Update data service with all current values
+        const updateData = {
+            searchMode: searchMode,
+            stores: stores,
+            storeCount: stores.length,
+            target: this.target.value,
+            findPrompt: this.findPrompt.value || '',
+            replacePrompt: this.replacePrompt.value || ''
+        };
+        // Add selectedClusters only when searchMode is cluster
+        if (searchMode === 'cluster' && selectedClusters) {
+            updateData.selectedClusters = selectedClusters;
+        }
+        this.dataService.updateData(updateData);
+        // Trigger save as draft
+        this.dataService.triggerSaveDraft();
+    }
+    // Canvas setup methods
+    setupZoomHandlers(canvas) {
+        // Disable object selection globally
+        canvas.selection = false;
+        canvas.on("mouse:wheel", (opt) => {
+            const e = opt.e;
+            if (e.ctrlKey || e.metaKey) {
+                const delta = e.deltaY;
+                let zoom = canvas.getZoom();
+                zoom *= 0.995 ** delta;
+                zoom = Math.max(0.2, Math.min(zoom, 3));
+                canvas.zoomToPoint({ x: e.offsetX, y: e.offsetY }, zoom);
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        });
+        let isDragging = false;
+        let lastPosX = 0;
+        let lastPosY = 0;
+        canvas.on("mouse:down", (opt) => {
+            // Handle fixture clicks - use findTarget to get the actual group
+            if (opt.target) {
+                const obj = opt.target;
+                // Check if it's a fixture group or nested within one
+                let fixtureGroup = obj;
+                // Traverse up to find the fixture group
+                let attempts = 0;
+                while (fixtureGroup && !fixtureGroup.fixtureId && !fixtureGroup.objType && attempts < 10) {
+                    if (fixtureGroup.parent) {
+                        fixtureGroup = fixtureGroup.parent;
+                    }
+                    else if (fixtureGroup.group) {
+                        fixtureGroup = fixtureGroup.group;
+                    }
+                    else {
+                        break;
+                    }
+                    attempts++;
+                }
+                // Check if we found a fixture group
+                if (fixtureGroup.objType === "fixture" || fixtureGroup.fixtureId) {
+                    this.onFixtureClick(fixtureGroup);
+                    canvas.setActiveObject(fixtureGroup);
+                    canvas.requestRenderAll();
+                    return;
+                }
+                // For other elements, just highlight
+                canvas.setActiveObject(opt.target);
+                canvas.requestRenderAll();
+                return;
+            }
+            if (!opt.target) {
+                isDragging = true;
+                canvas.selection = false;
+                const e = opt.e;
+                lastPosX = e.clientX;
+                lastPosY = e.clientY;
+            }
+        });
+        canvas.on("mouse:move", (opt) => {
+            if (isDragging && canvas.viewportTransform && !opt.target) {
+                const e = opt.e;
+                const vpt = canvas.viewportTransform;
+                vpt[4] += e.clientX - lastPosX;
+                vpt[5] += e.clientY - lastPosY;
+                canvas.requestRenderAll();
+                lastPosX = e.clientX;
+                lastPosY = e.clientY;
+            }
+        });
+        canvas.on("mouse:up", () => {
+            isDragging = false;
+            canvas.selection = false;
+        });
+        // Prevent all object movement (walls, entrances, fixtures, other elements)
+        canvas.on("object:moving", (e) => {
+            const obj = e.target;
+            if (obj && obj.objType) {
+                e.e.preventDefault();
+                e.e.stopPropagation();
+                // Reset position
+                obj.setCoords();
+                canvas.requestRenderAll();
+            }
+        });
+        // Prevent all object modifications (scaling, rotating, etc.)
+        canvas.on("object:modified", (e) => {
+            const obj = e.target;
+            if (obj && obj.objType) {
+                // Reset any changes
+                obj.setCoords();
+                canvas.requestRenderAll();
+            }
+        });
+        // Prevent object scaling
+        canvas.on("object:scaling", (e) => {
+            const obj = e.target;
+            if (obj && obj.objType) {
+                e.e.preventDefault();
+                e.e.stopPropagation();
+                obj.setCoords();
+                canvas.requestRenderAll();
+            }
+        });
+        // Prevent object rotating
+        canvas.on("object:rotating", (e) => {
+            const obj = e.target;
+            if (obj && obj.objType) {
+                e.e.preventDefault();
+                e.e.stopPropagation();
+                obj.setCoords();
+                canvas.requestRenderAll();
+            }
+        });
+    }
+    async getStoreFixtures(storeId) {
+        if (!this.previewCanvas) {
+            console.warn('Canvas not initialized');
+            this.canvasLoading = false;
+            return;
+        }
+        this.canvasLoading = true;
+        this.storeBuilderService.getStoreFixtures({ id: [storeId] })
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: async (res) => {
+                if (!res?.data?.[0]?.floors?.length) {
+                    this.canvasLoading = false;
+                    return;
+                }
+                this.planoData = structuredClone(res.data[0]);
+                this.floorData = structuredClone(res.data[0].floors[0]);
+                // Apply stored findResponseData and replaceResponseData if available for this store
+                // This updates the floorData with the stored fixture changes and sets selectedFixtureData
+                this.applyStoredResponseData();
+                // Open panel if we have selected fixture data
+                if (this.selectedFixtureData) {
+                    this.isRightPanelCollapsed = false;
+                }
+                // Collect all fixtures for preview
+                this.collectAllFixtures();
+                // Ensure canvas is initialized before rendering
+                if (!this.previewCanvas) {
+                    this.initializeCanvas();
+                }
+                if (this.previewCanvas) {
+                    // Render the planogram with the updated floorData (which includes stored response data)
+                    await this.renderFloor(this.previewCanvas);
+                    this.canvasLoading = false;
+                    // Re-center and highlight the selected fixture if stored response data exists
+                    setTimeout(() => {
+                        if (this.previewCanvasContainerRef?.nativeElement) {
+                            this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);
+                            this.fitCanvasToLayoutAnimated(this.previewCanvas);
+                            // Highlight the fixture if we have stored response data
+                            if (this.selectedFixture?.fixtureId) {
+                                const actionFixture = this.previewCanvas.getObjects().find((obj) => obj.objType === "fixture" && obj.fixtureId === this.selectedFixture.fixtureId);
+                                if (actionFixture) {
+                                    this.highlightFixture(this.previewCanvas, actionFixture, false);
+                                }
+                            }
+                        }
+                        // Automatically trigger find and replace if prompts are available and store doesn't have results
+                        this.autoFindAndReplaceIfNeeded();
+                    }, 300);
+                }
+                else {
+                    this.canvasLoading = false;
+                }
+            },
+            error: (err) => {
+                this.canvasLoading = false;
+                console.error('Error fetching plano:', err);
+            },
+        });
+    }
+    resizeCanvas(canvas, container) {
+        const containerEl = container.nativeElement;
+        canvas.setDimensions({
+            width: containerEl.clientWidth,
+            height: containerEl.clientHeight,
+        });
+        canvas.requestRenderAll();
+    }
+    fitCanvasToLayoutAnimated(canvas) {
+        if (!canvas)
+            return;
+        const bounds = this.getFullLayoutBounds(canvas);
+        if (!bounds.width || !bounds.height)
+            return;
+        const canvasW = canvas.getWidth();
+        const canvasH = canvas.getHeight();
+        const scaleX = canvasW / bounds.width;
+        const scaleY = canvasH / bounds.height;
+        const targetZoom = Math.min(scaleX, scaleY) * 0.9;
+        const targetVpt = [...(canvas.viewportTransform || [1, 0, 0, 1, 0, 0])];
+        targetVpt[0] = targetZoom;
+        targetVpt[3] = targetZoom;
+        targetVpt[4] = canvasW / 2 - (bounds.left + bounds.width / 2) * targetZoom;
+        targetVpt[5] = canvasH / 2 - (bounds.top + bounds.height / 2) * targetZoom;
+        const startVpt = [...canvas.viewportTransform];
+        fabric.util.animate({
+            startValue: 0,
+            endValue: 1,
+            duration: 100,
+            easing: fabric.util.ease.easeOutCubic,
+            onChange: (value) => {
+                const vpt = canvas.viewportTransform;
+                vpt[0] = startVpt[0] + (targetVpt[0] - startVpt[0]) * value;
+                vpt[3] = startVpt[3] + (targetVpt[3] - startVpt[3]) * value;
+                vpt[4] = startVpt[4] + (targetVpt[4] - startVpt[4]) * value;
+                vpt[5] = startVpt[5] + (targetVpt[5] - startVpt[5]) * value;
+                canvas.requestRenderAll();
+            },
+        });
+    }
+    getFullLayoutBounds(canvas) {
+        const objects = canvas.getObjects();
+        if (!objects.length)
+            return { left: 0, top: 0, width: 0, height: 0 };
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const obj of objects) {
+            const rect = obj.getBoundingRect();
+            minX = Math.min(minX, rect.left);
+            minY = Math.min(minY, rect.top);
+            maxX = Math.max(maxX, rect.left + rect.width);
+            maxY = Math.max(maxY, rect.top + rect.height);
+        }
+        return { left: minX, top: minY, width: maxX - minX, height: maxY - minY };
+    }
+    async renderFloor(canvas) {
+        await this.drawInitialContent(canvas);
+    }
+    async drawInitialContent(canvas) {
+        canvas.clear();
+        await this.drawLayoutElements(canvas);
+    }
+    // Automatically trigger find and replace if prompts are available and store doesn't have results
+    autoFindAndReplaceIfNeeded() {
+        if (!this.selectedStoreForPreview || !this.findReplaceData) {
+            return;
+        }
+        // Check if prompts are available
+        const hasFindPrompt = this.findReplaceData.findPrompt && this.findReplaceData.findPrompt.trim().length > 0;
+        const hasReplacePrompt = this.findReplaceData.replacePrompt && this.findReplaceData.replacePrompt.trim().length > 0;
+        if (!hasFindPrompt || !hasReplacePrompt) {
+            return;
+        }
+        // Check if current store already has findResponseData and replaceResponseData
+        const store = this.findReplaceData.stores?.find((s) => s.storeName === this.selectedStoreForPreview.storeName);
+        // If store already has findResponseData, skip auto-find to preserve the highlight
+        // Only auto-run find if store doesn't already have findResponseData
+        if (store?.findResponseData) {
+            // If store has findResponseData but not replaceResponseData, we could auto-run replace
+            // but for now, we'll skip to preserve the highlight that was just set
+            return;
+        }
+        // Set the prompts in the form controls if not already set
+        if (!this.findPrompt.value && this.findReplaceData.findPrompt) {
+            this.findPrompt.setValue(this.findReplaceData.findPrompt, { emitEvent: false });
+        }
+        if (!this.replacePrompt.value && this.findReplaceData.replacePrompt) {
+            this.replacePrompt.setValue(this.findReplaceData.replacePrompt, { emitEvent: false });
+        }
+        // Automatically trigger find first, then replace after find completes
+        this.autoFind();
+    }
+    // Auto find - will trigger replace after completion
+    autoFind() {
+        if (!this.findPrompt.value || !this.selectedStoreForPreview) {
+            return;
+        }
+        this.findLoading = true;
+        this.canvasLoading = true;
+        const payload = {
+            selectionCriteria: this.findPrompt.value,
+            stores: [this.selectedStoreForPreview.storeName],
+        };
+        this.storeBuilderService.findFixture(payload)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: (res) => {
+                this.findLoading = false;
+                this.canvasLoading = false;
+                if (res.code === 200) {
+                    // Check if the response indicates "NOT FOUND"
+                    if (res.status === 'success' && res.message === 'NOT FOUND') {
+                        this.toastService.getWarningToast('No matching fixture found for the given prompt');
+                        return;
+                    }
+                    // Check if res.data exists before processing
+                    if (!res.data) {
+                        this.toastService.getWarningToast('No matching fixture found for the given prompt');
+                        return;
+                    }
+                    this.updateAiResponseFixture(res.data);
+                    // Store the found fixture for potential replace operation
+                    this.selectedFixture = {
+                        fixtureId: res.data._id,
+                        fixtureType: res.data.fixtureType,
+                    };
+                    this.selectedFixtureData = res.data;
+                    // Save findResponseData to the specific store
+                    this.saveFindResponseData(res.data);
+                    // Render the floor and wait for it to complete
+                    this.renderFloor(this.previewCanvas).then(() => {
+                        // Wait for canvas to fully render before highlighting
+                        setTimeout(() => {
+                            const actionFixture = this.previewCanvas.getObjects().find((obj) => obj.objType === "fixture" && obj.fixtureId === res.data._id);
+                            if (actionFixture) {
+                                this.highlightFixture(this.previewCanvas, actionFixture, true);
+                            }
+                            // After find completes, automatically trigger replace
+                            setTimeout(() => {
+                                this.autoReplace();
+                            }, 500);
+                        }, 300);
+                    });
+                }
+            },
+            error: () => {
+                this.findLoading = false;
+                this.canvasLoading = false;
+            },
+        });
+    }
+    // Auto replace - called after auto find completes
+    autoReplace() {
+        if (!this.replacePrompt.value) {
+            return;
+        }
+        // Check if a fixture is selected for replacement
+        if (!this.selectedFixture?.fixtureId && !this.selectedFixtureData?._id) {
+            return;
+        }
+        // Use Replace API for selected fixture
+        const fixtureId = this.selectedFixture?.fixtureId || this.selectedFixtureData?._id;
+        this.replaceLoading = true;
+        this.canvasLoading = true;
+        const payload = {
+            fixtureId: fixtureId,
+            updateType: this.target.value,
+            updationCriteria: this.replacePrompt.value,
+        };
+        // Store the original fixture before replace for before/after comparison
+        const originalFixture = this.selectedFixtureData ? structuredClone(this.selectedFixtureData) : null;
+        this.storeBuilderService.replaceFixture(payload)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: (res) => {
+                this.replaceLoading = false;
+                this.canvasLoading = false;
+                if (res.code === 200) {
+                    // Store original fixture for before/after comparison
+                    this.originalFixtureData = originalFixture;
+                    this.updateAiResponseFixture(res.data);
+                    // Save replaceResponseData to the specific store
+                    this.saveReplaceResponseData(res.data);
+                    // Update selected fixture data (after replace)
+                    this.selectedFixture = {
+                        fixtureId: res.data._id,
+                        fixtureType: res.data.fixtureType,
+                    };
+                    this.selectedFixtureData = res.data;
+                    // Render the floor and wait for it to complete
+                    this.renderFloor(this.previewCanvas).then(() => {
+                        // Wait for canvas to fully render before highlighting
+                        setTimeout(() => {
+                            const actionFixture = this.previewCanvas.getObjects().find((obj) => obj.objType === "fixture" && obj.fixtureId === res.data._id);
+                            if (actionFixture) {
+                                this.highlightFixture(this.previewCanvas, actionFixture, true);
+                            }
+                        }, 300);
+                    });
+                }
+            },
+            error: () => {
+                this.replaceLoading = false;
+                this.canvasLoading = false;
+            },
+        });
+    }
+    // Find and Replace button handlers
+    onFind() {
+        if (!this.findPrompt.value || !this.selectedStoreForPreview) {
+            return;
+        }
+        this.findLoading = true;
+        this.canvasLoading = true;
+        const payload = {
+            selectionCriteria: this.findPrompt.value,
+            stores: [this.selectedStoreForPreview.storeName],
+        };
+        this.storeBuilderService.findFixture(payload)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: (res) => {
+                this.findLoading = false;
+                this.canvasLoading = false;
+                if (res.code === 200) {
+                    // Check if the response indicates "NOT FOUND"
+                    if (res.status === 'success' && res.message === 'NOT FOUND') {
+                        this.toastService.getWarningToast('No matching fixture found for the given prompt');
+                        return;
+                    }
+                    // Check if res.data exists before processing
+                    if (!res.data) {
+                        this.toastService.getWarningToast('No matching fixture found for the given prompt');
+                        return;
+                    }
+                    this.updateAiResponseFixture(res.data);
+                    // Store the found fixture for potential replace operation
+                    this.selectedFixture = {
+                        fixtureId: res.data._id,
+                        fixtureType: res.data.fixtureType,
+                    };
+                    this.selectedFixtureData = res.data;
+                    // Save findResponseData to the specific store
+                    this.saveFindResponseData(res.data);
+                    // Render the floor and wait for it to complete
+                    this.renderFloor(this.previewCanvas).then(() => {
+                        // Wait for canvas to fully render before highlighting
+                        setTimeout(() => {
+                            const actionFixture = this.previewCanvas.getObjects().find((obj) => obj.objType === "fixture" && obj.fixtureId === res.data._id);
+                            if (actionFixture) {
+                                this.highlightFixture(this.previewCanvas, actionFixture, true);
+                            }
+                        }, 300);
+                    });
+                }
+            },
+            error: () => {
+                this.findLoading = false;
+                this.canvasLoading = false;
+            },
+        });
+    }
+    onReplace() {
+        if (!this.replacePrompt.value) {
+            return;
+        }
+        // Check if a fixture is selected for replacement
+        if (!this.selectedFixture?.fixtureId && !this.selectedFixtureData?._id) {
+            return;
+        }
+        // Use Replace API for selected fixture
+        const fixtureId = this.selectedFixture?.fixtureId || this.selectedFixtureData?._id;
+        this.replaceLoading = true;
+        this.canvasLoading = true;
+        const payload = {
+            fixtureId: fixtureId,
+            updateType: this.target.value,
+            updationCriteria: this.replacePrompt.value,
+        };
+        // Store the original fixture before replace for before/after comparison
+        const originalFixture = this.selectedFixtureData ? structuredClone(this.selectedFixtureData) : null;
+        this.storeBuilderService.replaceFixture(payload)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: (res) => {
+                this.replaceLoading = false;
+                this.canvasLoading = false;
+                if (res.code === 200) {
+                    // Store original fixture for before/after comparison
+                    this.originalFixtureData = originalFixture;
+                    this.updateAiResponseFixture(res.data);
+                    // Save replaceResponseData to the specific store
+                    this.saveReplaceResponseData(res.data);
+                    // Update selected fixture data (after replace)
+                    this.selectedFixture = {
+                        fixtureId: res.data._id,
+                        fixtureType: res.data.fixtureType,
+                    };
+                    this.selectedFixtureData = res.data;
+                    // Render the floor and wait for it to complete
+                    this.renderFloor(this.previewCanvas).then(() => {
+                        // Wait for canvas to fully render before highlighting
+                        setTimeout(() => {
+                            const actionFixture = this.previewCanvas.getObjects().find((obj) => obj.objType === "fixture" && obj.fixtureId === res.data._id);
+                            if (actionFixture) {
+                                this.highlightFixture(this.previewCanvas, actionFixture, true);
+                            }
+                        }, 300);
+                    });
+                }
+            },
+            error: () => {
+                this.replaceLoading = false;
+                this.canvasLoading = false;
+            },
+        });
+    }
+    // Helper method to get findResponseData for current store
+    getCurrentStoreFindResponseData() {
+        if (!this.findReplaceData?.stores || !this.selectedStoreForPreview) {
+            return null;
+        }
+        const store = this.findReplaceData.stores.find((s) => s.storeName === this.selectedStoreForPreview.storeName);
+        return store?.findResponseData || null;
+    }
+    // Save findResponseData to specific store and trigger save as draft
+    saveFindResponseData(responseData) {
+        if (!this.findReplaceData || !this.selectedStoreForPreview) {
+            return;
+        }
+        const updatedStores = (this.findReplaceData.stores || []).map((store) => {
+            if (store.storeName === this.selectedStoreForPreview.storeName) {
+                return {
+                    ...store,
+                    findResponseData: responseData?._id
+                };
+            }
+            return store;
+        });
+        // Update local findReplaceData immediately
+        this.findReplaceData = {
+            ...this.findReplaceData,
+            stores: updatedStores
+        };
+        // Update the data service
+        this.dataService.updateData({
+            stores: updatedStores
+        });
+        // Trigger save as draft
+        this.dataService.triggerSaveDraft();
+    }
+    // Save replaceResponseData to specific store and trigger save as draft
+    // Only saves vmConfig and/or shelfConfig based on target
+    saveReplaceResponseData(responseData) {
+        if (!this.findReplaceData || !this.selectedStoreForPreview) {
+            return;
+        }
+        const target = this.target.value;
+        const replaceData = {};
+        // Extract only the relevant configs based on target
+        if (target === 'vm' || target === 'both') {
+            if (responseData?.vmConfig) {
+                replaceData.vmConfig = responseData.vmConfig;
+            }
+        }
+        if (target === 'merch' || target === 'both') {
+            if (responseData?.shelfConfig) {
+                replaceData.shelfConfig = responseData.shelfConfig;
+            }
+        }
+        const updatedStores = (this.findReplaceData.stores || []).map((store) => {
+            if (store.storeName === this.selectedStoreForPreview.storeName) {
+                return {
+                    ...store,
+                    replaceResponseData: replaceData
+                };
+            }
+            return store;
+        });
+        // Update local findReplaceData immediately
+        this.findReplaceData = {
+            ...this.findReplaceData,
+            stores: updatedStores
+        };
+        // Update the data service
+        this.dataService.updateData({
+            stores: updatedStores
+        });
+        // Trigger save as draft
+        this.dataService.triggerSaveDraft();
+    }
+    updateAiResponseFixture(fixture) {
+        let matchFound = false;
+        for (let i = 0; i < this.floorData.layoutPolygon.length; i++) {
+            const element = this.floorData.layoutPolygon[i];
+            if (element.elementType === 'wall' && Array.isArray(element.fixtures)) {
+                for (let j = 0; j < element.fixtures.length; j++) {
+                    const fx = element.fixtures[j];
+                    if (fx._id === fixture._id) {
+                        // Preserve existing vmConfig if the new fixture doesn't have it
+                        const existingVmConfig = fx.vmConfig || [];
+                        const updatedFixture = {
+                            ...fixture,
+                            // Preserve vmConfig from existing fixture if new fixture doesn't have it
+                            vmConfig: fixture.vmConfig || existingVmConfig
+                        };
+                        this.floorData.layoutPolygon[i].fixtures[j] = updatedFixture;
+                        matchFound = true;
+                        this.selectedFixture = updatedFixture;
+                        break;
+                    }
+                }
+            }
+        }
+        if (matchFound)
+            return;
+        for (let i = 0; i < this.floorData?.centerFixture.length; i++) {
+            const fx = this.floorData?.centerFixture[i];
+            if (fx._id === fixture._id) {
+                // Preserve existing vmConfig if the new fixture doesn't have it
+                const existingVmConfig = fx.vmConfig || [];
+                const updatedFixture = {
+                    ...fixture,
+                    // Preserve vmConfig from existing fixture if new fixture doesn't have it
+                    vmConfig: fixture.vmConfig || existingVmConfig
+                };
+                this.floorData.centerFixture[i] = updatedFixture;
+                this.selectedFixture = updatedFixture;
+                break;
+            }
+        }
+    }
+    highlightFixture(canvas, group, blink = false) {
+        this.removeHighlight(canvas);
+        this.cancelHighlightBlink = false;
+        const center = group.getCenterPoint();
+        const realWidth = group.width * group.scaleX;
+        const realHeight = group.height * group.scaleY;
+        const rect = new fabric.Rect({
+            left: center.x,
+            top: center.y,
+            width: realWidth + 8,
+            height: realHeight + 8,
+            rx: 5,
+            ry: 5,
+            stroke: "#00aaff",
+            strokeWidth: 3,
+            fill: "transparent",
+            selectable: false,
+            evented: false,
+            originX: "center",
+            originY: "center",
+            angle: group.angle || 0,
+            opacity: blink ? 0 : 1,
+        });
+        rect.data = { type: "fixture-highlight" };
+        canvas.add(rect);
+        canvas.moveObjectTo(rect, canvas.getObjects().length - 1);
+        canvas.requestRenderAll();
+        this.activeHighlight = rect;
+        if (!blink)
+            return;
+        let cycles = 0;
+        const blinkOnce = () => {
+            if (this.cancelHighlightBlink) {
+                this.removeHighlight(canvas);
+                return;
+            }
+            rect.animate({ opacity: 1 }, {
+                duration: 200,
+                onChange: () => canvas.requestRenderAll(),
+                onComplete: () => {
+                    if (this.cancelHighlightBlink) {
+                        this.removeHighlight(canvas);
+                        return;
+                    }
+                    rect.animate({ opacity: 0 }, {
+                        duration: 200,
+                        onChange: () => canvas.requestRenderAll(),
+                        onComplete: () => {
+                            if (this.cancelHighlightBlink) {
+                                this.removeHighlight(canvas);
+                                return;
+                            }
+                            cycles++;
+                            if (cycles < 20) {
+                                blinkOnce();
+                            }
+                            else {
+                                if (!this.cancelHighlightBlink) {
+                                    rect.set({ opacity: 1 });
+                                    canvas.requestRenderAll();
+                                }
+                            }
+                        },
+                    });
+                },
+            });
+        };
+        blinkOnce();
+    }
+    removeHighlight(canvas) {
+        this.cancelHighlightBlink = true;
+        canvas.getObjects().forEach((obj) => {
+            if (obj.data?.type === "fixture-highlight") {
+                canvas.remove(obj);
+            }
+        });
+        this.activeHighlight = null;
+        canvas.requestRenderAll();
+    }
+    // Planogram rendering methods (simplified versions from collection-update-ai)
+    toPixels(value, unit, dpi = 2.8) {
+        let pixels;
+        if (unit === "mm") {
+            pixels = (value / 25.4) * dpi;
+        }
+        else if (unit === "ft") {
+            pixels = value * 12 * dpi;
+        }
+        else {
+            throw new Error("Unsupported unit. Use 'mm' or 'ft'.");
+        }
+        return Number(pixels.toFixed(4));
+    }
+    async drawLayoutElements(canvas) {
+        if (!this.floorData)
+            return;
+        for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {
+            const element = this.floorData.layoutPolygon[index];
+            let wall;
+            element.relativePosition ??= { x: 0, y: 0, unit: "ft" };
+            const x = this.toPixels(element.relativePosition.x, element.unit);
+            const y = this.toPixels(element.relativePosition.y, element.unit);
+            if (element.elementType === "wall") {
+                const height = this.wallThickness;
+                const width = this.toPixels(element.distance, element.unit);
+                wall = await this.drawWall(canvas, x, y, height, width, element);
+            }
+            else if (element.elementType === "entrance") {
+                this.drawEntrance(canvas, x, y, 80, 75, 40, element);
+            }
+            if (element.elementType === "wall") {
+                const fixtureGroups = [];
+                for (let j = 0; j < element?.fixtures?.length; j++) {
+                    const fixture = element.fixtures[j];
+                    const fx = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);
+                    const fy = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);
+                    const fh = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+                    const fw = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+                    const fixtureObj = await this.drawFixture(canvas, fx, fy, fh, fw, fixture);
+                    fixtureGroups.push(fixtureObj);
+                }
+                if (element.isLocked && wall) {
+                    canvas.remove(wall);
+                    fixtureGroups.forEach((f) => canvas.remove(f));
+                    const combinedGroup = new fabric.Group([wall, ...fixtureGroups], {
+                        hasControls: false,
+                        selectable: false,
+                        lockMovementX: true,
+                        lockMovementY: true,
+                        lockRotation: true,
+                        lockScalingX: true,
+                        lockScalingY: true,
+                        subTargetCheck: true,
+                    });
+                    combinedGroup.set({ isLocked: true });
+                    canvas.add(combinedGroup);
+                }
+                for (let j = 0; j < element?.otherElements?.length; j++) {
+                    const otherElement = element.otherElements[j];
+                    const ox = this.toPixels(otherElement.relativePosition.x, "ft");
+                    const oy = this.toPixels(otherElement.relativePosition.y, "ft");
+                    const oa = otherElement.relativePosition.angle;
+                    const oh = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);
+                    const ow = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);
+                    this.drawOtherElementsWithLabel(canvas, ox, oy, oa, ow, oh, otherElement);
+                }
+            }
+        }
+        for (let i = 0; i < this.floorData?.centerFixture?.length; i++) {
+            const fixture = this.floorData.centerFixture[i];
+            const x = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);
+            const y = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);
+            const h = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+            const w = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+            await this.drawFixture(canvas, x, y, h, w, fixture);
+        }
+        for (let j = 0; j < this.floorData?.otherElements?.length; j++) {
+            const otherElement = this.floorData.otherElements[j];
+            const x = this.toPixels(otherElement.relativePosition.x, "ft");
+            const y = this.toPixels(otherElement.relativePosition.y, "ft");
+            const a = otherElement.relativePosition.angle;
+            const h = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);
+            const w = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);
+            this.drawOtherElementsWithLabel(canvas, x, y, a, w, h, otherElement);
+        }
+        return true;
+    }
+    async drawWall(canvas, x, y, height, width, elementData) {
+        const radius = 5;
+        const fillColor = "#F6FCFF";
+        const strokeColor = "#D0D5DD";
+        const labelColor = "#009BF3";
+        let text = `${this.titleCase.transform(elementData.elementType)} ${elementData.elementNumber}`;
+        const wall = new fabric.Rect({
+            left: 0,
+            top: 0,
+            width,
+            height,
+            rx: radius,
+            ry: radius,
+            fill: fillColor,
+            stroke: strokeColor,
+            strokeWidth: 0.27,
+            selectable: false,
+            strokeUniform: true,
+        });
+        const centerX = width / 2;
+        const centerY = height / 2;
+        const isVertical = height > width;
+        const label = new fabric.FabricText(text, {
+            left: centerX,
+            top: centerY,
+            fontSize: 10,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: labelColor,
+            originX: "center",
+            originY: "center",
+            angle: isVertical ? -90 : 0,
+            selectable: false,
+        });
+        const arrowHead = 5;
+        const elements = [wall, label];
+        if (isVertical) {
+            const textWidth = label.width || 0;
+            const topArrowY = 5;
+            const topArrowEndY = centerY - textWidth / 2 - 5;
+            if (topArrowEndY > topArrowY + arrowHead) {
+                elements.push(new fabric.Line([centerX, topArrowY, centerX, topArrowEndY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: centerX,
+                    top: topArrowY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: 0,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "bottom",
+                    selectable: false,
+                }));
+            }
+            const bottomArrowStartY = centerY + textWidth / 2 + 5;
+            const bottomArrowEndY = height - 5;
+            if (bottomArrowEndY > bottomArrowStartY + arrowHead) {
+                elements.push(new fabric.Line([centerX, bottomArrowStartY, centerX, bottomArrowEndY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: centerX,
+                    top: bottomArrowEndY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: 180,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "top",
+                    selectable: false,
+                }));
+            }
+        }
+        else {
+            const textWidth = label.width || 0;
+            const leftArrowStartX = 5;
+            const leftArrowEndX = centerX - textWidth / 2 - 5;
+            if (leftArrowEndX > leftArrowStartX + arrowHead) {
+                elements.push(new fabric.Line([leftArrowStartX, centerY, leftArrowEndX, centerY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: leftArrowStartX,
+                    top: centerY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: -90,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "center",
+                    selectable: false,
+                }));
+            }
+            const rightArrowStartX = centerX + textWidth / 2 + 5;
+            const rightArrowEndX = width - 5;
+            if (rightArrowEndX > rightArrowStartX + arrowHead) {
+                elements.push(new fabric.Line([rightArrowStartX, centerY, rightArrowEndX, centerY], {
+                    stroke: labelColor,
+                    strokeWidth: 1,
+                    selectable: false,
+                }), new fabric.Triangle({
+                    left: rightArrowEndX,
+                    top: centerY,
+                    width: arrowHead,
+                    height: arrowHead,
+                    angle: 90,
+                    fill: labelColor,
+                    originX: "center",
+                    originY: "center",
+                    selectable: false,
+                }));
+            }
+        }
+        const group = new fabric.Group(elements, {
+            left: x,
+            top: y,
+            hasControls: false,
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockRotation: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            evented: true,
+            hoverCursor: "default",
+            angle: elementData.angle,
+            subTargetCheck: true,
+        });
+        group.objType = elementData.elementType;
+        group.data = elementData;
+        canvas.add(group);
+        // If newly added, focus it once
+        if (elementData?.newAdded) {
+            try {
+                canvas.setActiveObject(group);
+                canvas.requestRenderAll();
+            }
+            catch { }
+            delete elementData.newAdded;
+        }
+        return group;
+    }
+    drawEntrance(canvas, x, y, width, height, arrowWidth, elementData) {
+        const bodyWidth = width - arrowWidth;
+        const pathData = [
+            `M 0 0`,
+            `L ${bodyWidth} 0`,
+            `L ${bodyWidth} ${-height / 2}`,
+            `L ${width} ${height / 2}`,
+            `L ${bodyWidth} ${height + height / 2}`,
+            `L ${bodyWidth} ${height}`,
+            `L 0 ${height}`,
+            `Z`,
+        ].join(" ");
+        const arrow = new fabric.Path(pathData, {
+            fill: "#03A9F4",
+            selectable: false,
+            evented: false,
+        });
+        const maxTextHeight = height - 6;
+        const text = new fabric.Text("Entrance", {
+            fontFamily: "Arial",
+            fontWeight: "bold",
+            fill: "white",
+            angle: -90,
+            originX: "center",
+            originY: "center",
+            left: 15,
+            top: height / 2,
+            fontSize: 20,
+            selectable: false,
+            evented: false,
+        });
+        const textBounds = text.getBoundingRect();
+        if (textBounds.height > maxTextHeight) {
+            const scale = maxTextHeight / textBounds.height;
+            text.set("fontSize", text.fontSize * scale);
+        }
+        const group = new fabric.Group([arrow, text], {
+            left: x,
+            top: y,
+            hasControls: false,
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockScalingFlip: true,
+            lockRotation: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            evented: true,
+            hoverCursor: "default",
+            angle: elementData.angle,
+        });
+        group.objType = elementData.elementType;
+        group.data = elementData;
+        canvas.add(group);
+    }
+    async drawFixture(canvas, x, y, height, width, fixtureData) {
+        let fixtureColor;
+        // if (["fixture", "fixture-redo"].includes(this.publishingState)) {
+        //   fixtureColor = {
+        //     primary:
+        //       fixtureData.status == "" && fixtureData.taskStatus == "submit"
+        //         ? "#a5a6a8"
+        //         : fixtureData.status == "agree"
+        //         ? "#6CE9A6"
+        //         : "#51C1FF",
+        //     fill:
+        //       fixtureData.status == "" && fixtureData.taskStatus == "submit"
+        //         ? "#f3f4f8"
+        //         : fixtureData.status == "agree"
+        //         ? "#6CE9A6"
+        //         : "#EAF8FF",
+        //     vmFill:
+        //       fixtureData.status == "" && fixtureData.taskStatus == "submit"
+        //         ? "#a5a6a8"
+        //         : "#6938EF",
+        //   };
+        // }
+        if (fixtureData.fixtureName === "space")
+            return;
+        const radius = 5;
+        const mainContainer = new fabric.Rect({
+            left: x,
+            top: y,
+            width: width,
+            height: height,
+            rx: radius,
+            ry: radius,
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "white",
+        });
+        const topWidth = width / 1.05;
+        const topHeight = (15 / 100) * height;
+        const topX = x + (width - topWidth) / 2;
+        const topY = y + this.verticalMargin;
+        const topContainer = new fabric.Rect({
+            left: topX,
+            top: topY,
+            width: topWidth,
+            height: topHeight,
+            rx: radius,
+            ry: radius,
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "white",
+        });
+        const innerBoxHeight = topHeight / 2;
+        const innerTopBox = new fabric.Path(`M ${topX + radius} ${topY} 
+              L ${topX + topWidth - radius} ${topY} 
+              Q ${topX + topWidth} ${topY} ${topX + topWidth} ${topY + radius} 
+              L ${topX + topWidth} ${topY + innerBoxHeight} 
+              L ${topX} ${topY + innerBoxHeight} 
+              L ${topX} ${topY + radius} 
+              Q ${topX} ${topY} ${topX + radius} ${topY} Z`, {
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "transparent",
+        });
+        const topText = new fabric.Textbox(`Fixture ${fixtureData.associatedElementFixtureNumber
+            ? fixtureData.associatedElementFixtureNumber +
+                (fixtureData?.fixtureNumber
+                    ? " - FX-" + fixtureData.fixtureNumber
+                    : "")
+            : "new"}`, {
+            left: topX + topWidth / 2,
+            top: topY + innerBoxHeight / 2,
+            fontSize: 5,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#101828",
+            originX: "center",
+            originY: "center",
+            width: topWidth,
+            height: innerBoxHeight,
+            textAlign: "center",
+        });
+        const secondBoxY = topY + innerBoxHeight;
+        const innerBottomBox = new fabric.Path(`M ${topX} ${secondBoxY} 
+          L ${topX + topWidth} ${secondBoxY} 
+          L ${topX + topWidth} ${secondBoxY + innerBoxHeight - radius} 
+          Q ${topX + topWidth} ${secondBoxY + innerBoxHeight} ${topX + topWidth - radius} ${secondBoxY + innerBoxHeight} 
+          L ${topX + radius} ${secondBoxY + innerBoxHeight} 
+          Q ${topX} ${secondBoxY + innerBoxHeight} ${topX} ${secondBoxY + innerBoxHeight - radius} 
+          L ${topX} ${secondBoxY} Z`, {
+            fill: "#344054",
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+        });
+        let fontSize = 5;
+        let bottomText;
+        const textContent = `${fixtureData?.fixtureName} - ${fixtureData?.fixtureWidth.value} ${fixtureData?.fixtureWidth.unit}`;
+        const createBottomText = (fs) => new fabric.Textbox(textContent, {
+            left: topX + topWidth / 2,
+            top: secondBoxY + innerBoxHeight / 2,
+            fontSize: fs,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#FFFFFF",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            width: topWidth,
+        });
+        do {
+            bottomText = createBottomText(fontSize);
+            fontSize -= 0.5;
+        } while (bottomText.height > innerBoxHeight && fontSize > 2);
+        const midWidth = width / 1.05;
+        const midHeight = (77 / 100) * height;
+        const midX = x + (width - midWidth) / 2;
+        const midY = topY + topHeight + this.verticalMargin;
+        const midContainer = new fabric.Rect({
+            left: midX,
+            top: midY,
+            width: midWidth,
+            height: midHeight,
+            rx: radius,
+            ry: radius,
+            stroke: fixtureColor?.primary ?? "#51C1FF",
+            strokeWidth: 0.27,
+            fill: "white",
+        });
+        const shelfCount = fixtureData.shelfConfig?.length;
+        const boxHeight = midHeight / (shelfCount + 2);
+        const firstBoxY = midY;
+        const firstBox = new fabric.Path(`M ${midX + radius} ${firstBoxY} 
+              L ${midX + midWidth - radius} ${firstBoxY} 
+              Q ${midX + midWidth} ${firstBoxY} ${midX + midWidth} ${firstBoxY + radius} 
+              L ${midX + midWidth} ${firstBoxY + boxHeight} 
+              L ${midX} ${firstBoxY + boxHeight} 
+              L ${midX} ${firstBoxY + radius} 
+              Q ${midX} ${firstBoxY} ${midX + radius} ${firstBoxY} Z`, {
+            fill: fixtureColor?.fill
+                ? fixtureColor?.fill
+                : fixtureData.issue
+                    ? "#D92D20"
+                    : "#EAF8FF",
+            stroke: fixtureColor?.primary
+                ? fixtureColor?.primary
+                : fixtureData.issue
+                    ? "#D92D20"
+                    : "#6BCAFF",
+            strokeWidth: 0.27,
+        });
+        const firstBoxText = new fabric.Textbox(`${fixtureData?.header?.label ? fixtureData.header.label : ""}`, {
+            left: midX + midWidth / 2,
+            top: firstBoxY + boxHeight / 2,
+            fontSize: 7,
+            fontFamily: "Inter",
+            fontWeight: "600",
+            fill: fixtureData.issue ? "#fff" : "#101828",
+            originX: "center",
+            originY: "center",
+            width: midWidth,
+            height: boxHeight,
+            textAlign: "center",
+        });
+        const shelves = [];
+        const shelfHeight = midHeight - 2 * boxHeight;
+        if (fixtureData.productResolutionLevel === "L1") {
+            const boxY = firstBoxY + boxHeight;
+            const shelf = new fabric.Rect({
+                left: midX,
+                top: boxY,
+                width: midWidth,
+                height: shelfHeight,
+                // stroke: '#51C1FF',
+                stroke: fixtureColor?.primary
+                    ? fixtureColor?.primary
+                    : fixtureData.issue
+                        ? "#D92D20"
+                        : "#51C1FF",
+                strokeWidth: 0.27,
+                fill: "white",
+            });
+            const text = fixtureData?.productBrandName?.join(" + ") || "";
+            // Wrap text within fixture width and shrink to fit vertical space
+            const maxTextWidth = midWidth * 0.9;
+            const maxTextHeight = shelfHeight * 0.8;
+            let fontSizeL1 = 6;
+            const createWrappedTextbox = (fs) => new fabric.Textbox(text, {
+                left: midX + midWidth / 2,
+                top: boxY + shelfHeight / 2,
+                originX: "center",
+                originY: "center",
+                width: maxTextWidth,
+                fontSize: fs,
+                fontFamily: "Inter",
+                fontWeight: "500",
+                textAlign: "center",
+                fill: "#333",
+                selectable: false,
+                evented: false,
+            });
+            let wrappedText = createWrappedTextbox(fontSizeL1);
+            while (wrappedText.height > maxTextHeight && fontSizeL1 > 2) {
+                fontSizeL1 -= 0.5;
+                wrappedText = createWrappedTextbox(fontSizeL1);
+            }
+            const padding = 2;
+            const background = new fabric.Rect({
+                left: midX + midWidth / 2,
+                top: boxY + shelfHeight / 2,
+                originX: "center",
+                originY: "center",
+                width: Math.min(maxTextWidth, wrappedText.width) + padding,
+                height: wrappedText.getScaledHeight() + 2,
+                fill: "rgba(255, 255, 255, 0.5)",
+                selectable: false,
+                evented: false,
+                rx: 1,
+                ry: 1,
+            });
+            shelves.push(shelf, background, wrappedText);
+        }
+        else if (fixtureData.productResolutionLevel === "L2") {
+            for (let i = 0; i < shelfCount; i++) {
+                const boxY = firstBoxY + boxHeight * (i + 1);
+                const shelf = new fabric.Rect({
+                    left: midX,
+                    top: boxY,
+                    width: midWidth,
+                    height: boxHeight,
+                    stroke: fixtureColor?.primary
+                        ? fixtureColor?.primary
+                        : fixtureData.issue
+                            ? "#D92D20"
+                            : "#51C1FF",
+                    strokeWidth: 0.27,
+                    fill: "white",
+                });
+                shelves.push(shelf);
+                if (fixtureData.shelfConfig?.[i].shelfType === "tray") {
+                    const trayRows = fixtureData.shelfConfig?.[i].trayRows || 1;
+                    const rowSpacing = boxHeight / trayRows;
+                    for (let r = 1; r < trayRows; r++) {
+                        const lineY = boxY + r * rowSpacing;
+                        const trayLine = new fabric.Line([midX, lineY, midX + midWidth, lineY], {
+                            stroke: "#999",
+                            strokeWidth: 0.2,
+                            selectable: false,
+                            evented: false,
+                        });
+                        shelves.push(trayLine);
+                    }
+                }
+                const text = fixtureData.shelfConfig?.[i].productBrandName?.join(" + ") || "";
+                // L2: Single-line ellipsis against full shelf width
+                const horizontalPadding = 6;
+                const maxTextWidth = Math.max(0, midWidth - horizontalPadding);
+                const maxTextHeight = boxHeight * 0.8;
+                const baseFontSize = 5;
+                const measure = (t) => new fabric.Text(t, {
+                    fontSize: baseFontSize,
+                    fontFamily: "Inter",
+                    fontWeight: "500",
+                });
+                let displayText = text;
+                let measured = measure(displayText);
+                if ((measured.width ?? 0) > maxTextWidth) {
+                    const ellipsis = "...";
+                    let leftIdx = 0;
+                    let rightIdx = text.length;
+                    while (leftIdx < rightIdx) {
+                        const midIdx = Math.floor((leftIdx + rightIdx) / 2);
+                        const candidate = text.slice(0, midIdx) + ellipsis;
+                        measured = measure(candidate);
+                        if ((measured.width ?? 0) > maxTextWidth) {
+                            rightIdx = midIdx;
+                        }
+                        else {
+                            leftIdx = midIdx + 1;
+                        }
+                    }
+                    displayText = text.slice(0, Math.max(0, leftIdx - 1)) + ellipsis;
+                    measured = measure(displayText);
+                }
+                const background = new fabric.Rect({
+                    left: midX + midWidth / 2,
+                    top: boxY + boxHeight / 2,
+                    originX: "center",
+                    originY: "center",
+                    width: midWidth,
+                    height: Math.min(maxTextHeight, measured.height ?? 10) + 2,
+                    fill: "rgba(255, 255, 255, 0.5)",
+                    selectable: false,
+                    evented: false,
+                    rx: 1,
+                    ry: 1,
+                });
+                const finalText = new fabric.Text(displayText, {
+                    left: midX + midWidth / 2,
+                    top: boxY + boxHeight / 2,
+                    originX: "center",
+                    originY: "center",
+                    fontSize: baseFontSize,
+                    fontFamily: "Inter",
+                    fontWeight: "500",
+                    fill: "#333",
+                    selectable: false,
+                    evented: false,
+                });
+                shelves.push(background, finalText);
+            }
+        }
+        else if (fixtureData.productResolutionLevel === "L3") {
+            const sequentialGroups = [];
+            let previousZone = null;
+            for (const shelf of fixtureData.shelfConfig) {
+                const zone = shelf.zone || "Unknown";
+                if (zone !== previousZone) {
+                    sequentialGroups.push({ zone, shelves: [shelf] });
+                    previousZone = zone;
+                }
+                else {
+                    sequentialGroups[sequentialGroups.length - 1].shelves.push(shelf);
+                }
+            }
+            let currentShelfIndex = 0;
+            for (const group of sequentialGroups) {
+                const { zone, shelves: shelvesInGroup } = group;
+                const groupStartIndex = currentShelfIndex;
+                const groupLength = shelvesInGroup.length;
+                const groupTopY = firstBoxY + boxHeight * (groupStartIndex + 1);
+                const groupBottomY = groupTopY + boxHeight * groupLength;
+                for (let j = 0; j < shelvesInGroup.length; j++) {
+                    const shelfData = shelvesInGroup[j];
+                    const boxY = firstBoxY + boxHeight * (currentShelfIndex + 1);
+                    const shelfRect = new fabric.Rect({
+                        left: midX,
+                        top: boxY,
+                        width: midWidth,
+                        height: boxHeight,
+                        stroke: fixtureColor?.primary
+                            ? fixtureColor?.primary
+                            : fixtureData.issue
+                                ? "#D92D20"
+                                : "#51C1FF",
+                        strokeWidth: 0.27,
+                        fill: "white",
+                    });
+                    shelves.push(shelfRect);
+                    if (shelfData.shelfType === "tray") {
+                        const trayRows = shelfData.trayRows || 0;
+                        const productPerShelf = shelfData.productPerShelf || 0;
+                        const rowSpacing = boxHeight / trayRows;
+                        const columnSpacing = midWidth / productPerShelf;
+                        for (let r = 1; r < trayRows; r++) {
+                            const lineY = boxY + r * rowSpacing;
+                            const trayLine = new fabric.Line([midX, lineY, midX + midWidth, lineY], {
+                                stroke: "#999",
+                                strokeWidth: 0.2,
+                                selectable: false,
+                                evented: false,
+                            });
+                            shelves.push(trayLine);
+                        }
+                        for (let c = 1; c < productPerShelf; c++) {
+                            const lineX = midX + c * columnSpacing;
+                            const verticalLine = new fabric.Line([lineX, boxY, lineX, boxY + boxHeight], {
+                                stroke: "#999",
+                                strokeWidth: 0.2,
+                                selectable: false,
+                                evented: false,
+                            });
+                            shelves.push(verticalLine);
+                        }
+                    }
+                    currentShelfIndex++;
+                }
+                const groupBottomLine = new fabric.Line([midX, groupBottomY, midX + midWidth, groupBottomY], {
+                    stroke: fixtureColor?.primary
+                        ? fixtureColor?.primary
+                        : fixtureData.issue
+                            ? "#D92D20"
+                            : "#51C1FF",
+                    strokeWidth: 1,
+                    selectable: false,
+                    evented: false,
+                });
+                shelves.push(groupBottomLine);
+                if (fixtureData.fixtureType === "wall") {
+                    const labelPadding = 2;
+                    const labelText = new fabric.Textbox(zone, {
+                        left: midX + midWidth - labelPadding,
+                        top: groupBottomY,
+                        fontSize: 5,
+                        fontFamily: "Inter",
+                        fontWeight: "600",
+                        fill: "#707070",
+                        originX: "right",
+                        originY: "bottom",
+                        width: midWidth / 2,
+                        textAlign: "right",
+                    });
+                    shelves.push(labelText);
+                }
+                const groupCenterX = midX + midWidth / 2;
+                const groupCenterY = groupTopY + (groupBottomY - groupTopY) / 2;
+                const sectionBrands = new Set();
+                shelvesInGroup?.forEach((shelf) => {
+                    shelf.productBrandName?.forEach((brand) => {
+                        sectionBrands.add(brand);
+                    });
+                });
+                if ([...sectionBrands].length) {
+                    const text = [...sectionBrands].join(" + ");
+                    const padding = 2;
+                    const maxTextWidth = midWidth;
+                    const rectWidth = midWidth * 0.9;
+                    const maxTextHeight = 20;
+                    let fontSize = 6;
+                    let wrappedText;
+                    const createTextbox = (fs) => {
+                        return new fabric.Textbox(text, {
+                            fontSize: fs,
+                            fontFamily: "Inter",
+                            fontWeight: "400",
+                            width: maxTextWidth,
+                            textAlign: "center",
+                            originX: "center",
+                            originY: "center",
+                            fill: "#101828",
+                            selectable: false,
+                            evented: false,
+                            left: groupCenterX,
+                            top: groupCenterY,
+                        });
+                    };
+                    do {
+                        wrappedText = createTextbox(fontSize);
+                        fontSize -= 0.5;
+                    } while (wrappedText.height > maxTextHeight && fontSize > 2);
+                    const rectHeight = wrappedText.getScaledHeight() + padding;
+                    const groupCenterText = new fabric.Rect({
+                        left: groupCenterX,
+                        top: groupCenterY,
+                        originX: "center",
+                        originY: "center",
+                        width: rectWidth,
+                        height: rectHeight,
+                        fill: "rgba(255, 255, 255, 0.5)",
+                        selectable: false,
+                        evented: false,
+                        rx: 1,
+                        ry: 1,
+                    });
+                    shelves.push(groupCenterText, wrappedText);
+                }
+            }
+        }
+        if (fixtureData?.vmConfig?.length) {
+            for (let i = 0; i < fixtureData.vmConfig.length; i++) {
+                const vm = fixtureData.vmConfig[i];
+                const startIndex = vm.startYPosition - 1;
+                const endIndex = vm.endYPosition - 1;
+                const shelfTopY = firstBoxY + boxHeight * (startIndex + 1);
+                const shelfHeightSpan = boxHeight * (endIndex - startIndex + 1);
+                let vmHeightPx = shelfHeightSpan;
+                let y = shelfTopY;
+                if (vm.yZone && vm.yZone !== "stretch") {
+                    vmHeightPx = shelfHeightSpan / 3;
+                    switch (vm.yZone) {
+                        case "top":
+                            y = shelfTopY;
+                            break;
+                        case "middle":
+                            y = shelfTopY + vmHeightPx;
+                            break;
+                        case "bottom":
+                            y = shelfTopY + 2 * vmHeightPx;
+                            break;
+                        default:
+                            y = shelfTopY;
+                    }
+                }
+                let x = midX;
+                let width = midWidth;
+                if (!vm.xZone || vm.xZone === "stretch") {
+                    width = midWidth;
+                    x = midX;
+                }
+                else {
+                    const sectionWidth = midWidth / 3;
+                    switch (vm.xZone) {
+                        case "left":
+                            width = sectionWidth;
+                            x = midX;
+                            break;
+                        case "middle":
+                            width = sectionWidth;
+                            x = midX + sectionWidth;
+                            break;
+                        case "right":
+                            width = sectionWidth;
+                            x = midX + 2 * sectionWidth;
+                            break;
+                        default:
+                            width = midWidth;
+                            x = midX;
+                    }
+                }
+                if (vm.vmImageUrl) {
+                    try {
+                        const vmImage = await fabric.FabricImage.fromURL(`${this.cdnUrl}${vm.vmImageUrl}?v=${Date.now()}`, {
+                            crossOrigin: "anonymous",
+                        });
+                        vmImage.set({
+                            left: x + width / 2,
+                            top: y + vmHeightPx / 2,
+                            originX: "center",
+                            originY: "center",
+                            scaleX: width / vmImage.width,
+                            scaleY: vmHeightPx / vmImage.height,
+                            selectable: false,
+                            evented: false,
+                        });
+                        shelves.push(vmImage);
+                    }
+                    catch (err) {
+                        console.error(`Error loading image for VM: ${vm.vmImageUrl}`, err);
+                    }
+                }
+                else {
+                    const vmBox = new fabric.Rect({
+                        left: x,
+                        top: y,
+                        width,
+                        height: vmHeightPx,
+                        fill: fixtureColor?.vmFill ?? "#6938EF",
+                        selectable: false,
+                        evented: false,
+                    });
+                    let fontSize = 5;
+                    let vmText;
+                    const createVmText = (fs) => new fabric.Textbox(vm.vmName || "", {
+                        left: x + width / 2,
+                        top: y + vmHeightPx / 2,
+                        originX: "center",
+                        originY: "center",
+                        fontSize: fs,
+                        fontFamily: "Inter",
+                        fontWeight: "600",
+                        fill: "white",
+                        textAlign: "center",
+                        width: width,
+                        selectable: false,
+                        evented: false,
+                    });
+                    do {
+                        vmText = createVmText(fontSize);
+                        fontSize -= 0.5;
+                    } while (vmText.height > vmHeightPx && fontSize > 2);
+                    shelves.push(vmBox, vmText);
+                }
+            }
+        }
+        const lastBoxY = firstBoxY + boxHeight * (shelfCount + 1);
+        const lastBox = new fabric.Path(`M ${midX} ${lastBoxY} 
+              L ${midX + midWidth} ${lastBoxY} 
+              L ${midX + midWidth} ${lastBoxY + boxHeight - radius} 
+              Q ${midX + midWidth} ${lastBoxY + boxHeight} ${midX + midWidth - radius} ${lastBoxY + boxHeight} 
+              L ${midX + radius} ${lastBoxY + boxHeight} 
+              Q ${midX} ${lastBoxY + boxHeight} ${midX} ${lastBoxY + boxHeight - radius} 
+              L ${midX} ${lastBoxY} Z`, {
+            fill: fixtureColor?.fill
+                ? fixtureColor?.fill
+                : fixtureData.issue
+                    ? "#FEE4E2"
+                    : "#EAF8FF",
+            stroke: fixtureColor?.primary
+                ? fixtureColor?.primary
+                : fixtureData.issue
+                    ? "#D92D20"
+                    : "#6BCAFF",
+            strokeWidth: 0.27,
+        });
+        const lastBoxText = new fabric.Textbox(`${fixtureData?.footer?.label ? fixtureData.footer.label : ""}`, {
+            left: midX + midWidth / 2,
+            top: lastBoxY + boxHeight / 2,
+            fontSize: 5,
+            fontFamily: "Inter",
+            fontWeight: "600",
+            fill: "#101828",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            width: midWidth,
+            heigth: boxHeight,
+        });
+        const bottomWidth = width / 1.05;
+        const bottomHeight = (3 / 100) * height;
+        const bottomX = x + (width - bottomWidth) / 2;
+        const bottomY = midY + midHeight + this.verticalMargin;
+        const bottomContainer = new fabric.Rect({
+            left: bottomX,
+            top: bottomY,
+            width: bottomWidth,
+            height: bottomHeight,
+            rx: radius,
+            ry: radius,
+            stroke: "transparent",
+            fill: "transparent",
+        });
+        const bottomTextContent = new fabric.Textbox(`Shelves - ${fixtureData.shelfConfig?.length} . Products -  ${fixtureData.fixtureCapacity} . VM - ${fixtureData.vmConfig?.length}`, {
+            left: bottomX + bottomWidth / 2,
+            top: bottomY + bottomHeight / 2,
+            fontSize: 5,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#333",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            width: bottomWidth,
+            height: bottomHeight,
+        });
+        const fixtureGroup = new fabric.Group([
+            mainContainer,
+            topContainer,
+            innerTopBox,
+            topText,
+            innerBottomBox,
+            bottomText,
+            midContainer,
+            firstBox,
+            firstBoxText,
+            ...shelves,
+            lastBox,
+            lastBoxText,
+            bottomContainer,
+            bottomTextContent,
+        ], {
+            left: x,
+            top: y,
+            evented: true,
+            selectable: false,
+            hoverCursor: "default",
+            lockScalingX: true,
+            lockScalingY: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            lockRotation: true,
+            hasControls: false,
+            subTargetCheck: true,
+            angle: fixtureData.relativePosition?.angle ?? 0,
+        });
+        fixtureGroup.fixtureType = fixtureData.fixtureType;
+        fixtureGroup.wallIndex = fixtureData.associatedElementNumber;
+        fixtureGroup.fixtureIndex = fixtureData.associatedElementFixtureNumber;
+        fixtureGroup.fixtureId = fixtureData._id;
+        fixtureGroup.issue = fixtureData.issue;
+        fixtureGroup.issueData = fixtureData.issueData;
+        fixtureGroup.taskType = fixtureData.taskType;
+        fixtureGroup.vmConfig = fixtureData.vmConfig;
+        fixtureGroup.objType = "fixture";
+        // Add click handler directly on the fixture group
+        fixtureGroup.on("mousedown", (event) => {
+            // Use the fixture group itself (which has all the fixture properties)
+            // The event.target might be a child element, so we use fixtureGroup directly
+            if (fixtureGroup && fixtureGroup.fixtureId) {
+                this.onFixtureClick(fixtureGroup);
+            }
+        });
+        canvas.add(fixtureGroup);
+        // If newly added, focus it once
+        if (fixtureData?.newAdded) {
+            try {
+                canvas.setActiveObject(fixtureGroup);
+                canvas.requestRenderAll();
+            }
+            catch { }
+            delete fixtureData.newAdded;
+        }
+        return fixtureGroup;
+    }
+    drawOtherElementsWithLabel(canvas, x, y, a, width, height, element) {
+        const rect = new fabric.Rect({
+            width,
+            height,
+            rx: 2,
+            ry: 2,
+            fill: "#DAF1FF",
+            stroke: "#6BCAFF",
+            strokeWidth: 2,
+            originX: "center",
+            originY: "center",
+        });
+        const text = new fabric.Textbox(element.fixtureName, {
+            width: width - 8,
+            fontSize: 14,
+            fontFamily: "Inter",
+            fontWeight: "500",
+            fill: "#101828",
+            originX: "center",
+            originY: "center",
+            textAlign: "center",
+            editable: false,
+            splitByGrapheme: true,
+        });
+        const textBounds = text.getBoundingRect();
+        if (textBounds.height > height - 8) {
+            const scale = (height - 8) / textBounds.height;
+            text.set("fontSize", text.fontSize * scale);
+        }
+        const group = new fabric.Group([rect, text], {
+            left: x,
+            top: y,
+            angle: a,
+            originX: "center",
+            originY: "center",
+            hasControls: false,
+            selectable: false,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockRotation: true,
+            lockMovementX: true,
+            lockMovementY: true,
+            evented: true,
+            hoverCursor: "default",
+        });
+        group.objType = "others";
+        group.data = element;
+        canvas.add(group);
+        if (element?.newAdded) {
+            try {
+                canvas.setActiveObject(group);
+                canvas.requestRenderAll();
+            }
+            catch { }
+            delete element.newAdded;
+        }
+        return group;
+    }
+    collectAllFixtures() {
+        this.allFixtureInstances = [];
+        // Collect wall fixtures
+        if (this.floorData?.layoutPolygon) {
+            for (const element of this.floorData.layoutPolygon) {
+                if (element.fixtures && Array.isArray(element.fixtures)) {
+                    this.allFixtureInstances.push(...element.fixtures);
+                }
+            }
+        }
+        // Collect floor fixtures
+        if (this.floorData?.centerFixture && Array.isArray(this.floorData.centerFixture)) {
+            this.allFixtureInstances.push(...this.floorData.centerFixture);
+        }
+    }
+    onFixtureClick(target) {
+        if (!target || !this.floorData)
+            return;
+        const fixtureId = target.fixtureId;
+        const fixtureType = target.fixtureType;
+        if (!fixtureId) {
+            console.warn('Fixture click: No fixtureId found on target', target);
+            return;
+        }
+        // Find the fixture data
+        let fixtureData = null;
+        if (fixtureType === "wall") {
+            const wallIndex = target.wallIndex;
+            if (this.floorData.layoutPolygon && wallIndex !== undefined && wallIndex !== null) {
+                // Find wall by elementNumber (wallIndex is the elementNumber)
+                const wall = this.floorData.layoutPolygon.find((w) => w.elementNumber === wallIndex);
+                if (wall && wall.fixtures) {
+                    // Always use fixtureId to find the fixture (more reliable than index-based lookup)
+                    fixtureData = wall.fixtures.find((f) => f._id === fixtureId);
+                }
+            }
+        }
+        else if (fixtureType === "floor") {
+            fixtureData = this.floorData.centerFixture?.find((f) => f._id === fixtureId);
+        }
+        if (!fixtureData) {
+            console.warn('Fixture click: Fixture data not found', {
+                fixtureId,
+                fixtureType,
+                wallIndex: target.wallIndex,
+                fixtureIndex: target.fixtureIndex,
+                floorData: this.floorData
+            });
+            return;
+        }
+        // Ensure vmConfig is always an array (even if empty) to avoid display issues
+        // Handle cases where vmConfig might be null, undefined, or not an array
+        if (!Array.isArray(fixtureData.vmConfig)) {
+            fixtureData.vmConfig = [];
+        }
+        // Create a deep clone to ensure change detection works
+        const clonedData = structuredClone(fixtureData);
+        this.selectedFixture = {
+            fixtureId: fixtureId,
+            fixtureType: fixtureType,
+            wallIndex: target.wallIndex,
+            fixtureIndex: target.fixtureIndex,
+        };
+        // Check if this fixture has replaceResponseData (for before/after comparison)
+        const store = this.findReplaceData?.stores?.find((s) => s.storeName === this.selectedStoreForPreview?.storeName);
+        // If this fixture matches the findResponseData and has replaceResponseData,
+        // restore the original fixture data for before/after comparison
+        if (store?.findResponseData === fixtureId && store?.replaceResponseData) {
+            // Restore originalFixtureData from the map (persists even when clicking other fixtures)
+            const storedOriginal = this.originalFixturesMap.get(fixtureId);
+            if (storedOriginal) {
+                this.originalFixtureData = structuredClone(storedOriginal);
+            }
+            else {
+                // If not in map (shouldn't happen if applyStoredResponseData ran), 
+                // use current fixture as fallback
+                this.originalFixtureData = structuredClone(clonedData);
+            }
+        }
+        else {
+            // No replace data for this fixture, clear original
+            this.originalFixtureData = null;
+        }
+        // Force change detection by creating a new object reference
+        this.selectedFixtureData = null;
+        this.cdr.detectChanges();
+        setTimeout(() => {
+            this.selectedFixtureData = clonedData;
+            this.isRightPanelCollapsed = false;
+            this.cdr.detectChanges();
+            // Re-center planogram when panel opens (similar to manage-planogram)
+            setTimeout(() => {
+                if (this.previewCanvas && this.previewCanvasContainerRef?.nativeElement) {
+                    this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);
+                    this.fitCanvasToLayoutAnimated(this.previewCanvas);
+                }
+            }, 400);
+        }, 0);
+    }
+    toggleRightPanel() {
+        this.isRightPanelCollapsed = !this.isRightPanelCollapsed;
+        // Resize canvas when panel is toggled
+        setTimeout(() => {
+            if (this.previewCanvas && this.previewCanvasContainerRef?.nativeElement) {
+                this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);
+                this.fitCanvasToLayoutAnimated(this.previewCanvas);
+            }
+        }, 400);
+    }
+    ngOnDestroy() {
+        if (this.previewCanvas) {
+            this.previewCanvas.dispose();
+        }
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PrepareTemplateComponent, deps: [{ token: i1.StoreBuilderService }, { token: i2.CollectionUpdateAiDataService }, { token: i3.TitleCasePipe }, { token: i0.ChangeDetectorRef }, { token: i4.GlobalStateService }, { token: i5.Router }, { token: i5.ActivatedRoute }, { token: i6.ToastService }, { token: i7.NgbModal }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: PrepareTemplateComponent, isStandalone: true, selector: "lib-prepare-template", providers: [TitleCasePipe], viewQueries: [{ propertyName: "previewCanvasRef", first: true, predicate: ["previewCanvas"], descendants: true }, { propertyName: "previewCanvasContainerRef", first: true, predicate: ["previewCanvasContainer"], descendants: true }], ngImport: i0, template: "<div class=\"main-card\">\r\n    <form>\r\n        <!-- Section 1: Add Stores -->\r\n        <div class=\"section-row\">\r\n            <div class=\"section-number\">1</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Add stores</h2>\r\n                <div class=\"store-input-wrapper\">\r\n                   <div class=\"store-dropdown\">\r\n                        <lib-reactive-select\r\n                            [idField]=\"'value'\"\r\n                            [nameField]=\"'label'\"\r\n                            [data]=\"searchModes\"\r\n                            [formControl]=\"selectedMode\" \r\n                            >\r\n                        </lib-reactive-select>\r\n                    </div> \r\n                    <lib-store-select \r\n                        [options]=\"storeOptions\"\r\n                        [initialSelected]=\"selectedStores\"\r\n                        (selectedChange)=\"onStoresSelected($event)\">\r\n                    </lib-store-select>\r\n                    <button class=\"btn-apply\" type=\"button\" (click)=\"onApply()\" [disabled]=\"loading || findLoading || replaceLoading || savingDraft\">\r\n                        {{ savingDraft ? 'Saving...' : 'Apply' }}\r\n                    </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Section 2: Choose Target -->\r\n        <div class=\"section-row\" *ngIf=\"hasStores\">\r\n            <div class=\"section-number\">2</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Choose target</h2>\r\n                <div class=\"target-buttons\">\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'both'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"both\" [formControl]=\"target\">\r\n                        Both\r\n                    </label>\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'merch'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"merch\" [formControl]=\"target\">\r\n                        Merchandise\r\n                    </label>\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'vm'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"vm\" [formControl]=\"target\">\r\n                        Visual Merchandise\r\n                    </label>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Section 3: Find and Replace -->\r\n        <div class=\"section-row\" *ngIf=\"hasStores\">\r\n            <div class=\"section-number\">3</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Provide an instruction to find and replace in the selected store</h2>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Find and Replace Inputs -->\r\n        <div class=\"find-replace-wrapper\" *ngIf=\"hasStores\">\r\n            <div class=\"find-replace-box\">\r\n                <label class=\"find-replace-label\">Target</label>\r\n                <div class=\"find-replace-input\">\r\n                    <textarea \r\n                        placeholder=\"Instruct what to find it in the selected store\"\r\n                        [formControl]=\"findPrompt\"></textarea>\r\n                    <div class=\"input-btn-container\">\r\n                        <button \r\n                            class=\"btn-find\" \r\n                            type=\"button\"\r\n                            (click)=\"onFind()\"\r\n                            [disabled]=\"findLoading || replaceLoading || !selectedStoreForPreview\">\r\n                            {{ findLoading ? 'Processing...' : 'Find' }}\r\n                        </button>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n            \r\n            <div class=\"arrow-icon\">\r\n                <svg width=\"27\" height=\"15\" viewBox=\"0 0 27 15\" fill=\"none\">\r\n                    <path d=\"M26.7071 8.07107C27.0976 7.68054 27.0976 7.04738 26.7071 6.65685L20.3431 0.292893C19.9526 -0.097631 19.3195 -0.097631 18.9289 0.292893C18.5384 0.683418 18.5384 1.31658 18.9289 1.70711L24.5858 7.36396L18.9289 13.0208C18.5384 13.4113 18.5384 14.0445 18.9289 14.435C19.3195 14.8256 19.9526 14.8256 20.3431 14.435L26.7071 8.07107ZM0 7.36396V8.36396H26V7.36396V6.36396H0V7.36396Z\" fill=\"#98A2B3\"/>\r\n                </svg>\r\n            </div>\r\n            \r\n            <div class=\"find-replace-box\">\r\n                <label class=\"find-replace-label\">Change</label>\r\n                <div class=\"find-replace-input\">\r\n                    <textarea \r\n                        placeholder=\"Type what would you like to replace in the selected fixture\"\r\n                        [formControl]=\"replacePrompt\"></textarea>\r\n                    <div class=\"input-btn-container\">\r\n                        <button \r\n                            class=\"btn-replace\" \r\n                            type=\"button\"\r\n                            (click)=\"onReplace()\"\r\n                            [disabled]=\"!findPrompt.value || !replacePrompt.value || findLoading || replaceLoading || !getCurrentStoreFindResponseData()\">\r\n                            {{ replaceLoading ? 'Processing...' : 'Replace' }}\r\n                        </button>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Preview Section -->\r\n        <div class=\"preview-wrapper\" *ngIf=\"hasStores\">\r\n            <div class=\"row g-0 preview-layout\">\r\n                <!-- Left Column: Canvas -->\r\n                <div class=\"col\" [ngClass]=\"{ \r\n                    'col-6': !isRightPanelCollapsed && selectedFixtureData && originalFixtureData,\r\n                    'col-9': !isRightPanelCollapsed && selectedFixtureData && !originalFixtureData, \r\n                    'col-12': isRightPanelCollapsed || !selectedFixtureData \r\n                }\">\r\n                    <div class=\"d-flex align-items-start gap-3 mb-3\">\r\n                        <!-- Store Dropdown -->\r\n                        <lib-store-dropdown \r\n                            *ngIf=\"hasStores && storeDropdownItems.length > 0\"\r\n                            [items]=\"storeDropdownItems\"\r\n                            [idField]=\"'storeId'\"\r\n                            [searchField]=\"'storeName'\"\r\n                            [multi]=\"false\"\r\n                            [selectedValues]=\"selectedStoreValues\"\r\n                            (selected)=\"onStoreSelectedForPreview($event)\">\r\n                        </lib-store-dropdown>\r\n                        \r\n                        <!-- Content Area -->\r\n                        <div class=\"flex-grow-1\">\r\n                            <!-- Preview Title -->\r\n                            <p class=\"fw-semibold mb-1\" style=\"font-size: 14px; color: #1d2939;\">\r\n                                Preview \r\n                                <span *ngIf=\"getStoreCount() > 0\" style=\"font-weight: 400; color: #667085;\">\r\n                                    ({{ getStoreCount() }} {{ getStoreCount() === 1 ? 'Store' : 'Stores' }})\r\n                                </span>\r\n                            </p>\r\n                            \r\n                            <!-- Description -->\r\n                            <p class=\"mb-0\" style=\"font-size: 14px; color: #475467;\">Check if the prompt fit into the expected results in order to proceed to review and approve</p>\r\n                        </div>\r\n                    </div>\r\n\r\n                    <!-- Canvas Container -->\r\n                    <div class=\"canvas-container\" #previewCanvasContainer *ngIf=\"selectedStoreForPreview\">\r\n                        <div class=\"canvas-loading\" *ngIf=\"canvasLoading\">\r\n                            <div class=\"spinner-border text-primary\" role=\"status\">\r\n                                <span class=\"visually-hidden\">Loading...</span>\r\n                            </div>\r\n                        </div>\r\n                        <canvas #previewCanvas></canvas>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Right Column: Fixture Preview -->\r\n                <div class=\"fixture-preview-panel\" \r\n                     *ngIf=\"selectedFixtureData && !isRightPanelCollapsed\"\r\n                     [ngClass]=\"{ 'col-6': originalFixtureData, 'col-3': !originalFixtureData }\"\r\n                     [style.min-width]=\"originalFixtureData ? '680px' : '340px'\">\r\n                    <div class=\"s-card\">\r\n                        <!-- Panel Header -->\r\n                        <div class=\"fixture-preview-header\">\r\n                            <div class=\"header-card\">\r\n                                <div class=\"card-content\">\r\n                                    <!-- <div class=\"product-image-container\">\r\n                                        <img \r\n                                            alt=\"Product\" \r\n                                            class=\"product-image\"\r\n                                        />\r\n                                    </div> -->\r\n                                    <div class=\"name\">{{ getFixtureLabel() }}</div>\r\n                                    <div class=\"specs-container\" *ngIf=\"getFixtureCategory() || getFixtureWidth() || getShelfCount() > 0 || getFixtureCapacity() > 0\">\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureCategory()\">{{ getFixtureCategory() }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getFixtureCategory() && (getFixtureWidth() || getShelfCount() > 0 || getFixtureCapacity() > 0)\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureWidth()\">{{ getFixtureWidth() }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getFixtureWidth() && (getShelfCount() > 0 || getFixtureCapacity() > 0)\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getShelfCount() > 0\">{{ getShelfCount() }} {{ getShelfCount() === 1 ? 'Shelf' : 'Shelves' }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getShelfCount() > 0 && getFixtureCapacity() > 0\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureCapacity() > 0\">{{ getFixtureCapacity() }} Capacity</span>\r\n                                    </div>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n\r\n                        <!-- Fixture Component -->\r\n                        <div class=\"fixture-preview-content\">\r\n                            <!-- Show Before/After when replace data exists -->\r\n                            <div *ngIf=\"originalFixtureData\" class=\"before-after-container\">\r\n                                <div class=\"before-section\">\r\n                                    <div class=\"section-header\">\r\n                                        <h6 class=\"section-label mb-0\">Before</h6>\r\n                                    </div>\r\n                                    <div class=\"fixture-wrapper\">\r\n                                        <lib-store-fixture \r\n                                            [fixture]=\"originalFixtureData\" \r\n                                            [showColors]=\"true\"\r\n                                            [showVMs]=\"true\"\r\n                                            [showBCs]=\"true\">\r\n                                        </lib-store-fixture>\r\n                                    </div>\r\n                                </div>\r\n                                <div class=\"after-section\">\r\n                                    <div class=\"section-header\">\r\n                                        <h6 class=\"section-label mb-0\">After</h6>\r\n                                    </div>\r\n                                    <div class=\"fixture-wrapper\">\r\n                                        <lib-store-fixture \r\n                                            [fixture]=\"selectedFixtureData\" \r\n                                            [showColors]=\"true\"\r\n                                            [showVMs]=\"true\"\r\n                                            [showBCs]=\"true\">\r\n                                        </lib-store-fixture>\r\n                                    </div>\r\n                                </div>\r\n                            </div>\r\n                            \r\n                            <!-- Show single fixture when no replace data -->\r\n                            <div *ngIf=\"!originalFixtureData\" class=\"single-fixture-container\">\r\n                                <div class=\"fixture-wrapper\">\r\n                                    <lib-store-fixture \r\n                                        [fixture]=\"selectedFixtureData\" \r\n                                        [showColors]=\"true\"\r\n                                        [showVMs]=\"true\"\r\n                                        [showBCs]=\"true\">\r\n                                    </lib-store-fixture>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Collapse Button -->\r\n                <div class=\"collapse-handler right\" \r\n                     *ngIf=\"selectedFixtureData\"\r\n                     (click)=\"toggleRightPanel()\">\r\n                    <svg *ngIf=\"isRightPanelCollapsed\" xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\"\r\n                        viewBox=\"0 0 18 18\" fill=\"none\">\r\n                        <path d=\"M8.27308 12.636L4.63672 8.99964L8.27308 5.36328M13.364 12.636L9.72763 8.99964L13.364 5.36328\"\r\n                            stroke=\"#101828\" stroke-width=\"1.45455\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg>\r\n                    <svg *ngIf=\"!isRightPanelCollapsed\" xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\"\r\n                        viewBox=\"0 0 18 18\" fill=\"none\">\r\n                        <path d=\"M9.72692 5.36399L13.3633 9.00036L9.72692 12.6367M4.63601 5.36399L8.27237 9.00036L4.63601 12.6367\"\r\n                            stroke=\"#101828\" stroke-width=\"1.45455\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        <!-- No Preview Section -->\r\n        <div class=\"no-preview\" *ngIf=\"hasStores && !selectedStoreForPreview\">\r\n            <div >\r\n                <svg width=\"315\" height=\"155\" viewBox=\"0 0 315 155\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                    <path d=\"M103.81 47.0195C89.5463 47.0197 77.9834 58.5824 77.9834 72.8457C77.9834 78.7617 73.9803 85.5059 68.0643 85.5059H45.2588C30.9953 85.5059 19.4316 97.0686 19.4316 111.332C19.4316 125.596 30.9953 137.158 45.2588 137.158H183.357C200.248 137.158 216.32 123.992 233.21 123.992H299.245C304 123.992 307.854 120.137 307.854 115.383C307.853 110.629 303.999 106.774 299.245 106.774H211.625C209.98 106.774 208.588 105.553 208.12 103.976C207.381 101.486 209.082 98.6719 211.679 98.6719H241.909C256.172 98.6717 267.735 87.109 267.735 72.8457C267.735 58.5824 256.172 47.0198 241.909 47.0195H103.81Z\" fill=\"#EAECF0\"/>\r\n                    <rect width=\"240.694\" height=\"16.9956\" rx=\"8.4978\" transform=\"matrix(-1 0 0 1 246.603 48.8574)\" fill=\"#EAECF0\"/>\r\n                    <circle cx=\"5.42147\" cy=\"5.42147\" r=\"5.42147\" transform=\"matrix(-1 0 0 1 56.2979 113.281)\" fill=\"#6BCAFF\"/>\r\n                    <circle cx=\"3.25288\" cy=\"3.25288\" r=\"3.25288\" transform=\"matrix(-1 0 0 1 244.965 68.8262)\" fill=\"#00A3FF\"/>\r\n                    <circle cx=\"3.25288\" cy=\"3.25288\" r=\"3.25288\" transform=\"matrix(-1 0 0 1 215.689 13.5273)\" fill=\"#00A3FF\"/>\r\n                    <circle cx=\"2.16859\" cy=\"2.16859\" r=\"2.16859\" transform=\"matrix(-1 0 0 1 104.006 138.221)\" fill=\"#00A3FF\"/>\r\n                    <rect x=\"68.501\" y=\"44.1523\" width=\"166.999\" height=\"97.9371\" rx=\"15.1015\" fill=\"#6BCAFF\" stroke=\"#00A3FF\" stroke-width=\"3\"/>\r\n                    <mask id=\"path-8-inside-1_936_150383\" fill=\"white\">\r\n                    <path d=\"M93.1172 19C94.0625 19 94.9892 19.0828 95.8887 19.2422V116.784C94.9892 116.625 94.0625 116.542 93.1172 116.542H82.7744C74.0642 116.542 67.0031 123.603 67.0029 132.313V34.7715C67.0029 26.0612 74.0641 19 82.7744 19H93.1172Z\"/>\r\n                    </mask>\r\n                    <path d=\"M93.1172 19C94.0625 19 94.9892 19.0828 95.8887 19.2422V116.784C94.9892 116.625 94.0625 116.542 93.1172 116.542H82.7744C74.0642 116.542 67.0031 123.603 67.0029 132.313V34.7715C67.0029 26.0612 74.0641 19 82.7744 19H93.1172Z\" fill=\"#6BCAFF\"/>\r\n                    <path d=\"M93.1172 19L93.1173 16H93.1172V19ZM95.8887 19.2422H98.8887V16.7271L96.4122 16.2882L95.8887 19.2422ZM95.8887 116.784L95.3651 119.738L98.8887 120.363V116.784H95.8887ZM93.1172 116.542L93.1173 113.542H93.1172V116.542ZM67.0029 132.313H64.0029L70.0029 132.314L67.0029 132.313ZM93.1172 19L93.1171 22C93.8872 22 94.6387 22.0674 95.3651 22.1961L95.8887 19.2422L96.4122 16.2882C95.3396 16.0981 94.2377 16 93.1173 16L93.1172 19ZM95.8887 19.2422H92.8887V116.784H95.8887H98.8887V19.2422H95.8887ZM95.8887 116.784L96.4122 113.83C95.3396 113.64 94.2377 113.542 93.1173 113.542L93.1172 116.542L93.1171 119.542C93.8872 119.542 94.6387 119.609 95.3651 119.738L95.8887 116.784ZM93.1172 116.542V113.542H82.7744V116.542V119.542H93.1172V116.542ZM82.7744 116.542V113.542C72.4073 113.542 64.0032 121.947 64.0029 132.313L67.0029 132.313L70.0029 132.314C70.0031 125.26 75.7212 119.542 82.7744 119.542V116.542ZM67.0029 132.313H70.0029V34.7715H67.0029H64.0029V132.313H67.0029ZM67.0029 34.7715H70.0029C70.0029 27.718 75.721 22 82.7744 22V19V16C72.4072 16 64.0029 24.4043 64.0029 34.7715H67.0029ZM82.7744 19V22H93.1172V19V16H82.7744V19Z\" fill=\"#00A3FF\" mask=\"url(#path-8-inside-1_936_150383)\"/>\r\n                    <line x1=\"76.9619\" y1=\"42.6523\" x2=\"76.9619\" y2=\"84.4881\" stroke=\"#99DAFF\" stroke-width=\"3.98436\" stroke-linecap=\"round\"/>\r\n                    <circle cx=\"218.206\" cy=\"70.1755\" r=\"3.29663\" fill=\"white\"/>\r\n                    <circle cx=\"111.787\" cy=\"55.167\" r=\"2.52637\" fill=\"#99DAFF\"/>\r\n                    <circle cx=\"99.3845\" cy=\"124.986\" r=\"3.44505\" fill=\"white\"/>\r\n                    <path d=\"M135.529 33.4717C151.285 24.3749 171.432 29.7732 180.529 45.5293C188.56 59.4398 185.291 76.7707 173.573 86.9004L193.457 121.339C194.932 123.894 194.056 127.161 191.501 128.636C188.946 130.111 185.679 129.236 184.204 126.681L164.466 92.4932C149.447 98.6552 131.814 92.92 123.472 78.4717C114.375 62.7156 119.773 42.5685 135.529 33.4717ZM172.698 50.0518C166.099 38.6209 151.482 34.7041 140.051 41.3037C128.62 47.9035 124.703 62.5204 131.303 73.9512C137.902 85.3817 152.519 89.2977 163.95 82.6982C175.381 76.0987 179.297 61.4826 172.698 50.0518Z\" fill=\"white\"/>\r\n                    <circle cx=\"153.001\" cy=\"57.0017\" r=\"23.8994\" transform=\"rotate(-30 153.001 57.0017)\" fill=\"#99DAFF\"/>\r\n                    <mask id=\"path-16-inside-2_936_150383\" fill=\"white\">\r\n                    <path d=\"M153.384 40.9957C153.435 39.7001 152.423 38.5927 151.131 38.7095C148.858 38.9151 146.636 39.5491 144.586 40.5854C141.835 41.976 139.484 44.045 137.755 46.597C136.026 49.149 134.977 52.0996 134.706 55.1701C134.504 57.4583 134.739 59.7568 135.391 61.9447C135.762 63.1872 137.166 63.7169 138.35 63.1891C139.534 62.6612 140.044 61.2746 139.73 60.0165C139.37 58.5735 139.251 57.0753 139.383 55.583C139.584 53.3078 140.361 51.1214 141.642 49.2304C142.924 47.3394 144.666 45.8063 146.704 44.7758C148.041 44.1 149.477 43.6551 150.95 43.4542C152.235 43.2792 153.333 42.2913 153.384 40.9957Z\"/>\r\n                    </mask>\r\n                    <path d=\"M153.384 40.9957C153.435 39.7001 152.423 38.5927 151.131 38.7095C148.858 38.9151 146.636 39.5491 144.586 40.5854C141.835 41.976 139.484 44.045 137.755 46.597C136.026 49.149 134.977 52.0996 134.706 55.1701C134.504 57.4583 134.739 59.7568 135.391 61.9447C135.762 63.1872 137.166 63.7169 138.35 63.1891C139.534 62.6612 140.044 61.2746 139.73 60.0165C139.37 58.5735 139.251 57.0753 139.383 55.583C139.584 53.3078 140.361 51.1214 141.642 49.2304C142.924 47.3394 144.666 45.8063 146.704 44.7758C148.041 44.1 149.477 43.6551 150.95 43.4542C152.235 43.2792 153.333 42.2913 153.384 40.9957Z\" stroke=\"white\" stroke-width=\"6\" mask=\"url(#path-16-inside-2_936_150383)\"/>\r\n                    <path d=\"M136.529 28.4717C152.285 19.3749 172.432 24.7732 181.529 40.5293C189.56 54.4398 186.291 71.7707 174.573 81.9004L194.457 116.339C195.932 118.894 195.056 122.161 192.501 123.636C189.946 125.111 186.679 124.236 185.204 121.681L165.466 87.4932C150.447 93.6552 132.814 87.92 124.472 73.4717C115.375 57.7156 120.773 37.5685 136.529 28.4717ZM173.698 45.0518C167.099 33.6209 152.482 29.7041 141.051 36.3037C129.62 42.9035 125.703 57.5204 132.303 68.9512C138.902 80.3817 153.519 84.2977 164.95 77.6982C176.381 71.0987 180.297 56.4826 173.698 45.0518Z\" fill=\"#00A3FF\"/>\r\n                    </svg>                    \r\n            </div>\r\n            <h3>No preview yet</h3>\r\n            <p>Add a find and replacement to preview.</p>\r\n        </div>\r\n\r\n        <!-- Action Button Section -->\r\n        <div class=\"action-button-section\" *ngIf=\"hasStores\">\r\n            <button class=\"btn-apply\" type=\"button\" (click)=\"onReviewAndReplace()\" [disabled]=\"loading || findLoading || replaceLoading || batchProcessing\">\r\n                {{ batchProcessing ? 'Processing...' : 'Review And Replace' }}\r\n            </button>\r\n        </div>\r\n    </form>\r\n</div>\r\n", styles: [".btn-apply{padding:10px 18px;font-size:16px;font-weight:600;color:#fff;background:#00a3ff;border:1px solid #00a3ff;border-radius:8px;box-shadow:0 1px 2px #1018280d;height:44px;flex-shrink:0;white-space:nowrap;transition:background-color .2s ease,border-color .2s ease;cursor:pointer}.btn-apply:hover{background:#0092e6;border-color:#0092e6}.action-button-section{display:flex;justify-content:flex-end;margin-top:32px;margin-left:34px}.main-card{background:#fff;border-radius:12px;padding:24px;box-shadow:0 1px 3px #0000001a}.section-row{display:flex;gap:8px;margin-bottom:32px}.section-connector{display:flex;gap:8px;margin-bottom:32px;margin-top:-24px}.connector-line{width:24px;flex-shrink:0;display:flex;align-items:flex-start;justify-content:center}.connector-line svg{display:block}.connector-spacer{flex:1}.section-number{width:24px;height:24px;background:#f2f4f7;border-radius:100px;display:flex;align-items:center;justify-content:center;font-size:14px;font-weight:600;flex-shrink:0}.section-content{flex:1}.section-title{font-size:14px;font-weight:600;color:#1d2939;margin:0 0 12px}.store-input-wrapper{display:flex;gap:8px;align-items:center}.store-dropdown{width:124px;flex-shrink:0}.store-dropdown select{padding:10px 14px;font-size:16px;font-weight:500;color:#101828;background:#fff;border:1px solid #d0d5dd;border-radius:8px;box-shadow:0 1px 2px #1018280d;width:100%}lib-store-select{flex:1;min-width:0}.tags-input{flex:1;padding:10px 14px;background:#fff;border:1px solid #d0d5dd;border-radius:8px;box-shadow:0 1px 2px #1018280d;display:flex;gap:8px;flex-wrap:wrap;min-height:44px}.tag{background:#f2f4f7;padding:2px 6px 2px 8px;border-radius:16px;display:inline-flex;align-items:center;gap:4px;font-size:12px;font-weight:500;color:#344054}.tag-close{width:12px;height:12px;cursor:pointer;display:flex;align-items:center;justify-content:center}.target-buttons{display:flex;border:1px solid #d0d5dd;border-radius:8px;overflow:hidden;box-shadow:0 1px 2px #1018280d;width:fit-content}.target-btn{padding:10px 16px;font-size:14px;font-weight:500;background:#fff;border:none;border-right:1px solid #d0d5dd;color:#344054;cursor:pointer;transition:background-color .2s;min-width:140px;display:flex;align-items:center;justify-content:center}.target-btn:last-child{border-right:none}.target-btn.active{background:#eaf8ff;color:#1d2939}.target-btn input[type=radio]{display:none}.find-replace-wrapper{margin-left:34px;display:flex;gap:16px;align-items:center}.preview-wrapper{margin-left:34px;margin-top:24px;margin-bottom:32px}.preview-wrapper lib-store-dropdown{width:180px;flex-shrink:0}.preview-wrapper .btn-find,.preview-wrapper .btn-replace{padding:8px 16px;font-size:14px;font-weight:500;border-radius:8px;border:1px solid #d0d5dd;background:#fff;color:#344054;cursor:pointer;transition:all .2s ease}.preview-wrapper .btn-find:hover:not(:disabled),.preview-wrapper .btn-replace:hover:not(:disabled){background:#f9fafb;border-color:#98a2b3}.preview-wrapper .btn-find:disabled,.preview-wrapper .btn-replace:disabled{opacity:.5;cursor:not-allowed}.preview-wrapper .btn-find{border-color:#00a3ff;color:#00a3ff}.preview-wrapper .btn-find:hover:not(:disabled){background:#eaf8ff}.preview-wrapper .btn-replace{border-color:#16a34a;color:#16a34a}.preview-wrapper .btn-replace:hover:not(:disabled){background:#f0fdf4}.preview-wrapper .btn-replace:disabled{background:#f2f4f7!important;border-color:#d0d5dd!important;color:#98a2b3!important;opacity:1;cursor:not-allowed}.preview-wrapper .canvas-container{position:relative;border:1px solid #e5e7eb;border-radius:8px;padding:0;background:#f9fafb;min-height:77vh;width:100%;overflow:hidden;flex:1}.preview-wrapper .canvas-container .canvas-loading{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);z-index:10}.preview-wrapper .canvas-container canvas{background:#fff;width:100%!important;height:100%!important;display:block}.find-replace-box{flex:1;display:flex;flex-direction:column;gap:4px}.find-replace-label{font-size:14px;font-weight:400;color:#1d2939}.find-replace-input{background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:10px;min-height:120px;display:flex;flex-direction:column;justify-content:space-between}.find-replace-input:focus,.find-replace-input:focus-within{outline:none;box-shadow:none;border-color:#d0d5dd}.find-replace-input textarea{border:none;outline:none;font-size:14px;color:#1d2939;resize:none;flex:1;font-family:Inter,sans-serif}.find-replace-input textarea:focus{outline:none;box-shadow:none}.find-replace-input textarea::placeholder{color:#98a2b3}.input-btn-container{display:flex;justify-content:flex-end}.btn-find{padding:9px 14px;font-size:11px;font-weight:600;color:#344054;background:#fff;border:1px solid #d0d5dd;border-radius:7px;box-shadow:0 1px 2px #1018280d}.btn-replace{padding:9px 14px;font-size:11px;font-weight:600;color:#fff;background:#00a3ff;border:1px solid #00a3ff;border-radius:7px;box-shadow:0 1px 2px #1018280d;transition:background-color .2s ease,border-color .2s ease,color .2s ease;cursor:pointer}.btn-replace:hover:not(:disabled){background:#0092e6;border-color:#0092e6}.btn-replace:disabled{background:#f2f4f7!important;border-color:#d0d5dd!important;color:#98a2b3!important;opacity:1;cursor:not-allowed;box-shadow:none}.arrow-icon{width:26px;flex-shrink:0;display:flex;align-items:center;justify-content:center}.no-preview{text-align:center;padding:60px 20px}.no-preview h3{font-size:18px;font-weight:600;color:#1d2939;margin-bottom:8px}.no-preview p{font-size:14px;color:#667085;margin:0}@media (max-width: 992px){.header-card{flex-wrap:wrap}.stepper-container{order:2;width:100%;margin-top:16px}.find-replace-wrapper{flex-direction:column;margin-left:0}.arrow-icon{transform:rotate(90deg)}}@media (max-width: 768px){.header-card .d-flex{flex-direction:column;gap:16px}.stepper-line{width:30px}.store-input-wrapper{flex-direction:column}.store-dropdown{width:100%}.target-buttons{flex-direction:column;width:100%}.target-btn{border-right:none;border-bottom:1px solid #d0d5dd;width:100%}.target-btn:last-child{border-bottom:none}.section-row{flex-direction:column}}@media (max-width: 576px){body,.header-card,.main-card{padding:12px}.stepper-text{font-size:12px}}.preview-layout{position:relative;display:flex;align-items:stretch}.preview-layout>.col,.preview-layout>.fixture-preview-panel{display:flex;flex-direction:column}.fixture-preview-panel{background:#fafbfc;height:100%;overflow-y:auto;display:flex;flex-direction:column}.fixture-preview-panel .s-card{background:#fff;border-radius:8px;margin:12px;box-shadow:0 1px 3px #0000001a;min-height:77vh;display:flex;flex-direction:column;flex:1}.fixture-preview-panel .s-card .fixture-preview-header{padding:16px;border-bottom:1px solid #EAECF0}.fixture-preview-panel .s-card .fixture-preview-header .header-card{background:#f9fafb;border-radius:6.536px;padding:9.804px 6.536px;display:flex;flex-direction:column;align-items:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content{display:flex;flex-direction:column;gap:6.536px;align-items:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .product-image-container{width:25.651px;height:25.651px;position:relative;overflow:hidden}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .product-image-container .product-image{position:absolute;width:300.85%;height:160.87%;left:-100.43%;top:-30.43%;max-width:none;object-fit:cover}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .name{font-family:Inter,sans-serif;font-weight:600;font-size:16px;line-height:19.608px;color:#101828;text-align:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .specs-container{display:flex;gap:4.664px;align-items:center;flex-wrap:wrap;justify-content:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .specs-container .spec-text{font-family:Inter,sans-serif;font-weight:500;font-size:14px;line-height:16.34px;color:#475467}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .specs-container .dot{width:2.332px;height:2.332px;background:#98a2b3;border-radius:50%;flex-shrink:0}.fixture-preview-panel .s-card .fixture-preview-content{padding:16px;max-height:calc(100vh - 200px);overflow-y:auto}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container{display:flex;flex-direction:row;gap:16px;align-items:flex-start}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section{display:flex;flex-direction:column;flex:1;min-width:0;background:#f9fafb;border-radius:8px;padding:12px}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .section-header,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .section-header{display:flex;align-items:center;justify-content:center;margin-bottom:12px;gap:8px}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .section-header .section-label,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .section-header .section-label{font-size:14px;font-weight:600;color:#1d2939;letter-spacing:.5px;margin:0}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .section-header .brand-name-small,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .section-header .brand-name-small{font-size:14px;font-weight:500;color:#475467}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .fixture-wrapper,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .fixture-wrapper,.fixture-preview-panel .s-card .fixture-preview-content .single-fixture-container .fixture-wrapper{background:#fff;border-radius:4px;padding:8px;box-shadow:0 1px 2px #0000000d}.collapse-handler{position:absolute;right:0;top:50%;transform:translateY(-50%);width:32px;height:64px;background:#fff;border:1px solid #EAECF0;border-left:none;border-radius:0 8px 8px 0;display:flex;align-items:center;justify-content:center;cursor:pointer;z-index:10;box-shadow:-2px 0 4px #0000000d}.collapse-handler:hover{background:#f9fafb}.collapse-handler svg{width:18px;height:18px}.collapse-handler.right{right:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i8.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i8.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i8.RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: ["name", "formControlName", "value"] }, { kind: "directive", type: i8.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i8.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i8.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i8.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: ReactiveSelectComponent, selector: "lib-reactive-select", inputs: ["idField", "nameField", "subTextField", "searchField", "label", "data", "action", "search", "prefix", "actionLabel"], outputs: ["actionClick"] }, { kind: "component", type: StoreSelectComponent, selector: "lib-store-select", inputs: ["options", "initialSelected"], outputs: ["selectedChange"] }, { kind: "component", type: StoreDropdownComponent, selector: "lib-store-dropdown", inputs: ["items", "searchField", "multi", "idField", "selectedValues", "disabled", "label"], outputs: ["selected"] }, { kind: "component", type: StoreFixtureComponent, selector: "lib-store-fixture", inputs: ["fixture", "showColors", "showVMs", "showBCs"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PrepareTemplateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-prepare-template', standalone: true, imports: [CommonModule, ReactiveFormsModule, FormsModule, ReactiveSelectComponent, StoreSelectComponent, StoreDropdownComponent, StoreFixtureComponent], providers: [TitleCasePipe], template: "<div class=\"main-card\">\r\n    <form>\r\n        <!-- Section 1: Add Stores -->\r\n        <div class=\"section-row\">\r\n            <div class=\"section-number\">1</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Add stores</h2>\r\n                <div class=\"store-input-wrapper\">\r\n                   <div class=\"store-dropdown\">\r\n                        <lib-reactive-select\r\n                            [idField]=\"'value'\"\r\n                            [nameField]=\"'label'\"\r\n                            [data]=\"searchModes\"\r\n                            [formControl]=\"selectedMode\" \r\n                            >\r\n                        </lib-reactive-select>\r\n                    </div> \r\n                    <lib-store-select \r\n                        [options]=\"storeOptions\"\r\n                        [initialSelected]=\"selectedStores\"\r\n                        (selectedChange)=\"onStoresSelected($event)\">\r\n                    </lib-store-select>\r\n                    <button class=\"btn-apply\" type=\"button\" (click)=\"onApply()\" [disabled]=\"loading || findLoading || replaceLoading || savingDraft\">\r\n                        {{ savingDraft ? 'Saving...' : 'Apply' }}\r\n                    </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Section 2: Choose Target -->\r\n        <div class=\"section-row\" *ngIf=\"hasStores\">\r\n            <div class=\"section-number\">2</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Choose target</h2>\r\n                <div class=\"target-buttons\">\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'both'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"both\" [formControl]=\"target\">\r\n                        Both\r\n                    </label>\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'merch'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"merch\" [formControl]=\"target\">\r\n                        Merchandise\r\n                    </label>\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'vm'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"vm\" [formControl]=\"target\">\r\n                        Visual Merchandise\r\n                    </label>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Section 3: Find and Replace -->\r\n        <div class=\"section-row\" *ngIf=\"hasStores\">\r\n            <div class=\"section-number\">3</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Provide an instruction to find and replace in the selected store</h2>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Find and Replace Inputs -->\r\n        <div class=\"find-replace-wrapper\" *ngIf=\"hasStores\">\r\n            <div class=\"find-replace-box\">\r\n                <label class=\"find-replace-label\">Target</label>\r\n                <div class=\"find-replace-input\">\r\n                    <textarea \r\n                        placeholder=\"Instruct what to find it in the selected store\"\r\n                        [formControl]=\"findPrompt\"></textarea>\r\n                    <div class=\"input-btn-container\">\r\n                        <button \r\n                            class=\"btn-find\" \r\n                            type=\"button\"\r\n                            (click)=\"onFind()\"\r\n                            [disabled]=\"findLoading || replaceLoading || !selectedStoreForPreview\">\r\n                            {{ findLoading ? 'Processing...' : 'Find' }}\r\n                        </button>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n            \r\n            <div class=\"arrow-icon\">\r\n                <svg width=\"27\" height=\"15\" viewBox=\"0 0 27 15\" fill=\"none\">\r\n                    <path d=\"M26.7071 8.07107C27.0976 7.68054 27.0976 7.04738 26.7071 6.65685L20.3431 0.292893C19.9526 -0.097631 19.3195 -0.097631 18.9289 0.292893C18.5384 0.683418 18.5384 1.31658 18.9289 1.70711L24.5858 7.36396L18.9289 13.0208C18.5384 13.4113 18.5384 14.0445 18.9289 14.435C19.3195 14.8256 19.9526 14.8256 20.3431 14.435L26.7071 8.07107ZM0 7.36396V8.36396H26V7.36396V6.36396H0V7.36396Z\" fill=\"#98A2B3\"/>\r\n                </svg>\r\n            </div>\r\n            \r\n            <div class=\"find-replace-box\">\r\n                <label class=\"find-replace-label\">Change</label>\r\n                <div class=\"find-replace-input\">\r\n                    <textarea \r\n                        placeholder=\"Type what would you like to replace in the selected fixture\"\r\n                        [formControl]=\"replacePrompt\"></textarea>\r\n                    <div class=\"input-btn-container\">\r\n                        <button \r\n                            class=\"btn-replace\" \r\n                            type=\"button\"\r\n                            (click)=\"onReplace()\"\r\n                            [disabled]=\"!findPrompt.value || !replacePrompt.value || findLoading || replaceLoading || !getCurrentStoreFindResponseData()\">\r\n                            {{ replaceLoading ? 'Processing...' : 'Replace' }}\r\n                        </button>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Preview Section -->\r\n        <div class=\"preview-wrapper\" *ngIf=\"hasStores\">\r\n            <div class=\"row g-0 preview-layout\">\r\n                <!-- Left Column: Canvas -->\r\n                <div class=\"col\" [ngClass]=\"{ \r\n                    'col-6': !isRightPanelCollapsed && selectedFixtureData && originalFixtureData,\r\n                    'col-9': !isRightPanelCollapsed && selectedFixtureData && !originalFixtureData, \r\n                    'col-12': isRightPanelCollapsed || !selectedFixtureData \r\n                }\">\r\n                    <div class=\"d-flex align-items-start gap-3 mb-3\">\r\n                        <!-- Store Dropdown -->\r\n                        <lib-store-dropdown \r\n                            *ngIf=\"hasStores && storeDropdownItems.length > 0\"\r\n                            [items]=\"storeDropdownItems\"\r\n                            [idField]=\"'storeId'\"\r\n                            [searchField]=\"'storeName'\"\r\n                            [multi]=\"false\"\r\n                            [selectedValues]=\"selectedStoreValues\"\r\n                            (selected)=\"onStoreSelectedForPreview($event)\">\r\n                        </lib-store-dropdown>\r\n                        \r\n                        <!-- Content Area -->\r\n                        <div class=\"flex-grow-1\">\r\n                            <!-- Preview Title -->\r\n                            <p class=\"fw-semibold mb-1\" style=\"font-size: 14px; color: #1d2939;\">\r\n                                Preview \r\n                                <span *ngIf=\"getStoreCount() > 0\" style=\"font-weight: 400; color: #667085;\">\r\n                                    ({{ getStoreCount() }} {{ getStoreCount() === 1 ? 'Store' : 'Stores' }})\r\n                                </span>\r\n                            </p>\r\n                            \r\n                            <!-- Description -->\r\n                            <p class=\"mb-0\" style=\"font-size: 14px; color: #475467;\">Check if the prompt fit into the expected results in order to proceed to review and approve</p>\r\n                        </div>\r\n                    </div>\r\n\r\n                    <!-- Canvas Container -->\r\n                    <div class=\"canvas-container\" #previewCanvasContainer *ngIf=\"selectedStoreForPreview\">\r\n                        <div class=\"canvas-loading\" *ngIf=\"canvasLoading\">\r\n                            <div class=\"spinner-border text-primary\" role=\"status\">\r\n                                <span class=\"visually-hidden\">Loading...</span>\r\n                            </div>\r\n                        </div>\r\n                        <canvas #previewCanvas></canvas>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Right Column: Fixture Preview -->\r\n                <div class=\"fixture-preview-panel\" \r\n                     *ngIf=\"selectedFixtureData && !isRightPanelCollapsed\"\r\n                     [ngClass]=\"{ 'col-6': originalFixtureData, 'col-3': !originalFixtureData }\"\r\n                     [style.min-width]=\"originalFixtureData ? '680px' : '340px'\">\r\n                    <div class=\"s-card\">\r\n                        <!-- Panel Header -->\r\n                        <div class=\"fixture-preview-header\">\r\n                            <div class=\"header-card\">\r\n                                <div class=\"card-content\">\r\n                                    <!-- <div class=\"product-image-container\">\r\n                                        <img \r\n                                            alt=\"Product\" \r\n                                            class=\"product-image\"\r\n                                        />\r\n                                    </div> -->\r\n                                    <div class=\"name\">{{ getFixtureLabel() }}</div>\r\n                                    <div class=\"specs-container\" *ngIf=\"getFixtureCategory() || getFixtureWidth() || getShelfCount() > 0 || getFixtureCapacity() > 0\">\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureCategory()\">{{ getFixtureCategory() }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getFixtureCategory() && (getFixtureWidth() || getShelfCount() > 0 || getFixtureCapacity() > 0)\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureWidth()\">{{ getFixtureWidth() }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getFixtureWidth() && (getShelfCount() > 0 || getFixtureCapacity() > 0)\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getShelfCount() > 0\">{{ getShelfCount() }} {{ getShelfCount() === 1 ? 'Shelf' : 'Shelves' }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getShelfCount() > 0 && getFixtureCapacity() > 0\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureCapacity() > 0\">{{ getFixtureCapacity() }} Capacity</span>\r\n                                    </div>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n\r\n                        <!-- Fixture Component -->\r\n                        <div class=\"fixture-preview-content\">\r\n                            <!-- Show Before/After when replace data exists -->\r\n                            <div *ngIf=\"originalFixtureData\" class=\"before-after-container\">\r\n                                <div class=\"before-section\">\r\n                                    <div class=\"section-header\">\r\n                                        <h6 class=\"section-label mb-0\">Before</h6>\r\n                                    </div>\r\n                                    <div class=\"fixture-wrapper\">\r\n                                        <lib-store-fixture \r\n                                            [fixture]=\"originalFixtureData\" \r\n                                            [showColors]=\"true\"\r\n                                            [showVMs]=\"true\"\r\n                                            [showBCs]=\"true\">\r\n                                        </lib-store-fixture>\r\n                                    </div>\r\n                                </div>\r\n                                <div class=\"after-section\">\r\n                                    <div class=\"section-header\">\r\n                                        <h6 class=\"section-label mb-0\">After</h6>\r\n                                    </div>\r\n                                    <div class=\"fixture-wrapper\">\r\n                                        <lib-store-fixture \r\n                                            [fixture]=\"selectedFixtureData\" \r\n                                            [showColors]=\"true\"\r\n                                            [showVMs]=\"true\"\r\n                                            [showBCs]=\"true\">\r\n                                        </lib-store-fixture>\r\n                                    </div>\r\n                                </div>\r\n                            </div>\r\n                            \r\n                            <!-- Show single fixture when no replace data -->\r\n                            <div *ngIf=\"!originalFixtureData\" class=\"single-fixture-container\">\r\n                                <div class=\"fixture-wrapper\">\r\n                                    <lib-store-fixture \r\n                                        [fixture]=\"selectedFixtureData\" \r\n                                        [showColors]=\"true\"\r\n                                        [showVMs]=\"true\"\r\n                                        [showBCs]=\"true\">\r\n                                    </lib-store-fixture>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Collapse Button -->\r\n                <div class=\"collapse-handler right\" \r\n                     *ngIf=\"selectedFixtureData\"\r\n                     (click)=\"toggleRightPanel()\">\r\n                    <svg *ngIf=\"isRightPanelCollapsed\" xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\"\r\n                        viewBox=\"0 0 18 18\" fill=\"none\">\r\n                        <path d=\"M8.27308 12.636L4.63672 8.99964L8.27308 5.36328M13.364 12.636L9.72763 8.99964L13.364 5.36328\"\r\n                            stroke=\"#101828\" stroke-width=\"1.45455\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg>\r\n                    <svg *ngIf=\"!isRightPanelCollapsed\" xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\"\r\n                        viewBox=\"0 0 18 18\" fill=\"none\">\r\n                        <path d=\"M9.72692 5.36399L13.3633 9.00036L9.72692 12.6367M4.63601 5.36399L8.27237 9.00036L4.63601 12.6367\"\r\n                            stroke=\"#101828\" stroke-width=\"1.45455\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        <!-- No Preview Section -->\r\n        <div class=\"no-preview\" *ngIf=\"hasStores && !selectedStoreForPreview\">\r\n            <div >\r\n                <svg width=\"315\" height=\"155\" viewBox=\"0 0 315 155\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                    <path d=\"M103.81 47.0195C89.5463 47.0197 77.9834 58.5824 77.9834 72.8457C77.9834 78.7617 73.9803 85.5059 68.0643 85.5059H45.2588C30.9953 85.5059 19.4316 97.0686 19.4316 111.332C19.4316 125.596 30.9953 137.158 45.2588 137.158H183.357C200.248 137.158 216.32 123.992 233.21 123.992H299.245C304 123.992 307.854 120.137 307.854 115.383C307.853 110.629 303.999 106.774 299.245 106.774H211.625C209.98 106.774 208.588 105.553 208.12 103.976C207.381 101.486 209.082 98.6719 211.679 98.6719H241.909C256.172 98.6717 267.735 87.109 267.735 72.8457C267.735 58.5824 256.172 47.0198 241.909 47.0195H103.81Z\" fill=\"#EAECF0\"/>\r\n                    <rect width=\"240.694\" height=\"16.9956\" rx=\"8.4978\" transform=\"matrix(-1 0 0 1 246.603 48.8574)\" fill=\"#EAECF0\"/>\r\n                    <circle cx=\"5.42147\" cy=\"5.42147\" r=\"5.42147\" transform=\"matrix(-1 0 0 1 56.2979 113.281)\" fill=\"#6BCAFF\"/>\r\n                    <circle cx=\"3.25288\" cy=\"3.25288\" r=\"3.25288\" transform=\"matrix(-1 0 0 1 244.965 68.8262)\" fill=\"#00A3FF\"/>\r\n                    <circle cx=\"3.25288\" cy=\"3.25288\" r=\"3.25288\" transform=\"matrix(-1 0 0 1 215.689 13.5273)\" fill=\"#00A3FF\"/>\r\n                    <circle cx=\"2.16859\" cy=\"2.16859\" r=\"2.16859\" transform=\"matrix(-1 0 0 1 104.006 138.221)\" fill=\"#00A3FF\"/>\r\n                    <rect x=\"68.501\" y=\"44.1523\" width=\"166.999\" height=\"97.9371\" rx=\"15.1015\" fill=\"#6BCAFF\" stroke=\"#00A3FF\" stroke-width=\"3\"/>\r\n                    <mask id=\"path-8-inside-1_936_150383\" fill=\"white\">\r\n                    <path d=\"M93.1172 19C94.0625 19 94.9892 19.0828 95.8887 19.2422V116.784C94.9892 116.625 94.0625 116.542 93.1172 116.542H82.7744C74.0642 116.542 67.0031 123.603 67.0029 132.313V34.7715C67.0029 26.0612 74.0641 19 82.7744 19H93.1172Z\"/>\r\n                    </mask>\r\n                    <path d=\"M93.1172 19C94.0625 19 94.9892 19.0828 95.8887 19.2422V116.784C94.9892 116.625 94.0625 116.542 93.1172 116.542H82.7744C74.0642 116.542 67.0031 123.603 67.0029 132.313V34.7715C67.0029 26.0612 74.0641 19 82.7744 19H93.1172Z\" fill=\"#6BCAFF\"/>\r\n                    <path d=\"M93.1172 19L93.1173 16H93.1172V19ZM95.8887 19.2422H98.8887V16.7271L96.4122 16.2882L95.8887 19.2422ZM95.8887 116.784L95.3651 119.738L98.8887 120.363V116.784H95.8887ZM93.1172 116.542L93.1173 113.542H93.1172V116.542ZM67.0029 132.313H64.0029L70.0029 132.314L67.0029 132.313ZM93.1172 19L93.1171 22C93.8872 22 94.6387 22.0674 95.3651 22.1961L95.8887 19.2422L96.4122 16.2882C95.3396 16.0981 94.2377 16 93.1173 16L93.1172 19ZM95.8887 19.2422H92.8887V116.784H95.8887H98.8887V19.2422H95.8887ZM95.8887 116.784L96.4122 113.83C95.3396 113.64 94.2377 113.542 93.1173 113.542L93.1172 116.542L93.1171 119.542C93.8872 119.542 94.6387 119.609 95.3651 119.738L95.8887 116.784ZM93.1172 116.542V113.542H82.7744V116.542V119.542H93.1172V116.542ZM82.7744 116.542V113.542C72.4073 113.542 64.0032 121.947 64.0029 132.313L67.0029 132.313L70.0029 132.314C70.0031 125.26 75.7212 119.542 82.7744 119.542V116.542ZM67.0029 132.313H70.0029V34.7715H67.0029H64.0029V132.313H67.0029ZM67.0029 34.7715H70.0029C70.0029 27.718 75.721 22 82.7744 22V19V16C72.4072 16 64.0029 24.4043 64.0029 34.7715H67.0029ZM82.7744 19V22H93.1172V19V16H82.7744V19Z\" fill=\"#00A3FF\" mask=\"url(#path-8-inside-1_936_150383)\"/>\r\n                    <line x1=\"76.9619\" y1=\"42.6523\" x2=\"76.9619\" y2=\"84.4881\" stroke=\"#99DAFF\" stroke-width=\"3.98436\" stroke-linecap=\"round\"/>\r\n                    <circle cx=\"218.206\" cy=\"70.1755\" r=\"3.29663\" fill=\"white\"/>\r\n                    <circle cx=\"111.787\" cy=\"55.167\" r=\"2.52637\" fill=\"#99DAFF\"/>\r\n                    <circle cx=\"99.3845\" cy=\"124.986\" r=\"3.44505\" fill=\"white\"/>\r\n                    <path d=\"M135.529 33.4717C151.285 24.3749 171.432 29.7732 180.529 45.5293C188.56 59.4398 185.291 76.7707 173.573 86.9004L193.457 121.339C194.932 123.894 194.056 127.161 191.501 128.636C188.946 130.111 185.679 129.236 184.204 126.681L164.466 92.4932C149.447 98.6552 131.814 92.92 123.472 78.4717C114.375 62.7156 119.773 42.5685 135.529 33.4717ZM172.698 50.0518C166.099 38.6209 151.482 34.7041 140.051 41.3037C128.62 47.9035 124.703 62.5204 131.303 73.9512C137.902 85.3817 152.519 89.2977 163.95 82.6982C175.381 76.0987 179.297 61.4826 172.698 50.0518Z\" fill=\"white\"/>\r\n                    <circle cx=\"153.001\" cy=\"57.0017\" r=\"23.8994\" transform=\"rotate(-30 153.001 57.0017)\" fill=\"#99DAFF\"/>\r\n                    <mask id=\"path-16-inside-2_936_150383\" fill=\"white\">\r\n                    <path d=\"M153.384 40.9957C153.435 39.7001 152.423 38.5927 151.131 38.7095C148.858 38.9151 146.636 39.5491 144.586 40.5854C141.835 41.976 139.484 44.045 137.755 46.597C136.026 49.149 134.977 52.0996 134.706 55.1701C134.504 57.4583 134.739 59.7568 135.391 61.9447C135.762 63.1872 137.166 63.7169 138.35 63.1891C139.534 62.6612 140.044 61.2746 139.73 60.0165C139.37 58.5735 139.251 57.0753 139.383 55.583C139.584 53.3078 140.361 51.1214 141.642 49.2304C142.924 47.3394 144.666 45.8063 146.704 44.7758C148.041 44.1 149.477 43.6551 150.95 43.4542C152.235 43.2792 153.333 42.2913 153.384 40.9957Z\"/>\r\n                    </mask>\r\n                    <path d=\"M153.384 40.9957C153.435 39.7001 152.423 38.5927 151.131 38.7095C148.858 38.9151 146.636 39.5491 144.586 40.5854C141.835 41.976 139.484 44.045 137.755 46.597C136.026 49.149 134.977 52.0996 134.706 55.1701C134.504 57.4583 134.739 59.7568 135.391 61.9447C135.762 63.1872 137.166 63.7169 138.35 63.1891C139.534 62.6612 140.044 61.2746 139.73 60.0165C139.37 58.5735 139.251 57.0753 139.383 55.583C139.584 53.3078 140.361 51.1214 141.642 49.2304C142.924 47.3394 144.666 45.8063 146.704 44.7758C148.041 44.1 149.477 43.6551 150.95 43.4542C152.235 43.2792 153.333 42.2913 153.384 40.9957Z\" stroke=\"white\" stroke-width=\"6\" mask=\"url(#path-16-inside-2_936_150383)\"/>\r\n                    <path d=\"M136.529 28.4717C152.285 19.3749 172.432 24.7732 181.529 40.5293C189.56 54.4398 186.291 71.7707 174.573 81.9004L194.457 116.339C195.932 118.894 195.056 122.161 192.501 123.636C189.946 125.111 186.679 124.236 185.204 121.681L165.466 87.4932C150.447 93.6552 132.814 87.92 124.472 73.4717C115.375 57.7156 120.773 37.5685 136.529 28.4717ZM173.698 45.0518C167.099 33.6209 152.482 29.7041 141.051 36.3037C129.62 42.9035 125.703 57.5204 132.303 68.9512C138.902 80.3817 153.519 84.2977 164.95 77.6982C176.381 71.0987 180.297 56.4826 173.698 45.0518Z\" fill=\"#00A3FF\"/>\r\n                    </svg>                    \r\n            </div>\r\n            <h3>No preview yet</h3>\r\n            <p>Add a find and replacement to preview.</p>\r\n        </div>\r\n\r\n        <!-- Action Button Section -->\r\n        <div class=\"action-button-section\" *ngIf=\"hasStores\">\r\n            <button class=\"btn-apply\" type=\"button\" (click)=\"onReviewAndReplace()\" [disabled]=\"loading || findLoading || replaceLoading || batchProcessing\">\r\n                {{ batchProcessing ? 'Processing...' : 'Review And Replace' }}\r\n            </button>\r\n        </div>\r\n    </form>\r\n</div>\r\n", styles: [".btn-apply{padding:10px 18px;font-size:16px;font-weight:600;color:#fff;background:#00a3ff;border:1px solid #00a3ff;border-radius:8px;box-shadow:0 1px 2px #1018280d;height:44px;flex-shrink:0;white-space:nowrap;transition:background-color .2s ease,border-color .2s ease;cursor:pointer}.btn-apply:hover{background:#0092e6;border-color:#0092e6}.action-button-section{display:flex;justify-content:flex-end;margin-top:32px;margin-left:34px}.main-card{background:#fff;border-radius:12px;padding:24px;box-shadow:0 1px 3px #0000001a}.section-row{display:flex;gap:8px;margin-bottom:32px}.section-connector{display:flex;gap:8px;margin-bottom:32px;margin-top:-24px}.connector-line{width:24px;flex-shrink:0;display:flex;align-items:flex-start;justify-content:center}.connector-line svg{display:block}.connector-spacer{flex:1}.section-number{width:24px;height:24px;background:#f2f4f7;border-radius:100px;display:flex;align-items:center;justify-content:center;font-size:14px;font-weight:600;flex-shrink:0}.section-content{flex:1}.section-title{font-size:14px;font-weight:600;color:#1d2939;margin:0 0 12px}.store-input-wrapper{display:flex;gap:8px;align-items:center}.store-dropdown{width:124px;flex-shrink:0}.store-dropdown select{padding:10px 14px;font-size:16px;font-weight:500;color:#101828;background:#fff;border:1px solid #d0d5dd;border-radius:8px;box-shadow:0 1px 2px #1018280d;width:100%}lib-store-select{flex:1;min-width:0}.tags-input{flex:1;padding:10px 14px;background:#fff;border:1px solid #d0d5dd;border-radius:8px;box-shadow:0 1px 2px #1018280d;display:flex;gap:8px;flex-wrap:wrap;min-height:44px}.tag{background:#f2f4f7;padding:2px 6px 2px 8px;border-radius:16px;display:inline-flex;align-items:center;gap:4px;font-size:12px;font-weight:500;color:#344054}.tag-close{width:12px;height:12px;cursor:pointer;display:flex;align-items:center;justify-content:center}.target-buttons{display:flex;border:1px solid #d0d5dd;border-radius:8px;overflow:hidden;box-shadow:0 1px 2px #1018280d;width:fit-content}.target-btn{padding:10px 16px;font-size:14px;font-weight:500;background:#fff;border:none;border-right:1px solid #d0d5dd;color:#344054;cursor:pointer;transition:background-color .2s;min-width:140px;display:flex;align-items:center;justify-content:center}.target-btn:last-child{border-right:none}.target-btn.active{background:#eaf8ff;color:#1d2939}.target-btn input[type=radio]{display:none}.find-replace-wrapper{margin-left:34px;display:flex;gap:16px;align-items:center}.preview-wrapper{margin-left:34px;margin-top:24px;margin-bottom:32px}.preview-wrapper lib-store-dropdown{width:180px;flex-shrink:0}.preview-wrapper .btn-find,.preview-wrapper .btn-replace{padding:8px 16px;font-size:14px;font-weight:500;border-radius:8px;border:1px solid #d0d5dd;background:#fff;color:#344054;cursor:pointer;transition:all .2s ease}.preview-wrapper .btn-find:hover:not(:disabled),.preview-wrapper .btn-replace:hover:not(:disabled){background:#f9fafb;border-color:#98a2b3}.preview-wrapper .btn-find:disabled,.preview-wrapper .btn-replace:disabled{opacity:.5;cursor:not-allowed}.preview-wrapper .btn-find{border-color:#00a3ff;color:#00a3ff}.preview-wrapper .btn-find:hover:not(:disabled){background:#eaf8ff}.preview-wrapper .btn-replace{border-color:#16a34a;color:#16a34a}.preview-wrapper .btn-replace:hover:not(:disabled){background:#f0fdf4}.preview-wrapper .btn-replace:disabled{background:#f2f4f7!important;border-color:#d0d5dd!important;color:#98a2b3!important;opacity:1;cursor:not-allowed}.preview-wrapper .canvas-container{position:relative;border:1px solid #e5e7eb;border-radius:8px;padding:0;background:#f9fafb;min-height:77vh;width:100%;overflow:hidden;flex:1}.preview-wrapper .canvas-container .canvas-loading{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);z-index:10}.preview-wrapper .canvas-container canvas{background:#fff;width:100%!important;height:100%!important;display:block}.find-replace-box{flex:1;display:flex;flex-direction:column;gap:4px}.find-replace-label{font-size:14px;font-weight:400;color:#1d2939}.find-replace-input{background:#fff;border:1px solid #d0d5dd;border-radius:8px;padding:10px;min-height:120px;display:flex;flex-direction:column;justify-content:space-between}.find-replace-input:focus,.find-replace-input:focus-within{outline:none;box-shadow:none;border-color:#d0d5dd}.find-replace-input textarea{border:none;outline:none;font-size:14px;color:#1d2939;resize:none;flex:1;font-family:Inter,sans-serif}.find-replace-input textarea:focus{outline:none;box-shadow:none}.find-replace-input textarea::placeholder{color:#98a2b3}.input-btn-container{display:flex;justify-content:flex-end}.btn-find{padding:9px 14px;font-size:11px;font-weight:600;color:#344054;background:#fff;border:1px solid #d0d5dd;border-radius:7px;box-shadow:0 1px 2px #1018280d}.btn-replace{padding:9px 14px;font-size:11px;font-weight:600;color:#fff;background:#00a3ff;border:1px solid #00a3ff;border-radius:7px;box-shadow:0 1px 2px #1018280d;transition:background-color .2s ease,border-color .2s ease,color .2s ease;cursor:pointer}.btn-replace:hover:not(:disabled){background:#0092e6;border-color:#0092e6}.btn-replace:disabled{background:#f2f4f7!important;border-color:#d0d5dd!important;color:#98a2b3!important;opacity:1;cursor:not-allowed;box-shadow:none}.arrow-icon{width:26px;flex-shrink:0;display:flex;align-items:center;justify-content:center}.no-preview{text-align:center;padding:60px 20px}.no-preview h3{font-size:18px;font-weight:600;color:#1d2939;margin-bottom:8px}.no-preview p{font-size:14px;color:#667085;margin:0}@media (max-width: 992px){.header-card{flex-wrap:wrap}.stepper-container{order:2;width:100%;margin-top:16px}.find-replace-wrapper{flex-direction:column;margin-left:0}.arrow-icon{transform:rotate(90deg)}}@media (max-width: 768px){.header-card .d-flex{flex-direction:column;gap:16px}.stepper-line{width:30px}.store-input-wrapper{flex-direction:column}.store-dropdown{width:100%}.target-buttons{flex-direction:column;width:100%}.target-btn{border-right:none;border-bottom:1px solid #d0d5dd;width:100%}.target-btn:last-child{border-bottom:none}.section-row{flex-direction:column}}@media (max-width: 576px){body,.header-card,.main-card{padding:12px}.stepper-text{font-size:12px}}.preview-layout{position:relative;display:flex;align-items:stretch}.preview-layout>.col,.preview-layout>.fixture-preview-panel{display:flex;flex-direction:column}.fixture-preview-panel{background:#fafbfc;height:100%;overflow-y:auto;display:flex;flex-direction:column}.fixture-preview-panel .s-card{background:#fff;border-radius:8px;margin:12px;box-shadow:0 1px 3px #0000001a;min-height:77vh;display:flex;flex-direction:column;flex:1}.fixture-preview-panel .s-card .fixture-preview-header{padding:16px;border-bottom:1px solid #EAECF0}.fixture-preview-panel .s-card .fixture-preview-header .header-card{background:#f9fafb;border-radius:6.536px;padding:9.804px 6.536px;display:flex;flex-direction:column;align-items:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content{display:flex;flex-direction:column;gap:6.536px;align-items:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .product-image-container{width:25.651px;height:25.651px;position:relative;overflow:hidden}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .product-image-container .product-image{position:absolute;width:300.85%;height:160.87%;left:-100.43%;top:-30.43%;max-width:none;object-fit:cover}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .name{font-family:Inter,sans-serif;font-weight:600;font-size:16px;line-height:19.608px;color:#101828;text-align:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .specs-container{display:flex;gap:4.664px;align-items:center;flex-wrap:wrap;justify-content:center}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .specs-container .spec-text{font-family:Inter,sans-serif;font-weight:500;font-size:14px;line-height:16.34px;color:#475467}.fixture-preview-panel .s-card .fixture-preview-header .header-card .card-content .specs-container .dot{width:2.332px;height:2.332px;background:#98a2b3;border-radius:50%;flex-shrink:0}.fixture-preview-panel .s-card .fixture-preview-content{padding:16px;max-height:calc(100vh - 200px);overflow-y:auto}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container{display:flex;flex-direction:row;gap:16px;align-items:flex-start}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section{display:flex;flex-direction:column;flex:1;min-width:0;background:#f9fafb;border-radius:8px;padding:12px}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .section-header,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .section-header{display:flex;align-items:center;justify-content:center;margin-bottom:12px;gap:8px}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .section-header .section-label,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .section-header .section-label{font-size:14px;font-weight:600;color:#1d2939;letter-spacing:.5px;margin:0}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .section-header .brand-name-small,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .section-header .brand-name-small{font-size:14px;font-weight:500;color:#475467}.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .before-section .fixture-wrapper,.fixture-preview-panel .s-card .fixture-preview-content .before-after-container .after-section .fixture-wrapper,.fixture-preview-panel .s-card .fixture-preview-content .single-fixture-container .fixture-wrapper{background:#fff;border-radius:4px;padding:8px;box-shadow:0 1px 2px #0000000d}.collapse-handler{position:absolute;right:0;top:50%;transform:translateY(-50%);width:32px;height:64px;background:#fff;border:1px solid #EAECF0;border-left:none;border-radius:0 8px 8px 0;display:flex;align-items:center;justify-content:center;cursor:pointer;z-index:10;box-shadow:-2px 0 4px #0000000d}.collapse-handler:hover{background:#f9fafb}.collapse-handler svg{width:18px;height:18px}.collapse-handler.right{right:0}\n"] }]
+        }], ctorParameters: () => [{ type: i1.StoreBuilderService }, { type: i2.CollectionUpdateAiDataService }, { type: i3.TitleCasePipe }, { type: i0.ChangeDetectorRef }, { type: i4.GlobalStateService }, { type: i5.Router }, { type: i5.ActivatedRoute }, { type: i6.ToastService }, { type: i7.NgbModal }], propDecorators: { previewCanvasRef: [{
+                type: ViewChild,
+                args: ['previewCanvas']
+            }], previewCanvasContainerRef: [{
+                type: ViewChild,
+                args: ['previewCanvasContainer']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prepare-template.component.js","sourceRoot":"","sources":["../../../../../../../../projects/tango-store-builder/src/lib/components/collection-update-ai/find-replace-layout/prepare-template/prepare-template.component.ts","../../../../../../../../projects/tango-store-builder/src/lib/components/collection-update-ai/find-replace-layout/prepare-template/prepare-template.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, OnDestroy, AfterViewInit, ViewChild, ElementRef, ChangeDetectorRef } from '@angular/core';\r\nimport { ReactiveFormsModule, FormsModule } from '@angular/forms';\r\nimport { CommonModule, TitleCasePipe } from '@angular/common';\r\nimport { Router, ActivatedRoute } from '@angular/router';\r\nimport { ReactiveSelectComponent } from '../../../reactive-select/reactive-select.component';\r\nimport { StoreSelectComponent, StoreOption } from '../../components/store-select/store-select.component';\r\nimport { StoreDropdownComponent } from '../../components/store-dropdown/store-dropdown.component';\r\nimport { FormControl } from '@angular/forms';\r\nimport { StoreBuilderService } from '../../../../services/store-builder.service';\r\nimport { CollectionUpdateAiDataService } from '../../services/data.service';\r\nimport { Store, FindReplace } from '../../models/find-replace.model';\r\nimport { Subject, takeUntil } from 'rxjs';\r\nimport * as fabric from \"fabric\";\r\nimport { StoreFixtureComponent } from '../../components/store-fixture/store-fixture.component';\r\nimport { VmLibraryList } from '../../../../interfaces/vm-library.interface';\r\nimport { GlobalStateService } from 'tango-app-ui-global';\r\nimport { ToastService } from 'tango-app-ui-shared';\r\nimport { NgbModal } from '@ng-bootstrap/ng-bootstrap';\r\nimport { BatchConfirmationModalComponent } from './batch-confirmation-modal/batch-confirmation-modal.component';\r\n\r\n@Component({\r\n  selector: 'lib-prepare-template',\r\n  standalone: true,\r\n  imports: [CommonModule, ReactiveFormsModule, FormsModule, ReactiveSelectComponent, StoreSelectComponent, StoreDropdownComponent, StoreFixtureComponent],\r\n  templateUrl: './prepare-template.component.html',\r\n  styleUrl: './prepare-template.component.scss',\r\n  providers: [TitleCasePipe]\r\n})\r\n\r\nexport class PrepareTemplateComponent implements OnInit, OnDestroy, AfterViewInit {\r\n  searchModes = [\r\n    { value: 'store', label: 'Stores' },\r\n    { value: 'cluster', label: 'Clusters' },\r\n  ];\r\n  selectedMode = new FormControl('store');\r\n  target = new FormControl('both');\r\n  findPrompt = new FormControl('');\r\n  replacePrompt = new FormControl('');\r\n  \r\n  storeOptions: StoreOption[] = [];\r\n  clusterData: any[] = []; // Store full cluster data with stores\r\n  loading: boolean = false;\r\n  savingDraft: boolean = false;\r\n  batchProcessing: boolean = false;\r\n  private destroy$ = new Subject<void>();\r\n  \r\n  selectedStores: StoreOption[] = [];\r\n  findReplaceData: FindReplace | null = null;\r\n  selectedStoreForPreview: any = null;\r\n  storeListForDropdown: any[] = [];\r\n  storeDropdownItems: any[] = [];\r\n  selectedStoreValues: any[] = [];\r\n\r\n  // Canvas properties\r\n  @ViewChild('previewCanvas') previewCanvasRef!: ElementRef<HTMLCanvasElement>;\r\n  @ViewChild('previewCanvasContainer') previewCanvasContainerRef!: ElementRef<HTMLDivElement>;\r\n  previewCanvas!: fabric.Canvas;\r\n  planoData: any;\r\n  floorData: any;\r\n  wallThickness = 30;\r\n  verticalMargin = (1.25 / 100) * this.toPixels(1524, \"mm\");\r\n  cdnUrl: string = '';\r\n  activeHighlight: fabric.Rect | null = null;\r\n  cancelHighlightBlink = false;\r\n  selectedFixture: any;\r\n  selectedFixtureData: any = null;\r\n  originalFixtureData: any = null; // Original fixture before replace (for before/after comparison)\r\n  private originalFixturesMap: Map<string, any> = new Map(); // Store original fixtures by fixtureId\r\n  isRightPanelCollapsed = false;\r\n  canvasLoading = false;\r\n  findLoading = false;\r\n  replaceLoading = false;\r\n  allFixtureInstances: any[] = [];\r\n  vmList: VmLibraryList[] = [];\r\n  clientId: string = '';\r\n  hideMetadata: boolean = false;\r\n\r\n  get hasStores(): boolean {\r\n    return !!(this.findReplaceData?.stores && this.findReplaceData.stores.length > 0);\r\n  }\r\n\r\n  getStoreCount(): number {\r\n    return this.findReplaceData?.storeCount || this.findReplaceData?.stores?.length || 0;\r\n  }\r\n\r\n  getCurrentFixtureData(): any {\r\n    return this.selectedFixtureData || this.originalFixtureData;\r\n  }\r\n\r\n  getFixtureLabel(): string {\r\n    const fixture = this.getCurrentFixtureData();\r\n    return fixture?.header?.label || '';\r\n  }\r\n\r\n  getFixtureCategory(): string {\r\n    const fixture = this.getCurrentFixtureData();\r\n    return fixture?.fixtureCategory || '';\r\n  }\r\n\r\n  getFixtureWidth(): string {\r\n    const fixture = this.getCurrentFixtureData();\r\n    if (!fixture?.fixtureWidth) return '';\r\n    const width = fixture.fixtureWidth.value;\r\n    const unit = fixture.fixtureWidth.unit || 'mm';\r\n    let dimensionStr = `${width}${unit}`;\r\n    // Convert to feet if needed (1200mm = 4ft)\r\n    if (unit === 'mm' && width === 1200) {\r\n      dimensionStr = `${width}${unit}/4ft`;\r\n    } else if (unit === 'mm' && width > 0) {\r\n      const feet = Math.round(width / 300);\r\n      if (feet > 0) {\r\n        dimensionStr = `${width}${unit}/${feet}ft`;\r\n      }\r\n    }\r\n    return dimensionStr;\r\n  }\r\n\r\n  getShelfCount(): number {\r\n    const fixture = this.getCurrentFixtureData();\r\n    return fixture?.shelfConfig?.length || 0;\r\n  }\r\n\r\n  getFixtureCapacity(): number {\r\n    const fixture = this.getCurrentFixtureData();\r\n    return fixture?.fixtureCapacity || 0;\r\n  }\r\n\r\n  constructor(\r\n    private storeBuilderService: StoreBuilderService,\r\n    private dataService: CollectionUpdateAiDataService,\r\n    private titleCase: TitleCasePipe,\r\n    private cdr: ChangeDetectorRef,\r\n    private gs: GlobalStateService,\r\n    private router: Router,\r\n    private route: ActivatedRoute,\r\n    private toastService: ToastService,\r\n    private modalService: NgbModal\r\n  ) {}\r\n\r\n  private previousSearchMode: 'store' | 'cluster' | null = null;\r\n  private isInitialLoad = true;\r\n  private hasRestoredData = false;\r\n  private isUpdatingFromService = false;\r\n\r\n  ngOnInit(): void {\r\n    // Get client ID and CDN URL\r\n    this.gs.environment\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((env) => {\r\n        this.cdnUrl = env.planogramCDN || '';\r\n      });\r\n\r\n    this.gs.dataRangeValue\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((data) => {\r\n        if (data?.client) {\r\n          this.clientId = data.client;\r\n        } else {\r\n          const headerData = JSON.parse(\r\n            localStorage.getItem(\"header-filters\") as string\r\n          );\r\n          if (headerData?.client) {\r\n            this.clientId = headerData.client;\r\n          }\r\n        }\r\n      });\r\n\r\n    // Subscribe to data service to restore saved data\r\n    this.dataService.getFindReplaceData()\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((data) => {\r\n        // Prevent infinite loops by skipping updates when we're updating from form changes\r\n        if (this.isUpdatingFromService) {\r\n          return;\r\n        }\r\n        \r\n        this.findReplaceData = data;\r\n        \r\n        // Update store dropdown items when stores change\r\n        this.updateStoreDropdownItems();\r\n        \r\n        if (data && !this.hasRestoredData) {\r\n          // Restore all form values on first data load\r\n          this.restoreFormValues(data);\r\n          this.hasRestoredData = true;\r\n        } else if (data && this.hasRestoredData) {\r\n          // If data already restored, only handle searchMode changes\r\n          if (data.searchMode && data.searchMode !== this.previousSearchMode) {\r\n            this.selectedMode.setValue(data.searchMode, { emitEvent: false });\r\n            this.previousSearchMode = data.searchMode;\r\n            this.loadStoresOrClusters(data);\r\n          }\r\n          // Update selected store for preview if stores exist\r\n          if (data.stores && data.stores.length > 0 && !this.selectedStoreForPreview) {\r\n            const newStore = this.storeDropdownItems[0];\r\n            if (newStore && (!this.selectedStoreForPreview || this.selectedStoreForPreview.storeId !== newStore.storeId)) {\r\n              this.selectedStoreForPreview = newStore;\r\n              this.updateSelectedStoreValues();\r\n              \r\n              // Restore findResponseData and replaceResponseData for the selected store if available\r\n              this.restoreStoreResponseData(newStore.storeName);\r\n              \r\n              // Load planogram for the selected store\r\n              this.cdr.detectChanges();\r\n              setTimeout(() => {\r\n                if (this.initializeCanvas()) {\r\n                  this.loadPlanogramForStore(newStore.storeName);\r\n                }\r\n              }, 50);\r\n            }\r\n          }\r\n        } else if (!data && this.isInitialLoad) {\r\n          // Load initial data if no saved data\r\n          this.loadStoresOrClusters();\r\n          this.isInitialLoad = false;\r\n        }\r\n      });\r\n\r\n    // Subscribe to save draft loading state\r\n    this.dataService.getLoadingState()\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((isLoading) => {\r\n        this.savingDraft = isLoading;\r\n      });\r\n\r\n    // Watch for mode changes\r\n    this.selectedMode.valueChanges\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((newMode) => {\r\n        if (newMode !== this.previousSearchMode && !this.isUpdatingFromService) {\r\n          this.previousSearchMode = newMode as 'store' | 'cluster';\r\n          this.loadStoresOrClusters();\r\n          // Clear selected stores when mode changes manually\r\n          this.selectedStores = [];\r\n          // Clear selectedClusters when switching to store mode\r\n          if (newMode === 'store') {\r\n            this.dataService.updateData({ selectedClusters: undefined });\r\n          }\r\n        }\r\n      });\r\n\r\n    // Watch for target changes - debounce to prevent excessive updates\r\n    this.target.valueChanges\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((value) => {\r\n        if (value && !this.isUpdatingFromService) {\r\n          this.isUpdatingFromService = true;\r\n          this.dataService.updateData({ target: value as 'merch' | 'vm' | 'both' });\r\n          setTimeout(() => {\r\n            this.isUpdatingFromService = false;\r\n          }, 0);\r\n        }\r\n      });\r\n\r\n    // Watch for find prompt changes - debounce to prevent excessive updates\r\n    this.findPrompt.valueChanges\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((value) => {\r\n        if (!this.isUpdatingFromService) {\r\n          this.isUpdatingFromService = true;\r\n          this.dataService.updateData({ findPrompt: value || '' });\r\n          setTimeout(() => {\r\n            this.isUpdatingFromService = false;\r\n          }, 0);\r\n        }\r\n      });\r\n\r\n    // Watch for replace prompt changes - debounce to prevent excessive updates\r\n    this.replacePrompt.valueChanges\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((value) => {\r\n        if (!this.isUpdatingFromService) {\r\n          this.isUpdatingFromService = true;\r\n          this.dataService.updateData({ replacePrompt: value || '' });\r\n          setTimeout(() => {\r\n            this.isUpdatingFromService = false;\r\n          }, 0);\r\n        }\r\n      });\r\n  }\r\n\r\n  private restoreFormValues(data: FindReplace): void {\r\n    // Restore searchMode\r\n    if (data.searchMode) {\r\n      this.selectedMode.setValue(data.searchMode, { emitEvent: false });\r\n      this.previousSearchMode = data.searchMode;\r\n    }\r\n    \r\n    // Restore target\r\n    if (data.target) {\r\n      this.target.setValue(data.target, { emitEvent: false });\r\n    }\r\n    \r\n    // Restore findPrompt\r\n    if (data.findPrompt) {\r\n      this.findPrompt.setValue(data.findPrompt, { emitEvent: false });\r\n    }\r\n    \r\n    // Restore replacePrompt\r\n    if (data.replacePrompt) {\r\n      this.replacePrompt.setValue(data.replacePrompt, { emitEvent: false });\r\n    }\r\n    \r\n    // Load stores/clusters and restore selections\r\n    if (data.searchMode) {\r\n      this.loadStoresOrClusters(data);\r\n    } else {\r\n      this.loadStoresOrClusters();\r\n    }\r\n    \r\n    // Set initial selected store for preview\r\n    if (data.stores && data.stores.length > 0) {\r\n      this.updateStoreDropdownItems();\r\n      if (this.storeDropdownItems.length > 0) {\r\n        this.selectedStoreForPreview = this.storeDropdownItems[0];\r\n        this.updateSelectedStoreValues();\r\n        // Load planogram after view is initialized\r\n        this.cdr.detectChanges();\r\n        setTimeout(() => {\r\n          if (this.initializeCanvas() && this.selectedStoreForPreview) {\r\n            this.loadPlanogramForStore(this.selectedStoreForPreview.storeName);\r\n          } else {\r\n            // Retry if canvas not ready\r\n            setTimeout(() => {\r\n              if (this.initializeCanvas() && this.selectedStoreForPreview) {\r\n                this.loadPlanogramForStore(this.selectedStoreForPreview.storeName);\r\n              }\r\n            }, 200);\r\n          }\r\n        }, 100);\r\n      }\r\n    }\r\n    \r\n    this.isInitialLoad = false;\r\n  }\r\n\r\n  private updateStoreDropdownItems(): void {\r\n    if (!this.findReplaceData?.stores) {\r\n      this.storeDropdownItems = [];\r\n      this.selectedStoreValues = [];\r\n      return;\r\n    }\r\n    \r\n    const newItems = this.findReplaceData.stores.map((store: Store) => ({\r\n      storeId: store.storeId || store.storeName,\r\n      storeName: store.storeName,\r\n      _id: store.storeId || store.storeName\r\n    }));\r\n    \r\n    // Only update if items actually changed\r\n    const itemsChanged = JSON.stringify(newItems) !== JSON.stringify(this.storeDropdownItems);\r\n    if (itemsChanged) {\r\n      this.storeDropdownItems = newItems;\r\n      this.updateSelectedStoreValues();\r\n    }\r\n  }\r\n\r\n  private updateSelectedStoreValues(): void {\r\n    if (this.selectedStoreForPreview) {\r\n      this.selectedStoreValues = [this.selectedStoreForPreview];\r\n    } else {\r\n      this.selectedStoreValues = [];\r\n    }\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    // Canvas will be initialized when store is selected and canvas element is available\r\n  }\r\n\r\n  initializeCanvas(): boolean {\r\n    if (this.previewCanvas) {\r\n      return true; // Already initialized\r\n    }\r\n    \r\n    if (this.previewCanvasRef?.nativeElement) {\r\n      try {\r\n        this.previewCanvas = new fabric.Canvas(this.previewCanvasRef.nativeElement, {\r\n          selectionFullyContained: true,\r\n          perPixelTargetFind: true,\r\n          targetFindTolerance: 5,\r\n        });\r\n        this.setupZoomHandlers(this.previewCanvas);\r\n        return true;\r\n      } catch (error) {\r\n        console.error('Error initializing canvas:', error);\r\n        return false;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  onStoreSelectedForPreview(store: any): void {\r\n    if (store && (!this.selectedStoreForPreview || this.selectedStoreForPreview.storeId !== store.storeId)) {\r\n      this.selectedStoreForPreview = store;\r\n      this.updateSelectedStoreValues();\r\n      \r\n      // Clear selected fixture when switching stores\r\n      this.selectedFixture = null;\r\n      this.selectedFixtureData = null;\r\n      this.originalFixtureData = null;\r\n      this.originalFixturesMap.clear(); // Clear the map when switching stores\r\n      \r\n      // Restore findResponseData and replaceResponseData for the selected store if available\r\n      this.restoreStoreResponseData(store.storeName);\r\n      \r\n      // Force change detection to ensure canvas element is in DOM\r\n      this.cdr.detectChanges();\r\n      \r\n      // Initialize canvas if not already done, then load planogram\r\n      setTimeout(() => {\r\n        if (this.initializeCanvas()) {\r\n          this.loadPlanogramForStore(store.storeName);\r\n        } else {\r\n          // Retry after a short delay if canvas element not ready\r\n          setTimeout(() => {\r\n            if (this.initializeCanvas()) {\r\n              this.loadPlanogramForStore(store.storeName);\r\n            }\r\n          }, 100);\r\n        }\r\n      }, 50);\r\n    }\r\n  }\r\n\r\n  // Restore findResponseData and replaceResponseData for a specific store\r\n  private restoreStoreResponseData(storeName: string): void {\r\n    if (!this.findReplaceData?.stores) {\r\n      return;\r\n    }\r\n\r\n    const store = this.findReplaceData.stores.find(\r\n      (s: Store) => s.storeName === storeName\r\n    );\r\n\r\n    if (!store) {\r\n      return;\r\n    }\r\n\r\n    // findResponseData is a string (fixture _id)\r\n    // replaceResponseData is an object with vmConfig and/or shelfConfig\r\n    const fixtureId = store.findResponseData;\r\n    if (!fixtureId) return;\r\n\r\n    this.selectedFixture = { fixtureId, fixtureType: undefined };\r\n    // We'll re-hydrate selectedFixtureData from the loaded planogram (floorData) after load.\r\n    this.selectedFixtureData = null;\r\n  }\r\n\r\n  // Apply stored findResponseData and replaceResponseData to floor data\r\n  private applyStoredResponseData(): void {\r\n    if (!this.findReplaceData?.stores || !this.selectedStoreForPreview || !this.floorData) {\r\n      return;\r\n    }\r\n\r\n    const store = this.findReplaceData.stores.find(\r\n      (s: Store) => s.storeName === this.selectedStoreForPreview.storeName\r\n    );\r\n\r\n    if (!store) {\r\n      return;\r\n    }\r\n\r\n    // findResponseData is a string (fixture _id) - use it to find the fixture\r\n    const fixtureId = store.findResponseData;\r\n    if (!fixtureId) return;\r\n\r\n    // Find the fixture in floorData\r\n    const fixture = this.getFixtureByIdFromFloor(fixtureId);\r\n    if (!fixture) return;\r\n\r\n    // Apply replaceResponseData configs if available (merge with existing fixture)\r\n    if (store.replaceResponseData) {\r\n      // Store the original fixture (before replace) for before/after comparison\r\n      const originalFixture = structuredClone(fixture);\r\n      this.originalFixtureData = originalFixture;\r\n      // Also store it in the map so it persists when clicking other fixtures\r\n      this.originalFixturesMap.set(fixtureId, originalFixture);\r\n      \r\n      const updatedFixture = { ...fixture };\r\n      \r\n      // Merge vmConfig if present in replaceResponseData\r\n      if (store.replaceResponseData.vmConfig) {\r\n        updatedFixture.vmConfig = store.replaceResponseData.vmConfig;\r\n      }\r\n      \r\n      // Merge shelfConfig if present in replaceResponseData\r\n      if (store.replaceResponseData.shelfConfig) {\r\n        updatedFixture.shelfConfig = store.replaceResponseData.shelfConfig;\r\n      }\r\n\r\n      // Update the fixture in floorData\r\n      this.updateAiResponseFixture(updatedFixture);\r\n      \r\n      // Set selected fixture data (after replace)\r\n      this.selectedFixture = {\r\n        fixtureId: updatedFixture._id,\r\n        fixtureType: updatedFixture.fixtureType,\r\n      };\r\n      this.selectedFixtureData = updatedFixture;\r\n    } else {\r\n      // No replaceResponseData, clear original fixture and just set the selected fixture from findResponseData\r\n      this.originalFixtureData = null;\r\n      this.selectedFixture = {\r\n        fixtureId: fixture._id,\r\n        fixtureType: fixture.fixtureType,\r\n      };\r\n      this.selectedFixtureData = fixture;\r\n    }\r\n  }\r\n\r\n  private getFixtureByIdFromFloor(fixtureId: string): any | null {\r\n    if (!fixtureId || !this.floorData) return null;\r\n\r\n    for (const element of this.floorData.layoutPolygon || []) {\r\n      if (element?.elementType === \"wall\" && Array.isArray(element.fixtures)) {\r\n        const hit = element.fixtures.find((fx: any) => fx?._id === fixtureId);\r\n        if (hit) return hit;\r\n      }\r\n    }\r\n\r\n    for (const fx of this.floorData.centerFixture || []) {\r\n      if (fx?._id === fixtureId) return fx;\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  async loadPlanogramForStore(storeName: string): Promise<void> {\r\n    if (!storeName) {\r\n      console.warn('Cannot load planogram: storeName not available');\r\n      return;\r\n    }\r\n    \r\n    if (!this.previewCanvas) {\r\n      console.warn('Canvas not initialized, attempting to initialize...');\r\n      if (!this.initializeCanvas()) {\r\n        console.error('Failed to initialize canvas');\r\n        return;\r\n      }\r\n    }\r\n    \r\n    this.canvasLoading = true;\r\n    try {\r\n      // Get planoId from store name\r\n      const response: any = await this.storeBuilderService.getPlanoId({ stores: [storeName.toUpperCase()] }).toPromise();\r\n      \r\n      if (response?.code === 200 && response?.data?.length > 0) {\r\n        const planoId = response.data[0]._id;\r\n        await this.getStoreFixtures(planoId);\r\n      } else {\r\n        console.warn('No planogram found for store:', storeName);\r\n        this.canvasLoading = false;\r\n      }\r\n    } catch (error) {\r\n      console.error('Error loading planogram:', error);\r\n      this.canvasLoading = false;\r\n    }\r\n  }\r\n\r\n  loadStoresOrClusters(savedData?: FindReplace): void {\r\n    const searchMode = this.selectedMode.value as 'store' | 'cluster';\r\n    if (!searchMode) return;\r\n\r\n    this.loading = true;\r\n    this.storeBuilderService.getStoreOrClusterList({ searchMode })\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: (response: any) => {\r\n          this.loading = false;\r\n          if (response?.code === 200 && response?.data && Array.isArray(response.data)) {\r\n            if (searchMode === 'store') {\r\n              // For store mode, use data directly\r\n              this.storeOptions = response.data.map((item: any) => ({\r\n                id: item.id,\r\n                label: item.label\r\n              }));\r\n              this.clusterData = []; // Clear cluster data\r\n              \r\n              // Restore saved selections for store mode\r\n              if (savedData?.stores && savedData.stores.length > 0) {\r\n                this.restoreStoreSelections(savedData.stores);\r\n              }\r\n            } else {\r\n              // For cluster mode, show clusters in the dropdown\r\n              // Store full cluster data for later use\r\n              this.clusterData = response.data;\r\n              this.storeOptions = response.data.map((cluster: any) => ({\r\n                id: cluster.id,\r\n                label: cluster.label\r\n              }));\r\n              \r\n              // Restore saved selections for cluster mode\r\n              if (savedData?.stores && savedData.stores.length > 0) {\r\n                this.restoreClusterSelections(savedData.stores);\r\n              }\r\n            }\r\n          } else {\r\n            this.storeOptions = [];\r\n            this.clusterData = [];\r\n          }\r\n        },\r\n        error: (error) => {\r\n          this.loading = false;\r\n          console.error('Error loading stores/clusters:', error);\r\n          this.storeOptions = [];\r\n        }\r\n      });\r\n  }\r\n\r\n  restoreStoreSelections(savedStores: Store[]): void {\r\n    // Match saved stores by storeName\r\n    const savedStoreNames = new Set(savedStores.map(s => s.storeName));\r\n    this.selectedStores = this.storeOptions.filter(option => \r\n      savedStoreNames.has(option.label)\r\n    );\r\n  }\r\n\r\n  restoreClusterSelections(_savedStores: Store[]): void {\r\n    // Restore cluster selection ONLY from selectedClusters (no derivation from stores)\r\n    const savedClusters = this.findReplaceData?.selectedClusters || [];\r\n    if (!savedClusters.length) {\r\n      this.selectedStores = [];\r\n      return;\r\n    }\r\n\r\n    const savedClusterIds = new Set(savedClusters.map(c => c.id));\r\n    const selectedClusters: StoreOption[] = [];\r\n\r\n    this.clusterData.forEach((cluster: any) => {\r\n      if (savedClusterIds.has(cluster.id)) {\r\n        selectedClusters.push({\r\n          id: cluster.id,\r\n          label: cluster.label\r\n        });\r\n      }\r\n    });\r\n\r\n    this.selectedStores = selectedClusters;\r\n  }\r\n\r\n  onStoresSelected(stores: StoreOption[]) {\r\n    this.selectedStores = stores;\r\n  }\r\n\r\n  async onReviewAndReplace(): Promise<void> {\r\n    if (!this.findReplaceData?._id) {\r\n      console.error('No find replace ID available');\r\n      return;\r\n    }\r\n\r\n    // Show confirmation modal\r\n    const modalRef = this.modalService.open(BatchConfirmationModalComponent, {\r\n      centered: true,\r\n      size: 'md',\r\n      backdrop: 'static',\r\n      windowClass: 'batch-confirmation-modal'\r\n    });\r\n\r\n    // Pass store count to modal\r\n    modalRef.componentInstance.storeCount = this.getStoreCount();\r\n\r\n    try {\r\n      const result = await modalRef.result;\r\n      if (result) {\r\n        // User confirmed, proceed with batch process\r\n        this.proceedWithBatchProcess();\r\n      }\r\n    } catch (error) {\r\n      // User dismissed the modal\r\n      console.log('Batch confirmation modal dismissed');\r\n    }\r\n  }\r\n\r\n  private proceedWithBatchProcess(): void {\r\n    if (!this.findReplaceData?._id) {\r\n      console.error('No find replace ID available');\r\n      return;\r\n    }\r\n\r\n    this.loading = true;\r\n    this.batchProcessing = true;\r\n    const findReplaceId = this.findReplaceData._id;\r\n    \r\n    this.storeBuilderService.batchFindReplace({ findReplaceId })\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: (response: any) => {\r\n          this.loading = false;\r\n          this.batchProcessing = false;\r\n          if (response?.code === 200) {\r\n            // Refetch find replace data to update UI\r\n            this.dataService.loadAndSetFindReplaceDataById(findReplaceId);\r\n          } else {\r\n            console.error('Failed to start batch find replace:', response?.message);\r\n          }\r\n        },\r\n        error: (error) => {\r\n          this.loading = false;\r\n          this.batchProcessing = false;\r\n          console.error('Error starting batch find replace:', error);\r\n        }\r\n      });\r\n  }\r\n\r\n  onApply(): void {\r\n    const searchMode = this.selectedMode.value as 'store' | 'cluster';\r\n    let stores: Store[] = [];\r\n    let selectedClusters: Array<{ id: string; label: string }> | undefined = undefined;\r\n    \r\n    if (searchMode === 'store') {\r\n      // For store mode, convert selected stores directly\r\n      stores = this.selectedStores.map((storeOption: StoreOption) => ({\r\n        storeName: storeOption.label,\r\n      }));\r\n    } else {\r\n      // For cluster mode, save selected clusters and extract all stores from selected clusters\r\n      selectedClusters = this.selectedStores.map((storeOption: StoreOption) => ({\r\n        id: storeOption.id,\r\n        label: storeOption.label\r\n      }));\r\n      \r\n      const selectedClusterIds = new Set(this.selectedStores.map(s => s.id));\r\n      stores = [];\r\n      \r\n      // Find selected clusters and extract their stores\r\n      this.clusterData.forEach((cluster: any) => {\r\n        if (selectedClusterIds.has(cluster.id) && cluster.stores && Array.isArray(cluster.stores)) {\r\n          cluster.stores.forEach((store: any) => {\r\n            stores.push({\r\n              storeName: store.label ,\r\n            });\r\n          });\r\n        }\r\n      });\r\n    }\r\n\r\n    // Update data service with all current values\r\n    const updateData: any = {\r\n      searchMode: searchMode,\r\n      stores: stores,\r\n      storeCount: stores.length,\r\n      target: this.target.value as 'merch' | 'vm' | 'both',\r\n      findPrompt: this.findPrompt.value || '',\r\n      replacePrompt: this.replacePrompt.value || ''\r\n    };\r\n\r\n    // Add selectedClusters only when searchMode is cluster\r\n    if (searchMode === 'cluster' && selectedClusters) {\r\n      updateData.selectedClusters = selectedClusters;\r\n    }\r\n\r\n    this.dataService.updateData(updateData);\r\n\r\n    // Trigger save as draft\r\n    this.dataService.triggerSaveDraft();\r\n  }\r\n\r\n  // Canvas setup methods\r\n  setupZoomHandlers(canvas: fabric.Canvas): void {\r\n    // Disable object selection globally\r\n    canvas.selection = false;\r\n    \r\n    canvas.on(\"mouse:wheel\", (opt: fabric.TEvent<WheelEvent>) => {\r\n      const e = opt.e;\r\n      if (e.ctrlKey || e.metaKey) {\r\n        const delta = e.deltaY;\r\n        let zoom = canvas.getZoom();\r\n        zoom *= 0.995 ** delta;\r\n        zoom = Math.max(0.2, Math.min(zoom, 3));\r\n        canvas.zoomToPoint({ x: e.offsetX, y: e.offsetY } as fabric.Point, zoom);\r\n        e.preventDefault();\r\n        e.stopPropagation();\r\n      }\r\n    });\r\n\r\n    let isDragging = false;\r\n    let lastPosX = 0;\r\n    let lastPosY = 0;\r\n\r\n    canvas.on(\"mouse:down\", (opt: any) => {\r\n      // Handle fixture clicks - use findTarget to get the actual group\r\n      if (opt.target) {\r\n        const obj = opt.target as any;\r\n        // Check if it's a fixture group or nested within one\r\n        let fixtureGroup = obj;\r\n        \r\n        // Traverse up to find the fixture group\r\n        let attempts = 0;\r\n        while (fixtureGroup && !(fixtureGroup as any).fixtureId && !(fixtureGroup as any).objType && attempts < 10) {\r\n          if ((fixtureGroup as any).parent) {\r\n            fixtureGroup = (fixtureGroup as any).parent;\r\n          } else if ((fixtureGroup as any).group) {\r\n            fixtureGroup = (fixtureGroup as any).group;\r\n          } else {\r\n            break;\r\n          }\r\n          attempts++;\r\n        }\r\n        \r\n        // Check if we found a fixture group\r\n        if ((fixtureGroup as any).objType === \"fixture\" || (fixtureGroup as any).fixtureId) {\r\n          this.onFixtureClick(fixtureGroup);\r\n          canvas.setActiveObject(fixtureGroup);\r\n          canvas.requestRenderAll();\r\n          return;\r\n        }\r\n        \r\n        // For other elements, just highlight\r\n        canvas.setActiveObject(opt.target);\r\n        canvas.requestRenderAll();\r\n        return;\r\n      }\r\n      \r\n      if (!opt.target) {\r\n        isDragging = true;\r\n        canvas.selection = false;\r\n        const e = opt.e;\r\n        lastPosX = e.clientX;\r\n        lastPosY = e.clientY;\r\n      }\r\n    });\r\n\r\n    canvas.on(\"mouse:move\", (opt: any) => {\r\n      if (isDragging && canvas.viewportTransform && !opt.target) {\r\n        const e = opt.e;\r\n        const vpt = canvas.viewportTransform;\r\n        vpt[4] += e.clientX - lastPosX;\r\n        vpt[5] += e.clientY - lastPosY;\r\n        canvas.requestRenderAll();\r\n        lastPosX = e.clientX;\r\n        lastPosY = e.clientY;\r\n      }\r\n    });\r\n\r\n    canvas.on(\"mouse:up\", () => {\r\n      isDragging = false;\r\n      canvas.selection = false;\r\n    });\r\n\r\n    // Prevent all object movement (walls, entrances, fixtures, other elements)\r\n    canvas.on(\"object:moving\", (e: any) => {\r\n      const obj = e.target;\r\n      if (obj && (obj as any).objType) {\r\n        e.e.preventDefault();\r\n        e.e.stopPropagation();\r\n        // Reset position\r\n        obj.setCoords();\r\n        canvas.requestRenderAll();\r\n      }\r\n    });\r\n\r\n    // Prevent all object modifications (scaling, rotating, etc.)\r\n    canvas.on(\"object:modified\", (e: any) => {\r\n      const obj = e.target;\r\n      if (obj && (obj as any).objType) {\r\n        // Reset any changes\r\n        obj.setCoords();\r\n        canvas.requestRenderAll();\r\n      }\r\n    });\r\n\r\n    // Prevent object scaling\r\n    canvas.on(\"object:scaling\", (e: any) => {\r\n      const obj = e.target;\r\n      if (obj && (obj as any).objType) {\r\n        e.e.preventDefault();\r\n        e.e.stopPropagation();\r\n        obj.setCoords();\r\n        canvas.requestRenderAll();\r\n      }\r\n    });\r\n\r\n    // Prevent object rotating\r\n    canvas.on(\"object:rotating\", (e: any) => {\r\n      const obj = e.target;\r\n      if (obj && (obj as any).objType) {\r\n        e.e.preventDefault();\r\n        e.e.stopPropagation();\r\n        obj.setCoords();\r\n        canvas.requestRenderAll();\r\n      }\r\n    });\r\n  }\r\n\r\n  async getStoreFixtures(storeId: string): Promise<void> {\r\n    if (!this.previewCanvas) {\r\n      console.warn('Canvas not initialized');\r\n      this.canvasLoading = false;\r\n      return;\r\n    }\r\n\r\n    this.canvasLoading = true;\r\n    this.storeBuilderService.getStoreFixtures({ id: [storeId] })\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: async (res: any) => {\r\n          if (!res?.data?.[0]?.floors?.length) {\r\n            this.canvasLoading = false;\r\n            return;\r\n          }\r\n\r\n          this.planoData = structuredClone(res.data[0]);\r\n          this.floorData = structuredClone(res.data[0].floors[0]);\r\n          \r\n          // Apply stored findResponseData and replaceResponseData if available for this store\r\n          // This updates the floorData with the stored fixture changes and sets selectedFixtureData\r\n          this.applyStoredResponseData();\r\n          \r\n          // Open panel if we have selected fixture data\r\n          if (this.selectedFixtureData) {\r\n            this.isRightPanelCollapsed = false;\r\n          }\r\n          \r\n          // Collect all fixtures for preview\r\n          this.collectAllFixtures();\r\n          \r\n          // Ensure canvas is initialized before rendering\r\n          if (!this.previewCanvas) {\r\n            this.initializeCanvas();\r\n          }\r\n          \r\n          if (this.previewCanvas) {\r\n            // Render the planogram with the updated floorData (which includes stored response data)\r\n            await this.renderFloor(this.previewCanvas);\r\n            this.canvasLoading = false;\r\n\r\n            // Re-center and highlight the selected fixture if stored response data exists\r\n            setTimeout(() => {\r\n              if (this.previewCanvasContainerRef?.nativeElement) {\r\n                this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);\r\n                this.fitCanvasToLayoutAnimated(this.previewCanvas);\r\n                \r\n                // Highlight the fixture if we have stored response data\r\n                if (this.selectedFixture?.fixtureId) {\r\n                  const actionFixture = this.previewCanvas.getObjects().find(\r\n                    (obj: any) => obj.objType === \"fixture\" && obj.fixtureId === this.selectedFixture.fixtureId\r\n                  ) as fabric.Group | undefined;\r\n                  if (actionFixture) {\r\n                    this.highlightFixture(this.previewCanvas, actionFixture, false);\r\n                  }\r\n                }\r\n              }\r\n              \r\n              // Automatically trigger find and replace if prompts are available and store doesn't have results\r\n              this.autoFindAndReplaceIfNeeded();\r\n            }, 300);\r\n          } else {\r\n            this.canvasLoading = false;\r\n          }\r\n        },\r\n        error: (err: any) => {\r\n          this.canvasLoading = false;\r\n          console.error('Error fetching plano:', err);\r\n        },\r\n      });\r\n  }\r\n\r\n  resizeCanvas(canvas: fabric.Canvas, container: ElementRef<HTMLDivElement>): void {\r\n    const containerEl = container.nativeElement;\r\n    canvas.setDimensions({\r\n      width: containerEl.clientWidth,\r\n      height: containerEl.clientHeight,\r\n    });\r\n    canvas.requestRenderAll();\r\n  }\r\n\r\n  private fitCanvasToLayoutAnimated(canvas: fabric.Canvas) {\r\n    if (!canvas) return;\r\n    const bounds = this.getFullLayoutBounds(canvas);\r\n    if (!bounds.width || !bounds.height) return;\r\n\r\n    const canvasW = canvas.getWidth();\r\n    const canvasH = canvas.getHeight();\r\n    const scaleX = canvasW / bounds.width;\r\n    const scaleY = canvasH / bounds.height;\r\n    const targetZoom = Math.min(scaleX, scaleY) * 0.9;\r\n\r\n    const targetVpt = [...(canvas.viewportTransform || [1, 0, 0, 1, 0, 0])] as fabric.TMat2D;\r\n    targetVpt[0] = targetZoom;\r\n    targetVpt[3] = targetZoom;\r\n    targetVpt[4] = canvasW / 2 - (bounds.left + bounds.width / 2) * targetZoom;\r\n    targetVpt[5] = canvasH / 2 - (bounds.top + bounds.height / 2) * targetZoom;\r\n\r\n    const startVpt = [...canvas.viewportTransform!] as fabric.TMat2D;\r\n\r\n    fabric.util.animate({\r\n      startValue: 0,\r\n      endValue: 1,\r\n      duration: 100,\r\n      easing: fabric.util.ease.easeOutCubic,\r\n      onChange: (value: number) => {\r\n        const vpt = canvas.viewportTransform!;\r\n        vpt[0] = startVpt[0] + (targetVpt[0] - startVpt[0]) * value;\r\n        vpt[3] = startVpt[3] + (targetVpt[3] - startVpt[3]) * value;\r\n        vpt[4] = startVpt[4] + (targetVpt[4] - startVpt[4]) * value;\r\n        vpt[5] = startVpt[5] + (targetVpt[5] - startVpt[5]) * value;\r\n        canvas.requestRenderAll();\r\n      },\r\n    });\r\n  }\r\n\r\n  private getFullLayoutBounds(canvas: fabric.Canvas) {\r\n    const objects = canvas.getObjects();\r\n    if (!objects.length) return { left: 0, top: 0, width: 0, height: 0 };\r\n\r\n    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\r\n\r\n    for (const obj of objects) {\r\n      const rect = obj.getBoundingRect();\r\n      minX = Math.min(minX, rect.left);\r\n      minY = Math.min(minY, rect.top);\r\n      maxX = Math.max(maxX, rect.left + rect.width);\r\n      maxY = Math.max(maxY, rect.top + rect.height);\r\n    }\r\n\r\n    return { left: minX, top: minY, width: maxX - minX, height: maxY - minY };\r\n  }\r\n\r\n  async renderFloor(canvas: fabric.Canvas) {\r\n    await this.drawInitialContent(canvas);\r\n  }\r\n\r\n  async drawInitialContent(canvas: fabric.Canvas): Promise<void> {\r\n    canvas.clear();\r\n    await this.drawLayoutElements(canvas);\r\n  }\r\n\r\n  // Automatically trigger find and replace if prompts are available and store doesn't have results\r\n  private autoFindAndReplaceIfNeeded(): void {\r\n    if (!this.selectedStoreForPreview || !this.findReplaceData) {\r\n      return;\r\n    }\r\n\r\n    // Check if prompts are available\r\n    const hasFindPrompt = this.findReplaceData.findPrompt && this.findReplaceData.findPrompt.trim().length > 0;\r\n    const hasReplacePrompt = this.findReplaceData.replacePrompt && this.findReplaceData.replacePrompt.trim().length > 0;\r\n\r\n    if (!hasFindPrompt || !hasReplacePrompt) {\r\n      return;\r\n    }\r\n\r\n    // Check if current store already has findResponseData and replaceResponseData\r\n    const store = this.findReplaceData.stores?.find(\r\n      (s: Store) => s.storeName === this.selectedStoreForPreview.storeName\r\n    );\r\n\r\n    // If store already has findResponseData, skip auto-find to preserve the highlight\r\n    // Only auto-run find if store doesn't already have findResponseData\r\n    if (store?.findResponseData) {\r\n      // If store has findResponseData but not replaceResponseData, we could auto-run replace\r\n      // but for now, we'll skip to preserve the highlight that was just set\r\n      return;\r\n    }\r\n\r\n    // Set the prompts in the form controls if not already set\r\n    if (!this.findPrompt.value && this.findReplaceData.findPrompt) {\r\n      this.findPrompt.setValue(this.findReplaceData.findPrompt, { emitEvent: false });\r\n    }\r\n    if (!this.replacePrompt.value && this.findReplaceData.replacePrompt) {\r\n      this.replacePrompt.setValue(this.findReplaceData.replacePrompt, { emitEvent: false });\r\n    }\r\n\r\n    // Automatically trigger find first, then replace after find completes\r\n    this.autoFind();\r\n  }\r\n\r\n  // Auto find - will trigger replace after completion\r\n  private autoFind(): void {\r\n    if (!this.findPrompt.value || !this.selectedStoreForPreview) {\r\n      return;\r\n    }\r\n\r\n    this.findLoading = true;\r\n    this.canvasLoading = true;\r\n    const payload = {\r\n      selectionCriteria: this.findPrompt.value,\r\n      stores: [this.selectedStoreForPreview.storeName],\r\n    };\r\n\r\n    this.storeBuilderService.findFixture(payload)\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: (res: any) => {\r\n          this.findLoading = false;\r\n          this.canvasLoading = false;\r\n          if (res.code === 200) {\r\n            // Check if the response indicates \"NOT FOUND\"\r\n            if (res.status === 'success' && res.message === 'NOT FOUND') {\r\n              this.toastService.getWarningToast('No matching fixture found for the given prompt');\r\n              return;\r\n            }\r\n            \r\n            // Check if res.data exists before processing\r\n            if (!res.data) {\r\n              this.toastService.getWarningToast('No matching fixture found for the given prompt');\r\n              return;\r\n            }\r\n            \r\n            this.updateAiResponseFixture(res.data);\r\n            // Store the found fixture for potential replace operation\r\n            this.selectedFixture = {\r\n              fixtureId: res.data._id,\r\n              fixtureType: res.data.fixtureType,\r\n            };\r\n            this.selectedFixtureData = res.data;\r\n            \r\n            // Save findResponseData to the specific store\r\n            this.saveFindResponseData(res.data);\r\n            \r\n            // Render the floor and wait for it to complete\r\n            this.renderFloor(this.previewCanvas).then(() => {\r\n              // Wait for canvas to fully render before highlighting\r\n              setTimeout(() => {\r\n                const actionFixture = this.previewCanvas.getObjects().find(\r\n                  (obj: any) => obj.objType === \"fixture\" && obj.fixtureId === res.data._id\r\n                ) as fabric.Group | undefined;\r\n                if (actionFixture) {\r\n                  this.highlightFixture(this.previewCanvas, actionFixture, true);\r\n                }\r\n                \r\n                // After find completes, automatically trigger replace\r\n                setTimeout(() => {\r\n                  this.autoReplace();\r\n                }, 500);\r\n              }, 300);\r\n            });\r\n          }\r\n        },\r\n        error: () => {\r\n          this.findLoading = false;\r\n          this.canvasLoading = false;\r\n        },\r\n      });\r\n  }\r\n\r\n  // Auto replace - called after auto find completes\r\n  private autoReplace(): void {\r\n    if (!this.replacePrompt.value) {\r\n      return;\r\n    }\r\n\r\n    // Check if a fixture is selected for replacement\r\n    if (!this.selectedFixture?.fixtureId && !this.selectedFixtureData?._id) {\r\n      return;\r\n    }\r\n\r\n    // Use Replace API for selected fixture\r\n    const fixtureId = this.selectedFixture?.fixtureId || this.selectedFixtureData?._id;\r\n    \r\n    this.replaceLoading = true;\r\n    this.canvasLoading = true;\r\n    const payload = {\r\n      fixtureId: fixtureId,\r\n      updateType: this.target.value,\r\n      updationCriteria: this.replacePrompt.value,\r\n    };\r\n\r\n    // Store the original fixture before replace for before/after comparison\r\n    const originalFixture = this.selectedFixtureData ? structuredClone(this.selectedFixtureData) : null;\r\n    \r\n    this.storeBuilderService.replaceFixture(payload)\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: (res: any) => {\r\n          this.replaceLoading = false;\r\n          this.canvasLoading = false;\r\n          if (res.code === 200) {\r\n            // Store original fixture for before/after comparison\r\n            this.originalFixtureData = originalFixture;\r\n            \r\n            this.updateAiResponseFixture(res.data);\r\n            \r\n            // Save replaceResponseData to the specific store\r\n            this.saveReplaceResponseData(res.data);\r\n            \r\n            // Update selected fixture data (after replace)\r\n            this.selectedFixture = {\r\n              fixtureId: res.data._id,\r\n              fixtureType: res.data.fixtureType,\r\n            };\r\n            this.selectedFixtureData = res.data;\r\n            \r\n            // Render the floor and wait for it to complete\r\n            this.renderFloor(this.previewCanvas).then(() => {\r\n              // Wait for canvas to fully render before highlighting\r\n              setTimeout(() => {\r\n                const actionFixture = this.previewCanvas.getObjects().find(\r\n                  (obj: any) => obj.objType === \"fixture\" && obj.fixtureId === res.data._id\r\n                ) as fabric.Group | undefined;\r\n                if (actionFixture) {\r\n                  this.highlightFixture(this.previewCanvas, actionFixture, true);\r\n                }\r\n              }, 300);\r\n            });\r\n          }\r\n        },\r\n        error: () => {\r\n          this.replaceLoading = false;\r\n          this.canvasLoading = false;\r\n        },\r\n      });\r\n  }\r\n\r\n  // Find and Replace button handlers\r\n  onFind(): void {\r\n    if (!this.findPrompt.value || !this.selectedStoreForPreview) {\r\n      return;\r\n    }\r\n\r\n    this.findLoading = true;\r\n    this.canvasLoading = true;\r\n    const payload = {\r\n      selectionCriteria: this.findPrompt.value,\r\n      stores: [this.selectedStoreForPreview.storeName],\r\n    };\r\n\r\n    this.storeBuilderService.findFixture(payload)\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: (res: any) => {\r\n          this.findLoading = false;\r\n          this.canvasLoading = false;\r\n          if (res.code === 200) {\r\n            // Check if the response indicates \"NOT FOUND\"\r\n            if (res.status === 'success' && res.message === 'NOT FOUND') {\r\n              this.toastService.getWarningToast('No matching fixture found for the given prompt');\r\n              return;\r\n            }\r\n            \r\n            // Check if res.data exists before processing\r\n            if (!res.data) {\r\n              this.toastService.getWarningToast('No matching fixture found for the given prompt');\r\n              return;\r\n            }\r\n            \r\n            this.updateAiResponseFixture(res.data);\r\n            // Store the found fixture for potential replace operation\r\n            this.selectedFixture = {\r\n              fixtureId: res.data._id,\r\n              fixtureType: res.data.fixtureType,\r\n            };\r\n            this.selectedFixtureData = res.data;\r\n            \r\n            // Save findResponseData to the specific store\r\n            this.saveFindResponseData(res.data);\r\n            \r\n            // Render the floor and wait for it to complete\r\n            this.renderFloor(this.previewCanvas).then(() => {\r\n              // Wait for canvas to fully render before highlighting\r\n              setTimeout(() => {\r\n                const actionFixture = this.previewCanvas.getObjects().find(\r\n                  (obj: any) => obj.objType === \"fixture\" && obj.fixtureId === res.data._id\r\n                ) as fabric.Group | undefined;\r\n                if (actionFixture) {\r\n                  this.highlightFixture(this.previewCanvas, actionFixture, true);\r\n                }\r\n              }, 300);\r\n            });\r\n          }\r\n        },\r\n        error: () => {\r\n          this.findLoading = false;\r\n          this.canvasLoading = false;\r\n        },\r\n      });\r\n  }\r\n\r\n  onReplace(): void {\r\n    if (!this.replacePrompt.value) {\r\n      return;\r\n    }\r\n\r\n    // Check if a fixture is selected for replacement\r\n    if (!this.selectedFixture?.fixtureId && !this.selectedFixtureData?._id) {\r\n      return;\r\n    }\r\n\r\n    // Use Replace API for selected fixture\r\n    const fixtureId = this.selectedFixture?.fixtureId || this.selectedFixtureData?._id;\r\n    \r\n    this.replaceLoading = true;\r\n    this.canvasLoading = true;\r\n    const payload = {\r\n      fixtureId: fixtureId,\r\n      updateType: this.target.value,\r\n      updationCriteria: this.replacePrompt.value,\r\n    };\r\n\r\n    // Store the original fixture before replace for before/after comparison\r\n    const originalFixture = this.selectedFixtureData ? structuredClone(this.selectedFixtureData) : null;\r\n    \r\n    this.storeBuilderService.replaceFixture(payload)\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe({\r\n        next: (res: any) => {\r\n          this.replaceLoading = false;\r\n          this.canvasLoading = false;\r\n          if (res.code === 200) {\r\n            // Store original fixture for before/after comparison\r\n            this.originalFixtureData = originalFixture;\r\n            \r\n            this.updateAiResponseFixture(res.data);\r\n            \r\n            // Save replaceResponseData to the specific store\r\n            this.saveReplaceResponseData(res.data);\r\n            \r\n            // Update selected fixture data (after replace)\r\n            this.selectedFixture = {\r\n              fixtureId: res.data._id,\r\n              fixtureType: res.data.fixtureType,\r\n            };\r\n            this.selectedFixtureData = res.data;\r\n            \r\n            // Render the floor and wait for it to complete\r\n            this.renderFloor(this.previewCanvas).then(() => {\r\n              // Wait for canvas to fully render before highlighting\r\n              setTimeout(() => {\r\n                const actionFixture = this.previewCanvas.getObjects().find(\r\n                  (obj: any) => obj.objType === \"fixture\" && obj.fixtureId === res.data._id\r\n                ) as fabric.Group | undefined;\r\n                if (actionFixture) {\r\n                  this.highlightFixture(this.previewCanvas, actionFixture, true);\r\n                }\r\n              }, 300);\r\n            });\r\n          }\r\n        },\r\n        error: () => {\r\n          this.replaceLoading = false;\r\n          this.canvasLoading = false;\r\n        },\r\n      });\r\n  }\r\n\r\n  // Helper method to get findResponseData for current store\r\n  getCurrentStoreFindResponseData(): string | null {\r\n    if (!this.findReplaceData?.stores || !this.selectedStoreForPreview) {\r\n      return null;\r\n    }\r\n    const store = this.findReplaceData.stores.find(\r\n      (s: Store) => s.storeName === this.selectedStoreForPreview.storeName\r\n    );\r\n    return store?.findResponseData || null;\r\n  }\r\n\r\n  // Save findResponseData to specific store and trigger save as draft\r\n  private saveFindResponseData(responseData: any): void {\r\n    if (!this.findReplaceData || !this.selectedStoreForPreview) {\r\n      return;\r\n    }\r\n\r\n    const updatedStores = (this.findReplaceData.stores || []).map((store: Store) => {\r\n      if (store.storeName === this.selectedStoreForPreview.storeName) {\r\n        return {\r\n          ...store,\r\n          findResponseData: responseData?._id\r\n        };\r\n      }\r\n      return store;\r\n    });\r\n\r\n    // Update local findReplaceData immediately\r\n    this.findReplaceData = {\r\n      ...this.findReplaceData,\r\n      stores: updatedStores\r\n    };\r\n\r\n    // Update the data service\r\n    this.dataService.updateData({\r\n      stores: updatedStores\r\n    });\r\n\r\n    // Trigger save as draft\r\n    this.dataService.triggerSaveDraft();\r\n  }\r\n\r\n  // Save replaceResponseData to specific store and trigger save as draft\r\n  // Only saves vmConfig and/or shelfConfig based on target\r\n  private saveReplaceResponseData(responseData: any): void {\r\n    if (!this.findReplaceData || !this.selectedStoreForPreview) {\r\n      return;\r\n    }\r\n\r\n    const target = this.target.value as 'merch' | 'vm' | 'both';\r\n    const replaceData: { vmConfig?: any[]; shelfConfig?: any[] } = {};\r\n\r\n    // Extract only the relevant configs based on target\r\n    if (target === 'vm' || target === 'both') {\r\n      if (responseData?.vmConfig) {\r\n        replaceData.vmConfig = responseData.vmConfig;\r\n      }\r\n    }\r\n    \r\n    if (target === 'merch' || target === 'both') {\r\n      if (responseData?.shelfConfig) {\r\n        replaceData.shelfConfig = responseData.shelfConfig;\r\n      }\r\n    }\r\n\r\n    const updatedStores = (this.findReplaceData.stores || []).map((store: Store) => {\r\n      if (store.storeName === this.selectedStoreForPreview.storeName) {\r\n        return {\r\n          ...store,\r\n          replaceResponseData: replaceData\r\n        };\r\n      }\r\n      return store;\r\n    });\r\n\r\n    // Update local findReplaceData immediately\r\n    this.findReplaceData = {\r\n      ...this.findReplaceData,\r\n      stores: updatedStores\r\n    };\r\n\r\n    // Update the data service\r\n    this.dataService.updateData({\r\n      stores: updatedStores\r\n    });\r\n\r\n    // Trigger save as draft\r\n    this.dataService.triggerSaveDraft();\r\n  }\r\n\r\n  updateAiResponseFixture(fixture: any) {\r\n    let matchFound = false;\r\n    for (let i = 0; i < this.floorData.layoutPolygon.length; i++) {\r\n      const element = this.floorData.layoutPolygon[i];\r\n      if (element.elementType === 'wall' && Array.isArray(element.fixtures)) {\r\n        for (let j = 0; j < element.fixtures.length; j++) {\r\n          const fx = element.fixtures[j];\r\n          if (fx._id === fixture._id) {\r\n            // Preserve existing vmConfig if the new fixture doesn't have it\r\n            const existingVmConfig = fx.vmConfig || [];\r\n            const updatedFixture = { \r\n              ...fixture,\r\n              // Preserve vmConfig from existing fixture if new fixture doesn't have it\r\n              vmConfig: fixture.vmConfig || existingVmConfig\r\n            };\r\n            this.floorData.layoutPolygon[i].fixtures[j] = updatedFixture;\r\n            matchFound = true;\r\n            this.selectedFixture = updatedFixture;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (matchFound) return;\r\n\r\n    for (let i = 0; i < this.floorData?.centerFixture.length; i++) {\r\n      const fx = this.floorData?.centerFixture[i];\r\n      if (fx._id === fixture._id) {\r\n        // Preserve existing vmConfig if the new fixture doesn't have it\r\n        const existingVmConfig = fx.vmConfig || [];\r\n        const updatedFixture = { \r\n          ...fixture,\r\n          // Preserve vmConfig from existing fixture if new fixture doesn't have it\r\n          vmConfig: fixture.vmConfig || existingVmConfig\r\n        };\r\n        this.floorData.centerFixture[i] = updatedFixture;\r\n        this.selectedFixture = updatedFixture;\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  highlightFixture(canvas: fabric.Canvas, group: any, blink: boolean = false) {\r\n    this.removeHighlight(canvas);\r\n    this.cancelHighlightBlink = false;\r\n\r\n    const center = group.getCenterPoint();\r\n    const realWidth = group.width! * group.scaleX!;\r\n    const realHeight = group.height! * group.scaleY!;\r\n\r\n    const rect = new fabric.Rect({\r\n      left: center.x,\r\n      top: center.y,\r\n      width: realWidth + 8,\r\n      height: realHeight + 8,\r\n      rx: 5,\r\n      ry: 5,\r\n      stroke: \"#00aaff\",\r\n      strokeWidth: 3,\r\n      fill: \"transparent\",\r\n      selectable: false,\r\n      evented: false,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      angle: group.angle || 0,\r\n      opacity: blink ? 0 : 1,\r\n    });\r\n\r\n    (rect as any).data = { type: \"fixture-highlight\" };\r\n    canvas.add(rect);\r\n    canvas.moveObjectTo(rect, canvas.getObjects().length - 1);\r\n    canvas.requestRenderAll();\r\n    this.activeHighlight = rect;\r\n\r\n    if (!blink) return;\r\n\r\n    let cycles = 0;\r\n    const blinkOnce = () => {\r\n      if (this.cancelHighlightBlink) {\r\n        this.removeHighlight(canvas);\r\n        return;\r\n      }\r\n      rect.animate({ opacity: 1 }, {\r\n        duration: 200,\r\n        onChange: () => canvas.requestRenderAll(),\r\n        onComplete: () => {\r\n          if (this.cancelHighlightBlink) {\r\n            this.removeHighlight(canvas);\r\n            return;\r\n          }\r\n          rect.animate({ opacity: 0 }, {\r\n            duration: 200,\r\n            onChange: () => canvas.requestRenderAll(),\r\n            onComplete: () => {\r\n              if (this.cancelHighlightBlink) {\r\n                this.removeHighlight(canvas);\r\n                return;\r\n              }\r\n              cycles++;\r\n              if (cycles < 20) {\r\n                blinkOnce();\r\n              } else {\r\n                if (!this.cancelHighlightBlink) {\r\n                  rect.set({ opacity: 1 });\r\n                  canvas.requestRenderAll();\r\n                }\r\n              }\r\n            },\r\n          });\r\n        },\r\n      });\r\n    };\r\n    blinkOnce();\r\n  }\r\n\r\n  removeHighlight(canvas: fabric.Canvas) {\r\n    this.cancelHighlightBlink = true;\r\n    canvas.getObjects().forEach((obj) => {\r\n      if ((obj as any).data?.type === \"fixture-highlight\") {\r\n        canvas.remove(obj);\r\n      }\r\n    });\r\n    this.activeHighlight = null;\r\n    canvas.requestRenderAll();\r\n  }\r\n\r\n  // Planogram rendering methods (simplified versions from collection-update-ai)\r\n  toPixels(value: number, unit: string, dpi = 2.8) {\r\n    let pixels: number;\r\n    if (unit === \"mm\") {\r\n      pixels = (value / 25.4) * dpi;\r\n    } else if (unit === \"ft\") {\r\n      pixels = value * 12 * dpi;\r\n    } else {\r\n      throw new Error(\"Unsupported unit. Use 'mm' or 'ft'.\");\r\n    }\r\n    return Number(pixels.toFixed(4));\r\n  }\r\n\r\n  async drawLayoutElements(canvas: fabric.Canvas) {\r\n    if (!this.floorData) return;\r\n    \r\n    for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {\r\n      const element = this.floorData.layoutPolygon[index];\r\n      let wall;\r\n\r\n      element.relativePosition ??= { x: 0, y: 0, unit: \"ft\" };\r\n      const x = this.toPixels(element.relativePosition.x, element.unit);\r\n      const y = this.toPixels(element.relativePosition.y, element.unit);\r\n\r\n      if (element.elementType === \"wall\") {\r\n        const height = this.wallThickness;\r\n        const width = this.toPixels(element.distance, element.unit);\r\n        wall = await this.drawWall(canvas, x, y, height, width, element);\r\n      } else if (element.elementType === \"entrance\") {\r\n        this.drawEntrance(canvas, x, y, 80, 75, 40, element);\r\n      }\r\n\r\n      if (element.elementType === \"wall\") {\r\n        const fixtureGroups: fabric.Group[] = [];\r\n        for (let j = 0; j < element?.fixtures?.length; j++) {\r\n          const fixture = element.fixtures[j];\r\n          const fx = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);\r\n          const fy = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);\r\n          const fh = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);\r\n          const fw = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);\r\n          const fixtureObj = await this.drawFixture(canvas, fx, fy, fh, fw, fixture);\r\n          fixtureGroups.push(fixtureObj as fabric.Group);\r\n        }\r\n\r\n        if (element.isLocked && wall) {\r\n          canvas.remove(wall);\r\n          fixtureGroups.forEach((f) => canvas.remove(f));\r\n          const combinedGroup = new fabric.Group([wall, ...fixtureGroups], {\r\n            hasControls: false,\r\n            selectable: false,\r\n            lockMovementX: true,\r\n            lockMovementY: true,\r\n            lockRotation: true,\r\n            lockScalingX: true,\r\n            lockScalingY: true,\r\n            subTargetCheck: true,\r\n          });\r\n          combinedGroup.set({ isLocked: true });\r\n          canvas.add(combinedGroup);\r\n        }\r\n\r\n        for (let j = 0; j < element?.otherElements?.length; j++) {\r\n          const otherElement = element.otherElements[j];\r\n          const ox = this.toPixels(otherElement.relativePosition.x, \"ft\");\r\n          const oy = this.toPixels(otherElement.relativePosition.y, \"ft\");\r\n          const oa = otherElement.relativePosition.angle;\r\n          const oh = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);\r\n          const ow = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);\r\n          this.drawOtherElementsWithLabel(canvas, ox, oy, oa, ow, oh, otherElement);\r\n        }\r\n      }\r\n    }\r\n\r\n    for (let i = 0; i < this.floorData?.centerFixture?.length; i++) {\r\n      const fixture = this.floorData.centerFixture[i];\r\n      const x = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);\r\n      const y = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);\r\n      const h = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);\r\n      const w = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);\r\n      await this.drawFixture(canvas, x, y, h, w, fixture);\r\n    }\r\n\r\n    for (let j = 0; j < this.floorData?.otherElements?.length; j++) {\r\n      const otherElement = this.floorData.otherElements[j];\r\n      const x = this.toPixels(otherElement.relativePosition.x, \"ft\");\r\n      const y = this.toPixels(otherElement.relativePosition.y, \"ft\");\r\n      const a = otherElement.relativePosition.angle;\r\n      const h = this.toPixels(otherElement.fixtureStaticLength.value, otherElement.fixtureStaticLength.unit);\r\n      const w = this.toPixels(otherElement.fixtureStaticWidth.value, otherElement.fixtureStaticWidth.unit);\r\n      this.drawOtherElementsWithLabel(canvas, x, y, a, w, h, otherElement);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  async drawWall(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    height: number,\r\n    width: number,\r\n    elementData: any\r\n  ) {\r\n    const radius = 5;\r\n    const fillColor = \"#F6FCFF\";\r\n    const strokeColor = \"#D0D5DD\";\r\n    const labelColor = \"#009BF3\";\r\n    let text = `${this.titleCase.transform(elementData.elementType)} ${elementData.elementNumber\r\n      }`;\r\n\r\n    const wall = new fabric.Rect({\r\n      left: 0,\r\n      top: 0,\r\n      width,\r\n      height,\r\n      rx: radius,\r\n      ry: radius,\r\n      fill: fillColor,\r\n      stroke: strokeColor,\r\n      strokeWidth: 0.27,\r\n      selectable: false,\r\n      strokeUniform: true,\r\n    });\r\n\r\n    const centerX = width / 2;\r\n    const centerY = height / 2;\r\n    const isVertical = height > width;\r\n\r\n    const label = new fabric.FabricText(text, {\r\n      left: centerX,\r\n      top: centerY,\r\n      fontSize: 10,\r\n      fontFamily: \"Inter\",\r\n      fontWeight: \"500\",\r\n      fill: labelColor,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      angle: isVertical ? -90 : 0,\r\n      selectable: false,\r\n    });\r\n\r\n    const arrowHead = 5;\r\n    const elements: fabric.Object[] = [wall, label];\r\n\r\n    if (isVertical) {\r\n      const textWidth = label.width || 0;\r\n      const topArrowY = 5;\r\n      const topArrowEndY = centerY - textWidth / 2 - 5;\r\n\r\n      if (topArrowEndY > topArrowY + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line([centerX, topArrowY, centerX, topArrowEndY], {\r\n            stroke: labelColor,\r\n            strokeWidth: 1,\r\n            selectable: false,\r\n          }),\r\n          new fabric.Triangle({\r\n            left: centerX,\r\n            top: topArrowY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: 0,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"bottom\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n\r\n      const bottomArrowStartY = centerY + textWidth / 2 + 5;\r\n      const bottomArrowEndY = height - 5;\r\n\r\n      if (bottomArrowEndY > bottomArrowStartY + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line(\r\n            [centerX, bottomArrowStartY, centerX, bottomArrowEndY],\r\n            {\r\n              stroke: labelColor,\r\n              strokeWidth: 1,\r\n              selectable: false,\r\n            }\r\n          ),\r\n          new fabric.Triangle({\r\n            left: centerX,\r\n            top: bottomArrowEndY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: 180,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"top\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n    } else {\r\n      const textWidth = label.width || 0;\r\n      const leftArrowStartX = 5;\r\n      const leftArrowEndX = centerX - textWidth / 2 - 5;\r\n\r\n      if (leftArrowEndX > leftArrowStartX + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line([leftArrowStartX, centerY, leftArrowEndX, centerY], {\r\n            stroke: labelColor,\r\n            strokeWidth: 1,\r\n            selectable: false,\r\n          }),\r\n          new fabric.Triangle({\r\n            left: leftArrowStartX,\r\n            top: centerY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: -90,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"center\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n\r\n      const rightArrowStartX = centerX + textWidth / 2 + 5;\r\n      const rightArrowEndX = width - 5;\r\n\r\n      if (rightArrowEndX > rightArrowStartX + arrowHead) {\r\n        elements.push(\r\n          new fabric.Line(\r\n            [rightArrowStartX, centerY, rightArrowEndX, centerY],\r\n            {\r\n              stroke: labelColor,\r\n              strokeWidth: 1,\r\n              selectable: false,\r\n            }\r\n          ),\r\n          new fabric.Triangle({\r\n            left: rightArrowEndX,\r\n            top: centerY,\r\n            width: arrowHead,\r\n            height: arrowHead,\r\n            angle: 90,\r\n            fill: labelColor,\r\n            originX: \"center\",\r\n            originY: \"center\",\r\n            selectable: false,\r\n          })\r\n        );\r\n      }\r\n    }\r\n\r\n\r\n    const group = new fabric.Group(elements, {\r\n      left: x,\r\n      top: y,\r\n      hasControls: false,\r\n      selectable: false,\r\n      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockRotation: true,\r\n      lockMovementX: true,\r\n      lockMovementY: true,\r\n      evented: true,\r\n      hoverCursor: \"default\",\r\n      angle: elementData.angle,\r\n      subTargetCheck: true,\r\n    }) as fabric.Group & {\r\n      objType: string;\r\n      data: any;\r\n    };\r\n\r\n    group.objType = elementData.elementType;\r\n    group.data = elementData;\r\n\r\n\r\n    canvas.add(group);\r\n\r\n    // If newly added, focus it once\r\n    if ((elementData as any)?.newAdded) {\r\n      try {\r\n        canvas.setActiveObject(group);\r\n        canvas.requestRenderAll();\r\n      } catch { }\r\n      delete (elementData as any).newAdded;\r\n    }\r\n\r\n    return group;\r\n  }\r\n\r\n  drawEntrance(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    width: number,\r\n    height: number,\r\n    arrowWidth: number,\r\n    elementData: any\r\n  ) {\r\n    const bodyWidth = width - arrowWidth;\r\n\r\n    const pathData = [\r\n      `M 0 0`,\r\n      `L ${bodyWidth} 0`,\r\n      `L ${bodyWidth} ${-height / 2}`,\r\n      `L ${width} ${height / 2}`,\r\n      `L ${bodyWidth} ${height + height / 2}`,\r\n      `L ${bodyWidth} ${height}`,\r\n      `L 0 ${height}`,\r\n      `Z`,\r\n    ].join(\" \");\r\n\r\n    const arrow = new fabric.Path(pathData, {\r\n      fill: \"#03A9F4\",\r\n      selectable: false,\r\n      evented: false,\r\n    });\r\n\r\n    const maxTextHeight = height - 6;\r\n    const text = new fabric.Text(\"Entrance\", {\r\n      fontFamily: \"Arial\",\r\n      fontWeight: \"bold\",\r\n      fill: \"white\",\r\n      angle: -90,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      left: 15,\r\n      top: height / 2,\r\n      fontSize: 20,\r\n      selectable: false,\r\n      evented: false,\r\n    });\r\n\r\n    const textBounds = text.getBoundingRect();\r\n    if (textBounds.height > maxTextHeight) {\r\n      const scale = maxTextHeight / textBounds.height;\r\n      text.set(\"fontSize\", text.fontSize! * scale);\r\n    }\r\n\r\n    const group = new fabric.Group([arrow, text], {\r\n      left: x,\r\n      top: y,\r\n      hasControls: false,\r\n      selectable: false,\r\n      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockScalingFlip: true,\r\n      lockRotation: true,\r\n      lockMovementX: true,\r\n      lockMovementY: true,\r\n      evented: true,\r\n      hoverCursor: \"default\",\r\n      angle: elementData.angle,\r\n    }) as fabric.Group & {\r\n      objType: string;\r\n      data: any;\r\n    };\r\n\r\n    group.objType = elementData.elementType;\r\n    group.data = elementData;\r\n\r\n    canvas.add(group);\r\n  }\r\n\r\n  async drawFixture(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    height: number,\r\n    width: number,\r\n    fixtureData: any\r\n  ) {\r\n    let fixtureColor: any;\r\n    // if ([\"fixture\", \"fixture-redo\"].includes(this.publishingState)) {\r\n    //   fixtureColor = {\r\n    //     primary:\r\n    //       fixtureData.status == \"\" && fixtureData.taskStatus == \"submit\"\r\n    //         ? \"#a5a6a8\"\r\n    //         : fixtureData.status == \"agree\"\r\n    //         ? \"#6CE9A6\"\r\n    //         : \"#51C1FF\",\r\n    //     fill:\r\n    //       fixtureData.status == \"\" && fixtureData.taskStatus == \"submit\"\r\n    //         ? \"#f3f4f8\"\r\n    //         : fixtureData.status == \"agree\"\r\n    //         ? \"#6CE9A6\"\r\n    //         : \"#EAF8FF\",\r\n    //     vmFill:\r\n    //       fixtureData.status == \"\" && fixtureData.taskStatus == \"submit\"\r\n    //         ? \"#a5a6a8\"\r\n    //         : \"#6938EF\",\r\n    //   };\r\n    // }\r\n    if (fixtureData.fixtureName === \"space\") return;\r\n    const radius = 5;\r\n    const mainContainer = new fabric.Rect({\r\n      left: x,\r\n      top: y,\r\n      width: width,\r\n      height: height,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n      strokeWidth: 0.27,\r\n      fill: \"white\",\r\n    });\r\n\r\n    const topWidth = width / 1.05;\r\n    const topHeight = (15 / 100) * height;\r\n    const topX = x + (width - topWidth) / 2;\r\n    const topY = y + this.verticalMargin;\r\n\r\n    const topContainer = new fabric.Rect({\r\n      left: topX,\r\n      top: topY,\r\n      width: topWidth,\r\n      height: topHeight,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n      strokeWidth: 0.27,\r\n      fill: \"white\",\r\n    });\r\n\r\n    const innerBoxHeight = topHeight / 2;\r\n    const innerTopBox = new fabric.Path(\r\n      `M ${topX + radius} ${topY} \r\n              L ${topX + topWidth - radius} ${topY} \r\n              Q ${topX + topWidth} ${topY} ${topX + topWidth} ${topY + radius} \r\n              L ${topX + topWidth} ${topY + innerBoxHeight} \r\n              L ${topX} ${topY + innerBoxHeight} \r\n              L ${topX} ${topY + radius} \r\n              Q ${topX} ${topY} ${topX + radius} ${topY} Z`,\r\n      {\r\n        stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n        strokeWidth: 0.27,\r\n        fill: \"transparent\",\r\n      }\r\n    );\r\n\r\n    const topText = new fabric.Textbox(\r\n      `Fixture ${fixtureData.associatedElementFixtureNumber\r\n        ? fixtureData.associatedElementFixtureNumber +\r\n        (fixtureData?.fixtureNumber\r\n          ? \" - FX-\" + fixtureData.fixtureNumber\r\n          : \"\")\r\n        : \"new\"\r\n      }`,\r\n      {\r\n        left: topX + topWidth / 2,\r\n        top: topY + innerBoxHeight / 2,\r\n        fontSize: 5,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"500\",\r\n        fill: \"#101828\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        width: topWidth,\r\n        height: innerBoxHeight,\r\n        textAlign: \"center\",\r\n      }\r\n    );\r\n\r\n    const secondBoxY = topY + innerBoxHeight;\r\n\r\n    const innerBottomBox = new fabric.Path(\r\n      `M ${topX} ${secondBoxY} \r\n          L ${topX + topWidth} ${secondBoxY} \r\n          L ${topX + topWidth} ${secondBoxY + innerBoxHeight - radius} \r\n          Q ${topX + topWidth} ${secondBoxY + innerBoxHeight} ${topX + topWidth - radius\r\n      } ${secondBoxY + innerBoxHeight} \r\n          L ${topX + radius} ${secondBoxY + innerBoxHeight} \r\n          Q ${topX} ${secondBoxY + innerBoxHeight} ${topX} ${secondBoxY + innerBoxHeight - radius\r\n      } \r\n          L ${topX} ${secondBoxY} Z`,\r\n      {\r\n        fill: \"#344054\",\r\n        stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n        strokeWidth: 0.27,\r\n      }\r\n    );\r\n\r\n    let fontSize = 5;\r\n    let bottomText;\r\n\r\n    const textContent = `${fixtureData?.fixtureName} - ${fixtureData?.fixtureWidth.value} ${fixtureData?.fixtureWidth.unit}`;\r\n\r\n    const createBottomText = (fs: any) =>\r\n      new fabric.Textbox(textContent, {\r\n        left: topX + topWidth / 2,\r\n        top: secondBoxY + innerBoxHeight / 2,\r\n        fontSize: fs,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"500\",\r\n        fill: \"#FFFFFF\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        textAlign: \"center\",\r\n        width: topWidth,\r\n      });\r\n\r\n    do {\r\n      bottomText = createBottomText(fontSize);\r\n      fontSize -= 0.5;\r\n    } while (bottomText.height > innerBoxHeight && fontSize > 2);\r\n\r\n    const midWidth = width / 1.05;\r\n    const midHeight = (77 / 100) * height;\r\n    const midX = x + (width - midWidth) / 2;\r\n    const midY = topY + topHeight + this.verticalMargin;\r\n\r\n    const midContainer = new fabric.Rect({\r\n      left: midX,\r\n      top: midY,\r\n      width: midWidth,\r\n      height: midHeight,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: fixtureColor?.primary ?? \"#51C1FF\",\r\n      strokeWidth: 0.27,\r\n      fill: \"white\",\r\n    });\r\n\r\n    const shelfCount = fixtureData.shelfConfig?.length;\r\n    const boxHeight = midHeight / (shelfCount + 2);\r\n    const firstBoxY = midY;\r\n\r\n    const firstBox = new fabric.Path(\r\n      `M ${midX + radius} ${firstBoxY} \r\n              L ${midX + midWidth - radius} ${firstBoxY} \r\n              Q ${midX + midWidth} ${firstBoxY} ${midX + midWidth} ${firstBoxY + radius\r\n      } \r\n              L ${midX + midWidth} ${firstBoxY + boxHeight} \r\n              L ${midX} ${firstBoxY + boxHeight} \r\n              L ${midX} ${firstBoxY + radius} \r\n              Q ${midX} ${firstBoxY} ${midX + radius} ${firstBoxY} Z`,\r\n      {\r\n        fill: fixtureColor?.fill\r\n          ? fixtureColor?.fill\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#EAF8FF\",\r\n        stroke: fixtureColor?.primary\r\n          ? fixtureColor?.primary\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#6BCAFF\",\r\n        strokeWidth: 0.27,\r\n      }\r\n    );\r\n\r\n    const firstBoxText = new fabric.Textbox(\r\n      `${fixtureData?.header?.label ? fixtureData.header.label : \"\"}`,\r\n      {\r\n        left: midX + midWidth / 2,\r\n        top: firstBoxY + boxHeight / 2,\r\n        fontSize: 7,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"600\",\r\n        fill: fixtureData.issue ? \"#fff\" : \"#101828\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        width: midWidth,\r\n        height: boxHeight,\r\n        textAlign: \"center\",\r\n      }\r\n    );\r\n\r\n    const shelves: fabric.Object[] = [];\r\n    const shelfHeight = midHeight - 2 * boxHeight;\r\n\r\n    if (fixtureData.productResolutionLevel === \"L1\") {\r\n      const boxY = firstBoxY + boxHeight;\r\n\r\n      const shelf = new fabric.Rect({\r\n        left: midX,\r\n        top: boxY,\r\n        width: midWidth,\r\n        height: shelfHeight,\r\n        // stroke: '#51C1FF',\r\n        stroke: fixtureColor?.primary\r\n          ? fixtureColor?.primary\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#51C1FF\",\r\n        strokeWidth: 0.27,\r\n        fill: \"white\",\r\n      });\r\n\r\n      const text = fixtureData?.productBrandName?.join(\" + \") || \"\";\r\n\r\n      // Wrap text within fixture width and shrink to fit vertical space\r\n      const maxTextWidth = midWidth * 0.9;\r\n      const maxTextHeight = shelfHeight * 0.8;\r\n      let fontSizeL1 = 6;\r\n\r\n      const createWrappedTextbox = (fs: number) =>\r\n        new fabric.Textbox(text, {\r\n          left: midX + midWidth / 2,\r\n          top: boxY + shelfHeight / 2,\r\n          originX: \"center\",\r\n          originY: \"center\",\r\n          width: maxTextWidth,\r\n          fontSize: fs,\r\n          fontFamily: \"Inter\",\r\n          fontWeight: \"500\",\r\n          textAlign: \"center\",\r\n          fill: \"#333\",\r\n          selectable: false,\r\n          evented: false,\r\n        });\r\n\r\n      let wrappedText = createWrappedTextbox(fontSizeL1);\r\n      while (wrappedText.height > maxTextHeight && fontSizeL1 > 2) {\r\n        fontSizeL1 -= 0.5;\r\n        wrappedText = createWrappedTextbox(fontSizeL1);\r\n      }\r\n\r\n      const padding = 2;\r\n      const background = new fabric.Rect({\r\n        left: midX + midWidth / 2,\r\n        top: boxY + shelfHeight / 2,\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        width: Math.min(maxTextWidth, wrappedText.width!) + padding,\r\n        height: wrappedText.getScaledHeight() + 2,\r\n        fill: \"rgba(255, 255, 255, 0.5)\",\r\n        selectable: false,\r\n        evented: false,\r\n        rx: 1,\r\n        ry: 1,\r\n      });\r\n\r\n      shelves.push(shelf, background, wrappedText);\r\n    } else if (fixtureData.productResolutionLevel === \"L2\") {\r\n      for (let i = 0; i < shelfCount; i++) {\r\n        const boxY = firstBoxY + boxHeight * (i + 1);\r\n\r\n        const shelf = new fabric.Rect({\r\n          left: midX,\r\n          top: boxY,\r\n          width: midWidth,\r\n          height: boxHeight,\r\n          stroke: fixtureColor?.primary\r\n            ? fixtureColor?.primary\r\n            : fixtureData.issue\r\n              ? \"#D92D20\"\r\n              : \"#51C1FF\",\r\n          strokeWidth: 0.27,\r\n          fill: \"white\",\r\n        });\r\n\r\n        shelves.push(shelf);\r\n\r\n        if (fixtureData.shelfConfig?.[i].shelfType === \"tray\") {\r\n          const trayRows = fixtureData.shelfConfig?.[i].trayRows || 1;\r\n          const rowSpacing = boxHeight / trayRows;\r\n\r\n          for (let r = 1; r < trayRows; r++) {\r\n            const lineY = boxY + r * rowSpacing;\r\n\r\n            const trayLine = new fabric.Line(\r\n              [midX, lineY, midX + midWidth, lineY],\r\n              {\r\n                stroke: \"#999\",\r\n                strokeWidth: 0.2,\r\n                selectable: false,\r\n                evented: false,\r\n              }\r\n            );\r\n\r\n            shelves.push(trayLine);\r\n          }\r\n        }\r\n\r\n        const text =\r\n          fixtureData.shelfConfig?.[i].productBrandName?.join(\" + \") || \"\";\r\n\r\n        // L2: Single-line ellipsis against full shelf width\r\n        const horizontalPadding = 6;\r\n        const maxTextWidth = Math.max(0, midWidth - horizontalPadding);\r\n        const maxTextHeight = boxHeight * 0.8;\r\n        const baseFontSize = 5;\r\n\r\n        const measure = (t: string) =>\r\n          new fabric.Text(t, {\r\n            fontSize: baseFontSize,\r\n            fontFamily: \"Inter\",\r\n            fontWeight: \"500\",\r\n          });\r\n\r\n        let displayText = text;\r\n        let measured = measure(displayText);\r\n\r\n        if ((measured.width ?? 0) > maxTextWidth) {\r\n          const ellipsis = \"...\";\r\n          let leftIdx = 0;\r\n          let rightIdx = text.length;\r\n\r\n          while (leftIdx < rightIdx) {\r\n            const midIdx = Math.floor((leftIdx + rightIdx) / 2);\r\n            const candidate = text.slice(0, midIdx) + ellipsis;\r\n            measured = measure(candidate);\r\n            if ((measured.width ?? 0) > maxTextWidth) {\r\n              rightIdx = midIdx;\r\n            } else {\r\n              leftIdx = midIdx + 1;\r\n            }\r\n          }\r\n          displayText = text.slice(0, Math.max(0, leftIdx - 1)) + ellipsis;\r\n          measured = measure(displayText);\r\n        }\r\n\r\n        const background = new fabric.Rect({\r\n          left: midX + midWidth / 2,\r\n          top: boxY + boxHeight / 2,\r\n          originX: \"center\",\r\n          originY: \"center\",\r\n          width: midWidth,\r\n          height: Math.min(maxTextHeight, measured.height ?? 10) + 2,\r\n          fill: \"rgba(255, 255, 255, 0.5)\",\r\n          selectable: false,\r\n          evented: false,\r\n          rx: 1,\r\n          ry: 1,\r\n        });\r\n\r\n        const finalText = new fabric.Text(displayText, {\r\n          left: midX + midWidth / 2,\r\n          top: boxY + boxHeight / 2,\r\n          originX: \"center\",\r\n          originY: \"center\",\r\n          fontSize: baseFontSize,\r\n          fontFamily: \"Inter\",\r\n          fontWeight: \"500\",\r\n          fill: \"#333\",\r\n          selectable: false,\r\n          evented: false,\r\n        });\r\n\r\n        shelves.push(background, finalText);\r\n      }\r\n    } else if (fixtureData.productResolutionLevel === \"L3\") {\r\n      const sequentialGroups: { zone: string; shelves: any[] }[] = [];\r\n\r\n      let previousZone: string | null = null;\r\n\r\n      for (const shelf of fixtureData.shelfConfig) {\r\n        const zone = shelf.zone || \"Unknown\";\r\n        if (zone !== previousZone) {\r\n          sequentialGroups.push({ zone, shelves: [shelf] });\r\n          previousZone = zone;\r\n        } else {\r\n          sequentialGroups[sequentialGroups.length - 1].shelves.push(shelf);\r\n        }\r\n      }\r\n\r\n      let currentShelfIndex = 0;\r\n\r\n      for (const group of sequentialGroups) {\r\n        const { zone, shelves: shelvesInGroup } = group;\r\n\r\n        const groupStartIndex = currentShelfIndex;\r\n        const groupLength = shelvesInGroup.length;\r\n\r\n        const groupTopY = firstBoxY + boxHeight * (groupStartIndex + 1);\r\n        const groupBottomY = groupTopY + boxHeight * groupLength;\r\n\r\n        for (let j = 0; j < shelvesInGroup.length; j++) {\r\n          const shelfData = shelvesInGroup[j];\r\n          const boxY = firstBoxY + boxHeight * (currentShelfIndex + 1);\r\n\r\n          const shelfRect = new fabric.Rect({\r\n            left: midX,\r\n            top: boxY,\r\n            width: midWidth,\r\n            height: boxHeight,\r\n            stroke: fixtureColor?.primary\r\n              ? fixtureColor?.primary\r\n              : fixtureData.issue\r\n                ? \"#D92D20\"\r\n                : \"#51C1FF\",\r\n            strokeWidth: 0.27,\r\n            fill: \"white\",\r\n          });\r\n\r\n          shelves.push(shelfRect);\r\n\r\n          if (shelfData.shelfType === \"tray\") {\r\n            const trayRows = shelfData.trayRows || 0;\r\n            const productPerShelf = shelfData.productPerShelf || 0;\r\n\r\n            const rowSpacing = boxHeight / trayRows;\r\n            const columnSpacing = midWidth / productPerShelf;\r\n\r\n            for (let r = 1; r < trayRows; r++) {\r\n              const lineY = boxY + r * rowSpacing;\r\n\r\n              const trayLine = new fabric.Line(\r\n                [midX, lineY, midX + midWidth, lineY],\r\n                {\r\n                  stroke: \"#999\",\r\n                  strokeWidth: 0.2,\r\n                  selectable: false,\r\n                  evented: false,\r\n                }\r\n              );\r\n\r\n              shelves.push(trayLine);\r\n            }\r\n\r\n            for (let c = 1; c < productPerShelf; c++) {\r\n              const lineX = midX + c * columnSpacing;\r\n\r\n              const verticalLine = new fabric.Line(\r\n                [lineX, boxY, lineX, boxY + boxHeight],\r\n                {\r\n                  stroke: \"#999\",\r\n                  strokeWidth: 0.2,\r\n                  selectable: false,\r\n                  evented: false,\r\n                }\r\n              );\r\n\r\n              shelves.push(verticalLine);\r\n            }\r\n          }\r\n\r\n          currentShelfIndex++;\r\n        }\r\n\r\n        const groupBottomLine = new fabric.Line(\r\n          [midX, groupBottomY, midX + midWidth, groupBottomY],\r\n          {\r\n            stroke: fixtureColor?.primary\r\n              ? fixtureColor?.primary\r\n              : fixtureData.issue\r\n                ? \"#D92D20\"\r\n                : \"#51C1FF\",\r\n            strokeWidth: 1,\r\n            selectable: false,\r\n            evented: false,\r\n          }\r\n        );\r\n\r\n        shelves.push(groupBottomLine);\r\n\r\n        if (fixtureData.fixtureType === \"wall\") {\r\n          const labelPadding = 2;\r\n          const labelText = new fabric.Textbox(zone, {\r\n            left: midX + midWidth - labelPadding,\r\n            top: groupBottomY,\r\n            fontSize: 5,\r\n            fontFamily: \"Inter\",\r\n            fontWeight: \"600\",\r\n            fill: \"#707070\",\r\n            originX: \"right\",\r\n            originY: \"bottom\",\r\n            width: midWidth / 2,\r\n            textAlign: \"right\",\r\n          });\r\n\r\n          shelves.push(labelText);\r\n        }\r\n\r\n        const groupCenterX = midX + midWidth / 2;\r\n        const groupCenterY = groupTopY + (groupBottomY - groupTopY) / 2;\r\n\r\n        const sectionBrands = new Set();\r\n\r\n        shelvesInGroup?.forEach((shelf) => {\r\n          shelf.productBrandName?.forEach((brand: string) => {\r\n            sectionBrands.add(brand);\r\n          });\r\n        });\r\n\r\n        if ([...sectionBrands].length) {\r\n          const text = [...sectionBrands].join(\" + \");\r\n          const padding = 2;\r\n          const maxTextWidth = midWidth;\r\n          const rectWidth = midWidth * 0.9;\r\n          const maxTextHeight = 20;\r\n\r\n          let fontSize = 6;\r\n          let wrappedText;\r\n\r\n          const createTextbox = (fs: any) => {\r\n            return new fabric.Textbox(text, {\r\n              fontSize: fs,\r\n              fontFamily: \"Inter\",\r\n              fontWeight: \"400\",\r\n              width: maxTextWidth,\r\n              textAlign: \"center\",\r\n              originX: \"center\",\r\n              originY: \"center\",\r\n              fill: \"#101828\",\r\n              selectable: false,\r\n              evented: false,\r\n              left: groupCenterX,\r\n              top: groupCenterY,\r\n            });\r\n          };\r\n\r\n          do {\r\n            wrappedText = createTextbox(fontSize);\r\n            fontSize -= 0.5;\r\n          } while (wrappedText.height > maxTextHeight && fontSize > 2);\r\n\r\n          const rectHeight = wrappedText.getScaledHeight() + padding;\r\n\r\n          const groupCenterText = new fabric.Rect({\r\n            left: groupCenterX,\r\n            top: groupCenterY,\r\n            originX: \"center\",\r\n            originY: \"center\",\r\n            width: rectWidth,\r\n            height: rectHeight,\r\n            fill: \"rgba(255, 255, 255, 0.5)\",\r\n            selectable: false,\r\n            evented: false,\r\n            rx: 1,\r\n            ry: 1,\r\n          });\r\n\r\n          shelves.push(groupCenterText, wrappedText);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (fixtureData?.vmConfig?.length) {\r\n      for (let i = 0; i < fixtureData.vmConfig.length; i++) {\r\n        const vm = fixtureData.vmConfig[i];\r\n\r\n        const startIndex = vm.startYPosition - 1;\r\n        const endIndex = vm.endYPosition - 1;\r\n\r\n        const shelfTopY = firstBoxY + boxHeight * (startIndex + 1);\r\n        const shelfHeightSpan = boxHeight * (endIndex - startIndex + 1);\r\n\r\n        let vmHeightPx: number = shelfHeightSpan;\r\n        let y: number = shelfTopY;\r\n\r\n        if (vm.yZone && vm.yZone !== \"stretch\") {\r\n          vmHeightPx = shelfHeightSpan / 3;\r\n\r\n          switch (vm.yZone) {\r\n            case \"top\":\r\n              y = shelfTopY;\r\n              break;\r\n            case \"middle\":\r\n              y = shelfTopY + vmHeightPx;\r\n              break;\r\n            case \"bottom\":\r\n              y = shelfTopY + 2 * vmHeightPx;\r\n              break;\r\n            default:\r\n              y = shelfTopY;\r\n          }\r\n        }\r\n\r\n        let x = midX;\r\n        let width = midWidth;\r\n\r\n        if (!vm.xZone || vm.xZone === \"stretch\") {\r\n          width = midWidth;\r\n          x = midX;\r\n        } else {\r\n          const sectionWidth = midWidth / 3;\r\n          switch (vm.xZone) {\r\n            case \"left\":\r\n              width = sectionWidth;\r\n              x = midX;\r\n              break;\r\n            case \"middle\":\r\n              width = sectionWidth;\r\n              x = midX + sectionWidth;\r\n              break;\r\n            case \"right\":\r\n              width = sectionWidth;\r\n              x = midX + 2 * sectionWidth;\r\n              break;\r\n            default:\r\n              width = midWidth;\r\n              x = midX;\r\n          }\r\n        }\r\n\r\n        if (vm.vmImageUrl) {\r\n          try {\r\n            const vmImage: any = await fabric.FabricImage.fromURL(\r\n              `${this.cdnUrl}${vm.vmImageUrl}?v=${Date.now()}`,\r\n              {\r\n                crossOrigin: \"anonymous\",\r\n              }\r\n            );\r\n\r\n            vmImage.set({\r\n              left: x + width / 2,\r\n              top: y + vmHeightPx / 2,\r\n              originX: \"center\",\r\n              originY: \"center\",\r\n              scaleX: width / vmImage.width!,\r\n              scaleY: vmHeightPx / vmImage.height!,\r\n              selectable: false,\r\n              evented: false,\r\n            });\r\n\r\n            shelves.push(vmImage);\r\n          } catch (err) {\r\n            console.error(`Error loading image for VM: ${vm.vmImageUrl}`, err);\r\n          }\r\n        } else {\r\n          const vmBox = new fabric.Rect({\r\n            left: x,\r\n            top: y,\r\n            width,\r\n            height: vmHeightPx,\r\n            fill: fixtureColor?.vmFill ?? \"#6938EF\",\r\n            selectable: false,\r\n            evented: false,\r\n          });\r\n\r\n          let fontSize = 5;\r\n          let vmText;\r\n\r\n          const createVmText = (fs: number) =>\r\n            new fabric.Textbox(vm.vmName || \"\", {\r\n              left: x + width / 2,\r\n              top: y + vmHeightPx / 2,\r\n              originX: \"center\",\r\n              originY: \"center\",\r\n              fontSize: fs,\r\n              fontFamily: \"Inter\",\r\n              fontWeight: \"600\",\r\n              fill: \"white\",\r\n              textAlign: \"center\",\r\n              width: width,\r\n              selectable: false,\r\n              evented: false,\r\n            });\r\n\r\n          do {\r\n            vmText = createVmText(fontSize);\r\n            fontSize -= 0.5;\r\n          } while (vmText.height > vmHeightPx && fontSize > 2);\r\n\r\n          shelves.push(vmBox, vmText);\r\n        }\r\n      }\r\n    }\r\n\r\n    const lastBoxY = firstBoxY + boxHeight * (shelfCount + 1);\r\n    const lastBox = new fabric.Path(\r\n      `M ${midX} ${lastBoxY} \r\n              L ${midX + midWidth} ${lastBoxY} \r\n              L ${midX + midWidth} ${lastBoxY + boxHeight - radius} \r\n              Q ${midX + midWidth} ${lastBoxY + boxHeight} ${midX + midWidth - radius\r\n      } ${lastBoxY + boxHeight} \r\n              L ${midX + radius} ${lastBoxY + boxHeight} \r\n              Q ${midX} ${lastBoxY + boxHeight} ${midX} ${lastBoxY + boxHeight - radius\r\n      } \r\n              L ${midX} ${lastBoxY} Z`,\r\n      {\r\n        fill: fixtureColor?.fill\r\n          ? fixtureColor?.fill\r\n          : fixtureData.issue\r\n            ? \"#FEE4E2\"\r\n            : \"#EAF8FF\",\r\n        stroke: fixtureColor?.primary\r\n          ? fixtureColor?.primary\r\n          : fixtureData.issue\r\n            ? \"#D92D20\"\r\n            : \"#6BCAFF\",\r\n        strokeWidth: 0.27,\r\n      }\r\n    );\r\n\r\n    const lastBoxText = new fabric.Textbox(\r\n      `${fixtureData?.footer?.label ? fixtureData.footer.label : \"\"}`,\r\n      {\r\n        left: midX + midWidth / 2,\r\n        top: lastBoxY + boxHeight / 2,\r\n        fontSize: 5,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"600\",\r\n        fill: \"#101828\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        textAlign: \"center\",\r\n        width: midWidth,\r\n        heigth: boxHeight,\r\n      }\r\n    );\r\n\r\n    const bottomWidth = width / 1.05;\r\n    const bottomHeight = (3 / 100) * height;\r\n    const bottomX = x + (width - bottomWidth) / 2;\r\n    const bottomY = midY + midHeight + this.verticalMargin;\r\n\r\n    const bottomContainer = new fabric.Rect({\r\n      left: bottomX,\r\n      top: bottomY,\r\n      width: bottomWidth,\r\n      height: bottomHeight,\r\n      rx: radius,\r\n      ry: radius,\r\n      stroke: \"transparent\",\r\n      fill: \"transparent\",\r\n    });\r\n\r\n    const bottomTextContent = new fabric.Textbox(\r\n      `Shelves - ${fixtureData.shelfConfig?.length} . Products -  ${fixtureData.fixtureCapacity} . VM - ${fixtureData.vmConfig?.length}`,\r\n      {\r\n        left: bottomX + bottomWidth / 2,\r\n        top: bottomY + bottomHeight / 2,\r\n        fontSize: 5,\r\n        fontFamily: \"Inter\",\r\n        fontWeight: \"500\",\r\n        fill: \"#333\",\r\n        originX: \"center\",\r\n        originY: \"center\",\r\n        textAlign: \"center\",\r\n        width: bottomWidth,\r\n        height: bottomHeight,\r\n      }\r\n    );\r\n\r\n\r\n    const fixtureGroup = new fabric.Group(\r\n      [\r\n        mainContainer,\r\n        topContainer,\r\n        innerTopBox,\r\n        topText,\r\n        innerBottomBox,\r\n        bottomText,\r\n        midContainer,\r\n        firstBox,\r\n        firstBoxText,\r\n        ...shelves,\r\n        lastBox,\r\n        lastBoxText,\r\n        bottomContainer,\r\n        bottomTextContent,\r\n      ],\r\n      {\r\n        left: x,\r\n        top: y,\r\n        evented: true,\r\n        selectable: false,\r\n        hoverCursor: \"default\",\r\n        lockScalingX: true,\r\n        lockScalingY: true,\r\n        lockMovementX: true,\r\n        lockMovementY: true,\r\n        lockRotation: true,\r\n        hasControls: false,\r\n        subTargetCheck: true,\r\n        angle: fixtureData.relativePosition?.angle ?? 0,\r\n      }\r\n    ) as fabric.Group & {\r\n      wallIndex: number;\r\n      fixtureIndex: number;\r\n      fixtureId: string;\r\n      fixtureType: \"wall\" | \"floor\";\r\n      issue: boolean;\r\n      issueData: any;\r\n      taskType: string;\r\n      vmConfig: [];\r\n      objType: string;\r\n    };\r\n\r\n\r\n\r\n    fixtureGroup.fixtureType = fixtureData.fixtureType;\r\n    fixtureGroup.wallIndex = fixtureData.associatedElementNumber;\r\n    fixtureGroup.fixtureIndex = fixtureData.associatedElementFixtureNumber;\r\n    fixtureGroup.fixtureId = fixtureData._id;\r\n    fixtureGroup.issue = fixtureData.issue;\r\n    fixtureGroup.issueData = fixtureData.issueData;\r\n    fixtureGroup.taskType = fixtureData.taskType;\r\n    fixtureGroup.vmConfig = fixtureData.vmConfig;\r\n    fixtureGroup.objType = \"fixture\";\r\n\r\n    // Add click handler directly on the fixture group\r\n    fixtureGroup.on(\"mousedown\", (event: any) => {\r\n      // Use the fixture group itself (which has all the fixture properties)\r\n      // The event.target might be a child element, so we use fixtureGroup directly\r\n      if (fixtureGroup && (fixtureGroup as any).fixtureId) {\r\n        this.onFixtureClick(fixtureGroup);\r\n      }\r\n    });\r\n\r\n    canvas.add(fixtureGroup);\r\n\r\n    // If newly added, focus it once\r\n    if ((fixtureData as any)?.newAdded) {\r\n      try {\r\n        canvas.setActiveObject(fixtureGroup);\r\n        canvas.requestRenderAll();\r\n      } catch { }\r\n      delete (fixtureData as any).newAdded;\r\n    }\r\n\r\n    return fixtureGroup;\r\n  }\r\n\r\n  drawOtherElementsWithLabel(\r\n    canvas: fabric.Canvas,\r\n    x: number,\r\n    y: number,\r\n    a: number,\r\n    width: number,\r\n    height: number,\r\n    element: any\r\n  ): fabric.Group {\r\n    const rect = new fabric.Rect({\r\n      width,\r\n      height,\r\n      rx: 2,\r\n      ry: 2,\r\n      fill: \"#DAF1FF\",\r\n      stroke: \"#6BCAFF\",\r\n      strokeWidth: 2,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n    });\r\n\r\n    const text = new fabric.Textbox(element.fixtureName, {\r\n      width: width - 8,\r\n      fontSize: 14,\r\n      fontFamily: \"Inter\",\r\n      fontWeight: \"500\",\r\n      fill: \"#101828\",\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      textAlign: \"center\",\r\n      editable: false,\r\n      splitByGrapheme: true,\r\n    });\r\n\r\n    const textBounds = text.getBoundingRect();\r\n\r\n    if (textBounds.height > height - 8) {\r\n      const scale = (height - 8) / textBounds.height;\r\n      text.set(\"fontSize\", text.fontSize! * scale);\r\n    }\r\n\r\n    const group = new fabric.Group([rect, text], {\r\n      left: x,\r\n      top: y,\r\n      angle: a,\r\n      originX: \"center\",\r\n      originY: \"center\",\r\n      hasControls: false,\r\n      selectable: false,\r\n      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockRotation: true,\r\n      lockMovementX: true,\r\n      lockMovementY: true,\r\n      evented: true,\r\n      hoverCursor: \"default\",\r\n    }) as fabric.Group & {\r\n      objType: string;\r\n      data: any;\r\n    };\r\n\r\n    group.objType = \"others\";\r\n    group.data = element;\r\n\r\n    canvas.add(group);\r\n\r\n    if ((element as any)?.newAdded) {\r\n      try {\r\n        canvas.setActiveObject(group);\r\n        canvas.requestRenderAll();\r\n      } catch { }\r\n      delete (element as any).newAdded;\r\n    }\r\n\r\n    return group;\r\n  }\r\n\r\n  collectAllFixtures(): void {\r\n    this.allFixtureInstances = [];\r\n    \r\n    // Collect wall fixtures\r\n    if (this.floorData?.layoutPolygon) {\r\n      for (const element of this.floorData.layoutPolygon) {\r\n        if (element.fixtures && Array.isArray(element.fixtures)) {\r\n          this.allFixtureInstances.push(...element.fixtures);\r\n        }\r\n      }\r\n    }\r\n    \r\n    // Collect floor fixtures\r\n    if (this.floorData?.centerFixture && Array.isArray(this.floorData.centerFixture)) {\r\n      this.allFixtureInstances.push(...this.floorData.centerFixture);\r\n    }\r\n  }\r\n\r\n  onFixtureClick(target: any): void {\r\n    if (!target || !this.floorData) return;\r\n    \r\n    const fixtureId = (target as any).fixtureId;\r\n    const fixtureType = (target as any).fixtureType;\r\n    \r\n    if (!fixtureId) {\r\n      console.warn('Fixture click: No fixtureId found on target', target);\r\n      return;\r\n    }\r\n    \r\n    // Find the fixture data\r\n    let fixtureData: any = null;\r\n    \r\n    if (fixtureType === \"wall\") {\r\n      const wallIndex = (target as any).wallIndex;\r\n      \r\n      if (this.floorData.layoutPolygon && wallIndex !== undefined && wallIndex !== null) {\r\n        // Find wall by elementNumber (wallIndex is the elementNumber)\r\n        const wall = this.floorData.layoutPolygon.find(\r\n          (w: any) => w.elementNumber === wallIndex\r\n        );\r\n        if (wall && wall.fixtures) {\r\n          // Always use fixtureId to find the fixture (more reliable than index-based lookup)\r\n          fixtureData = wall.fixtures.find((f: any) => f._id === fixtureId);\r\n        }\r\n      }\r\n    } else if (fixtureType === \"floor\") {\r\n      fixtureData = this.floorData.centerFixture?.find((f: any) => f._id === fixtureId);\r\n    }\r\n    \r\n    if (!fixtureData) {\r\n      console.warn('Fixture click: Fixture data not found', { \r\n        fixtureId, \r\n        fixtureType, \r\n        wallIndex: (target as any).wallIndex, \r\n        fixtureIndex: (target as any).fixtureIndex,\r\n        floorData: this.floorData \r\n      });\r\n      return;\r\n    }\r\n    \r\n    // Ensure vmConfig is always an array (even if empty) to avoid display issues\r\n    // Handle cases where vmConfig might be null, undefined, or not an array\r\n    if (!Array.isArray(fixtureData.vmConfig)) {\r\n      fixtureData.vmConfig = [];\r\n    }\r\n    \r\n    // Create a deep clone to ensure change detection works\r\n    const clonedData = structuredClone(fixtureData);\r\n    \r\n    this.selectedFixture = {\r\n      fixtureId: fixtureId,\r\n      fixtureType: fixtureType,\r\n      wallIndex: (target as any).wallIndex,\r\n      fixtureIndex: (target as any).fixtureIndex,\r\n    };\r\n    \r\n    // Check if this fixture has replaceResponseData (for before/after comparison)\r\n    const store = this.findReplaceData?.stores?.find(\r\n      (s: Store) => s.storeName === this.selectedStoreForPreview?.storeName\r\n    );\r\n    \r\n    // If this fixture matches the findResponseData and has replaceResponseData,\r\n    // restore the original fixture data for before/after comparison\r\n    if (store?.findResponseData === fixtureId && store?.replaceResponseData) {\r\n      // Restore originalFixtureData from the map (persists even when clicking other fixtures)\r\n      const storedOriginal = this.originalFixturesMap.get(fixtureId);\r\n      if (storedOriginal) {\r\n        this.originalFixtureData = structuredClone(storedOriginal);\r\n      } else {\r\n        // If not in map (shouldn't happen if applyStoredResponseData ran), \r\n        // use current fixture as fallback\r\n        this.originalFixtureData = structuredClone(clonedData);\r\n      }\r\n    } else {\r\n      // No replace data for this fixture, clear original\r\n      this.originalFixtureData = null;\r\n    }\r\n    \r\n    // Force change detection by creating a new object reference\r\n    this.selectedFixtureData = null;\r\n    this.cdr.detectChanges();\r\n    \r\n    setTimeout(() => {\r\n      this.selectedFixtureData = clonedData;\r\n      this.isRightPanelCollapsed = false;\r\n      this.cdr.detectChanges();\r\n      \r\n      // Re-center planogram when panel opens (similar to manage-planogram)\r\n      setTimeout(() => {\r\n        if (this.previewCanvas && this.previewCanvasContainerRef?.nativeElement) {\r\n          this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);\r\n          this.fitCanvasToLayoutAnimated(this.previewCanvas);\r\n        }\r\n      }, 400);\r\n    }, 0);\r\n  }\r\n\r\n  toggleRightPanel(): void {\r\n    this.isRightPanelCollapsed = !this.isRightPanelCollapsed;\r\n    \r\n    // Resize canvas when panel is toggled\r\n    setTimeout(() => {\r\n      if (this.previewCanvas && this.previewCanvasContainerRef?.nativeElement) {\r\n        this.resizeCanvas(this.previewCanvas, this.previewCanvasContainerRef);\r\n        this.fitCanvasToLayoutAnimated(this.previewCanvas);\r\n      }\r\n    }, 400);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    if (this.previewCanvas) {\r\n      this.previewCanvas.dispose();\r\n    }\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n  }\r\n}\r\n","<div class=\"main-card\">\r\n    <form>\r\n        <!-- Section 1: Add Stores -->\r\n        <div class=\"section-row\">\r\n            <div class=\"section-number\">1</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Add stores</h2>\r\n                <div class=\"store-input-wrapper\">\r\n                   <div class=\"store-dropdown\">\r\n                        <lib-reactive-select\r\n                            [idField]=\"'value'\"\r\n                            [nameField]=\"'label'\"\r\n                            [data]=\"searchModes\"\r\n                            [formControl]=\"selectedMode\" \r\n                            >\r\n                        </lib-reactive-select>\r\n                    </div> \r\n                    <lib-store-select \r\n                        [options]=\"storeOptions\"\r\n                        [initialSelected]=\"selectedStores\"\r\n                        (selectedChange)=\"onStoresSelected($event)\">\r\n                    </lib-store-select>\r\n                    <button class=\"btn-apply\" type=\"button\" (click)=\"onApply()\" [disabled]=\"loading || findLoading || replaceLoading || savingDraft\">\r\n                        {{ savingDraft ? 'Saving...' : 'Apply' }}\r\n                    </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Section 2: Choose Target -->\r\n        <div class=\"section-row\" *ngIf=\"hasStores\">\r\n            <div class=\"section-number\">2</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Choose target</h2>\r\n                <div class=\"target-buttons\">\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'both'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"both\" [formControl]=\"target\">\r\n                        Both\r\n                    </label>\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'merch'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"merch\" [formControl]=\"target\">\r\n                        Merchandise\r\n                    </label>\r\n                    <label class=\"target-btn\" [class.active]=\"target.value === 'vm'\">\r\n                        <input type=\"radio\" name=\"target\" value=\"vm\" [formControl]=\"target\">\r\n                        Visual Merchandise\r\n                    </label>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Section 3: Find and Replace -->\r\n        <div class=\"section-row\" *ngIf=\"hasStores\">\r\n            <div class=\"section-number\">3</div>\r\n            <div class=\"section-content\">\r\n                <h2 class=\"section-title\">Provide an instruction to find and replace in the selected store</h2>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Find and Replace Inputs -->\r\n        <div class=\"find-replace-wrapper\" *ngIf=\"hasStores\">\r\n            <div class=\"find-replace-box\">\r\n                <label class=\"find-replace-label\">Target</label>\r\n                <div class=\"find-replace-input\">\r\n                    <textarea \r\n                        placeholder=\"Instruct what to find it in the selected store\"\r\n                        [formControl]=\"findPrompt\"></textarea>\r\n                    <div class=\"input-btn-container\">\r\n                        <button \r\n                            class=\"btn-find\" \r\n                            type=\"button\"\r\n                            (click)=\"onFind()\"\r\n                            [disabled]=\"findLoading || replaceLoading || !selectedStoreForPreview\">\r\n                            {{ findLoading ? 'Processing...' : 'Find' }}\r\n                        </button>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n            \r\n            <div class=\"arrow-icon\">\r\n                <svg width=\"27\" height=\"15\" viewBox=\"0 0 27 15\" fill=\"none\">\r\n                    <path d=\"M26.7071 8.07107C27.0976 7.68054 27.0976 7.04738 26.7071 6.65685L20.3431 0.292893C19.9526 -0.097631 19.3195 -0.097631 18.9289 0.292893C18.5384 0.683418 18.5384 1.31658 18.9289 1.70711L24.5858 7.36396L18.9289 13.0208C18.5384 13.4113 18.5384 14.0445 18.9289 14.435C19.3195 14.8256 19.9526 14.8256 20.3431 14.435L26.7071 8.07107ZM0 7.36396V8.36396H26V7.36396V6.36396H0V7.36396Z\" fill=\"#98A2B3\"/>\r\n                </svg>\r\n            </div>\r\n            \r\n            <div class=\"find-replace-box\">\r\n                <label class=\"find-replace-label\">Change</label>\r\n                <div class=\"find-replace-input\">\r\n                    <textarea \r\n                        placeholder=\"Type what would you like to replace in the selected fixture\"\r\n                        [formControl]=\"replacePrompt\"></textarea>\r\n                    <div class=\"input-btn-container\">\r\n                        <button \r\n                            class=\"btn-replace\" \r\n                            type=\"button\"\r\n                            (click)=\"onReplace()\"\r\n                            [disabled]=\"!findPrompt.value || !replacePrompt.value || findLoading || replaceLoading || !getCurrentStoreFindResponseData()\">\r\n                            {{ replaceLoading ? 'Processing...' : 'Replace' }}\r\n                        </button>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        \r\n        <!-- Preview Section -->\r\n        <div class=\"preview-wrapper\" *ngIf=\"hasStores\">\r\n            <div class=\"row g-0 preview-layout\">\r\n                <!-- Left Column: Canvas -->\r\n                <div class=\"col\" [ngClass]=\"{ \r\n                    'col-6': !isRightPanelCollapsed && selectedFixtureData && originalFixtureData,\r\n                    'col-9': !isRightPanelCollapsed && selectedFixtureData && !originalFixtureData, \r\n                    'col-12': isRightPanelCollapsed || !selectedFixtureData \r\n                }\">\r\n                    <div class=\"d-flex align-items-start gap-3 mb-3\">\r\n                        <!-- Store Dropdown -->\r\n                        <lib-store-dropdown \r\n                            *ngIf=\"hasStores && storeDropdownItems.length > 0\"\r\n                            [items]=\"storeDropdownItems\"\r\n                            [idField]=\"'storeId'\"\r\n                            [searchField]=\"'storeName'\"\r\n                            [multi]=\"false\"\r\n                            [selectedValues]=\"selectedStoreValues\"\r\n                            (selected)=\"onStoreSelectedForPreview($event)\">\r\n                        </lib-store-dropdown>\r\n                        \r\n                        <!-- Content Area -->\r\n                        <div class=\"flex-grow-1\">\r\n                            <!-- Preview Title -->\r\n                            <p class=\"fw-semibold mb-1\" style=\"font-size: 14px; color: #1d2939;\">\r\n                                Preview \r\n                                <span *ngIf=\"getStoreCount() > 0\" style=\"font-weight: 400; color: #667085;\">\r\n                                    ({{ getStoreCount() }} {{ getStoreCount() === 1 ? 'Store' : 'Stores' }})\r\n                                </span>\r\n                            </p>\r\n                            \r\n                            <!-- Description -->\r\n                            <p class=\"mb-0\" style=\"font-size: 14px; color: #475467;\">Check if the prompt fit into the expected results in order to proceed to review and approve</p>\r\n                        </div>\r\n                    </div>\r\n\r\n                    <!-- Canvas Container -->\r\n                    <div class=\"canvas-container\" #previewCanvasContainer *ngIf=\"selectedStoreForPreview\">\r\n                        <div class=\"canvas-loading\" *ngIf=\"canvasLoading\">\r\n                            <div class=\"spinner-border text-primary\" role=\"status\">\r\n                                <span class=\"visually-hidden\">Loading...</span>\r\n                            </div>\r\n                        </div>\r\n                        <canvas #previewCanvas></canvas>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Right Column: Fixture Preview -->\r\n                <div class=\"fixture-preview-panel\" \r\n                     *ngIf=\"selectedFixtureData && !isRightPanelCollapsed\"\r\n                     [ngClass]=\"{ 'col-6': originalFixtureData, 'col-3': !originalFixtureData }\"\r\n                     [style.min-width]=\"originalFixtureData ? '680px' : '340px'\">\r\n                    <div class=\"s-card\">\r\n                        <!-- Panel Header -->\r\n                        <div class=\"fixture-preview-header\">\r\n                            <div class=\"header-card\">\r\n                                <div class=\"card-content\">\r\n                                    <!-- <div class=\"product-image-container\">\r\n                                        <img \r\n                                            alt=\"Product\" \r\n                                            class=\"product-image\"\r\n                                        />\r\n                                    </div> -->\r\n                                    <div class=\"name\">{{ getFixtureLabel() }}</div>\r\n                                    <div class=\"specs-container\" *ngIf=\"getFixtureCategory() || getFixtureWidth() || getShelfCount() > 0 || getFixtureCapacity() > 0\">\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureCategory()\">{{ getFixtureCategory() }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getFixtureCategory() && (getFixtureWidth() || getShelfCount() > 0 || getFixtureCapacity() > 0)\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureWidth()\">{{ getFixtureWidth() }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getFixtureWidth() && (getShelfCount() > 0 || getFixtureCapacity() > 0)\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getShelfCount() > 0\">{{ getShelfCount() }} {{ getShelfCount() === 1 ? 'Shelf' : 'Shelves' }}</span>\r\n                                        <div class=\"dot\" *ngIf=\"getShelfCount() > 0 && getFixtureCapacity() > 0\"></div>\r\n                                        <span class=\"spec-text\" *ngIf=\"getFixtureCapacity() > 0\">{{ getFixtureCapacity() }} Capacity</span>\r\n                                    </div>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n\r\n                        <!-- Fixture Component -->\r\n                        <div class=\"fixture-preview-content\">\r\n                            <!-- Show Before/After when replace data exists -->\r\n                            <div *ngIf=\"originalFixtureData\" class=\"before-after-container\">\r\n                                <div class=\"before-section\">\r\n                                    <div class=\"section-header\">\r\n                                        <h6 class=\"section-label mb-0\">Before</h6>\r\n                                    </div>\r\n                                    <div class=\"fixture-wrapper\">\r\n                                        <lib-store-fixture \r\n                                            [fixture]=\"originalFixtureData\" \r\n                                            [showColors]=\"true\"\r\n                                            [showVMs]=\"true\"\r\n                                            [showBCs]=\"true\">\r\n                                        </lib-store-fixture>\r\n                                    </div>\r\n                                </div>\r\n                                <div class=\"after-section\">\r\n                                    <div class=\"section-header\">\r\n                                        <h6 class=\"section-label mb-0\">After</h6>\r\n                                    </div>\r\n                                    <div class=\"fixture-wrapper\">\r\n                                        <lib-store-fixture \r\n                                            [fixture]=\"selectedFixtureData\" \r\n                                            [showColors]=\"true\"\r\n                                            [showVMs]=\"true\"\r\n                                            [showBCs]=\"true\">\r\n                                        </lib-store-fixture>\r\n                                    </div>\r\n                                </div>\r\n                            </div>\r\n                            \r\n                            <!-- Show single fixture when no replace data -->\r\n                            <div *ngIf=\"!originalFixtureData\" class=\"single-fixture-container\">\r\n                                <div class=\"fixture-wrapper\">\r\n                                    <lib-store-fixture \r\n                                        [fixture]=\"selectedFixtureData\" \r\n                                        [showColors]=\"true\"\r\n                                        [showVMs]=\"true\"\r\n                                        [showBCs]=\"true\">\r\n                                    </lib-store-fixture>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n\r\n                <!-- Collapse Button -->\r\n                <div class=\"collapse-handler right\" \r\n                     *ngIf=\"selectedFixtureData\"\r\n                     (click)=\"toggleRightPanel()\">\r\n                    <svg *ngIf=\"isRightPanelCollapsed\" xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\"\r\n                        viewBox=\"0 0 18 18\" fill=\"none\">\r\n                        <path d=\"M8.27308 12.636L4.63672 8.99964L8.27308 5.36328M13.364 12.636L9.72763 8.99964L13.364 5.36328\"\r\n                            stroke=\"#101828\" stroke-width=\"1.45455\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg>\r\n                    <svg *ngIf=\"!isRightPanelCollapsed\" xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\"\r\n                        viewBox=\"0 0 18 18\" fill=\"none\">\r\n                        <path d=\"M9.72692 5.36399L13.3633 9.00036L9.72692 12.6367M4.63601 5.36399L8.27237 9.00036L4.63601 12.6367\"\r\n                            stroke=\"#101828\" stroke-width=\"1.45455\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg>\r\n                </div>\r\n            </div>\r\n        </div>\r\n        <!-- No Preview Section -->\r\n        <div class=\"no-preview\" *ngIf=\"hasStores && !selectedStoreForPreview\">\r\n            <div >\r\n                <svg width=\"315\" height=\"155\" viewBox=\"0 0 315 155\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                    <path d=\"M103.81 47.0195C89.5463 47.0197 77.9834 58.5824 77.9834 72.8457C77.9834 78.7617 73.9803 85.5059 68.0643 85.5059H45.2588C30.9953 85.5059 19.4316 97.0686 19.4316 111.332C19.4316 125.596 30.9953 137.158 45.2588 137.158H183.357C200.248 137.158 216.32 123.992 233.21 123.992H299.245C304 123.992 307.854 120.137 307.854 115.383C307.853 110.629 303.999 106.774 299.245 106.774H211.625C209.98 106.774 208.588 105.553 208.12 103.976C207.381 101.486 209.082 98.6719 211.679 98.6719H241.909C256.172 98.6717 267.735 87.109 267.735 72.8457C267.735 58.5824 256.172 47.0198 241.909 47.0195H103.81Z\" fill=\"#EAECF0\"/>\r\n                    <rect width=\"240.694\" height=\"16.9956\" rx=\"8.4978\" transform=\"matrix(-1 0 0 1 246.603 48.8574)\" fill=\"#EAECF0\"/>\r\n                    <circle cx=\"5.42147\" cy=\"5.42147\" r=\"5.42147\" transform=\"matrix(-1 0 0 1 56.2979 113.281)\" fill=\"#6BCAFF\"/>\r\n                    <circle cx=\"3.25288\" cy=\"3.25288\" r=\"3.25288\" transform=\"matrix(-1 0 0 1 244.965 68.8262)\" fill=\"#00A3FF\"/>\r\n                    <circle cx=\"3.25288\" cy=\"3.25288\" r=\"3.25288\" transform=\"matrix(-1 0 0 1 215.689 13.5273)\" fill=\"#00A3FF\"/>\r\n                    <circle cx=\"2.16859\" cy=\"2.16859\" r=\"2.16859\" transform=\"matrix(-1 0 0 1 104.006 138.221)\" fill=\"#00A3FF\"/>\r\n                    <rect x=\"68.501\" y=\"44.1523\" width=\"166.999\" height=\"97.9371\" rx=\"15.1015\" fill=\"#6BCAFF\" stroke=\"#00A3FF\" stroke-width=\"3\"/>\r\n                    <mask id=\"path-8-inside-1_936_150383\" fill=\"white\">\r\n                    <path d=\"M93.1172 19C94.0625 19 94.9892 19.0828 95.8887 19.2422V116.784C94.9892 116.625 94.0625 116.542 93.1172 116.542H82.7744C74.0642 116.542 67.0031 123.603 67.0029 132.313V34.7715C67.0029 26.0612 74.0641 19 82.7744 19H93.1172Z\"/>\r\n                    </mask>\r\n                    <path d=\"M93.1172 19C94.0625 19 94.9892 19.0828 95.8887 19.2422V116.784C94.9892 116.625 94.0625 116.542 93.1172 116.542H82.7744C74.0642 116.542 67.0031 123.603 67.0029 132.313V34.7715C67.0029 26.0612 74.0641 19 82.7744 19H93.1172Z\" fill=\"#6BCAFF\"/>\r\n                    <path d=\"M93.1172 19L93.1173 16H93.1172V19ZM95.8887 19.2422H98.8887V16.7271L96.4122 16.2882L95.8887 19.2422ZM95.8887 116.784L95.3651 119.738L98.8887 120.363V116.784H95.8887ZM93.1172 116.542L93.1173 113.542H93.1172V116.542ZM67.0029 132.313H64.0029L70.0029 132.314L67.0029 132.313ZM93.1172 19L93.1171 22C93.8872 22 94.6387 22.0674 95.3651 22.1961L95.8887 19.2422L96.4122 16.2882C95.3396 16.0981 94.2377 16 93.1173 16L93.1172 19ZM95.8887 19.2422H92.8887V116.784H95.8887H98.8887V19.2422H95.8887ZM95.8887 116.784L96.4122 113.83C95.3396 113.64 94.2377 113.542 93.1173 113.542L93.1172 116.542L93.1171 119.542C93.8872 119.542 94.6387 119.609 95.3651 119.738L95.8887 116.784ZM93.1172 116.542V113.542H82.7744V116.542V119.542H93.1172V116.542ZM82.7744 116.542V113.542C72.4073 113.542 64.0032 121.947 64.0029 132.313L67.0029 132.313L70.0029 132.314C70.0031 125.26 75.7212 119.542 82.7744 119.542V116.542ZM67.0029 132.313H70.0029V34.7715H67.0029H64.0029V132.313H67.0029ZM67.0029 34.7715H70.0029C70.0029 27.718 75.721 22 82.7744 22V19V16C72.4072 16 64.0029 24.4043 64.0029 34.7715H67.0029ZM82.7744 19V22H93.1172V19V16H82.7744V19Z\" fill=\"#00A3FF\" mask=\"url(#path-8-inside-1_936_150383)\"/>\r\n                    <line x1=\"76.9619\" y1=\"42.6523\" x2=\"76.9619\" y2=\"84.4881\" stroke=\"#99DAFF\" stroke-width=\"3.98436\" stroke-linecap=\"round\"/>\r\n                    <circle cx=\"218.206\" cy=\"70.1755\" r=\"3.29663\" fill=\"white\"/>\r\n                    <circle cx=\"111.787\" cy=\"55.167\" r=\"2.52637\" fill=\"#99DAFF\"/>\r\n                    <circle cx=\"99.3845\" cy=\"124.986\" r=\"3.44505\" fill=\"white\"/>\r\n                    <path d=\"M135.529 33.4717C151.285 24.3749 171.432 29.7732 180.529 45.5293C188.56 59.4398 185.291 76.7707 173.573 86.9004L193.457 121.339C194.932 123.894 194.056 127.161 191.501 128.636C188.946 130.111 185.679 129.236 184.204 126.681L164.466 92.4932C149.447 98.6552 131.814 92.92 123.472 78.4717C114.375 62.7156 119.773 42.5685 135.529 33.4717ZM172.698 50.0518C166.099 38.6209 151.482 34.7041 140.051 41.3037C128.62 47.9035 124.703 62.5204 131.303 73.9512C137.902 85.3817 152.519 89.2977 163.95 82.6982C175.381 76.0987 179.297 61.4826 172.698 50.0518Z\" fill=\"white\"/>\r\n                    <circle cx=\"153.001\" cy=\"57.0017\" r=\"23.8994\" transform=\"rotate(-30 153.001 57.0017)\" fill=\"#99DAFF\"/>\r\n                    <mask id=\"path-16-inside-2_936_150383\" fill=\"white\">\r\n                    <path d=\"M153.384 40.9957C153.435 39.7001 152.423 38.5927 151.131 38.7095C148.858 38.9151 146.636 39.5491 144.586 40.5854C141.835 41.976 139.484 44.045 137.755 46.597C136.026 49.149 134.977 52.0996 134.706 55.1701C134.504 57.4583 134.739 59.7568 135.391 61.9447C135.762 63.1872 137.166 63.7169 138.35 63.1891C139.534 62.6612 140.044 61.2746 139.73 60.0165C139.37 58.5735 139.251 57.0753 139.383 55.583C139.584 53.3078 140.361 51.1214 141.642 49.2304C142.924 47.3394 144.666 45.8063 146.704 44.7758C148.041 44.1 149.477 43.6551 150.95 43.4542C152.235 43.2792 153.333 42.2913 153.384 40.9957Z\"/>\r\n                    </mask>\r\n                    <path d=\"M153.384 40.9957C153.435 39.7001 152.423 38.5927 151.131 38.7095C148.858 38.9151 146.636 39.5491 144.586 40.5854C141.835 41.976 139.484 44.045 137.755 46.597C136.026 49.149 134.977 52.0996 134.706 55.1701C134.504 57.4583 134.739 59.7568 135.391 61.9447C135.762 63.1872 137.166 63.7169 138.35 63.1891C139.534 62.6612 140.044 61.2746 139.73 60.0165C139.37 58.5735 139.251 57.0753 139.383 55.583C139.584 53.3078 140.361 51.1214 141.642 49.2304C142.924 47.3394 144.666 45.8063 146.704 44.7758C148.041 44.1 149.477 43.6551 150.95 43.4542C152.235 43.2792 153.333 42.2913 153.384 40.9957Z\" stroke=\"white\" stroke-width=\"6\" mask=\"url(#path-16-inside-2_936_150383)\"/>\r\n                    <path d=\"M136.529 28.4717C152.285 19.3749 172.432 24.7732 181.529 40.5293C189.56 54.4398 186.291 71.7707 174.573 81.9004L194.457 116.339C195.932 118.894 195.056 122.161 192.501 123.636C189.946 125.111 186.679 124.236 185.204 121.681L165.466 87.4932C150.447 93.6552 132.814 87.92 124.472 73.4717C115.375 57.7156 120.773 37.5685 136.529 28.4717ZM173.698 45.0518C167.099 33.6209 152.482 29.7041 141.051 36.3037C129.62 42.9035 125.703 57.5204 132.303 68.9512C138.902 80.3817 153.519 84.2977 164.95 77.6982C176.381 71.0987 180.297 56.4826 173.698 45.0518Z\" fill=\"#00A3FF\"/>\r\n                    </svg>                    \r\n            </div>\r\n            <h3>No preview yet</h3>\r\n            <p>Add a find and replacement to preview.</p>\r\n        </div>\r\n\r\n        <!-- Action Button Section -->\r\n        <div class=\"action-button-section\" *ngIf=\"hasStores\">\r\n            <button class=\"btn-apply\" type=\"button\" (click)=\"onReviewAndReplace()\" [disabled]=\"loading || findLoading || replaceLoading || batchProcessing\">\r\n                {{ batchProcessing ? 'Processing...' : 'Review And Replace' }}\r\n            </button>\r\n        </div>\r\n    </form>\r\n</div>\r\n"]}