tango-app-ui-store-builder 1.0.28 → 1.0.30

package/esm2022/lib/components/collection-update-ai/collection-update-ai.component.mjs

@@ -0,0 +1,1486 @@
+import { Component, ViewChild } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule, Validators } from '@angular/forms';
+import { lastValueFrom, Subject, takeUntil } from 'rxjs';
+import * as fabric from "fabric";
+import { TitleCasePipe } from "@angular/common";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../services/store-builder.service";
+import * as i3 from "tango-app-ui-shared";
+import * as i4 from "@angular/router";
+import * as i5 from "@angular/common";
+export class CollectionUpdateAiComponent {
+    fb;
+    apiService;
+    toastService;
+    route;
+    titleCase;
+    form;
+    loading = false;
+    beforeCanvasRef;
+    beforeCanvas;
+    beforeContainerRef;
+    afterCanvasRef;
+    afterCanvas;
+    afterContainerRef;
+    destroy$ = new Subject();
+    planoData;
+    floorData;
+    wallThickness = 30;
+    verticalMargin = (1.25 / 100) * this.toPixels(1524, "mm");
+    cdnUrl;
+    activeHighlight = null;
+    cancelHighlightBlink = false;
+    storeChips = [];
+    selectedStore;
+    selectedFixture;
+    constructor(fb, apiService, toastService, route, titleCase) {
+        this.fb = fb;
+        this.apiService = apiService;
+        this.toastService = toastService;
+        this.route = route;
+        this.titleCase = titleCase;
+        this.form = this.fb.group({
+            stores: ['', Validators.required],
+            updateType: ['vm', Validators.required],
+            selectionCriteria: ['', Validators.required],
+            updationCriteria: ['', Validators.required],
+        });
+    }
+    ngAfterViewInit() {
+        this.route.queryParams
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((params) => {
+            if (params?.planoId) {
+                this.getStoreFixtures(params?.planoId);
+                if (params?.floorId) {
+                    this.floorData = { _id: params?.floorId };
+                }
+            }
+        });
+        this.beforeCanvas = new fabric.Canvas(this.beforeCanvasRef?.nativeElement, {
+            selectionFullyContained: true,
+            perPixelTargetFind: true,
+            targetFindTolerance: 5,
+        });
+        this.afterCanvas = new fabric.Canvas(this.afterCanvasRef?.nativeElement, {
+            selectionFullyContained: true,
+            perPixelTargetFind: true,
+            targetFindTolerance: 5,
+        });
+        this.setupZoomHandlers(this.beforeCanvas);
+        this.setupZoomHandlers(this.afterCanvas);
+    }
+    setupZoomHandlers(canvas) {
+        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) => {
+            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) {
+                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 = true;
+        });
+    }
+    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) {
+                        this.floorData.layoutPolygon[i].fixtures[j] = {
+                            ...fixture
+                        };
+                        matchFound = true;
+                        this.selectedFixture = fixture;
+                        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) {
+                this.floorData.centerFixture[i] = {
+                    ...fixture
+                };
+                this.selectedFixture = fixture;
+                break;
+            }
+        }
+    }
+    submitPrompt() {
+        if (this.form.invalid) {
+            this.form.markAllAsTouched();
+            return;
+        }
+        this.loading = true;
+        const payload = {
+            ...this.form.value,
+            stores: [this.selectedStore]
+        };
+        this.apiService.findFixtureAi(payload).subscribe({
+            next: (res) => {
+                this.loading = false;
+                if (res.code === 200) {
+                    this.updateAiResponseFixture(res.data);
+                    this.renderFloor(this.afterCanvas);
+                    setTimeout(() => {
+                        const actionFixture = this.afterCanvas
+                            .getObjects()
+                            .find((obj) => {
+                            return obj.objType === "fixture" && obj.fixtureId === res.data._id;
+                        });
+                        if (!actionFixture)
+                            return;
+                        this.highlightFixture(this.afterCanvas, actionFixture, true);
+                    }, 0);
+                }
+            },
+            error: () => {
+                this.loading = false;
+            },
+        });
+    }
+    async getStoreFixtures(storeId) {
+        this.loading = true;
+        this.apiService
+            .getStoreFixtures({ id: [storeId] })
+            .pipe(takeUntil(this.destroy$))
+            .subscribe({
+            next: async (res) => {
+                if (!res?.data?.[0]?.floors?.length) {
+                    return;
+                }
+                this.planoData = structuredClone(res.data[0]);
+                this.floorData = structuredClone(res.data[0].floors[0]);
+                this.renderFloor(this.beforeCanvas);
+                this.renderFloor(this.afterCanvas);
+                this.loading = false;
+                setTimeout(() => {
+                    this.resizeCanvas(this.beforeCanvas, this.beforeContainerRef);
+                    this.fitCanvasToLayoutAnimated(this.beforeCanvas);
+                    this.resizeCanvas(this.afterCanvas, this.afterContainerRef);
+                    this.fitCanvasToLayoutAnimated(this.afterCanvas);
+                }, 300);
+            },
+            error: (err) => {
+                this.loading = false;
+                this.toastService.getErrorToast("Failed to fetch plano");
+            },
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    }
+    resizeCanvas(canvas, conteiner) {
+        const container = conteiner.nativeElement;
+        canvas.setDimensions({
+            width: container.clientWidth - 50,
+            height: container.clientHeight - 40,
+        });
+        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();
+        // Final zoom to fit (with padding)
+        const scaleX = canvasW / bounds.width;
+        const scaleY = canvasH / bounds.height;
+        const targetZoom = Math.min(scaleX, scaleY) * 0.9; // padding 10%
+        // Desired viewport offset to center layout
+        const targetVpt = [
+            ...(canvas.viewportTransform || [1, 0, 0, 1, 0, 0]),
+        ];
+        targetVpt[0] = targetZoom; // scaleX
+        targetVpt[3] = targetZoom; // scaleY
+        targetVpt[4] = canvasW / 2 - (bounds.left + bounds.width / 2) * targetZoom; // center X
+        targetVpt[5] = canvasH / 2 - (bounds.top + bounds.height / 2) * targetZoom; // center Y
+        // Current viewport (starting point of animation)
+        const startVpt = [...canvas.viewportTransform];
+        fabric.util.animate({
+            startValue: 0,
+            endValue: 1,
+            duration: 100,
+            easing: fabric.util.ease.easeOutCubic,
+            onChange: (value) => {
+                const vpt = canvas.viewportTransform;
+                // Interpolate matrix values
+                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,
+        };
+    }
+    renderFloor(canvas) {
+        this.drawInitialContent(canvas);
+    }
+    async drawInitialContent(canvas) {
+        canvas.clear();
+        await this.drawLayoutElements(canvas);
+        // this.drawBg();
+    }
+    async drawLayoutElements(canvas) {
+        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") {
+                const arrowWidth = 80;
+                const arrowHeight = 75;
+                const arrowBase = 40;
+                this.drawEntrance(canvas, x, y, arrowWidth, arrowHeight, arrowBase, element);
+            }
+            if (element.elementType === "wall") {
+                const fixtureGroups = [];
+                for (let j = 0; j < element?.fixtures?.length; j++) {
+                    const fixture = element.fixtures[j];
+                    const x = this.toPixels(fixture.relativePosition.x, fixture.relativePosition.unit);
+                    const y = this.toPixels(fixture.relativePosition.y, fixture.relativePosition.unit);
+                    const fixtureHeight = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+                    const fixtureWidth = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+                    const fixtureObj = await this.drawFixture(canvas, x, y, fixtureHeight, fixtureWidth, 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: true,
+                        selectable: 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 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);
+                    const fixtureObj = this.drawOtherElementsWithLabel(canvas, x, y, a, w, h, otherElement);
+                    // elementsGroup.push(fixtureObj as fabric.Group);
+                }
+            }
+        }
+        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 fixtureHeight = this.toPixels(fixture.fixtureStaticLength.value, fixture.fixtureStaticLength.unit);
+            const fixtureWidth = this.toPixels(fixture.fixtureStaticWidth.value, fixture.fixtureStaticWidth.unit);
+            await this.drawFixture(canvas, x, y, fixtureHeight, fixtureWidth, 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);
+            const fixtureObj = this.drawOtherElementsWithLabel(canvas, x, y, a, w, h, otherElement);
+        }
+        return true;
+    }
+    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 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: true,
+            lockScalingX: isVertical,
+            lockScalingY: !isVertical,
+            // lockRotation: true,
+            evented: true,
+            hoverCursor: "pointer",
+            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,
+            lockScalingX: true,
+            lockScalingY: true,
+            lockScalingFlip: true,
+            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,
+            hoverCursor: "pointer",
+            lockScalingX: true,
+            lockScalingY: true,
+            subTargetCheck: true,
+            // hasControls: fixtureData.fixtureType === "floor",
+            // lockRotation: fixtureData.fixtureType !== "floor",
+            // lockMovementX: currentFixtureInfo?.wallDirection === 'up' || currentFixtureInfo?.wallDirection === 'down',
+            // lockMovementY: currentFixtureInfo?.wallDirection === 'right' || currentFixtureInfo?.wallDirection === 'left',
+            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";
+        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",
+        });
+        group.objType = "others";
+        group.data = element;
+        canvas.add(group);
+        if (element?.newAdded) {
+            try {
+                canvas.setActiveObject(group);
+                canvas.requestRenderAll();
+            }
+            catch { }
+            delete element.newAdded;
+        }
+        return group;
+    }
+    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;
+        // --- No blinking needed ---
+        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();
+    }
+    async applyStores() {
+        const value = this.form.value.stores;
+        if (!value)
+            return;
+        const codes = value
+            .split(',')
+            .map((s) => s.trim().toUpperCase())
+            .filter(Boolean);
+        const response = await lastValueFrom(this.apiService.getPlanoId({ stores: codes }));
+        const data = Array.isArray(response.data) ? response.data : [];
+        const foundStoreSet = new Set(data.map((store) => store.storeName.toUpperCase()));
+        const foundChips = data.map((store) => ({
+            storeCode: store.storeName,
+            status: 'pending',
+            planoId: store._id
+        }));
+        const notFoundChips = codes
+            .filter((code) => !foundStoreSet.has(code))
+            .map((code) => ({
+            storeCode: code,
+            status: 'not_found'
+        }));
+        this.storeChips = [...foundChips, ...notFoundChips];
+        const activeChip = this.storeChips.find((chip) => chip.status === 'pending');
+        this.selectedStore = activeChip?.storeCode;
+        this.getStoreFixtures(activeChip.planoId);
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async autoApprove() {
+        for (let i = 0; i < this.storeChips.length; i++) {
+            const { storeCode, status, planoId } = this.storeChips[i];
+            if (status === 'not_found')
+                continue;
+            const planoRes = await lastValueFrom(this.apiService.getStoreFixtures({ id: [planoId] }));
+            if (!planoRes?.data?.[0]?.floors?.length) {
+                return;
+            }
+            this.planoData = structuredClone(planoRes.data[0]);
+            this.floorData = structuredClone(planoRes.data[0].floors[0]);
+            this.renderFloor(this.beforeCanvas);
+            this.renderFloor(this.afterCanvas);
+            this.loading = false;
+            setTimeout(() => {
+                this.resizeCanvas(this.beforeCanvas, this.beforeContainerRef);
+                this.fitCanvasToLayoutAnimated(this.beforeCanvas);
+                this.resizeCanvas(this.afterCanvas, this.afterContainerRef);
+                this.fitCanvasToLayoutAnimated(this.afterCanvas);
+            }, 100);
+            const payload = {
+                ...this.form.value,
+                stores: [storeCode]
+            };
+            const aiRes = await lastValueFrom(this.apiService.findFixtureAi(payload));
+            if (aiRes.code === 200) {
+                this.updateAiResponseFixture(aiRes.data);
+                this.renderFloor(this.afterCanvas);
+                setTimeout(() => {
+                    const actionFixture = this.afterCanvas
+                        .getObjects()
+                        .find((obj) => {
+                        return obj.objType === "fixture" && obj.fixtureId === aiRes.data._id;
+                    });
+                    if (!actionFixture)
+                        return;
+                    this.highlightFixture(this.afterCanvas, actionFixture, true);
+                }, 0);
+            }
+            const updatePayload = {
+                fixtures: [this.selectedFixture]
+            };
+            await lastValueFrom(this.apiService.updateFixtureData(updatePayload));
+            this.storeChips[i].status = 'approved';
+            const activeChip = this.storeChips.find((chip) => chip.status === 'pending');
+            this.selectedStore = activeChip?.storeCode;
+            await this.delay(3000);
+        }
+    }
+    approveStore() {
+        const payload = {
+            fixtures: [this.selectedFixture]
+        };
+        this.apiService.updateFixtureData(payload).subscribe({
+            next: (res) => {
+                if (res.code === 200) {
+                    this.storeChips.find((chip) => chip.storeCode === this.selectedStore).status = 'approved';
+                    const nextChip = this.storeChips.find((chip) => chip.status === 'pending');
+                    this.selectedStore = nextChip?.storeCode;
+                    this.getStoreFixtures(nextChip.planoId);
+                }
+            }
+        });
+    }
+    selectStore(chip) {
+        this.selectedStore = chip.storeCode;
+        this.getStoreFixtures(chip.planoId);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CollectionUpdateAiComponent, deps: [{ token: i1.FormBuilder }, { token: i2.StoreBuilderService }, { token: i3.ToastService }, { token: i4.ActivatedRoute }, { token: i5.TitleCasePipe }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: CollectionUpdateAiComponent, isStandalone: true, selector: "lib-collection-update-ai", providers: [TitleCasePipe], viewQueries: [{ propertyName: "beforeCanvasRef", first: true, predicate: ["beforeCanvas"], descendants: true }, { propertyName: "beforeContainerRef", first: true, predicate: ["beforeCanvasContainer"], descendants: true }, { propertyName: "afterCanvasRef", first: true, predicate: ["afterCanvas"], descendants: true }, { propertyName: "afterContainerRef", first: true, predicate: ["afterCanvasContainer"], descendants: true }], ngImport: i0, template: "<form class=\"ai-container\" [formGroup]=\"form\" (ngSubmit)=\"submitPrompt()\">\r\n\r\n  <!-- ================= Applicable Stores ================= -->\r\n  <div class=\"field\">\r\n    <label>Applicable Stores</label>\r\n\r\n    <div class=\"d-flex gap-2 align-items-center\">\r\n      <input type=\"text\" class=\"form-control\" formControlName=\"stores\" placeholder=\"e.g. LKST345, LKST346\" />\r\n\r\n      <button type=\"button\" class=\"btn btn-outline\" (click)=\"applyStores()\">\r\n        Apply\r\n      </button>\r\n    </div>\r\n\r\n    <span class=\"error\" *ngIf=\"form.controls.stores.touched && form.controls.stores.invalid\">\r\n      Applicable stores is required\r\n    </span>\r\n  </div>\r\n\r\n  <!-- ================= Store Chips ================= -->\r\n  <div class=\"store-chips\" *ngIf=\"storeChips.length\">\r\n    <div (click)=\"selectStore(chip)\" class=\"store-chip\" *ngFor=\"let chip of storeChips\" [ngClass]=\"[\r\n      chip.status,\r\n      chip.storeCode === selectedStore ? 'active' : ''\r\n    ]\">\r\n      {{ chip.storeCode }}\r\n    </div>\r\n  </div>\r\n\r\n\r\n  <!-- ================= Update Type ================= -->\r\n  <div class=\"field\">\r\n    <label>Update Type</label>\r\n\r\n    <div class=\"radio-group\">\r\n      <label class=\"radio-option\">\r\n        <input type=\"radio\" formControlName=\"updateType\" value=\"vm\" />\r\n        VM\r\n      </label>\r\n\r\n      <label class=\"radio-option\">\r\n        <input type=\"radio\" formControlName=\"updateType\" value=\"pid\" />\r\n        PID\r\n      </label>\r\n    </div>\r\n\r\n    <span class=\"error\" *ngIf=\"form.controls.updateType.touched && form.controls.updateType.invalid\">\r\n      Update type is required\r\n    </span>\r\n  </div>\r\n\r\n  <!-- ================= AI Prompt ================= -->\r\n  <div class=\"field\">\r\n    <label>AI Prompt</label>\r\n\r\n    <div class=\"row\">\r\n\r\n      <!-- Selection Criteria -->\r\n      <div class=\"col-md-6\">\r\n        <div class=\"form-group\">\r\n          <label class=\"small fw-semibold\">Selection Criteria</label>\r\n\r\n          <textarea rows=\"3\" class=\"form-control\" formControlName=\"selectionCriteria\"\r\n            placeholder=\"e.g. Select premium shades on wall fixtures\"></textarea>\r\n\r\n          <span class=\"error\"\r\n            *ngIf=\"form.controls.selectionCriteria.touched && form.controls.selectionCriteria.invalid\">\r\n            Selection criteria is required\r\n          </span>\r\n        </div>\r\n      </div>\r\n\r\n      <!-- Updation Criteria -->\r\n      <div class=\"col-md-6\">\r\n        <div class=\"form-group\">\r\n          <label class=\"small fw-semibold\">Updation Criteria</label>\r\n\r\n          <textarea rows=\"3\" class=\"form-control\" formControlName=\"updationCriteria\"\r\n            placeholder=\"e.g. Move selected fixtures to mid shelves\"></textarea>\r\n\r\n          <span class=\"error\" *ngIf=\"form.controls.updationCriteria.touched && form.controls.updationCriteria.invalid\">\r\n            Updation criteria is required\r\n          </span>\r\n        </div>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <!-- ================= Submit ================= -->\r\n  <div class=\"d-flex justify-content-end mt-3\">\r\n    <button type=\"submit\" class=\"submit-btn\" [disabled]=\"loading\">\r\n      {{ loading ? 'Thinking\u2026' : 'Submit' }}\r\n    </button>\r\n  </div>\r\n\r\n  <!-- ================= Canvases ================= -->\r\n  <div class=\"canvas-grid mt-4\">\r\n\r\n    <div class=\"canvas-box\" #beforeCanvasContainer>\r\n      <div class=\"canvas-title\">Before Update</div>\r\n      <canvas #beforeCanvas></canvas>\r\n    </div>\r\n\r\n    <div class=\"canvas-box\" #afterCanvasContainer>\r\n      <div class=\"canvas-title\">After Update</div>\r\n      <canvas #afterCanvas></canvas>\r\n    </div>\r\n\r\n  </div>\r\n\r\n  <div class=\"d-flex align-items-center justify-content-end\">\r\n    <!-- ================= Auto Approve ================= -->\r\n    <button (click)=\"autoApprove()\" type=\"button\" class=\"btn btn-warning me-3\">\r\n      \u26A0 Auto Approve\r\n    </button>\r\n\r\n    <!-- ================= Approve Changes ================= -->\r\n    <button type=\"button\" class=\"btn btn-success\" (click)=\"approveStore()\" [disabled]=\"form.invalid\">\r\n      \u2714 Approve Changes\r\n    </button>\r\n  </div>\r\n\r\n\r\n</form>", styles: ["@charset \"UTF-8\";.ai-container{display:flex;flex-direction:column;gap:16px;height:100%}.field{display:flex;flex-direction:column;gap:6px}.field label{font-size:13px;font-weight:600;color:#374151}.field input,.field textarea{padding:10px;font-size:14px;border-radius:6px;border:1px solid #d1d5db}.error{font-size:12px;color:#dc2626}.submit-btn{width:140px;padding:10px;background:#2563eb;color:#fff;border:none;border-radius:6px;cursor:pointer}.submit-btn:disabled{background:#9ca3af}.canvas-grid{display:grid;grid-template-columns:1fr 1fr;gap:16px}.canvas-box{border:1px solid #e5e7eb;border-radius:8px;padding:8px;background:#f9fafb;display:flex;flex-direction:column;align-items:center;height:70dvh}.canvas-title{font-size:14px;font-weight:600;margin-bottom:8px}canvas{background:#fff;border-radius:4px}.approve-bar{display:flex;justify-content:flex-end;margin-top:auto}.approve-btn{padding:12px 20px;background:#16a34a;color:#fff;border:none;border-radius:6px;font-size:14px;cursor:pointer}.approve-btn:disabled{background:#9ca3af}.radio-group{display:flex;gap:20px;margin-top:6px}.radio-option{display:flex;align-items:center;gap:6px;cursor:pointer}.store-chips{display:flex;flex-wrap:wrap;gap:8px;margin-top:10px}.store-chip{padding:6px 12px;border-radius:14px;font-size:13px;font-weight:600;color:#fff;cursor:pointer}.store-chip.pending{background-color:#6c757d}.store-chip.approved{background-color:#198754}.store-chip.skipped{background-color:#0d6efd}.store-chip.not_found{background-color:#dc3545}.store-chip.active{animation:chip-pulse 1.4s infinite ease-in-out;z-index:2}.store-chip.active:after{content:\"\";position:absolute;inset:-3px;border-radius:16px;border:2px solid #20c997;box-shadow:0 0 6px #20c997b3,0 0 12px #20c99766;animation:ring-pulse 1.4s infinite ease-in-out;pointer-events:none}@keyframes chip-pulse{0%{transform:scale(1)}50%{transform:scale(1.025)}to{transform:scale(1)}}@keyframes ring-pulse{0%{opacity:.4}50%{opacity:.9}to{opacity:.4}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.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: i1.RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: ["name", "formControlName", "value"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CollectionUpdateAiComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-collection-update-ai', standalone: true, imports: [CommonModule, ReactiveFormsModule], providers: [TitleCasePipe], template: "<form class=\"ai-container\" [formGroup]=\"form\" (ngSubmit)=\"submitPrompt()\">\r\n\r\n  <!-- ================= Applicable Stores ================= -->\r\n  <div class=\"field\">\r\n    <label>Applicable Stores</label>\r\n\r\n    <div class=\"d-flex gap-2 align-items-center\">\r\n      <input type=\"text\" class=\"form-control\" formControlName=\"stores\" placeholder=\"e.g. LKST345, LKST346\" />\r\n\r\n      <button type=\"button\" class=\"btn btn-outline\" (click)=\"applyStores()\">\r\n        Apply\r\n      </button>\r\n    </div>\r\n\r\n    <span class=\"error\" *ngIf=\"form.controls.stores.touched && form.controls.stores.invalid\">\r\n      Applicable stores is required\r\n    </span>\r\n  </div>\r\n\r\n  <!-- ================= Store Chips ================= -->\r\n  <div class=\"store-chips\" *ngIf=\"storeChips.length\">\r\n    <div (click)=\"selectStore(chip)\" class=\"store-chip\" *ngFor=\"let chip of storeChips\" [ngClass]=\"[\r\n      chip.status,\r\n      chip.storeCode === selectedStore ? 'active' : ''\r\n    ]\">\r\n      {{ chip.storeCode }}\r\n    </div>\r\n  </div>\r\n\r\n\r\n  <!-- ================= Update Type ================= -->\r\n  <div class=\"field\">\r\n    <label>Update Type</label>\r\n\r\n    <div class=\"radio-group\">\r\n      <label class=\"radio-option\">\r\n        <input type=\"radio\" formControlName=\"updateType\" value=\"vm\" />\r\n        VM\r\n      </label>\r\n\r\n      <label class=\"radio-option\">\r\n        <input type=\"radio\" formControlName=\"updateType\" value=\"pid\" />\r\n        PID\r\n      </label>\r\n    </div>\r\n\r\n    <span class=\"error\" *ngIf=\"form.controls.updateType.touched && form.controls.updateType.invalid\">\r\n      Update type is required\r\n    </span>\r\n  </div>\r\n\r\n  <!-- ================= AI Prompt ================= -->\r\n  <div class=\"field\">\r\n    <label>AI Prompt</label>\r\n\r\n    <div class=\"row\">\r\n\r\n      <!-- Selection Criteria -->\r\n      <div class=\"col-md-6\">\r\n        <div class=\"form-group\">\r\n          <label class=\"small fw-semibold\">Selection Criteria</label>\r\n\r\n          <textarea rows=\"3\" class=\"form-control\" formControlName=\"selectionCriteria\"\r\n            placeholder=\"e.g. Select premium shades on wall fixtures\"></textarea>\r\n\r\n          <span class=\"error\"\r\n            *ngIf=\"form.controls.selectionCriteria.touched && form.controls.selectionCriteria.invalid\">\r\n            Selection criteria is required\r\n          </span>\r\n        </div>\r\n      </div>\r\n\r\n      <!-- Updation Criteria -->\r\n      <div class=\"col-md-6\">\r\n        <div class=\"form-group\">\r\n          <label class=\"small fw-semibold\">Updation Criteria</label>\r\n\r\n          <textarea rows=\"3\" class=\"form-control\" formControlName=\"updationCriteria\"\r\n            placeholder=\"e.g. Move selected fixtures to mid shelves\"></textarea>\r\n\r\n          <span class=\"error\" *ngIf=\"form.controls.updationCriteria.touched && form.controls.updationCriteria.invalid\">\r\n            Updation criteria is required\r\n          </span>\r\n        </div>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <!-- ================= Submit ================= -->\r\n  <div class=\"d-flex justify-content-end mt-3\">\r\n    <button type=\"submit\" class=\"submit-btn\" [disabled]=\"loading\">\r\n      {{ loading ? 'Thinking\u2026' : 'Submit' }}\r\n    </button>\r\n  </div>\r\n\r\n  <!-- ================= Canvases ================= -->\r\n  <div class=\"canvas-grid mt-4\">\r\n\r\n    <div class=\"canvas-box\" #beforeCanvasContainer>\r\n      <div class=\"canvas-title\">Before Update</div>\r\n      <canvas #beforeCanvas></canvas>\r\n    </div>\r\n\r\n    <div class=\"canvas-box\" #afterCanvasContainer>\r\n      <div class=\"canvas-title\">After Update</div>\r\n      <canvas #afterCanvas></canvas>\r\n    </div>\r\n\r\n  </div>\r\n\r\n  <div class=\"d-flex align-items-center justify-content-end\">\r\n    <!-- ================= Auto Approve ================= -->\r\n    <button (click)=\"autoApprove()\" type=\"button\" class=\"btn btn-warning me-3\">\r\n      \u26A0 Auto Approve\r\n    </button>\r\n\r\n    <!-- ================= Approve Changes ================= -->\r\n    <button type=\"button\" class=\"btn btn-success\" (click)=\"approveStore()\" [disabled]=\"form.invalid\">\r\n      \u2714 Approve Changes\r\n    </button>\r\n  </div>\r\n\r\n\r\n</form>", styles: ["@charset \"UTF-8\";.ai-container{display:flex;flex-direction:column;gap:16px;height:100%}.field{display:flex;flex-direction:column;gap:6px}.field label{font-size:13px;font-weight:600;color:#374151}.field input,.field textarea{padding:10px;font-size:14px;border-radius:6px;border:1px solid #d1d5db}.error{font-size:12px;color:#dc2626}.submit-btn{width:140px;padding:10px;background:#2563eb;color:#fff;border:none;border-radius:6px;cursor:pointer}.submit-btn:disabled{background:#9ca3af}.canvas-grid{display:grid;grid-template-columns:1fr 1fr;gap:16px}.canvas-box{border:1px solid #e5e7eb;border-radius:8px;padding:8px;background:#f9fafb;display:flex;flex-direction:column;align-items:center;height:70dvh}.canvas-title{font-size:14px;font-weight:600;margin-bottom:8px}canvas{background:#fff;border-radius:4px}.approve-bar{display:flex;justify-content:flex-end;margin-top:auto}.approve-btn{padding:12px 20px;background:#16a34a;color:#fff;border:none;border-radius:6px;font-size:14px;cursor:pointer}.approve-btn:disabled{background:#9ca3af}.radio-group{display:flex;gap:20px;margin-top:6px}.radio-option{display:flex;align-items:center;gap:6px;cursor:pointer}.store-chips{display:flex;flex-wrap:wrap;gap:8px;margin-top:10px}.store-chip{padding:6px 12px;border-radius:14px;font-size:13px;font-weight:600;color:#fff;cursor:pointer}.store-chip.pending{background-color:#6c757d}.store-chip.approved{background-color:#198754}.store-chip.skipped{background-color:#0d6efd}.store-chip.not_found{background-color:#dc3545}.store-chip.active{animation:chip-pulse 1.4s infinite ease-in-out;z-index:2}.store-chip.active:after{content:\"\";position:absolute;inset:-3px;border-radius:16px;border:2px solid #20c997;box-shadow:0 0 6px #20c997b3,0 0 12px #20c99766;animation:ring-pulse 1.4s infinite ease-in-out;pointer-events:none}@keyframes chip-pulse{0%{transform:scale(1)}50%{transform:scale(1.025)}to{transform:scale(1)}}@keyframes ring-pulse{0%{opacity:.4}50%{opacity:.9}to{opacity:.4}}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormBuilder }, { type: i2.StoreBuilderService }, { type: i3.ToastService }, { type: i4.ActivatedRoute }, { type: i5.TitleCasePipe }], propDecorators: { beforeCanvasRef: [{
+                type: ViewChild,
+                args: ['beforeCanvas']
+            }], beforeContainerRef: [{
+                type: ViewChild,
+                args: ["beforeCanvasContainer"]
+            }], afterCanvasRef: [{
+                type: ViewChild,
+                args: ['afterCanvas']
+            }], afterContainerRef: [{
+                type: ViewChild,
+                args: ["afterCanvasContainer"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-update-ai.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-store-builder/src/lib/components/collection-update-ai/collection-update-ai.component.ts","../../../../../../projects/tango-store-builder/src/lib/components/collection-update-ai/collection-update-ai.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ViewChild, ElementRef, OnDestroy, AfterViewInit } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { ReactiveFormsModule, FormBuilder, FormGroup, Validators } from '@angular/forms';\r\nimport { lastValueFrom, Subject, takeUntil } from 'rxjs';\r\nimport { StoreBuilderService } from '../../services/store-builder.service';\r\nimport { ToastService } from 'tango-app-ui-shared';\r\nimport * as fabric from \"fabric\";\r\nimport { ActivatedRoute } from '@angular/router';\r\nimport { TitleCasePipe } from \"@angular/common\";\r\n\r\ntype StoreStatus = 'pending' | 'approved' | 'skipped' | 'not_found';\r\n\r\ninterface StoreChip {\r\n  storeCode: string;\r\n  planoId: string;\r\n  status: StoreStatus;\r\n}\r\n@Component({\r\n  selector: 'lib-collection-update-ai',\r\n  templateUrl: './collection-update-ai.component.html',\r\n  styleUrl: './collection-update-ai.component.scss',\r\n  standalone: true,\r\n  imports: [CommonModule, ReactiveFormsModule],\r\n  providers: [TitleCasePipe],\r\n})\r\n\r\nexport class CollectionUpdateAiComponent implements OnDestroy, AfterViewInit {\r\n\r\n  form: FormGroup;\r\n  loading = false;\r\n\r\n  @ViewChild('beforeCanvas') beforeCanvasRef!: ElementRef<HTMLCanvasElement>;\r\n  beforeCanvas!: fabric.Canvas;\r\n  @ViewChild(\"beforeCanvasContainer\") beforeContainerRef!: ElementRef<HTMLDivElement>;\r\n  @ViewChild('afterCanvas') afterCanvasRef!: ElementRef<HTMLCanvasElement>;\r\n  afterCanvas!: fabric.Canvas;\r\n  @ViewChild(\"afterCanvasContainer\") afterContainerRef!: ElementRef<HTMLDivElement>;\r\n  destroy$ = new Subject();\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  storeChips: StoreChip[] = [];\r\n  selectedStore?: string;\r\n  selectedFixture: any\r\n\r\n\r\n\r\n\r\n  constructor(private fb: FormBuilder,\r\n    private apiService: StoreBuilderService,\r\n    private toastService: ToastService,\r\n    private route: ActivatedRoute,\r\n    private titleCase: TitleCasePipe,\r\n\r\n  ) {\r\n    this.form = this.fb.group({\r\n      stores: ['', Validators.required],\r\n      updateType: ['vm', Validators.required],\r\n      selectionCriteria: ['', Validators.required],\r\n      updationCriteria: ['', Validators.required],\r\n    });\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.route.queryParams\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((params) => {\r\n        if (params?.planoId) {\r\n          this.getStoreFixtures(params?.planoId);\r\n          if (params?.floorId) {\r\n            this.floorData = { _id: params?.floorId };\r\n          }\r\n        }\r\n      });\r\n\r\n    this.beforeCanvas = new fabric.Canvas(this.beforeCanvasRef?.nativeElement, {\r\n      selectionFullyContained: true,\r\n      perPixelTargetFind: true,\r\n      targetFindTolerance: 5,\r\n    });\r\n\r\n    this.afterCanvas = new fabric.Canvas(this.afterCanvasRef?.nativeElement, {\r\n      selectionFullyContained: true,\r\n      perPixelTargetFind: true,\r\n      targetFindTolerance: 5,\r\n    });\r\n\r\n\r\n    this.setupZoomHandlers(this.beforeCanvas);\r\n    this.setupZoomHandlers(this.afterCanvas);\r\n\r\n  }\r\n\r\n  setupZoomHandlers(canvas: fabric.Canvas): void {\r\n    canvas.on(\"mouse:wheel\", (opt: fabric.TEvent<WheelEvent>) => {\r\n      const e = opt.e;\r\n\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\r\n        zoom = Math.max(0.2, Math.min(zoom, 3));\r\n\r\n        canvas.zoomToPoint(\r\n          {\r\n            x: e.offsetX,\r\n            y: e.offsetY,\r\n          } as fabric.Point,\r\n          zoom\r\n        );\r\n\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      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) {\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 = true;\r\n    });\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\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\r\n          if (fx._id === fixture._id) {\r\n            this.floorData.layoutPolygon[i].fixtures[j] = {\r\n              ...fixture\r\n            };\r\n            matchFound = true\r\n            this.selectedFixture = fixture\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\r\n      if (fx._id === fixture._id) {\r\n        this.floorData.centerFixture[i] = {\r\n          ...fixture\r\n        }\r\n        this.selectedFixture = fixture\r\n        break;\r\n      }\r\n    }\r\n\r\n\r\n  }\r\n\r\n  submitPrompt() {\r\n    if (this.form.invalid) {\r\n      this.form.markAllAsTouched();\r\n      return;\r\n    }\r\n\r\n    this.loading = true;\r\n\r\n    const payload = {\r\n      ...this.form.value,\r\n      stores: [this.selectedStore]\r\n    };\r\n\r\n    this.apiService.findFixtureAi(payload).subscribe({\r\n      next: (res: any) => {\r\n        this.loading = false;\r\n\r\n        if (res.code === 200) {\r\n          this.updateAiResponseFixture(res.data)\r\n          this.renderFloor(this.afterCanvas)\r\n\r\n\r\n          setTimeout(() => {\r\n            const actionFixture = this.afterCanvas\r\n              .getObjects()\r\n              .find(\r\n                (obj: any) => {\r\n                  return obj.objType === \"fixture\" && obj.fixtureId === res.data._id\r\n                }\r\n              ) as fabric.Group | undefined;\r\n\r\n            if (!actionFixture) return;\r\n            this.highlightFixture(this.afterCanvas, actionFixture, true);\r\n          }, 0);\r\n        }\r\n      },\r\n      error: () => {\r\n        this.loading = false;\r\n      },\r\n    });\r\n  }\r\n\r\n\r\n  async getStoreFixtures(storeId: string) {\r\n    this.loading = true;\r\n    this.apiService\r\n      .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            return;\r\n          }\r\n\r\n          this.planoData = structuredClone(res.data[0]);\r\n\r\n          this.floorData = structuredClone(res.data[0].floors[0]);\r\n\r\n          this.renderFloor(this.beforeCanvas);\r\n          this.renderFloor(this.afterCanvas);\r\n\r\n          this.loading = false;\r\n          setTimeout(() => {\r\n            this.resizeCanvas(this.beforeCanvas, this.beforeContainerRef);\r\n            this.fitCanvasToLayoutAnimated(this.beforeCanvas);\r\n\r\n            this.resizeCanvas(this.afterCanvas, this.afterContainerRef);\r\n            this.fitCanvasToLayoutAnimated(this.afterCanvas);\r\n          }, 300);\r\n        },\r\n        error: (err: any) => {\r\n          this.loading = false;\r\n          this.toastService.getErrorToast(\"Failed to fetch plano\");\r\n        },\r\n      });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next(true);\r\n    this.destroy$.complete();\r\n  }\r\n\r\n  resizeCanvas(canvas: fabric.Canvas, conteiner: ElementRef<HTMLDivElement>): void {\r\n    const container = conteiner.nativeElement;\r\n    canvas.setDimensions({\r\n      width: container.clientWidth - 50,\r\n\r\n      height: container.clientHeight - 40,\r\n    });\r\n    canvas.requestRenderAll();\r\n  }\r\n\r\n  private fitCanvasToLayoutAnimated(canvas: fabric.Canvas) {\r\n    if (!canvas) return;\r\n\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\r\n    // Final zoom to fit (with padding)\r\n    const scaleX = canvasW / bounds.width;\r\n    const scaleY = canvasH / bounds.height;\r\n    const targetZoom = Math.min(scaleX, scaleY) * 0.9; // padding 10%\r\n\r\n    // Desired viewport offset to center layout\r\n    const targetVpt = [\r\n      ...(canvas.viewportTransform || [1, 0, 0, 1, 0, 0]),\r\n    ] as fabric.TMat2D;\r\n\r\n    targetVpt[0] = targetZoom; // scaleX\r\n    targetVpt[3] = targetZoom; // scaleY\r\n\r\n    targetVpt[4] = canvasW / 2 - (bounds.left + bounds.width / 2) * targetZoom; // center X\r\n    targetVpt[5] = canvasH / 2 - (bounds.top + bounds.height / 2) * targetZoom; // center Y\r\n\r\n    // Current viewport (starting point of animation)\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\r\n        // Interpolate matrix values\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\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,\r\n      minY = Infinity,\r\n      maxX = -Infinity,\r\n      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 {\r\n      left: minX,\r\n      top: minY,\r\n      width: maxX - minX,\r\n      height: maxY - minY,\r\n    };\r\n  }\r\n\r\n  renderFloor(canvas: fabric.Canvas) {\r\n    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    // this.drawBg();\r\n  }\r\n\r\n  async drawLayoutElements(canvas: fabric.Canvas) {\r\n    for (let index = 0; index < this.floorData.layoutPolygon.length; index++) {\r\n      const element = this.floorData.layoutPolygon[index];\r\n\r\n      let wall;\r\n\r\n      element.relativePosition ??= {\r\n        x: 0,\r\n        y: 0,\r\n        unit: \"ft\",\r\n      };\r\n\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        const arrowWidth = 80;\r\n        const arrowHeight = 75;\r\n        const arrowBase = 40;\r\n        this.drawEntrance(\r\n          canvas,\r\n          x,\r\n          y,\r\n          arrowWidth,\r\n          arrowHeight,\r\n          arrowBase,\r\n          element\r\n        );\r\n      }\r\n\r\n      if (element.elementType === \"wall\") {\r\n        const fixtureGroups: fabric.Group[] = [];\r\n\r\n        for (let j = 0; j < element?.fixtures?.length; j++) {\r\n          const fixture = element.fixtures[j];\r\n          const x = this.toPixels(\r\n            fixture.relativePosition.x,\r\n            fixture.relativePosition.unit\r\n          );\r\n          const y = this.toPixels(\r\n            fixture.relativePosition.y,\r\n            fixture.relativePosition.unit\r\n          );\r\n          const fixtureHeight = this.toPixels(\r\n            fixture.fixtureStaticLength.value,\r\n            fixture.fixtureStaticLength.unit\r\n          );\r\n          const fixtureWidth = this.toPixels(\r\n            fixture.fixtureStaticWidth.value,\r\n            fixture.fixtureStaticWidth.unit\r\n          );\r\n\r\n          const fixtureObj = await this.drawFixture(\r\n            canvas,\r\n            x,\r\n            y,\r\n            fixtureHeight,\r\n            fixtureWidth,\r\n            fixture\r\n          );\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\r\n          const combinedGroup = new fabric.Group([wall, ...fixtureGroups], {\r\n            hasControls: true,\r\n            selectable: true,\r\n            subTargetCheck: true,\r\n          });\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 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(\r\n            otherElement.fixtureStaticLength.value,\r\n            otherElement.fixtureStaticLength.unit\r\n          );\r\n          const w = this.toPixels(\r\n            otherElement.fixtureStaticWidth.value,\r\n            otherElement.fixtureStaticWidth.unit\r\n          );\r\n\r\n          const fixtureObj = this.drawOtherElementsWithLabel(\r\n            canvas,\r\n            x,\r\n            y,\r\n            a,\r\n            w,\r\n            h,\r\n            otherElement\r\n          );\r\n\r\n          // elementsGroup.push(fixtureObj as fabric.Group);\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(\r\n        fixture.relativePosition.x,\r\n        fixture.relativePosition.unit\r\n      );\r\n      const y = this.toPixels(\r\n        fixture.relativePosition.y,\r\n        fixture.relativePosition.unit\r\n      );\r\n      const fixtureHeight = this.toPixels(\r\n        fixture.fixtureStaticLength.value,\r\n        fixture.fixtureStaticLength.unit\r\n      );\r\n      const fixtureWidth = this.toPixels(\r\n        fixture.fixtureStaticWidth.value,\r\n        fixture.fixtureStaticWidth.unit\r\n      );\r\n      await this.drawFixture(\r\n        canvas,\r\n        x,\r\n        y,\r\n        fixtureHeight,\r\n        fixtureWidth,\r\n        fixture\r\n      );\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(\r\n        otherElement.fixtureStaticLength.value,\r\n        otherElement.fixtureStaticLength.unit\r\n      );\r\n      const w = this.toPixels(\r\n        otherElement.fixtureStaticWidth.value,\r\n        otherElement.fixtureStaticWidth.unit\r\n      );\r\n\r\n      const fixtureObj = this.drawOtherElementsWithLabel(\r\n        canvas,\r\n        x,\r\n        y,\r\n        a,\r\n        w,\r\n        h,\r\n        otherElement\r\n      );\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n\r\n  toPixels(value: number, unit: string, dpi = 2.8) {\r\n    let pixels: number;\r\n\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\r\n    return Number(pixels.toFixed(4));\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: true,\r\n      lockScalingX: isVertical,\r\n      lockScalingY: !isVertical,\r\n      // lockRotation: true,\r\n      evented: true,\r\n      hoverCursor: \"pointer\",\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      lockScalingX: true,\r\n      lockScalingY: true,\r\n      lockScalingFlip: true,\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 = [];\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        hoverCursor: \"pointer\",\r\n        lockScalingX: true,\r\n        lockScalingY: true,\r\n        subTargetCheck: true,\r\n        // hasControls: fixtureData.fixtureType === \"floor\",\r\n        // lockRotation: fixtureData.fixtureType !== \"floor\",\r\n        // lockMovementX: currentFixtureInfo?.wallDirection === 'up' || currentFixtureInfo?.wallDirection === 'down',\r\n        // lockMovementY: currentFixtureInfo?.wallDirection === 'right' || currentFixtureInfo?.wallDirection === 'left',\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\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    }) 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\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\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, // consistent padding\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\r\n    canvas.add(rect);\r\n    canvas.moveObjectTo(rect, canvas.getObjects().length - 1);\r\n    canvas.requestRenderAll();\r\n\r\n    this.activeHighlight = rect;\r\n\r\n    // --- No blinking needed ---\r\n    if (!blink) return;\r\n\r\n    let cycles = 0;\r\n\r\n    const blinkOnce = () => {\r\n      if (this.cancelHighlightBlink) {\r\n        this.removeHighlight(canvas);\r\n        return;\r\n      }\r\n\r\n      rect.animate(\r\n        { opacity: 1 },\r\n        {\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\r\n            rect.animate(\r\n              { opacity: 0 },\r\n              {\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\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      );\r\n    };\r\n\r\n    blinkOnce();\r\n  }\r\n\r\n  removeHighlight(canvas: fabric.Canvas,) {\r\n    this.cancelHighlightBlink = true;\r\n\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\r\n    this.activeHighlight = null;\r\n    canvas.requestRenderAll();\r\n  }\r\n\r\n  async applyStores() {\r\n    const value = this.form.value.stores;\r\n    if (!value) return;\r\n\r\n    const codes = value\r\n      .split(',')\r\n      .map((s: string) => s.trim().toUpperCase())\r\n      .filter(Boolean);\r\n\r\n    const response: any = await lastValueFrom(\r\n      this.apiService.getPlanoId({ stores: codes })\r\n    );\r\n\r\n    const data = Array.isArray(response.data) ? response.data : [];\r\n\r\n    const foundStoreSet = new Set(\r\n      data.map((store: any) => store.storeName.toUpperCase())\r\n    );\r\n\r\n    const foundChips = data.map((store: any) => ({\r\n      storeCode: store.storeName,\r\n      status: 'pending',\r\n      planoId: store._id\r\n    }));\r\n\r\n    const notFoundChips = codes\r\n      .filter((code: string) => !foundStoreSet.has(code))\r\n      .map((code: string) => ({\r\n        storeCode: code,\r\n        status: 'not_found'\r\n      }));\r\n\r\n    this.storeChips = [...foundChips, ...notFoundChips];\r\n    const activeChip = this.storeChips.find((chip) => chip.status === 'pending')\r\n    this.selectedStore = activeChip?.storeCode\r\n    this.getStoreFixtures(activeChip!.planoId)\r\n  }\r\n\r\n  private delay(ms: number): Promise<void> {\r\n    return new Promise(resolve => setTimeout(resolve, ms));\r\n  }\r\n\r\n  async autoApprove() {\r\n    for (let i = 0; i < this.storeChips.length; i++) {\r\n      const { storeCode, status, planoId } = this.storeChips[i];\r\n      if (status === 'not_found') continue;\r\n\r\n      const planoRes: any = await lastValueFrom(this.apiService.getStoreFixtures({ id: [planoId] }))\r\n\r\n      if (!planoRes?.data?.[0]?.floors?.length) {\r\n        return;\r\n      }\r\n\r\n      this.planoData = structuredClone(planoRes.data[0]);\r\n\r\n      this.floorData = structuredClone(planoRes.data[0].floors[0]);\r\n\r\n      this.renderFloor(this.beforeCanvas);\r\n      this.renderFloor(this.afterCanvas);\r\n\r\n      this.loading = false;\r\n      setTimeout(() => {\r\n        this.resizeCanvas(this.beforeCanvas, this.beforeContainerRef);\r\n        this.fitCanvasToLayoutAnimated(this.beforeCanvas);\r\n\r\n        this.resizeCanvas(this.afterCanvas, this.afterContainerRef);\r\n        this.fitCanvasToLayoutAnimated(this.afterCanvas);\r\n      }, 100);\r\n\r\n      const payload = {\r\n        ...this.form.value,\r\n        stores: [storeCode]\r\n      };\r\n\r\n      const aiRes: any = await lastValueFrom(this.apiService.findFixtureAi(payload))\r\n\r\n      if (aiRes.code === 200) {\r\n        this.updateAiResponseFixture(aiRes.data)\r\n        this.renderFloor(this.afterCanvas)\r\n\r\n\r\n        setTimeout(() => {\r\n          const actionFixture = this.afterCanvas\r\n            .getObjects()\r\n            .find(\r\n              (obj: any) => {\r\n                return obj.objType === \"fixture\" && obj.fixtureId === aiRes.data._id\r\n              }\r\n            ) as fabric.Group | undefined;\r\n\r\n          if (!actionFixture) return;\r\n          this.highlightFixture(this.afterCanvas, actionFixture, true);\r\n        }, 0);\r\n      }\r\n\r\n      const updatePayload = {\r\n        fixtures: [this.selectedFixture]\r\n      }\r\n\r\n      await lastValueFrom(this.apiService.updateFixtureData(updatePayload))\r\n      this.storeChips[i].status = 'approved'\r\n      const activeChip = this.storeChips.find((chip) => chip.status === 'pending')\r\n      this.selectedStore = activeChip?.storeCode\r\n\r\n      await this.delay(3000);\r\n\r\n    }\r\n  }\r\n\r\n  approveStore() {\r\n    const payload = {\r\n      fixtures: [this.selectedFixture]\r\n    }\r\n\r\n    this.apiService.updateFixtureData(payload).subscribe({\r\n      next: (res: any) => {\r\n        if (res.code === 200) {\r\n          this.storeChips.find((chip) => chip.storeCode === this.selectedStore)!.status = 'approved'\r\n          const nextChip = this.storeChips.find((chip) => chip.status === 'pending')\r\n          this.selectedStore = nextChip?.storeCode\r\n          this.getStoreFixtures(nextChip!.planoId)\r\n        }\r\n      }\r\n    })\r\n  }\r\n\r\n  selectStore(chip: StoreChip) {\r\n    this.selectedStore = chip.storeCode\r\n    this.getStoreFixtures(chip.planoId)\r\n  }\r\n}\r\n","<form class=\"ai-container\" [formGroup]=\"form\" (ngSubmit)=\"submitPrompt()\">\r\n\r\n  <!-- ================= Applicable Stores ================= -->\r\n  <div class=\"field\">\r\n    <label>Applicable Stores</label>\r\n\r\n    <div class=\"d-flex gap-2 align-items-center\">\r\n      <input type=\"text\" class=\"form-control\" formControlName=\"stores\" placeholder=\"e.g. LKST345, LKST346\" />\r\n\r\n      <button type=\"button\" class=\"btn btn-outline\" (click)=\"applyStores()\">\r\n        Apply\r\n      </button>\r\n    </div>\r\n\r\n    <span class=\"error\" *ngIf=\"form.controls.stores.touched && form.controls.stores.invalid\">\r\n      Applicable stores is required\r\n    </span>\r\n  </div>\r\n\r\n  <!-- ================= Store Chips ================= -->\r\n  <div class=\"store-chips\" *ngIf=\"storeChips.length\">\r\n    <div (click)=\"selectStore(chip)\" class=\"store-chip\" *ngFor=\"let chip of storeChips\" [ngClass]=\"[\r\n      chip.status,\r\n      chip.storeCode === selectedStore ? 'active' : ''\r\n    ]\">\r\n      {{ chip.storeCode }}\r\n    </div>\r\n  </div>\r\n\r\n\r\n  <!-- ================= Update Type ================= -->\r\n  <div class=\"field\">\r\n    <label>Update Type</label>\r\n\r\n    <div class=\"radio-group\">\r\n      <label class=\"radio-option\">\r\n        <input type=\"radio\" formControlName=\"updateType\" value=\"vm\" />\r\n        VM\r\n      </label>\r\n\r\n      <label class=\"radio-option\">\r\n        <input type=\"radio\" formControlName=\"updateType\" value=\"pid\" />\r\n        PID\r\n      </label>\r\n    </div>\r\n\r\n    <span class=\"error\" *ngIf=\"form.controls.updateType.touched && form.controls.updateType.invalid\">\r\n      Update type is required\r\n    </span>\r\n  </div>\r\n\r\n  <!-- ================= AI Prompt ================= -->\r\n  <div class=\"field\">\r\n    <label>AI Prompt</label>\r\n\r\n    <div class=\"row\">\r\n\r\n      <!-- Selection Criteria -->\r\n      <div class=\"col-md-6\">\r\n        <div class=\"form-group\">\r\n          <label class=\"small fw-semibold\">Selection Criteria</label>\r\n\r\n          <textarea rows=\"3\" class=\"form-control\" formControlName=\"selectionCriteria\"\r\n            placeholder=\"e.g. Select premium shades on wall fixtures\"></textarea>\r\n\r\n          <span class=\"error\"\r\n            *ngIf=\"form.controls.selectionCriteria.touched && form.controls.selectionCriteria.invalid\">\r\n            Selection criteria is required\r\n          </span>\r\n        </div>\r\n      </div>\r\n\r\n      <!-- Updation Criteria -->\r\n      <div class=\"col-md-6\">\r\n        <div class=\"form-group\">\r\n          <label class=\"small fw-semibold\">Updation Criteria</label>\r\n\r\n          <textarea rows=\"3\" class=\"form-control\" formControlName=\"updationCriteria\"\r\n            placeholder=\"e.g. Move selected fixtures to mid shelves\"></textarea>\r\n\r\n          <span class=\"error\" *ngIf=\"form.controls.updationCriteria.touched && form.controls.updationCriteria.invalid\">\r\n            Updation criteria is required\r\n          </span>\r\n        </div>\r\n      </div>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <!-- ================= Submit ================= -->\r\n  <div class=\"d-flex justify-content-end mt-3\">\r\n    <button type=\"submit\" class=\"submit-btn\" [disabled]=\"loading\">\r\n      {{ loading ? 'Thinking…' : 'Submit' }}\r\n    </button>\r\n  </div>\r\n\r\n  <!-- ================= Canvases ================= -->\r\n  <div class=\"canvas-grid mt-4\">\r\n\r\n    <div class=\"canvas-box\" #beforeCanvasContainer>\r\n      <div class=\"canvas-title\">Before Update</div>\r\n      <canvas #beforeCanvas></canvas>\r\n    </div>\r\n\r\n    <div class=\"canvas-box\" #afterCanvasContainer>\r\n      <div class=\"canvas-title\">After Update</div>\r\n      <canvas #afterCanvas></canvas>\r\n    </div>\r\n\r\n  </div>\r\n\r\n  <div class=\"d-flex align-items-center justify-content-end\">\r\n    <!-- ================= Auto Approve ================= -->\r\n    <button (click)=\"autoApprove()\" type=\"button\" class=\"btn btn-warning me-3\">\r\n      ⚠ Auto Approve\r\n    </button>\r\n\r\n    <!-- ================= Approve Changes ================= -->\r\n    <button type=\"button\" class=\"btn btn-success\" (click)=\"approveStore()\" [disabled]=\"form.invalid\">\r\n      ✔ Approve Changes\r\n    </button>\r\n  </div>\r\n\r\n\r\n</form>"]}