# Copyright (c) 2019-2022 Manfred Moitzi
# License: MIT License
from __future__ import annotations
from typing import TYPE_CHECKING, Optional, Union, Iterable, Iterator
import math
import logging
from ezdxf.audit import AuditError
from ezdxf.lldxf import validator, const
from ezdxf.lldxf.attributes import (
    DXFAttr,
    DXFAttributes,
    DefSubclass,
    XType,
    RETURN_DEFAULT,
    group_code_mapping,
)
from ezdxf.lldxf.const import (
    DXF12,
    SUBCLASS_MARKER,
    DXF2010,
    DXF2000,
    DXF2007,
    DXF2004,
    DXFValueError,
    DXFTableEntryError,
    DXFTypeError,
)
from ezdxf.lldxf.types import get_xcode_for
from ezdxf.math import Vec3, Matrix44, NULLVEC, Z_AXIS
from ezdxf.math.transformtools import OCSTransform, NonUniformScalingError
from ezdxf.tools import take2
from ezdxf.render.arrows import ARROWS
from ezdxf.explode import explode_entity
from ezdxf.entitydb import EntitySpace
from .dxfentity import base_class, SubclassProcessor
from .dxfgfx import DXFGraphic, acdb_entity
from .factory import register_entity
from .dimstyleoverride import DimStyleOverride

if TYPE_CHECKING:
    from ezdxf.entities import DXFNamespace, DXFEntity, DimStyle
    from ezdxf.lldxf.tagwriter import AbstractTagWriter
    from ezdxf.layouts import BaseLayout, BlockLayout
    from ezdxf.audit import Auditor
    from ezdxf.query import EntityQuery
    from ezdxf.math import OCS

logger = logging.getLogger("ezdxf")
ADSK_CONSTRAINTS = "*ADSK_CONSTRAINTS"

__all__ = [
    "Dimension",
    "ArcDimension",
    "RadialDimensionLarge",
    "OverrideMixin",
    "DXF_DIMENSION_TYPES",
]

DXF_DIMENSION_TYPES = {"DIMENSION", "ARC_DIMENSION", "LARGE_RADIAL_DIMENSION"}

acdb_dimension = DefSubclass(
    "AcDbDimension",
    {
        # Version number: 0 = 2010
        "version": DXFAttr(280, default=0, dxfversion=DXF2010),
        # Name of the block that contains the entities that make up the dimension
        # picture. Dimensions in block references share the same geometry block,
        # therefore deleting the geometry block is very dangerous!
        # Important: DIMENSION constraints do not have this group code 2:
        "geometry": DXFAttr(2, validator=validator.is_valid_block_name),
        # Dimension style name:
        "dimstyle": DXFAttr(
            3,
            default="Standard",
            validator=validator.is_valid_table_name,
            # Do not fix automatically, but audit fixes value as 'Standard'
        ),
        # definition point for all dimension types in WCS:
        "defpoint": DXFAttr(10, xtype=XType.point3d, default=NULLVEC),
        # Midpoint of dimension text in OCS:
        "text_midpoint": DXFAttr(11, xtype=XType.point3d),
        # Insertion point for clones of a dimension (Baseline and Continue?) (in OCS)
        # located in AcDbDimension? Another error in the DXF reference?
        "insert": DXFAttr(12, xtype=XType.point3d, default=NULLVEC, optional=True),
        # Dimension type:
        # Important: Dimensional constraints do not have group code 70
        # Values 0–6 are integer values that represent the dimension type.
        # Values 32, 64, and 128 are bit values, which are added to the integer
        # values (value 32 is always set in R13 and later releases)
        # 0 = Rotated, horizontal, or vertical;
        # 1 = Aligned
        # 2 = Angular;
        # 3 = Diameter;
        # 4 = Radius
        # 5 = Angular 3 point and ARC_DIMENSION < DXF R2018
        # 6 = Ordinate
        # 8 = ARC_DIMENSION >= DXF R2018
        # 32 = Indicates that the block reference (group code 2) is referenced by
        # this dimension only
        # 64 = Ordinate type. This is a bit value (bit 7) used only with integer
        #   value 6. If set, ordinate is X-type; if not set, ordinate is Y-type
        # 128 = This is a bit value (bit 8) added to the other group 70 values if
        #   the dimension text has been positioned at a user-defined location
        #   rather than at the default location.
        "dimtype": DXFAttr(70, default=0),
        # Attachment point:
        # 1 = Top left
        # 2 = Top center
        # 3 = Top right
        # 4 = Middle left
        # 5 = Middle center
        # 6 = Middle right
        # 7 = Bottom left
        # 8 = Bottom center
        # 9 = Bottom right
        "attachment_point": DXFAttr(
            71,
            default=5,
            dxfversion=DXF2000,
            validator=validator.is_in_integer_range(0, 10),
            fixer=RETURN_DEFAULT,
        ),
        # Dimension text line-spacing style
        # 1 (or missing) = At least (taller characters will override)
        # 2 = Exact (taller characters will not override)
        "line_spacing_style": DXFAttr(
            72,
            default=1,
            dxfversion=DXF2000,
            optional=True,
            validator=validator.is_in_integer_range(1, 3),
            fixer=RETURN_DEFAULT,
        ),
        # Dimension text-line spacing factor:
        # Percentage of default (3-on-5) line spacing to be applied. Valid values
        # range from 0.25 to 4.00
        "line_spacing_factor": DXFAttr(
            41,
            dxfversion=DXF2000,
            optional=True,
            validator=validator.is_in_float_range(0.25, 4.00),
            fixer=validator.fit_into_float_range(0.25, 4.00),
        ),
        # Actual measurement (optional; read-only value)
        "actual_measurement": DXFAttr(42, dxfversion=DXF2000, optional=True),
        "unknown1": DXFAttr(73, dxfversion=DXF2000, optional=True),
        "flip_arrow_1": DXFAttr(
            74,
            dxfversion=DXF2000,
            optional=True,
            validator=validator.is_integer_bool,
            fixer=validator.fix_integer_bool,
        ),
        "flip_arrow_2": DXFAttr(
            75,
            dxfversion=DXF2000,
            optional=True,
            validator=validator.is_integer_bool,
            fixer=validator.fix_integer_bool,
        ),
        # Dimension text explicitly entered by the user
        # default is the measurement.
        # If null or "<>", the dimension measurement is drawn as the text,
        # if " " (one blank space), the text is suppressed.
        # Anything else is drawn as the text.
        "text": DXFAttr(1, default="", optional=True),
        # Linear dimension types with an oblique angle have an optional group
        # code 52. When added to the rotation angle of the linear dimension (group
        # code 50), it gives the angle of the extension lines
        # DXF reference error: wrong subclass AcDbAlignedDimension
        "oblique_angle": DXFAttr(52, default=0, optional=True),
        # The optional group code 53 is the rotation angle of the dimension
        # text away from its default orientation (the direction of the dimension
        # line)
        "text_rotation": DXFAttr(53, default=0, optional=True),
        # All dimension types have an optional 51 group code, which
        # indicates the horizontal direction for the dimension entity.
        # The dimension entity determines the orientation of dimension text and
        # lines for horizontal, vertical, and rotated linear dimensions.
        # This group value is the negative of the angle between the OCS X axis and
        # the UCS X axis. It is always in the XY plane of the OCS
        "horizontal_direction": DXFAttr(51, default=0, optional=True),
        "extrusion": DXFAttr(
            210,
            xtype=XType.point3d,
            default=Z_AXIS,
            optional=True,
            validator=validator.is_not_null_vector,
            fixer=RETURN_DEFAULT,
        ),
    },
)
acdb_dimension_group_codes = group_code_mapping(acdb_dimension)

