<?php
/**
 * Icon Block - Server-side Rendering
 *
 * Dynamic render. Emits the inline SVG (from the shared PHP icon library) inside
 * the same wrapper structure the block used before it became dynamic, so
 * existing content renders identically — but with no client-side icon injection
 * (no `.airo-wp-lazy-icon` placeholder, no data-* attributes).
 *
 * The block root (`.airo-wp-icon`) is a plain block-level positioning wrapper —
 * core's constrained layout caps it at the theme's content width, exactly like
 * a paragraph. The visible icon is the inner `.airo-wp-icon__wrapper` element,
 * which shrink-wraps and is positioned inside the wrapper via `justify-content`
 * (`.airo-wp-justify`, driven by the `justification` attribute). All visual block
 * supports (color, background, border, padding) are routed from the wrapper to
 * that element by the shared `airowp_route_visual_supports()` helper —
 * otherwise a background or border would paint across the whole content column
 * instead of hugging the icon.
 *
 * `align` support narrowed from `left|center|right|wide|full` to `wide|full`
 * when `justification` replaced the left/center/right values, but WordPress's
 * `wp_register_alignment_support()` always registers the `align` ATTRIBUTE
 * with the full historical enum regardless of what `supports.align` lists —
 * the block.json subset only trims the editor's toolbar buttons. So a
 * published Icon that has never been re-opened and re-saved (deprecations
 * only run in the editor) can still carry a stored `align: "left"` here.
 * That value is read as a legacy justification fallback below. It is
 * intentionally NOT passed through to `get_block_wrapper_attributes()`'s
 * `class` argument for wide/full handling — `align` stays in `$attributes`
 * (untouched) so WordPress's own alignment-support code (invoked internally
 * by `get_block_wrapper_attributes()`) still emits `alignwide`/`alignfull`
 * for the current, legitimate use of those two values. It ALSO, unavoidably,
 * emits a stale `alignleft`/`aligncenter`/`alignright` class from that same
 * mechanism for un-migrated legacy content. That class is redundant — the
 * legacy justification fallback below already put the correct
 * `airo-wp-justify--{left|center|right}` class on this same wrapper — and
 * actively wrong: `margin-left/right: auto` (from core's own alignment CSS)
 * overrides `align-self` in flexbox, so it recentres the wrapper regardless
 * of `justify-content`. It is stripped from the wrapper below rather than
 * neutralized in CSS.
 *
 * @package airo-wp
 * @since 2.4.0
 *
 * @param array    $attributes Block attributes.
 * @param string   $content    Block content (unused for dynamic blocks).
 * @param WP_Block $block      Block instance.
 */

// Exit if accessed directly.
if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

