const preventLabelOverlapPlugin = {
  id: "preventLabelOverlap",
  beforeInit(chart) {
    chart._labeloverlap = {
      updatingAnnotations: false,
    };
  },
  afterLayout(chart) {
    // Use afterLayout instead of afterUpdate
    if (chart._labeloverlap.updatingAnnotations) {
      return;
    }

    const annotations = chart.options.plugins.annotation.annotations;

    if (!annotations) return;

    const annotationsArray = Array.isArray(annotations)
      ? annotations
      : Object.values(annotations);

    const positionedLabels = [];
    const chartLeftBoundary = chart.chartArea.left;
    const chartRightBoundary = chart.chartArea.right;
    const chartTopBoundary = chart.chartArea.top;
    const chartBottomBoundary = chart.chartArea.bottom;

    annotationsArray.forEach((annotation) => {
      if (annotation.type === "label" && annotation.display !== false) {
        const xScale = chart.scales[annotation.xScaleID || "x"];
        const yScale = chart.scales[annotation.yScaleID || "y"];

        if (!xScale || !yScale) {
          console.warn("Scale not found for annotation", annotation);
          return;
        }

        const xValue = annotation.xValue;
        let yValue = annotation.yValue;

        let xPixel =
          xScale.getPixelForValue(xValue) + (annotation.xAdjust || 0);
        let yPixel =
          yScale.getPixelForValue(yValue) + (annotation.yAdjust || 0);

        const width = annotation.width || 120;
        const height = annotation.height || 0;

        let adjustedYPixel = yPixel;
        let adjustedXPixel = xPixel;

        const spacing = 15;

        // Adjust for left and right boundaries
        if (adjustedXPixel + width > chartRightBoundary) {
          adjustedXPixel = chartRightBoundary - width - 10;
        }

        if (adjustedXPixel < chartLeftBoundary + width) {
          adjustedXPixel = chartLeftBoundary + width / 2 + 10;
        }

        let safetyCounter = 0;
        let overlapFound;
        do {
          overlapFound = false;

          // Check for overlap with other labels
          for (let posLabel of positionedLabels) {
            if (
              adjustedXPixel < posLabel.x + posLabel.width + spacing &&
              adjustedXPixel + width + spacing > posLabel.x &&
              adjustedYPixel < posLabel.y + posLabel.height + spacing &&
              adjustedYPixel + height + spacing > posLabel.y
            ) {
              adjustedYPixel = posLabel.y - height - spacing;
              overlapFound = true;

              // If adjustedYPixel goes above the chart boundary, adjust X position instead
              if (adjustedYPixel < chartTopBoundary) {
                adjustedYPixel = chartTopBoundary + 10;
                adjustedXPixel += width + spacing;

                // Ensure X stays within the boundaries
                if (adjustedXPixel + width > chartRightBoundary) {
                  adjustedXPixel = chartRightBoundary - width - 10;
                }

                overlapFound = true;
              }
            }
          }

          safetyCounter++;
          if (safetyCounter >= 50) {
            console.warn(
              "Safety counter triggered to prevent infinite loop during overlap adjustments"
            );
            break;
          }
        } while (overlapFound);

        // Final enforcement for bottom boundary
        if (adjustedYPixel + height > chartBottomBoundary) {
          adjustedYPixel = chartBottomBoundary - height - 10;
        }

        const newYAdjust = adjustedYPixel - yPixel;
        const newXAdjust = adjustedXPixel - xPixel;
        annotation.yAdjust = (annotation.yAdjust || 0) + newYAdjust;
        annotation.xAdjust = (annotation.xAdjust || 0) + newXAdjust;

        positionedLabels.push({
          id: annotation.id,
          x: adjustedXPixel,
          y: adjustedYPixel,
          width: width,
          height: height,
        });
      }
    });

    // Assign z-index based on vertical position
    positionedLabels.sort((a, b) => a.y - b.y);
    positionedLabels.forEach((label, index) => {
      const annotation = annotationsArray.find((ann) => ann.id === label.id);
      if (annotation) {
        annotation.z = index + 1;
      }
    });

    chart._labeloverlap.updatingAnnotations = true;
    try {
      chart.update();
    } catch (error) {
      console.error("Error updating the chart:", error);
    }
    chart._labeloverlap.updatingAnnotations = false;
  },
};