acdb_dimension_dummy = DefSubclass(
    "AcDbDimensionDummy",
    {
        # Definition point for linear and angular dimensions (in WCS)
        # 'defpoint' (10,20,30) specifies the dimension line location.
        # 'text_midpoint' (11,21,31) specifies the midpoint of the dimension text.
        # (13,23,33) specifies the start point of the first extension line:
        "defpoint2": DXFAttr(13, xtype=XType.point3d, default=NULLVEC),
        # (14,24,34) specifies the start point of the second extension line:
        "defpoint3": DXFAttr(14, xtype=XType.point3d, default=NULLVEC),
        # Angle of rotated, horizontal, or vertical dimensions:
        "angle": DXFAttr(50, default=0),
        # Definition point for diameter, radius, and angular dimensions (in WCS)
        "defpoint4": DXFAttr(15, xtype=XType.point3d, default=NULLVEC),
        # Leader length for radius and diameter dimensions
        "leader_length": DXFAttr(40),
        # Point defining dimension arc for angular dimensions (in OCS)
        # 'defpoint2' (13,23,33) and 'defpoint3' (14,24,34) specify the endpoints
        # of the line used to determine the first extension line.
        # 'defpoint' (10,20,30) and 'defpoint4' (15,25,35) specify the endpoints of
        # the line used to determine the second extension line.
        # 'defpoint5' (16,26,36) specifies the location of the dimension line arc.
        # 'text_midpoint' (11,21,31) specifies the midpoint of the dimension text.
        "defpoint5": DXFAttr(16, xtype=XType.point3d, default=NULLVEC),
    },
)
acdb_dimension_dummy_group_codes = group_code_mapping(acdb_dimension_dummy)


# noinspection PyUnresolvedReferences
class OverrideMixin:
    def get_dim_style(self) -> DimStyle:
        """Returns the associated :class:`DimStyle` entity."""
        assert self.doc is not None, "valid DXF document required"  # type: ignore

        dim_style_name = self.dxf.dimstyle  # type: ignore
        # raises ValueError if not exist, but all dim styles in use should
        # exist!
        return self.doc.dimstyles.get(dim_style_name)  # type: ignore

    def dim_style_attributes(self) -> DXFAttributes:
        """Returns all valid DXF attributes (internal API)."""
        return self.get_dim_style().DXFATTRIBS

    def dim_style_attr_names_to_handles(self, data: dict, dxfversion: str) -> dict:
        """`Ezdxf` uses internally only resource names for arrows, linetypes
        and text styles, but DXF 2000 and later requires handles for these
        resources, this method translates resource names into related handles.
        (e.g. 'dimtxsty': 'FancyStyle' -> 'dimtxsty_handle', <handle of FancyStyle>)

        Args:
            data: dictionary of overridden DimStyle attributes as names (ezdxf)
            dxfversion: target DXF version

        Returns: dictionary with resource names replaced by handles

        Raises:
            DXFTableEntry: text style or line type does not exist
            DXFKeyError: referenced block does not exist

        (internal API)

        """
        data = dict(data)
        blocks = self.doc.blocks  # type: ignore

        def set_arrow_handle(attrib_name, block_name):
            attrib_name += "_handle"
            if block_name in ARROWS:
                # Create all arrows on demand
                block_name = ARROWS.create_block(blocks, block_name)
            if block_name == "_CLOSEDFILLED":  # special arrow
                handle = "0"  # set special #0 handle for closed filled arrow
            else:
                block = blocks[block_name]
                handle = block.block_record_handle
            data[attrib_name] = handle

        def set_linetype_handle(attrib_name, linetype_name):
            try:
                ltype = self.doc.linetypes.get(linetype_name)
            except DXFTableEntryError:
                logger.warning(f'Required line type "{linetype_name}" does not exist.')
            else:
                data[attrib_name + "_handle"] = ltype.dxf.handle

        if dxfversion > DXF12:
            # transform block names into block record handles
            for attrib_name in ("dimblk", "dimblk1", "dimblk2", "dimldrblk"):
                try:
                    block_name = data.pop(attrib_name)
                except KeyError:
                    pass
                else:
                    set_arrow_handle(attrib_name, block_name)

            # replace 'dimtxsty' attribute by 'dimtxsty_handle'
            try:
                dimtxsty = data.pop("dimtxsty")
            except KeyError:
                pass
            else:
                txtstyle = self.doc.styles.get(dimtxsty)  # type: ignore
                data["dimtxsty_handle"] = txtstyle.dxf.handle

        if dxfversion >= DXF2007:
            # transform linetype names into LTYPE entry handles
            for attrib_name in ("dimltype", "dimltex1", "dimltex2"):
                try:
                    linetype_name = data.pop(attrib_name)
                except KeyError:
                    pass
                else:
                    set_linetype_handle(attrib_name, linetype_name)
        return data

    def set_acad_dstyle(self, data: dict) -> None:
        """Set XDATA section ACAD:DSTYLE, to override DIMSTYLE attributes for
        this DIMENSION entity.

        Args:
            data: ``dict`` with DIMSTYLE attribute names as keys.

        (internal API)

        """
        assert self.doc is not None, "valid DXF document required"  # type: ignore
        # ezdxf uses internally only resource names for arrows, line types and
        # text styles, but DXF 2000 and later requires handles for these
        # resources:
        actual_dxfversion = self.doc.dxfversion  # type: ignore
        data = self.dim_style_attr_names_to_handles(data, actual_dxfversion)
        tags = []
        dim_style_attributes = self.dim_style_attributes()
        for key, value in data.items():
            if key not in dim_style_attributes:
                logger.debug(f'Ignore unknown DIMSTYLE attribute: "{key}"')
                continue
            dxf_attr = dim_style_attributes.get(key)
            # Skip internal and virtual tags:
            if dxf_attr and dxf_attr.code > 0:
                if dxf_attr.dxfversion > actual_dxfversion:
                    logger.debug(
                        f'Unsupported DIMSTYLE attribute "{key}" for '  # type: ignore
                        f"DXF version {self.doc.acad_release}"  # type: ignore
                    )
                    continue
                code = dxf_attr.code
                tags.append((1070, code))
                if code == 5:
                    # DimStyle 'dimblk' has group code 5 but is not a handle
                    tags.append((1000, value))
                else:
                    tags.append((get_xcode_for(code), value))

        if len(tags):
            self.set_xdata_list("ACAD", "DSTYLE", tags)  # type: ignore

    def dim_style_attr_handles_to_names(self, data: dict) -> dict:
        """`Ezdxf` uses internally only resource names for arrows, line types
        and text styles, but DXF 2000 and later requires handles for these
        resources, this method translates resource handles into related names.
        (e.g. 'dimtxsty_handle', <handle of FancyStyle> -> 'dimtxsty': 'FancyStyle')

        Args:
            data: dictionary of overridden DimStyle attributes as handles,
                requires DXF R2000+

        Returns: dictionary with resource as handles replaced by names

        Raises:
            DXFTableEntry: text style or line type does not exist
            DXFKeyError: referenced block does not exist

        (internal API)

        """
        data = dict(data)
        db = self.doc.entitydb  # type: ignore

        def set_arrow_name(attrib_name: str, handle: str):
            # Special handle for default arrow CLOSEDFILLED:
            if handle == "0":
                # Special name for default arrow CLOSEDFILLED:
                data[attrib_name] = ""
                return
            try:
                block_record = db[handle]
            except KeyError:
                logger.warning(
                    f"Required arrow block #{handle} does not exist, "
                    f"ignoring {attrib_name.upper()} override."
                )
                return
            name = block_record.dxf.name
            # Translate block name into ACAD standard name _OPEN30 -> OPEN30
            if name.startswith("_"):
                acad_arrow_name = name[1:]
                if ARROWS.is_acad_arrow(acad_arrow_name):
                    name = acad_arrow_name
            data[attrib_name] = name

        def set_ltype_name(attrib_name: str, handle: str):
            try:
                ltype = db[handle]
            except KeyError:
                logger.warning(
                    f"Required line type #{handle} does not exist, "
                    f"ignoring {attrib_name.upper()} override."
                )
            else:
                data[attrib_name] = ltype.dxf.name

        # transform block record handles into block names
        for attrib_name in ("dimblk", "dimblk1", "dimblk2", "dimldrblk"):
            blkrec_handle = data.pop(attrib_name + "_handle", None)
            if blkrec_handle:
                set_arrow_name(attrib_name, blkrec_handle)

        # replace 'dimtxsty_handle' attribute by 'dimtxsty'
        dimtxsty_handle = data.pop("dimtxsty_handle", None)
        if dimtxsty_handle:
            try:
                txtstyle = db[dimtxsty_handle]
            except KeyError:
                logger.warning(
                    f"Required text style #{dimtxsty_handle} does not exist, "
                    f"ignoring DIMTXSTY override."
                )
            else:
                data["dimtxsty"] = txtstyle.dxf.name

        # transform linetype handles into LTYPE entry names
        for attrib_name in ("dimltype", "dimltex1", "dimltex2"):
            handle = data.pop(attrib_name + "_handle", None)
            if handle:
                set_ltype_name(attrib_name, handle)
        return data

    def get_acad_dstyle(self, dim_style: DimStyle) -> dict:
        """Get XDATA section ACAD:DSTYLE, to override DIMSTYLE attributes for
        this DIMENSION entity. Returns a ``dict`` with DIMSTYLE attribute names
        as keys.

        (internal API)
        """
        try:
            data = self.get_xdata_list("ACAD", "DSTYLE")  # type: ignore
        except DXFValueError:
            return {}
        attribs = {}
        codes = dim_style.CODE_TO_DXF_ATTRIB
        for code_tag, value_tag in take2(data):
            group_code = code_tag.value
            value = value_tag.value
            if group_code in codes:
                attribs[codes[group_code]] = value
        return self.dim_style_attr_handles_to_names(attribs)


@register_entity
class Dimension(DXFGraphic, OverrideMixin):
    """DXF DIMENSION entity"""

    DXFTYPE = "DIMENSION"
    DXFATTRIBS = DXFAttributes(
        base_class, acdb_entity, acdb_dimension, acdb_dimension_dummy
    )
    LINEAR = 0
    ALIGNED = 1
    ANGULAR = 2
    DIAMETER = 3
    RADIUS = 4
    ANGULAR_3P = 5
    ORDINATE = 6
    ARC = 8
    ORDINATE_TYPE = 64
    USER_LOCATION_OVERRIDE = 128

    # WARNING for destroy() method:
    # Do not destroy associated anonymous block, if DIMENSION is used in a
    # block, the same geometry block maybe used by multiple block references.
    def __init__(self) -> None:
        super().__init__()
        # store the content of the geometry block for virtual entities
        self.virtual_block_content: Optional[EntitySpace] = None

    def copy(self) -> Dimension:
        virtual_copy = super().copy()
        # The new virtual copy can not reference the same geometry block as the
        # original dimension entity:
        virtual_copy.dxf.discard("geometry")
        return virtual_copy  # type: ignore

    def copy_data(self, entity: DXFEntity) -> None:
        assert isinstance(entity, Dimension)
        if self.virtual_block_content:
            # another copy of a virtual entity:
            virtual_content = EntitySpace(e.copy() for e in self.virtual_block_content)
        else:
            # entity is a new virtual copy of self and can not share the same
            # geometry block to be independently transformable:
            virtual_content = EntitySpace(self.virtual_entities())
            # virtual_entities() returns the entities already translated
            # to the insert location:
            entity.dxf.discard("insert")
        entity.virtual_block_content = virtual_content

    def post_bind_hook(self):
        """Called after binding a virtual dimension entity to a document.

        This method is not called at the loading stage and virtual dimension
        entities do not exist at the loading stage!

        """
        doc = self.doc
        if self.virtual_block_content and doc is not None:
            # create a new geometry block:
            block = self.doc.blocks.new_anonymous_block(type_char="D")
            # move virtual block content to the new geometry block:
            for entity in self.virtual_block_content:
                block.add_entity(entity)
            self.dxf.geometry = block.name
            # unlink virtual block content:
            self.virtual_block_content = None

    def load_dxf_attribs(
        self, processor: Optional[SubclassProcessor] = None
    ) -> DXFNamespace:
        dxf = super().load_dxf_attribs(processor)
        if processor:
            processor.fast_load_dxfattribs(
                dxf, acdb_dimension_group_codes, 2, recover=True
            )
            processor.fast_load_dxfattribs(
                dxf, acdb_dimension_dummy_group_codes, 3, log=False
            )
            # Ignore possible 5. subclass AcDbRotatedDimension, which has no
            # content.
        return dxf

    def export_entity(self, tagwriter: AbstractTagWriter) -> None:
        """Export entity specific data as DXF tags."""
        super().export_entity(tagwriter)
        if tagwriter.dxfversion == DXF12:
            self.dxf.export_dxf_attribs(
                tagwriter,
                [
                    "geometry",
                    "dimstyle",
                    "defpoint",
                    "text_midpoint",
                    "insert",
                    "dimtype",
                    "text",
                    "defpoint2",
                    "defpoint3",
                    "defpoint4",
                    "defpoint5",
                    "leader_length",
                    "angle",
                    "horizontal_direction",
                    "oblique_angle",
                    "text_rotation",
                ],
            )
            return

        # else DXF2000+
        tagwriter.write_tag2(SUBCLASS_MARKER, acdb_dimension.name)
        dim_type = self.dimtype
        self.dxf.export_dxf_attribs(
            tagwriter,
            [
                "version",
                "geometry",
                "dimstyle",
                "defpoint",
                "text_midpoint",
                "insert",
                "dimtype",
                "attachment_point",
                "line_spacing_style",
                "line_spacing_factor",
                "actual_measurement",
                "unknown1",
                "flip_arrow_1",
                "flip_arrow_2",
                "text",
                "oblique_angle",
                "text_rotation",
                "horizontal_direction",
                "extrusion",
            ],
        )
        # Processing by dimtype works only for the original DIMENSION entity.
        # Until DXF R2018 dimtype 5 was shared between ARC_DIMENSION and
        # angular & angular3p DIMENSION, which have different subclass
        # structures!
        if self.dxftype() != "DIMENSION":
            return

        if dim_type == 0:  # linear
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbAlignedDimension")
            self.dxf.export_dxf_attribs(tagwriter, ["defpoint2", "defpoint3", "angle"])
            # empty but required subclass
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbRotatedDimension")
        elif dim_type == 1:  # aligned
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbAlignedDimension")
            self.dxf.export_dxf_attribs(tagwriter, ["defpoint2", "defpoint3", "angle"])
        elif dim_type == 2:  # angular & angular3p
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDb2LineAngularDimension")
            self.dxf.export_dxf_attribs(
                tagwriter, ["defpoint2", "defpoint3", "defpoint4", "defpoint5"]
            )
        elif dim_type == 3:  # diameter
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbDiametricDimension")
            self.dxf.export_dxf_attribs(tagwriter, ["defpoint4", "leader_length"])
        elif dim_type == 4:  # radius
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbRadialDimension")
            self.dxf.export_dxf_attribs(tagwriter, ["defpoint4", "leader_length"])
        elif dim_type == 5:  # angular & angular3p
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDb3PointAngularDimension")
            self.dxf.export_dxf_attribs(
                tagwriter, ["defpoint2", "defpoint3", "defpoint4", "defpoint5"]
            )
        elif dim_type == 6:  # ordinate
            tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbOrdinateDimension")
            self.dxf.export_dxf_attribs(tagwriter, ["defpoint2", "defpoint3"])

    @property
    def dimtype(self) -> int:
        """:attr:`dxf.dimtype` without binary flags (32, 62, 128)."""
        # undocumented ARC_DIMENSION = 8 (DXF R2018)
        return self.dxf.dimtype & 15

    # Special DIMENSION - Dimensional constraints
    # No information in the DXF reference:
    # layer name is "*ADSK_CONSTRAINTS"
    # missing group code 2 - geometry block name
    # missing group code 70 - dimension type
    # has reactor to ACDBASSOCDEPENDENCY object
    # Autodesk example: architectural_example-imperial.dxf
    @property
    def is_dimensional_constraint(self) -> bool:
        """Returns ``True`` if the DIMENSION entity is a dimensional
        constraint object.
        """
        dxf = self.dxf
        return not dxf.hasattr("dimtype") and dxf.layer == ADSK_CONSTRAINTS

    def get_geometry_block(self) -> Optional[BlockLayout]:
        """Returns :class:`~ezdxf.layouts.BlockLayout` of associated anonymous
        dimension block, which contains the entities that make up the dimension
        picture. Returns ``None`` if block name is not set or the BLOCK itself
        does not exist

        """
        block_name = self.dxf.get("geometry", "*")
        return self.doc.blocks.get(block_name)  # type: ignore

    def get_measurement(self) -> Union[float, Vec3]:
        """Returns the actual dimension measurement in :ref:`WCS` units, no
        scaling applied for linear dimensions. Returns angle in degrees for
        angular dimension from 2 lines and angular dimension from 3 points.
        Returns vector from origin to feature location for ordinate dimensions.

        """
        tool = MEASUREMENT_TOOLS.get(self.dimtype)
        if tool:
            return tool(self)
        else:
            raise TypeError(f"Unknown DIMENSION type {self.dimtype}.")

    def override(self) -> DimStyleOverride:
        """Returns the :class:`~ezdxf.entities.DimStyleOverride` object."""
        return DimStyleOverride(self)

    def render(self) -> None:
        """Renders the graphical representation of the DIMENSION entity as DXF
        primitives (TEXT, LINE, ARC, ...) into an anonymous content BLOCK.
        """
        if self.is_virtual:
            raise DXFTypeError("can not render virtual entity")
        # Do not delete existing anonymous block, it is maybe referenced
        # by a dimension entity in another block reference! Dimensions in block
        # references share the same geometry block!
        self.override().render()

    def transform(self, m: Matrix44) -> Dimension:
        """Transform the DIMENSION entity by transformation matrix `m` inplace.

        Raises ``NonUniformScalingError()`` for non uniform scaling.

        """

        def transform_if_exist(name: str, func):
            if dxf.hasattr(name):
                dxf.set(name, func(dxf.get(name)))

        dxf = self.dxf
        ocs = OCSTransform(self.dxf.extrusion, m)

        for vertex_name in ("text_midpoint", "defpoint5", "insert"):
            transform_if_exist(vertex_name, ocs.transform_vertex)

        for angle_name in ("text_rotation", "horizontal_direction", "angle"):
            transform_if_exist(angle_name, ocs.transform_deg_angle)

        for vertex_name in ("defpoint", "defpoint2", "defpoint3", "defpoint4"):
            transform_if_exist(vertex_name, m.transform)

        dxf.extrusion = ocs.new_extrusion

        # ignore cloned geometry, this would transform the block content
        # multiple times:
        if not dxf.hasattr("insert"):
            self._transform_block_content(m)
        self.post_transform(m)
        return self

    def _block_content(self) -> Iterable[DXFGraphic]:
        if self.virtual_block_content or self.is_virtual:
            content = self.virtual_block_content
        else:
            content = self.get_geometry_block()  # type: ignore
        return content or []  # type: ignore

    def _transform_block_content(self, m: Matrix44) -> None:
        for entity in self._block_content():
            try:
                entity.transform(m)
            except (NotImplementedError, NonUniformScalingError):
                pass  # ignore transformation errors

    def __virtual_entities__(self) -> Iterator[DXFGraphic]:
        """Implements the SupportsVirtualEntities protocol."""

        def ocs_to_wcs(e: DXFGraphic, elevation: float):
            # - OCS entities have to get the extrusion vector and the
            #   elevation of the DIMENSION entity
            # - WCS entities have to be transformed to the WCS
            dxftype = e.dxftype()
            dxf = e.dxf
            if dxftype == "LINE":
                dxf.start = ocs.to_wcs(dxf.start.replace(z=elevation))
                dxf.end = ocs.to_wcs(dxf.end.replace(z=elevation))
            elif dxftype == "MTEXT":
                e.convert_rotation_to_text_direction()  # type: ignore
                dxf.extrusion = ocs.uz
                dxf.text_direction = ocs.to_wcs(dxf.text_direction)
                dxf.insert = ocs.to_wcs(dxf.insert.replace(z=elevation))
            elif dxftype == "POINT":
                dxf.location = ocs.to_wcs(dxf.location.replace(z=elevation))
            else:  # OCS entities
                dxf.extrusion = ocs.uz
                # set elevation:
                if dxf.hasattr("insert"):  # INSERT, TEXT
                    dxf.insert = dxf.insert.replace(z=elevation)
                elif dxf.hasattr("center"):  # ARC, CIRCLE
                    dxf.center = dxf.center.replace(z=elevation)
                elif dxftype == "SOLID":
                    # AutoCAD uses the SOLID entity to render the "solid fill"
                    # arrow directly without using a block reference as usual. >:(
                    for vtx_name in const.VERTEXNAMES:
                        point = dxf.get(vtx_name, NULLVEC).replace(z=elevation)
                        dxf.set(vtx_name, point)

        ocs = self.ocs()
        dim_elevation = self.dxf.text_midpoint.z
        transform = False
        insert = self.dxf.get("insert", None)
        if insert:
            transform = True
            insert = ocs.to_wcs(insert)
            m = Matrix44.translate(insert.x, insert.y, insert.z)

        for entity in self._block_content():
            try:
                copy = entity.copy()
            except DXFTypeError:
                continue

            if ocs.transform:
                # All block content entities are located in the OCS defined by
                # the DIMENSION entity, even the WCS entities LINE, MTEXT and
                # POINT:
                ocs_to_wcs(copy, dim_elevation)

            if transform:
                # noinspection PyUnboundLocalVariable
                copy.transform(m)
            yield copy

    def virtual_entities(self) -> Iterator[DXFGraphic]:
        """Yields the graphical representation of the anonymous content BLOCK as virtual
        DXF primitives (LINE, ARC, TEXT, ...).

        These virtual entities are located at the original location of the DIMENSION entity,
        but they are not stored in the entity database, have no handle and are not
        assigned to any layout.

        """
        return self.__virtual_entities__()

    def explode(self, target_layout: Optional[BaseLayout] = None) -> EntityQuery:
        """Explodes the graphical representation of the DIMENSION entity as DXF
        primitives (LINE, ARC, TEXT, ...) into the target layout, ``None`` for the same
        layout as the source DIMENSION entity.

        Returns an :class:`~ezdxf.query.EntityQuery` container containing all DXF
        primitives.

        Args:
            target_layout: target layout for the DXF primitives, ``None`` for same
                layout as source DIMENSION entity.

        """
        return explode_entity(self, target_layout)

    def destroy(self) -> None:
        # Let virtual content just go out of scope:
        del self.virtual_block_content
        super().destroy()

    def __referenced_blocks__(self) -> Iterable[str]:
        """Support for "ReferencedBlocks" protocol."""
        if self.doc:
            block_name = self.dxf.get("geometry", None)
            if block_name:
                block = self.doc.blocks.get(block_name)
                if block is not None:
                    return (block.block_record_handle,)
        return tuple()

    def audit(self, auditor: Auditor) -> None:
        super().audit(auditor)
        doc = auditor.doc
        dxf = self.dxf

        if dxf.get("geometry", "*") not in doc.blocks:
            auditor.fixed_error(
                code=AuditError.UNDEFINED_BLOCK,
                message=f"Removed {str(self)} without valid geometry block.",
            )
            auditor.trash(self)
            return

        dimstyle = dxf.get("dimstyle", "Standard")
        if not doc.dimstyles.has_entry(dimstyle):
            auditor.fixed_error(
                code=AuditError.INVALID_DIMSTYLE,
                message=f"Replaced invalid DIMSTYLE '{dimstyle}' by 'Standard'.",
            )
            dxf.discard("dimstyle")
        # AutoCAD ignores invalid data in the XDATA section, no need to
        # check or repair. Ezdxf also ignores invalid XDATA overrides.


acdb_arc_dimension = DefSubclass(
    "AcDbArcDimension",
    {
        # start point of the 1st extension line:
        "defpoint2": DXFAttr(13, xtype=XType.point3d, default=NULLVEC),
        # start point of the 2ndt extension line:
        "defpoint3": DXFAttr(14, xtype=XType.point3d, default=NULLVEC),
        # center of arc:
        "defpoint4": DXFAttr(15, xtype=XType.point3d, default=NULLVEC),
        "start_angle": DXFAttr(40),  # radians, unknown meaning
        "end_angle": DXFAttr(41),  # radians, unknown meaning
        "is_partial": DXFAttr(70, validator=validator.is_integer_bool),
        "has_leader": DXFAttr(71, validator=validator.is_integer_bool),
        "leader_point1": DXFAttr(16, xtype=XType.point3d, default=NULLVEC),
        "leader_point2": DXFAttr(17, xtype=XType.point3d, default=NULLVEC),
    },
)
acdb_arc_dimension_group_codes = group_code_mapping(acdb_arc_dimension)


@register_entity
class ArcDimension(Dimension):
    """DXF ARC_DIMENSION entity"""

    # dimtype is 5 for DXF version <= R2013
    # dimtype is 8 for DXF version >= R2018

    DXFTYPE = "ARC_DIMENSION"
    DXFATTRIBS = DXFAttributes(
        base_class, acdb_entity, acdb_dimension, acdb_arc_dimension
    )
    MIN_DXF_VERSION_FOR_EXPORT = DXF2000

    def load_dxf_attribs(
        self, processor: Optional[SubclassProcessor] = None
    ) -> DXFNamespace:
        # Skip Dimension loader:
        dxf = super(Dimension, self).load_dxf_attribs(processor)
        if processor:
            processor.fast_load_dxfattribs(
                dxf, acdb_dimension_group_codes, 2, recover=True
            )
            processor.fast_load_dxfattribs(
                dxf, acdb_arc_dimension_group_codes, 3, recover=True
            )
        return dxf

    def versioned_dimtype(self, dxfversion: str) -> int:
        if dxfversion > const.DXF2013:
            return (self.dxf.dimtype & 0xFFF0) | 8
        else:
            return (self.dxf.dimtype & 0xFFF0) | 5

    def export_entity(self, tagwriter: AbstractTagWriter) -> None:
        """Export entity specific data as DXF tags."""
        dimtype = self.dxf.dimtype  # preserve original dimtype
        self.dxf.dimtype = self.versioned_dimtype(tagwriter.dxfversion)
        super().export_entity(tagwriter)
        tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbArcDimension")
        self.dxf.export_dxf_attribs(
            tagwriter,
            [
                "defpoint2",
                "defpoint3",
                "defpoint4",
                "start_angle",
                "end_angle",
                "is_partial",
                "has_leader",
                "leader_point1",
                "leader_point2",
            ],
        )
        self.dxf.dimtype = dimtype  # restore original dimtype

    def transform(self, m: Matrix44) -> Dimension:
        """Transform the ARC_DIMENSION entity by transformation matrix `m` inplace.

        Raises ``NonUniformScalingError()`` for non uniform scaling.

        """

        def transform_if_exist(name: str, func):
            if dxf.hasattr(name):
                dxf.set(name, func(dxf.get(name)))

        dxf = self.dxf
        super().transform(m)
        for vertex_name in ("leader_point1", "leader_point2"):
            transform_if_exist(vertex_name, m.transform)

        return self


acdb_radial_dimension_large = DefSubclass(
    "AcDbRadialDimensionLarge",
    {
        # center_point = def_point from subclass AcDbDimension
        "chord_point": DXFAttr(13, xtype=XType.point3d, default=NULLVEC),
        "override_center": DXFAttr(14, xtype=XType.point3d, default=NULLVEC),
        "jog_point": DXFAttr(15, xtype=XType.point3d, default=NULLVEC),
        "unknown2": DXFAttr(40),
    },
)
acdb_radial_dimension_large_group_codes = group_code_mapping(
    acdb_radial_dimension_large
)


# Undocumented DXF entity - OpenDesignAlliance DWG Specification:
# chapter 20.4.30
@register_entity
class RadialDimensionLarge(Dimension):
    """DXF LARGE_RADIAL_DIMENSION entity"""

    DXFTYPE = "LARGE_RADIAL_DIMENSION"
    DXFATTRIBS = DXFAttributes(
        base_class, acdb_entity, acdb_dimension, acdb_radial_dimension_large
    )
    MIN_DXF_VERSION_FOR_EXPORT = DXF2004

    def load_dxf_attribs(
        self, processor: Optional[SubclassProcessor] = None
    ) -> DXFNamespace:
        # Skip Dimension loader:
        dxf = super(Dimension, self).load_dxf_attribs(processor)
        if processor:
            processor.fast_load_dxfattribs(
                dxf, acdb_dimension_group_codes, 2, recover=True
            )
            processor.fast_load_dxfattribs(
                dxf, acdb_radial_dimension_large_group_codes, 3, recover=True
            )
        return dxf

    def export_entity(self, tagwriter: AbstractTagWriter) -> None:
        """Export entity specific data as DXF tags."""
        super().export_entity(tagwriter)
        tagwriter.write_tag2(SUBCLASS_MARKER, "AcDbRadialDimensionLarge")
        self.dxf.export_dxf_attribs(
            tagwriter,
            ["chord_point", "override_center", "jog_point", "unknown2"],
        )

    def transform(self, m: Matrix44) -> Dimension:
        """Transform the LARGE_RADIAL_DIMENSION entity by transformation matrix
        `m` inplace.

        Raises ``NonUniformScalingError()`` for non uniform scaling.

        """

        def transform_if_exist(name: str, func):
            if dxf.hasattr(name):
                dxf.set(name, func(dxf.get(name)))

        dxf = self.dxf
        super().transform(m)
        # todo: are these WCS points?
        for vertex_name in ("chord_point", "override_center", "Jog_point"):
            transform_if_exist(vertex_name, m.transform)

        return self


# XDATA extension - meaning unknown
# 1001, ACAD_DSTYLE_DIMRADIAL_EXTENSION
# 1070, 387
# 1070, 1
# 1070, 388
# 1040, 0.0
# 1070, 390
# 1040, 0.0


# todo: DIMASSOC
acdb_dim_assoc = DefSubclass(
    "AcDbDimAssoc",
    {
        # Handle of dimension object:
        "dimension": DXFAttr(330),
        # Associativity flag (bit-coded)
        # 1 = First point reference
        # 2 = Second point reference
        # 4 = Third point reference
        # 8 = Fourth point reference
        "point_flag": DXFAttr(90),
        "trans_space": DXFAttr(
            70,
            validator=validator.is_integer_bool,
            fixer=validator.fix_integer_bool,
        ),
        # Rotated Dimension type (parallel, perpendicular)
        # Autodesk gone crazy: subclass AcDbOsnapPointRef with group code 1!!!!!
        #  }), DefSubclass('AcDbOsnapPointRef', {
        "rotated_dim_type": DXFAttr(71),
        # Object Osnap type:
        # 0 = None
        # 1 = Endpoint
        # 2 = Midpoint
        # 3 = Center
        # 4 = Node
        # 5 = Quadrant
        # 6 = Intersection
        # 7 = Insertion
        # 8 = Perpendicular
        # 9 = Tangent
        # 10 = Nearest
        # 11 = Apparent intersection
        # 12 = Parallel
        # 13 = Start point
        "osnap_type": DXFAttr(
            72,
            validator=validator.is_in_integer_range(0, 14),
            fixer=validator.fit_into_integer_range(0, 14),
        ),
        # ID of main object (geometry)
        "object_id": DXFAttr(331),
        # Subtype of main object (edge, face)
        "object_subtype": DXFAttr(73),
        # GsMarker of main object (index)
        "object_gs_marker": DXFAttr(91),
        # Handle (string) of Xref object
        "object_xref_id": DXFAttr(301),
        # Geometry parameter for Near Osnap
        "near_param": DXFAttr(40),
        # Osnap point in WCS
        "osnap_point": DXFAttr(10, xtype=XType.point3d),
        # ID of intersection object (geometry)
        "intersect_id": DXFAttr(332),
        # Subtype of intersection object (edge/face)
        "intersect_subtype": DXFAttr(74),
        # GsMarker of intersection object (index)
        "intersect_gs_marker": DXFAttr(92),
        # Handle (string) of intersection Xref object
        "intersect_xref_id": DXFAttr(302),
        # hasLastPointRef flag (true/false)
        "has_last_point_ref": DXFAttr(
            75,
            validator=validator.is_integer_bool,
            fixer=validator.fix_integer_bool,
        ),
    },
)


def measure_linear_distance(dim: Dimension) -> float:
    dxf = dim.dxf
    return linear_measurement(
        dxf.defpoint2,
        dxf.defpoint3,
        math.radians(dxf.get("angle", 0)),
        dim.ocs(),
    )


def measure_diameter_or_radius(dim: Dimension) -> float:
    p1 = Vec3(dim.dxf.defpoint)
    p2 = Vec3(dim.dxf.defpoint4)
    return (p2 - p1).magnitude


def measure_angle_between_two_lines(dim: Dimension) -> float:
    dxf = dim.dxf
    p1 = Vec3(dxf.defpoint2)  # 1. point of 1. extension line
    p2 = Vec3(dxf.defpoint3)  # 2. point of 1. extension line
    p3 = Vec3(dxf.defpoint4)  # 1. point of 2. extension line
    p4 = Vec3(dxf.defpoint)  # 2. point of 2. extension line
    dir1 = p2 - p1  # direction of 1. extension line
    dir2 = p4 - p3  # direction of 2. extension line
    return angle_between(dir1, dir2)


def measure_angle_between_three_points(dim: Dimension) -> float:
    dxf = dim.dxf
    p1 = Vec3(dxf.defpoint4)  # center
    p2 = Vec3(dxf.defpoint2)  # 1. extension line
    p3 = Vec3(dxf.defpoint3)  # 2. extension line
    dir1 = p2 - p1  # direction of 1. extension line
    dir2 = p3 - p1  # direction of 2. extension line
    return angle_between(dir1, dir2)


def get_feature_location(dim: Dimension) -> Vec3:
    origin = Vec3(dim.dxf.defpoint)
    feature_location = Vec3(dim.dxf.defpoint2)
    return feature_location - origin


def angle_between(v1: Vec3, v2: Vec3) -> float:
    angle = v2.angle_deg - v1.angle_deg
    return angle + 360 if angle < 0 else angle


def linear_measurement(
    p1: Vec3, p2: Vec3, angle: float = 0, ocs: Optional[OCS] = None
) -> float:
    """Returns distance from `p1` to `p2` projected onto ray defined by
    `angle`, `angle` in radians in the xy-plane.

    """
    if ocs is not None and ocs.uz != (0, 0, 1):
        p1 = ocs.to_wcs(p1)
        p2 = ocs.to_wcs(p2)
        # angle in OCS xy-plane
        ocs_direction = Vec3.from_angle(angle)
        measurement_direction = ocs.to_wcs(ocs_direction)
    else:
        # angle in WCS xy-plane
        measurement_direction = Vec3.from_angle(angle)

    t1 = measurement_direction.project(p1)  # type: ignore
    t2 = measurement_direction.project(p2)  # type: ignore
    return (t2 - t1).magnitude


# TODO: add ARC_DIMENSION dimtype=8 support
MEASUREMENT_TOOLS = {
    const.DIM_LINEAR: measure_linear_distance,
    const.DIM_ALIGNED: measure_linear_distance,
    const.DIM_ANGULAR: measure_angle_between_two_lines,
    const.DIM_DIAMETER: measure_diameter_or_radius,
    const.DIM_RADIUS: measure_diameter_or_radius,
    const.DIM_ANGULAR_3P: measure_angle_between_three_points,
    const.DIM_ORDINATE: get_feature_location,
}