if ( ! function_exists( 'airowp_render_icon' ) ) {
	/**
	 * Render the Icon block.
	 *
	 * @param array    $attributes Block attributes.
	 * @param string   $content    Inner block content (unused).
	 * @param WP_Block $block      Block instance.
	 * @return string Icon markup.
	 */
	function airowp_render_icon( $attributes, $content, $block ) {
		unset( $content, $block );

		// Theme-level defaults (settings.custom.airowp.icon), used when an
		// attribute is left unset — mirrors the frontend injector's behavior.
		$defaults = array();
		if ( class_exists( '\\airo-wp\\Icon_Injector' ) ) {
			$defaults = \airo-wp\Icon_Injector::get_icon_defaults();
		}
		$default_size  = isset( $defaults['size'] ) ? (int) $defaults['size'] : 48;
		$default_style = isset( $defaults['style'] ) ? (string) $defaults['style'] : 'filled';

		$icon              = ! empty( $attributes['icon'] ) ? (string) $attributes['icon'] : 'star';
		$icon_style        = ! empty( $attributes['iconStyle'] ) ? (string) $attributes['iconStyle'] : $default_style;
		$stroke_width      = isset( $attributes['strokeWidth'] ) ? (float) $attributes['strokeWidth'] : 1.5;
		$has_explicit_size = isset( $attributes['iconSize'] );
		$icon_size         = $has_explicit_size ? (int) $attributes['iconSize'] : $default_size;
		$rotation          = isset( $attributes['rotation'] ) ? (int) $attributes['rotation'] : 0;
		$is_decorative     = ! empty( $attributes['isDecorative'] );
		$aria_label        = isset( $attributes['ariaLabel'] ) ? (string) $attributes['ariaLabel'] : '';

		// Trusted SVG markup from the shared library (filled, or outlined wrapper).
		$svg = airowp_render_icon_svg( $icon, $icon_style, $stroke_width );
		if ( '' === $svg ) {
			return '';
		}

		// The wrapper below owns the accessible name (or decorative state).
		// Its nested SVG is only the drawing, not a second unnamed image.
		$svg_processor = new WP_HTML_Tag_Processor( $svg );
		while ( $svg_processor->next_tag( 'svg' ) ) {
			$svg_processor->set_attribute( 'aria-hidden', 'true' );
			$svg_processor->set_attribute( 'focusable', 'false' );
		}
		$svg = $svg_processor->get_updated_html();

		// Wrapper inline styles. Width/height are baked inline only when the author
		// set an explicit iconSize; left unset, sizing falls to the kit-tunable
		// `--wp--custom--airo-wp--icon--default-size` CSS var (see style.scss),
		// mirroring the pre-dynamic lazy save's hasExplicitSize behaviour so a Style
		// Kit / theme.json icon size is not silently overridden by an inline style.
		$wrapper_style = 'display:inline-flex;align-items:center;justify-content:center;border-radius:inherit;';
		if ( $has_explicit_size ) {
			$wrapper_style = sprintf( 'width:%1$dpx;height:%1$dpx;', $icon_size ) . $wrapper_style;
		}
		if ( 0 !== $rotation ) {
			$wrapper_style .= sprintf( 'transform:rotate(%ddeg);', $rotation );
		}

		// ARIA: decorative → hidden from AT; otherwise labelled with the
		// author's label. With no label, a linked icon still needs a name, so
		// it falls back to a humanized icon name (e.g. "circle-check" →
		// "Circle Check"). An unlabelled, unlinked icon is hidden instead:
		// announcing its slug tells a screen-reader user nothing true.
		$has_link = ! empty( $attributes['linkUrl'] );
		if ( $is_decorative || ( '' === trim( $aria_label ) && ! $has_link ) ) {
			$aria = ' role="presentation" aria-hidden="true"';
		} else {
			$label = '' !== trim( $aria_label ) ? $aria_label : ucwords( str_replace( '-', ' ', $icon ) );
			$aria  = sprintf( ' role="img" aria-label="%s"', esc_attr( $label ) );
		}

		$icon_html = sprintf(
			'<div class="airo-wp-icon__wrapper" style="%s"%s>%s</div>',
			esc_attr( $wrapper_style ),
			$aria,
			$svg
		);

		// Optional link wrap (mirrors save.js: plain <a>, noopener on _blank).
		$url = ! empty( $attributes['linkUrl'] ) ? esc_url( $attributes['linkUrl'] ) : '';
		if ( '' !== $url ) {
			$target = isset( $attributes['linkTarget'] ) ? (string) $attributes['linkTarget'] : '_self';
			$rel    = isset( $attributes['linkRel'] ) ? (string) $attributes['linkRel'] : '';
			if ( '_blank' === $target && '' === $rel ) {
				$rel = 'noopener noreferrer';
			}
			$rel_attr  = '' !== $rel ? sprintf( ' rel="%s"', esc_attr( $rel ) ) : '';
			$icon_html = sprintf(
				'<a href="%s" target="%s"%s>%s</a>',
				$url,
				esc_attr( $target ),
				$rel_attr,
				$icon_html
			);
		}

		// A stored `align` of left/center/right only ever exists on un-migrated
		// legacy content (the deprecation strips it on first editor re-save,
		// and a fresh icon never writes one) — so ITS presence, not
		// `justification`'s value, is what identifies "not yet migrated"
		// here. `justification` always reads back as a value (its own
		// block.json default fills in when the key is missing), so it cannot
		// be used to detect that. `align: wide|full` is unrelated (still a
		// live, current feature) and is left alone.
		$legacy_align  = isset( $attributes['align'] ) ? (string) $attributes['align'] : '';
		$justification = in_array( $legacy_align, array( 'left', 'center', 'right' ), true )
			? $legacy_align
			: ( isset( $attributes['justification'] ) ? (string) $attributes['justification'] : 'center' );
		$justify_class = in_array( $justification, array( 'left', 'center', 'right' ), true )
			? ' airo-wp-justify--' . $justification
			: '';

		$wrapper_attributes = get_block_wrapper_attributes(
			array( 'class' => 'airo-wp-icon airo-wp-justify' . $justify_class )
		);

		$html = sprintf( '<div %s>%s</div>', $wrapper_attributes, $icon_html );

		// Strip the stale alignleft/aligncenter/alignright class WordPress's
		// align support unavoidably adds for un-migrated legacy content (see
		// docblock above) — the `airo-wp-justify--{value}` class already
		// positions the wrapper correctly, and the stale class's `margin:
		// auto` fights it. alignwide/alignfull are left untouched: those
		// remain a live, current feature and must keep escaping the column.
		$align_processor = new WP_HTML_Tag_Processor( $html );
		if ( $align_processor->next_tag() ) {
			$align_processor->remove_class( 'alignleft' );
			$align_processor->remove_class( 'aligncenter' );
			$align_processor->remove_class( 'alignright' );
			$html = $align_processor->get_updated_html();
		}

		// The wrapper is now a full-column-width positioning box, so a background,
		// border or padding on it would paint across the column instead of hugging
		// the icon. Move them to the icon box.
		return airowp_route_visual_supports(
			$html,
			$attributes,
			'airo-wp-icon__wrapper',
			array( 'color', 'border', 'spacing.padding' )
		);
	}
}

// Output directly (WordPress captures echo'd output from render callbacks).
echo airowp_render_icon( $attributes, $content, $block ); // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped