code purpose:
each line when drawn must have a dimension line paralell to it with two arrowheads(which will be used for labeling the length later)

the problem:
everytime i draw a new line the arrowheads of the previous dimension line gets removed and i cant seem to find a fix for that

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QGraphicsView, QGraphicsScene, QVBoxLayout, QToolBar, QAction, QWidget,QGraphicsLineItem
from PyQt5.QtGui import QPen, QColor,QPolygonF,QBrush
from PyQt5.QtCore import Qt, QPointF,QRectF


class SketchView(QGraphicsView):
    def __init__(self):
        super().__init__()

        self.scene = QGraphicsScene(self)
        self.setScene(self.scene)

        # Set the initial visible area:

        self.grid_lines = []

        self.visible_area = QRectF(0, -2000, 3000, 2000)  # Start with a smaller visible area to fit within the new axes
        self.drawGrid()

       
        self.drawGrid() # Background grid

       
        self.setMouseTracking(True) # Enable mouse tracking

        # Initialize variables for panning and drawing
        self.dragging = False
        self.drawing = False
        self.last_pos = None
        self.start_point = None

        # Set the default zoom level
        self.default_zoom = (0.60, 0.50)
        self.current_zoom = self.default_zoom
        self.scale(self.current_zoom[0], self.current_zoom[1])

        # Drawing mode
        self.drawing_mode = None

        
        self.lines = []# List to store the drawn lines
        
        
        self.arrowheads = []# Initialize the arrowheads list to store arrowhead items

        
        self.line_dimension_map = {}#store each line with its related dimensionline 

        # Temporary lines
        self.temporary_line = None
        self.temporary_dimension_line = None


        self.dimension_line_arrows = {} # Store dimension lines and their accociated arrows


    def drawGrid(self):
        """
        Draws the grid in the visible area and ensures no overlapping.
        Clears previous grid lines before drawing new ones.
        """
        grid_spacing = 50
        pen = QPen(Qt.gray)

        # Clear old grid lines
        self.clearGridLines()

        # Calculate the rounded boundaries of the visible area
        x_min = int(self.visible_area.left() // grid_spacing) * grid_spacing
        x_max = int(self.visible_area.right() // grid_spacing) * grid_spacing
        y_min = int(self.visible_area.top() // grid_spacing) * grid_spacing
        y_max = int(self.visible_area.bottom() // grid_spacing) * grid_spacing

        # Draw vertical grid lines
        for x in range(x_min, x_max + grid_spacing, grid_spacing):
            line = self.scene.addLine(x, y_min, x, y_max, pen)
            self.grid_lines.append(line)

        # Draw horizontal grid lines
        for y in range(y_min, y_max + grid_spacing, grid_spacing):
            line = self.scene.addLine(x_min, y, x_max, y, pen)
            self.grid_lines.append(line)

        # Highlight the axes
        x_axis_pen = QPen(QColor(255, 0, 0))  # Red for x-axis
        y_axis_pen = QPen(QColor(0, 0, 255))  # Blue for y-axis
        x_axis_pen.setWidth(10)
        y_axis_pen.setWidth(10)
        #Update the axes to start from the bottom-left corner
        x_axis = self.scene.addLine(0, 0, 20000, 0, x_axis_pen)  # x-axis starts from (0, 0)
        y_axis = self.scene.addLine(0, 0, 0, -20000, y_axis_pen)  # y-axis starts from (0, 0)

        self.grid_lines.extend([x_axis, y_axis])


    def clearGridLines(self):
        """
        Removes the existing grid lines from the scene.
        """
        for line in self.grid_lines:
            self.scene.removeItem(line)
        self.grid_lines.clear()



    def wheelEvent(self, event):
        # Zoom in/out with mouse wheel
        delta = event.angleDelta().y() / 120
        zoom_factor = 1.1 if delta > 0 else 0.9
        new_zoom_x = self.current_zoom[0] * zoom_factor
        new_zoom_y = self.current_zoom[1] * zoom_factor

        # Calculate the corresponding visible area size
        current_width = self.visible_area.width() / self.current_zoom[0]
        current_height = self.visible_area.height() / self.current_zoom[1]

        # Prevent zooming out beyond 20,000 units
        if zoom_factor < 1.0 and (current_width >= 20000 or current_height >= 20000):
            return  # Do not apply further zoom-out

        # Apply the zoom
        self.scale(new_zoom_x / self.current_zoom[0], new_zoom_y / self.current_zoom[1])
        self.current_zoom = (new_zoom_x, new_zoom_y)

        # Extend the grid if zoomed outside the current visible area
        if new_zoom_x < self.default_zoom[0] or new_zoom_y < self.default_zoom[1]:
            self.scene.setSceneRect(self.scene.itemsBoundingRect())





    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            if self.drawing_mode and not self.lines:
                # Start the first line freely in drawing mode
                self.start_point = self.snapToGrid(self.mapToScene(event.pos()))
                self.drawing = True
            elif self.drawing_mode and self.lines:
                # Drawing continues from the end of the last line
                self.drawing = True
            elif self.drawing_mode is None:
                # Start panning
                self.dragging = True
                self.last_pos = event.pos()
                self.setCursor(Qt.ClosedHandCursor) 
                   

    def mouseMoveEvent(self, event):
        if self.dragging and self.drawing_mode is None:
            # Handle panning when not in drawing mode
            delta = event.pos() - self.last_pos
            self.horizontalScrollBar().setValue(
                self.horizontalScrollBar().value() - delta.x())
            self.verticalScrollBar().setValue(
                self.verticalScrollBar().value() - delta.y())
            self.last_pos = event.pos()
            self.setCursor(Qt.SizeAllCursor)
        elif self.drawing and self.start_point:
            # Draw a temporary line in drawing mode
            end_point = self.snapToGrid(self.mapToScene(event.pos()))
            self.drawTemporaryLine(self.start_point, end_point)

    def mouseReleaseEvent(self, event):
        if event.button() == Qt.LeftButton:
            if self.dragging and self.drawing_mode is None:
                # Stop panning
                self.dragging = False
                self.setCursor(Qt.ArrowCursor)
            elif self.drawing:
                # Finalize the current line
                end_point = self.snapToGrid(self.mapToScene(event.pos()))
                self.drawLine(self.start_point, end_point)

                # Check if the shape is closed
                if len(self.lines) > 1:
                    first_line_start = self.lines[0].line().p1()
                    if end_point == first_line_start:
                        # Shape is closed
                        self.drawing = False
                        self.drawing_mode = None
                        self.temp_line = None
                        self.update()  # Refresh the view
                        return

                # Automatically start a new line from the current endpoint
                self.start_point = end_point



    def drawTemporaryLine(self, start_point, end_point):
        """
        Draws a temporary line and its dimension line as the user moves the mouse.
        """
        # Remove any existing temporary lines
        if self.temporary_line:
            self.scene.removeItem(self.temporary_line)
            self.temporary_line = None

        if self.temporary_dimension_line:
            self.scene.removeItem(self.temporary_dimension_line)
            self.temporary_dimension_line = None

        # Draw the main temporary line
        temporary_pen = QPen(Qt.black)
        temporary_pen.setStyle(Qt.DashLine)
        temporary_pen.setWidth(self.pen_width)

        self.temporary_line = self.scene.addLine(
            start_point.x(), start_point.y(), end_point.x(), end_point.y(), temporary_pen)

        # Draw the temporary dimension line
        self.temporary_dimension_line = self.drawDimensionLine(start_point, end_point)
        


    def drawLine(self, start_point, end_point):
        """
        Draws a permanent line and adds it to the list of drawn lines.
        Calls drawDimensionLine to create a parallel dimension line.
        """
        # Draw the main line
        pen = QPen(self.pen_color)
        pen.setWidth(self.pen_width)
        main_line = self.scene.addLine(
            start_point.x(), start_point.y(), end_point.x(), end_point.y(), pen)
        self.lines.append(main_line)

        # Draw the associated dimension line
        dimension_line = self.drawDimensionLine(start_point, end_point)
        if dimension_line:  # Only store if a valid dimension line is created
            self.line_dimension_map[main_line] = dimension_line

        # Update the visible area and grid if necessary
        self.expandVisibleArea(end_point)



    def drawArrowHead(self, point, direction, line):
        """
        Draws a proper arrowhead at the given point in the specified direction.
        The arrowhead will be a triangle pointing in the direction of the line.
        """
        arrow_size = 15  # Size of the arrowhead, increase or decrease as needed
        arrow_angle = 30  # Angle of the arrowhead, can be adjusted for appearance

        # Calculate the points for the arrowhead (triangle)
        # The two points for the sides of the arrowhead
        left = QPointF(point.x() + direction.x() * arrow_size, point.y() + direction.y() * arrow_size)
        right = QPointF(point.x() - direction.x() * arrow_size, point.y() - direction.y() * arrow_size)

        # Add some slight angles to create the triangle shape (directional vector plus some rotation)
        left_angle = QPointF(left.x() + direction.y() * arrow_angle, left.y() - direction.x() * arrow_angle)
        right_angle = QPointF(right.x() + direction.y() * arrow_angle, right.y() - direction.x() * arrow_angle)

        # Create a QPolygonF for the arrowhead (triangle)
        arrow_head = QPolygonF([point, left_angle, right_angle])

        # Create a QPen for drawing the arrowhead
        arrow_pen = QPen(Qt.darkGray)
        arrow_pen.setWidth(2)  # Arrowhead should be thinner than the dimension line

        # Draw the arrowhead
        arrow_item = self.scene.addPolygon(arrow_head, arrow_pen)
        
        return arrow_item


    def drawDimensionLine(self, start_point, end_point):
        """
        Draws a parallel dimension line slightly shorter than the main line,
        adds arrowheads at both ends, and ensures previous arrowheads are removed.
        """
        dimension_pen = QPen(Qt.darkGray)
        dimension_pen.setWidth(6)
        offset = 20  # Distance from the main line
        shorter_factor = 0.85  # Dimension line will be slightly shorter
        
        # Calculate parallel points for the dimension line
        dx = end_point.x() - start_point.x()
        dy = end_point.y() - start_point.y()
        length = (dx**2 + dy**2)**0.5

        if length == 0:
            return None

        # Perpendicular unit vector
        nx = -dy / length
        ny = dx / length

        # Calculate offset points
        offset_start = QPointF(start_point.x() + nx * offset, start_point.y() + ny * offset)
        offset_end = QPointF(end_point.x() + nx * offset, end_point.y() + ny * offset)

        # Shorten the dimension line
        mid_x = (offset_start.x() + offset_end.x()) / 2
        mid_y = (offset_start.y() + offset_end.y()) / 2
        dimension_start = QPointF(mid_x + (offset_start.x() - mid_x) * shorter_factor,
                                  mid_y + (offset_start.y() - mid_y) * shorter_factor)
        
        dimension_end = QPointF(mid_x + (offset_end.x() - mid_x) * shorter_factor,
                                mid_y + (offset_end.y() - mid_y) * shorter_factor)

        # Draw the dimension line
        dimension_line = self.scene.addLine(
            dimension_start.x(), dimension_start.y(), dimension_end.x(), dimension_end.y(), dimension_pen)
        
        # Remove previous arrowheads before adding new ones
        for arrow in self.arrowheads:
            self.scene.removeItem(arrow)
        self.arrowheads.clear()

        # Draw arrowheads at both ends
        direction_start = QPointF(nx, ny)
        direction_end = QPointF(-nx, -ny)
        arrow_start = self.drawArrowHead(dimension_start, direction_start, dimension_line)
        arrow_end = self.drawArrowHead(dimension_end, direction_end, dimension_line)

        # Store the arrowheads to remove them later
        self.arrowheads = [arrow_start, arrow_end]

        return dimension_line


    def expandVisibleArea(self, point):
        """
        Expand the visible area to include the new point, allowing expansion 
        only in the positive x and y directions.
        """
        margin = 500  # Expand the grid by 500 units in all directions

        # Calculate the new boundaries for expansion
        new_left = self.visible_area.left()  # Fixed at 0
        new_top = min(self.visible_area.top(), point.y() - margin)  # Expand upwards
        new_right = max(self.visible_area.right(), point.x() + margin)  # Expand rightward
        new_bottom = self.visible_area.bottom()  # Fixed at 0

        # Update the visible area with the new boundaries
        self.visible_area = QRectF(new_left, new_top, new_right - new_left, new_bottom - new_top)
        self.drawGrid()  # Redraw the grid to include the expanded area





    def snapToGrid(self, point):
        # Snap a point to the nearest grid point
        grid_spacing = 50
        x = round(point.x() / grid_spacing) * grid_spacing
        y = round(point.y() / grid_spacing) * grid_spacing
        return QPointF(x, y)

    def DrawingMode(self, mode):
        # Set the drawing mode
        if self.drawing_mode == mode:
            self.drawing_mode = None

        else:
            self.drawing_mode = mode
            if mode == "external_wall":
                self.pen_color = Qt.black
                self.pen_width = 15
            elif mode == "internal_wall":
                self.pen_color = Qt.gray
                self.pen_width = 10


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # Create a central widget
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        layout = QVBoxLayout(central_widget)

        # Create a toolbar
        toolbar = QToolBar()
        self.addToolBar(Qt.LeftToolBarArea, toolbar)

        # Add actions to the toolbar
        external_wall_action = QAction("External Wall", self)
        external_wall_action.triggered.connect(lambda: self.sketch_view.DrawingMode("external_wall"))
        toolbar.addAction(external_wall_action)

        internal_wall_action = QAction("Internal Wall", self)
        internal_wall_action.triggered.connect(lambda: self.sketch_view.DrawingMode("internal_wall"))
        toolbar.addAction(internal_wall_action)


        # Add the QGraphicsView to the layout
        self.sketch_view = SketchView()
        layout.addWidget(self.sketch_view)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MainWindow()
    window.showMaximized()  # Start the program in full screen
    sys.exit(app.exec_())

the part where clears the temporary arrows to have a clean scene is this:

        for arrow in self.arrowheads:
            self.scene.removeItem(arrow)
        self.arrowheads.clear()

and without this part everything will be a mess(if you dont understand what i mean you may as well delete this part and run the code to see)but it seems to also remove the final arrowheads as well,i tried multiple things to keep those final arrows fixed at their position,but it doesnt seem to work,either i mess up something or program crashes completely

forexample:

       for arrow in self.arrowheads:
           if dimension_line:
               break
           else:
               self.scene.removeItem(arrow)
           self.arrowheads.clear()

here im trying to say if a dimension line is completed dont remove the arrow heads accociated to it

i know the fix might be actually simple,but i just cant seem to find it,tell me if you have any ideas-tnx