FormattedTextArea

class FormattedTextArea (FormattedTextField):
    """A FormattedTextField where the text is required to fit within a given area.

    * Reduces font size until the text fits within the reference layer's bounds.
    * Properly separates and formats flavor text with respect to an optional divider layer.
    * Centers the formatted text vertically with respect to the reference layer's bounds.
    """

    """
    * Properties
    """

    @cached_property
    def pt_reference(self) -> Optional[ReferenceLayer]:
        return self.kwargs.get('pt_reference', None)

    @cached_property
    def divider(self) -> Optional[Union[ArtLayer, LayerSet]]:
        """Divider layer, if provided and flavor text exists."""
        if (divider := self.kwargs.get('divider')) and all([self.flavor_text, self.contents, CFG.flavor_divider]):
            divider.visible = True
            return divider
        return

    @cached_property
    def scale_height(self) -> bool:
        """Scale text to fit reference height (Default: True)."""
        if scale_height := self.kwargs.get('scale_height'):
            return scale_height
        return True

    @cached_property
    def scale_width(self) -> bool:
        """Scale text to fit reference width (Default: False)."""
        if scale_width := self.kwargs.get('scale_width'):
            return scale_width
        return False

    @cached_property
    def fix_overflow_width(self) -> bool:
        """Scale text to fit bounding box width (Default: False)."""
        if fix_overflow_width := self.kwargs.get('fix_overflow_width'):
            return fix_overflow_width
        return True

    @cached_property
    def fix_overflow_height(self) -> bool:
        """Scale text to fit bounding box height (Default: If it overflows the bounds)."""
        if len(self.contents + self.flavor_text) > 280:
            return True
        if fix_overflow_height := self.kwargs.get('fix_overflow_height'):
            return fix_overflow_height
        return False

    """
    * Methods
    """

    def insert_divider(self):
        """Inserts and correctly positions flavor text divider."""

        # Create a reference layer with no effects
        flavor = self.layer.duplicate()
        rules = flavor.duplicate()
        flavor.rasterize(RasterizeType.EntireLayer)
        remove_trailing_text(rules, self.flavor_start)
        select_layer_bounds(rules, self.doc_selection)
        self.docref.activeLayer = flavor
        self.doc_selection.expand(2)
        self.doc_selection.clear()

        # Move flavor text to bottom, then position divider
        flavor.translate(0, self.layer.bounds[3] - flavor.bounds[3])
        position_between_layers(self.divider, rules, flavor)
        self.doc_selection.deselect()
        flavor.remove()
        rules.remove()

    def pre_scale_to_fit(self) -> Optional[float]:
        """Fix height overflow before formatting text."""
        contents = self.contents if not self.flavor_text else str(
            self.contents + "\r" + self.flavor_text)
        self.TI.contents = contents
        return scale_text_to_height(
            layer=self.layer,
            height=int(self.reference_dims['height']*1.1))

    def scale_to_fit(self, font_size: Optional[float] = None) -> None:
        """Scale font size to fit within any references."""

        # Scale layer to reference
        if self.reference_dims:

            # Resize the text until it fits the reference vertically
            if self.scale_height:
                font_size = scale_text_to_height(
                    layer=self.layer,
                    height=self.reference_dims['height'])

            # Resize the text until it fits the reference horizontally
            if self.scale_width:
                font_size = scale_text_to_width(
                    layer=self.layer,
                    width=self.reference_dims['width'],
                    step=0.2, font_size=font_size)

        # Resize the text until it fits the TextLayer bounding box
        if self.fix_overflow_width:
            scale_text_to_width_textbox(
                layer=self.layer, font_size=font_size)

    def position_within_reference(self):
        """Positions the layer with respect to the reference, if required."""

        # Ensure the layer is centered vertically
        dims = get_layer_dimensions(self.layer)
        self.layer.translate(0, self.reference_dims['center_y'] - dims['center_y'])

        # Ensure the layer is centered horizontally if needed
        if self.contents_centered and self.flavor_centered:
            self.layer.translate(0, self.reference_dims['center_x'] - dims['center_x'])

    def execute(self):

        # Skip if both are empty
        if not self.input:
            return
        font_size = None

        # Pre-scaling to prevent text overflow errors
        if self.fix_overflow_height and self.reference_dims:
            font_size = self.pre_scale_to_fit()

        # Execute text formatting
        super().execute()

        # Scale layer to fit reference
        self.scale_to_fit(font_size)

        # Position the layer properly
        if self.reference_dims:
            self.position_within_reference()

        # Insert flavor divider if needed
        if self.divider:
            self.insert_divider()

        # Shift vertically if the text overlaps the PT box
        if self.pt_reference:

            # Use newer methodology if top reference not provided
            delta = clear_reference_vertical(
                layer=self.layer,
                ref=self.pt_reference,
                docsel=self.doc_selection)

            # Shift the divider if layer was moved
            if delta < 0 and self.divider:
                self.divider.translate(0, delta)