# Copyright (c) 2010-2022, Manfred Moitzi
# License: MIT License
from __future__ import annotations
from typing import (
    Any,
    Callable,
    Iterable,
    Iterator,
    Optional,
    Sequence,
    TYPE_CHECKING,
    TypeVar,
)
from copy import deepcopy

from ezdxf.lldxf import const
from ezdxf.enums import (
    MTextEntityAlignment,
    MAP_MTEXT_ALIGN_TO_FLAGS,
)
from ezdxf.addons import MTextSurrogate
from ezdxf.math import UVec, Vec2

if TYPE_CHECKING:
    from ezdxf.layouts import BlockLayout
    from ezdxf.eztypes import GenericLayoutType

DEFAULT_TABLE_BG_LAYER = "TABLEBACKGROUND"
DEFAULT_TABLE_FG_LAYER = "TABLECONTENT"
DEFAULT_TABLE_GRID_LAYER = "TABLEGRID"
DEFAULT_TEXT_STYLE = "STANDARD"
DEFAULT_CELL_HEIGHT = 1.0
DEFAULT_CELL_WIDTH = 2.5
DEFAULT_CELL_CHAR_HEIGHT = 0.7
DEFAULT_CELL_LINE_SPACING = 1.5
DEFAULT_CELL_X_SCALE = 1.0
DEFAULT_CELL_Y_SCALE = 1.0
DEFAULT_CELL_TEXTCOLOR = const.BYLAYER
DEFAULT_CELL_BG_COLOR = None
DEFAULT_CELL_X_MARGIN = 0.1
DEFAULT_CELL_Y_MARGIN = 0.1
DEFAULT_BORDER_COLOR = 5
DEFAULT_BORDER_LINETYPE = "BYLAYER"
DEFAULT_BORDER_STATUS = True
DEFAULT_BORDER_PRIORITY = 50


T = TypeVar("T", bound="Cell")


class TablePainter:
    """The TablePainter class renders tables build from DXF primitives.

    The TablePainter instance contains all the data cells.

    Args:
        insert: insert location as or :class:`~ezdxf.math.UVec`
        nrows: row count
        ncols: column count
        cell_width: default cell width in drawing units
        cell_height: default cell height in drawing units
        default_grid: draw a grid of solid lines if ``True``, otherwise
            draw only explicit defined borders, the default grid has a
            priority of 50.

    """

    def __init__(
        self,
        insert: UVec,
        nrows: int,
        ncols: int,
        cell_width=DEFAULT_CELL_WIDTH,
        cell_height=DEFAULT_CELL_HEIGHT,
        default_grid=True,
    ):
        self.insert = Vec2(insert)
        self.nrows: int = nrows
        self.ncols: int = ncols
        self.row_heights: list[float] = [cell_height] * nrows
        self.col_widths: list[float] = [cell_width] * ncols
        self.bg_layer_name: str = DEFAULT_TABLE_BG_LAYER
        self.fg_layer_name: str = DEFAULT_TABLE_FG_LAYER
        self.grid_layer_name: str = DEFAULT_TABLE_GRID_LAYER
        self.styles: dict[str, CellStyle] = {"default": CellStyle()}
        if not default_grid:
            default_style = self.get_cell_style("default")
            default_style.set_border_status(False, False, False, False)

        self._cells: dict[tuple[int, int], Cell] = {}  # data cells
        self.frames: list[Frame] = []  # border frame objects
        self.empty_cell = Cell(self)  # represents all empty cells

    def set_col_width(self, index: int, value: float):
        """Set column width in drawing units of the given column index.

        Args:
            index: zero based column index
            value: new column width in drawing units

        """
        self.col_widths[index] = float(value)

    def set_row_height(self, index: int, value: float):
        """Set row height in drawing units of the given row index.

        Args:
            index: zero based row index
            value: new row height in drawing units
        """
        self.row_heights[index] = float(value)

    def text_cell(
        self,
        row: int,
        col: int,
        text: str,
        span: tuple[int, int] = (1, 1),
        style="default",
    ) -> TextCell:
        """Factory method to create a new text cell at location (row, col),
        with `text` as content, the `text` can be a line breaks ``'\\n'``.
        The final cell can spread over several cells defined by the argument
        `span`.

        """
        cell = TextCell(self, text, style=style, span=span)
        return self.set_cell(row, col, cell)

    def block_cell(
        self,
        row: int,
        col: int,
        blockdef: BlockLayout,
        span: tuple[int, int] = (1, 1),
        attribs=None,
        style="default",
    ) -> BlockCell:
        """Factory method to Create a new block cell at position (row, col).

        Content is a block reference inserted by an INSERT entity,
        attributes will be added if the block definition contains ATTDEF.
        Assignments are defined by attribs-key to attdef-tag association.

        Example: attribs = {'num': 1} if an ATTDEF with tag=='num' in
        the block definition exists, an attrib with text=str(1) will be
        created and added to the insert entity.

        The cell spans over 'span' cells and has the cell style with the
        name 'style'.
        """
        if attribs is None:
            attribs = {}
        cell = BlockCell(
            self, blockdef, style=style, attribs=attribs, span=span
        )
        return self.set_cell(row, col, cell)

    @property
    def table_width(self) -> float:
        """Returns the total table width."""
        return sum(self.col_widths)

    @property
    def table_height(self) -> float:
        """Returns the total table height."""
        return sum(self.row_heights)

    def set_cell(self, row: int, col: int, cell: T) -> T:
        """Insert a cell at position (row, col)."""
        row, col = self.validate_index(row, col)
        self._cells[row, col] = cell
        return cell

    def get_cell(self, row: int, col: int) -> Cell:
        """Get cell at location (row, col)."""
        row, col = self.validate_index(row, col)
        try:
            return self._cells[row, col]
        except KeyError:
            return self.empty_cell  # empty cell with default style

    def validate_index(self, row: int, col: int) -> tuple[int, int]:
        row = int(row)
        col = int(col)
        if row < 0 or row >= self.nrows or col < 0 or col >= self.ncols:
            raise IndexError("cell index out of range")
        return row, col

    def frame(
        self,
        row: int,
        col: int,
        width: int = 1,
        height: int = 1,
        style="default",
    ) -> Frame:
        """Creates a frame around the give cell area, starting at (row, col) and
        covering `width` columns and `height` rows. The `style` argument is the
        name of a :class:`CellStyle`.
        """
        frame = Frame(self, pos=(row, col), span=(height, width), style=style)
        self.frames.append(frame)
        return frame

    def new_cell_style(self, name: str, **kwargs) -> CellStyle:
        """Factory method to create a new :class:`CellStyle` object, overwrites
        an already existing cell style.

        Args:
            name: style name as string
            kwargs: see attributes of class :class:`CellStyle`

        """
        assert (
            isinstance(name, str) and name != ""
        ), "name has to be a non-empty string"
        style: CellStyle = deepcopy(self.get_cell_style("default"))
        style.update(kwargs)
        self.styles[name] = style
        return style

    @staticmethod
    def new_border_style(
        color: int = const.BYLAYER,
        status=True,
        priority: int = 100,
        linetype: str = "BYLAYER",
        lineweight: int = const.LINEWEIGHT_BYLAYER,
    ) -> BorderStyle:
        """Factory method to create a new border style.

        Args:
            status: ``True`` for visible, ``False`` for invisible
            color: :ref:`ACI`
            linetype: linetype name, default is "BYLAYER"
            lineweight: lineweight as int, default is by layer
            priority: drawing priority, higher priorities cover lower priorities

        """
        border_style = BorderStyle()
        border_style.color = color
        border_style.linetype = linetype
        border_style.lineweight = lineweight
        border_style.status = status
        border_style.priority = priority
        return border_style

    def get_cell_style(self, name: str) -> CellStyle:
        """Get cell style by name."""
        return self.styles[name]

    def iter_visible_cells(
        self, visibility_map: VisibilityMap
    ) -> Iterator[tuple[int, int, Cell]]:
        """Iterate over all visible cells"""
        return (
            (row, col, self.get_cell(row, col)) for row, col in visibility_map
        )

    def render(self, layout: GenericLayoutType, insert: Optional[UVec] = None):
        """Render table to layout."""
        insert_backup = self.insert
        if insert is not None:
            self.insert = Vec2(insert)
        visibility_map = VisibilityMap(self)
        grid = Grid(self)
        for row, col, cell in self.iter_visible_cells(visibility_map):
            grid.render_cell_background(layout, row, col, cell)
            grid.render_cell_content(layout, row, col, cell)
        grid.render_lines(layout, visibility_map)
        self.insert = insert_backup


class VisibilityMap:
    """Stores the visibility of the table cells."""

    def __init__(self, table: TablePainter):
        """Create the visibility map for table."""
        self.table: TablePainter = table
        self._hidden_cells: set[tuple[int, int]] = set()
        self._create_visibility_map()

    def _create_visibility_map(self):
        """Set visibility for all existing cells."""
        for row, col in iter(self):
            cell = self.table.get_cell(row, col)
            self._set_span_visibility(row, col, cell.span)

    def _set_span_visibility(self, row: int, col: int, span: tuple[int, int]):
        """Set the visibility of the given cell.

        The cell itself is visible, all other cells in the span-range
        (tuple: width, height) are invisible, they are covered by the
        main cell (row, col).
        """

        if span != (1, 1):
            nrows, ncols = span
            for rowx in range(nrows):
                for colx in range(ncols):
                    # switch all cells in span range to invisible
                    self.hide(row + rowx, col + colx)
        # switch content cell visible
        self.show(row, col)

    def show(self, row: int, col: int):
        """Show cell (row, col)."""
        try:
            self._hidden_cells.remove((row, col))
        except KeyError:
            pass

    def hide(self, row: int, col: int) -> None:
        """Hide cell (row, col)."""
        self._hidden_cells.add((row, col))

    def iter_all_cells(self) -> Iterator[tuple[int, int]]:
        """Iterate over all cell indices, yields (row, col) tuples."""
        for row in range(self.table.nrows):
            for col in range(self.table.ncols):
                yield row, col

    def is_visible_cell(self, row: int, col: int) -> bool:
        """True if cell (row, col)  is visible, else False."""
        return (row, col) not in self._hidden_cells

    def __iter__(self) -> Iterator[tuple[int, int]]:
        """Iterate over all visible cells."""
        return (
            (row, col)
            for (row, col) in self.iter_all_cells()
            if self.is_visible_cell(row, col)
        )


class CellStyle:
    """Cell style object.

    .. important::

        Always instantiate new styles by the factory method:
        :meth:`TablePainter.new_cell_style`

    """

    def __init__(self, data: Optional[dict[str, Any]] = None):
        # text style is ignored by block cells
        self.text_style = "STANDARD"
        # text height in drawing units, ignored by block cells
        self.char_height = DEFAULT_CELL_CHAR_HEIGHT
        # line spacing in percent = char_height * line_spacing, ignored by block cells
        self.line_spacing = DEFAULT_CELL_LINE_SPACING
        # text stretching factor (width factor) or block reference x-scaling factor
        self.scale_x = DEFAULT_CELL_X_SCALE
        # block reference y-axis scaling factor, ignored by text cells
        self.scale_y = DEFAULT_CELL_Y_SCALE
        # dxf color index, ignored by block cells
        self.text_color = DEFAULT_CELL_TEXTCOLOR
        # text or block rotation in degrees
        self.rotation = 0.0
        # Letters are stacked top-to-bottom, but not rotated
        self.stacked = False
        # text and block alignment, see ezdxf.enums.MTextEntityAlignment
        self.align = MTextEntityAlignment.TOP_CENTER
        # left and right cell margin in drawing units
        self.margin_x = DEFAULT_CELL_X_MARGIN
        # top and bottom cell margin in drawing units
        self.margin_y = DEFAULT_CELL_Y_MARGIN
        # background color, dxf color index, ignored by block cells
        self.bg_color = DEFAULT_CELL_BG_COLOR
        # left border style
        self.left = BorderStyle()
        # top border style
        self.top = BorderStyle()
        # right border style
        self.right = BorderStyle()
        # bottom border style
        self.bottom = BorderStyle()
        if data:
            self.update(data)

    def __getitem__(self, k: str) -> Any:
        return self.__dict__[k]

    def __setitem__(self, k: str, v: Any):
        if k in self.__dict__:
            self.__dict__.__setitem__(k, v)
        else:
            raise KeyError(f"invalid attribute name: {k}")

    def update(self, data: dict[str, Any]):
        for k, v in data.items():
            self.__setitem__(k, v)
        assert isinstance(
            self.align, MTextEntityAlignment
        ), "enum ezdxf.enums.MTextEntityAlignment for text alignments required"

    def set_border_status(self, left=True, right=True, top=True, bottom=True):
        """Set status of all cell borders at once."""
        self.left.status = left
        self.right.status = right
        self.top.status = top
        self.bottom.status = bottom

    def set_border_style(
        self, style: BorderStyle, left=True, right=True, top=True, bottom=True
    ):
        """Set border styles of all cell borders at once."""
        for border, status in (
            ("left", left),
            ("right", right),
            ("top", top),
            ("bottom", bottom),
        ):
            if status:
                self[border] = style

    @staticmethod
    def get_default_border_style() -> BorderStyle:
        return BorderStyle()

    def get_text_align_flags(self) -> tuple[int, int]:
        return MAP_MTEXT_ALIGN_TO_FLAGS[self.align]


class BorderStyle:
    """Border style class.

    .. important::

        Always instantiate new border styles by the factory method:
        :meth:`TablePainter.new_border_style`

    """

    def __init__(
        self,
        status: bool = DEFAULT_BORDER_STATUS,
        color: int = DEFAULT_BORDER_COLOR,
        linetype: str = DEFAULT_BORDER_LINETYPE,
        lineweight=const.LINEWEIGHT_BYLAYER,
        priority: int = DEFAULT_BORDER_PRIORITY,
    ):
        # border status, True for visible, False for hidden
        self.status = status
        # ACI
        self.color = color
        # linetype name, BYLAYER if None
        self.linetype = linetype
        # lineweight
        self.lineweight = lineweight
        # drawing priority, higher values cover lower values
        self.priority = priority


class Grid:
    """Grid contains the graphical representation of the table."""

    def __init__(self, table: TablePainter):
        self.table: TablePainter = table
        # contains the x-axis coords of the grid lines between the data columns.
        self.col_pos: list[float] = self._calc_col_pos()
        # contains the y-axis coords of the grid lines between the data rows.
        self.row_pos: list[float] = self._calc_row_pos()

        # _x_borders contains the horizontal border elements, list of border styles
        # get index with _border_index(row, col), which means the border element
        # above row, col, and row-indices are [0 .. nrows+1], nrows+1 for the
        # grid line below the last row; list contains only the border style with
        # the highest priority.
        self._x_borders: list[BorderStyle] = []  # created in _init_borders

        # _y_borders: same as _x_borders but for the vertical borders,
        # col-indices are [0 .. ncols+1], ncols+1 for the last grid line right
        # of the last column
        self._y_borders: list[BorderStyle] = []  # created in _init_borders
        # border style to delete borders inside of merged cells
        self.no_border = BorderStyle(
            status=False, priority=999, linetype="BYLAYER", color=0
        )

    def _init_borders(self, x_border: BorderStyle, y_border: BorderStyle):
        """Init the _hborders with  <hborder> and _vborders with <vborder>."""
        # <border_count> has more elements than necessary, but it unifies the
        # index calculation for _vborders and _hborders.
        # exact values are:
        # x_border_count = ncols * (nrows+1), hindex = ncols * <row> + <col>
        # y_border_count = nrows * (ncols+1), vindex = (ncols+1) * <row> + <col>
        border_count: int = (self.table.nrows + 1) * (self.table.ncols + 1)
        self._x_borders = [x_border] * border_count
        self._y_borders = [y_border] * border_count

    def _border_index(self, row: int, col: int) -> int:
        """Calculate linear index for border arrays _x_borders and _y_borders."""
        return row * (self.table.ncols + 1) + col

    def set_x_border(self, row: int, col: int, border_style: BorderStyle):
        """Set <border_style> for the horizontal border element above
        <row>, <col>.
        """
        return self._set_border_style(self._x_borders, row, col, border_style)

    def set_y_border(self, row: int, col: int, border_style: BorderStyle):
        """Set <border_style> for the vertical border element left of
        <row>, <col>.
        """
        return self._set_border_style(self._y_borders, row, col, border_style)

    def _set_border_style(
        self,
        borders: list[BorderStyle],
        row: int,
        col: int,
        border_style: BorderStyle,
    ):
        """Set <border_style> for <row>, <col> in <borders>."""
        border_index = self._border_index(row, col)
        actual_borderstyle = borders[border_index]
        if border_style.priority >= actual_borderstyle.priority:
            borders[border_index] = border_style

    def get_x_border(self, row: int, col: int) -> BorderStyle:
        """Get the horizontal border element above <row>, <col>.
        Last grid line (below <nrows>) is the element above of <nrows+1>.
        """
        return self._get_border(self._x_borders, row, col)

    def get_y_border(self, row: int, col: int) -> BorderStyle:
        """Get the vertical border element left of <row>, <col>.
        Last grid line (right of <ncols>) is the element left of <ncols+1>.
        """
        return self._get_border(self._y_borders, row, col)

    def _get_border(
        self, borders: list[BorderStyle], row: int, col: int
    ) -> BorderStyle:
        """Get border element at <row>, <col> from <borders>."""
        return borders[self._border_index(row, col)]

    def _calc_col_pos(self) -> list[float]:
        """Calculate the x-axis coords of the grid lines between the columns."""
        col_pos: list[float] = []
        start_x: float = self.table.insert.x
        sum_fields(start_x, self.table.col_widths, col_pos.append)
        return col_pos

    def _calc_row_pos(self) -> list[float]:
        """Calculate the y-axis coords of the grid lines between the rows."""
        row_pos: list[float] = []
        start_y: float = self.table.insert.y
        sum_fields(start_y, self.table.row_heights, row_pos.append, -1.0)
        return row_pos

    def cell_coords(
        self, row: int, col: int, span: tuple[int, int]
    ) -> tuple[float, float, float, float]:
        """Get the coordinates of the cell <row>,<col> as absolute drawing units.

        :return: a tuple (left, right, top, bottom)
        """
        top = self.row_pos[row]
        bottom = self.row_pos[row + span[0]]
        left = self.col_pos[col]
        right = self.col_pos[col + span[1]]
        return left, right, top, bottom

    def render_cell_background(
        self, layout: GenericLayoutType, row: int, col: int, cell: Cell
    ):
        """Render the cell background for (row, col) as SOLID entity."""
        style = cell.style
        if style.bg_color is None:
            return
        # get cell coords in absolute drawing units
        left, right, top, bottom = self.cell_coords(row, col, cell.span)
        layout.add_solid(
            points=((left, top), (left, bottom), (right, top), (right, bottom)),
            dxfattribs={
                "color": style.bg_color,
                "layer": self.table.bg_layer_name,
            },
        )

    def render_cell_content(
        self, layout: GenericLayoutType, row: int, col: int, cell: Cell
    ):
        """Render the cell content for <row>,<col> into layout object."""
        # get cell coords in absolute drawing units
        coords = self.cell_coords(row, col, cell.span)
        cell.render(layout, coords, self.table.fg_layer_name)

    def render_lines(self, layout: GenericLayoutType, vm: VisibilityMap):
        """Render all grid lines into layout object."""
        # Init borders with default_style top- and left border.
        default_style = self.table.get_cell_style("default")
        x_border = default_style.top
        y_border = default_style.left
        self._init_borders(x_border, y_border)
        self._set_frames(self.table.frames)
        self._set_borders(self.table.iter_visible_cells(vm))
        self._render_borders(layout, self.table)

    def _set_borders(self, visible_cells: Iterable[tuple[int, int, Cell]]):
        """Set borders of the visible cells."""
        for row, col, cell in visible_cells:
            bottom_row = row + cell.span[0]
            right_col = col + cell.span[1]
            self._set_rect_borders(row, bottom_row, col, right_col, cell.style)
            self._set_inner_borders(
                row, bottom_row, col, right_col, self.no_border
            )

    def _set_inner_borders(
        self,
        top_row: int,
        bottom_row: int,
        left_col: int,
        right_col: int,
        border_style: BorderStyle,
    ):
        """Set `border_style` to the inner borders of the rectangle (top_row,
        bottom_row, ...)
        """
        if bottom_row - top_row > 1:
            for col in range(left_col, right_col):
                for row in range(top_row + 1, bottom_row):
                    self.set_x_border(row, col, border_style)
        if right_col - left_col > 1:
            for row in range(top_row, bottom_row):
                for col in range(left_col + 1, right_col):
                    self.set_y_border(row, col, border_style)

    def _set_rect_borders(
        self,
        top_row: int,
        bottom_row: int,
        left_col: int,
        right_col: int,
        style: CellStyle,
    ):
        """Set border `style` to the rectangle (top_row, bottom_row, ...)

        The values describing the grid lines between the cells, see doc-strings
        for methods set_x_border() and set_y_border() and see comments for
        self._x_borders and self._y_borders.
        """
        for col in range(left_col, right_col):
            self.set_x_border(top_row, col, style.top)
            self.set_x_border(bottom_row, col, style.bottom)
        for row in range(top_row, bottom_row):
            self.set_y_border(row, left_col, style.left)
            self.set_y_border(row, right_col, style.right)

    def _set_frames(self, frames: Iterable[Frame]):
        """Set borders for all defined frames."""
        for frame in frames:
            top_row = frame.pos[0]
            left_col = frame.pos[1]
            bottom_row = top_row + frame.span[0]
            right_col = left_col + frame.span[1]
            self._set_rect_borders(
                top_row, bottom_row, left_col, right_col, frame.style
            )

    def _render_borders(self, layout: GenericLayoutType, table: TablePainter):
        """Render the grid lines as LINE entities into layout object."""

        def render_line(start: Vec2, end: Vec2, style: BorderStyle):
            """Render the LINE entity into layout object."""
            if style.status:
                layout.add_line(
                    start=start,
                    end=end,
                    dxfattribs={
                        "layer": layer,
                        "color": style.color,
                        "linetype": style.linetype,
                        "lineweight": style.lineweight,
                    },
                )

        def render_x_borders():
            """Draw the horizontal grid lines."""
            for row in range(table.nrows + 1):
                y = self.row_pos[row]
                for col in range(table.ncols):
                    left = self.col_pos[col]
                    right = self.col_pos[col + 1]
                    style = self.get_x_border(row, col)
                    render_line(Vec2(left, y), Vec2(right, y), style)

        def render_y_borders():
            """Draw the vertical grid lines."""
            for col in range(table.ncols + 1):
                x = self.col_pos[col]
                for row in range(table.nrows):
                    top = self.row_pos[row]
                    bottom = self.row_pos[row + 1]
                    style = self.get_y_border(row, col)
                    render_line(Vec2(x, top), Vec2(x, bottom), style)

        layer = table.grid_layer_name
        render_x_borders()
        render_y_borders()


class Frame:
    """Represent a rectangle cell area enclosed by borderlines.

    Args:
         table: the assigned data table
         pos: tuple (row, col), border goes left and top of pos
         span: count of cells that Frame covers, border goes right and below of this cells
         style: style name as string
    """

    def __init__(
        self,
        table: TablePainter,
        pos: tuple[int, int] = (0, 0),
        span: tuple[int, int] = (1, 1),
        style="default",
    ):
        self.table = table
        self.pos = pos
        self.span = span
        self.stylename = style

    @property
    def style(self) -> CellStyle:
        return self.table.get_cell_style(self.stylename)


class Cell:
    """Base class for table cells.

    Args:
        table: assigned data table
        style: style name as string
        span: tuple(spanrows, spancols), count of cells that cell covers

    A cell doesn't know its own position in the data table, because a cell can
    be used multiple times in the same or in different tables, therefore the
    cell itself can not determine if the cell-range reaches beyond the table
    borders.
    """

    def __init__(
        self,
        table: TablePainter,
        style="default",
        span: tuple[int, int] = (1, 1),
    ):
        self.table = table
        self.stylename = style
        # span values has to be >= 1
        self.span = span

    @property
    def span(self) -> tuple[int, int]:
        """Get/set table span parameters."""
        return self._span

    @span.setter
    def span(self, value: tuple[int, int]):
        """Ensures that span values are >= 1 in each direction."""
        self._span = (max(1, value[0]), max(1, value[1]))

    @property
    def style(self) -> CellStyle:
        """Returns the associated :class:`CellStyle`."""
        return self.table.get_cell_style(self.stylename)

    def render(
        self, layout: GenericLayoutType, coords: Sequence[float], layer: str
    ):
        """Renders the cell content into the given `layout`."""
        pass

    def get_workspace_coords(self, coords: Sequence[float]) -> Sequence[float]:
        """Reduces the cell-coords about the margin_x and the margin_y values."""
        margin_x = self.style.margin_x
        margin_y = self.style.margin_y
        return (
            coords[0] + margin_x,  # left
            coords[1] - margin_x,  # right
            coords[2] - margin_y,  # top
            coords[3] + margin_y,  # bottom
        )


CustomCell = Cell


class TextCell(Cell):
    """Implements a cell type containing a multi-line text. Uses the
    :class:`~ezdxf.addons.MTextSurrogate` add-on to render the multi-line
    text, therefore the content of these cells is compatible to DXF R12.

    Args:
        table: assigned data table
        text: multi line text, lines separated by the new line character ``"\\n"``
        style: cell style name as string
        span: tuple(rows, cols) area of cells to cover

    """

    def __init__(
        self,
        table: TablePainter,
        text: str,
        style="default",
        span: tuple[int, int] = (1, 1),
    ):
        super(TextCell, self).__init__(table, style, span)
        self.text = text

    def render(
        self, layout: GenericLayoutType, coords: Sequence[float], layer: str
    ):
        """Text cell.

        Args:
            layout: target layout
            coords: tuple of border-coordinates: left, right, top, bottom
            layer: target layer name as string

        """
        if not len(self.text):
            return

        left, right, top, bottom = self.get_workspace_coords(coords)
        style = self.style
        h_align, v_align = style.get_text_align_flags()
        rotated = self.style.rotation
        text = self.text
        if style.stacked:
            rotated = 0.0
            text = "\n".join((char for char in self.text.replace("\n", " ")))
        xpos = (left, float(left + right) / 2.0, right)[h_align]
        ypos = (bottom, float(bottom + top) / 2.0, top)[v_align - 1]
        mtext = MTextSurrogate(
            text,
            (xpos, ypos),
            line_spacing=self.style.line_spacing,
            style=self.style.text_style,
            char_height=self.style.char_height,
            rotation=rotated,
            width_factor=self.style.scale_x,
            align=style.align,
            color=self.style.text_color,
            layer=layer,
        )
        mtext.render(layout)


class BlockCell(Cell):
    """Implements a cell type containing a block reference.

    Args:
        table: table object
        blockdef: :class:`ezdxf.layouts.BlockLayout` instance
        attribs: BLOCK attributes as (tag, value) dictionary
        style: cell style name as string
        span: tuple(rows, cols) area of cells to cover

    """

    def __init__(
        self,
        table: TablePainter,
        blockdef: BlockLayout,
        style="default",
        attribs=None,
        span: tuple[int, int] = (1, 1),
    ):
        if attribs is None:
            attribs = {}
        super(BlockCell, self).__init__(table, style, span)
        self.block_name = blockdef.name  # dxf block name!
        self.attribs = attribs

    def render(
        self, layout: GenericLayoutType, coords: Sequence[float], layer: str
    ):
        """Create the cell content as INSERT-entity with trailing ATTRIB-Entities.

        Args:
            layout: target layout
            coords: tuple of border-coordinates : left, right, top, bottom
            layer: target layer name as string

        """
        left, right, top, bottom = self.get_workspace_coords(coords)
        style = self.style
        h_align, v_align = style.get_text_align_flags()
        xpos = (left, float(left + right) / 2.0, right)[h_align]
        ypos = (bottom, float(bottom + top) / 2.0, top)[v_align - 1]
        layout.add_auto_blockref(
            name=self.block_name,
            insert=(xpos, ypos),
            values=self.attribs,
            dxfattribs={
                "xscale": style.scale_x,
                "yscale": style.scale_y,
                "rotation": style.rotation,
                "layer": layer,
            },
        )


def sum_fields(
    start_value: float,
    fields: list[float],
    append: Callable[[float], None],
    sign: float = 1.0,
):
    """Adds step-by-step the fields-values, starting with <start_value>,
    and appends the resulting values to another object with the
    append-method.
    """
    position = start_value
    append(position)
    for element in fields:
        position += element * sign
        append(position)