<?php

namespace AdPresso\Frontend;

use AdPresso\Entities\Ad;
use AdPresso\Entities\Entity;
use AdPresso\Entities\Group;
use AdPresso\Entities\Placement;
use AdPresso\Factories\PlacementFactory;
use AdPresso\Infrastructure\Util;
use AdPresso\Notifications\NotificationManager;
use AdPresso\Runtime;
use AdPresso\RuntimeDebugger;

defined( 'ABSPATH' ) || exit;

/**
 * Registers all public (frontend) hook, like shortcodes
 */
class FrontendHooks {

	/**
	 * Gathers the JS configurations for virtual placements
	 * from shortcodes and blocks that are rendered at runtime.
	 * @var array
	 */
	private static array $virtual_js_configs = [];

	/**
	 * Registers the shortcodes in WordPress.
	 *
	 * @return void
	 */
	public function hooks(): void {
		add_shortcode( 'adpresso_ad', [ $this, 'render_ad_shortcode' ] );
		add_shortcode( 'adpresso_group', [ $this, 'render_group_shortcode' ] );
		add_action( 'wp_footer', [ $this, 'localize_virtual_configs' ], 20 );
		add_action( 'admin_footer', [ $this, 'localize_virtual_configs' ], 20 );
	}

	/**
	 * Shortcode-Callback for [adpresso-ad id="123"].
	 *
	 * @param array $atts Shortcode-Attributes.
	 *
	 * @return string The rendered HTML.
	 */
	public function render_ad_shortcode( array $atts ): string {
		$atts = is_array( $atts ) ? $atts : [];
		$id   = absint( $atts['id'] ?? 0 );
		if ( ! $id ) {
			return '';
		}

		$entity = Util::get_entity_from_post( $id );
		return FrontendHooks::render_virtual_entity( $entity, 'shortcode', $atts );
	}

	/**
	 * Shortcode-Callback for [adpresso-group id="456"].
	 *
	 * @param array $atts Shortcode-Attributes.
	 *
	 * @return string The rendered HTML.
	 */
	public function render_group_shortcode( array $atts ): string {
		$atts = is_array( $atts ) ? $atts : [];
		$id   = absint( $atts['id'] ?? 0 );
		if ( ! $id ) {
			return '';
		}

		$entity = Util::get_entity_from_post( $id );
		return FrontendHooks::render_virtual_entity( $entity, 'shortcode', $atts );
	}

	/**
	 * Renders a physical, manual placement.
	 *
	 * @param int    $placement_id The ID of the Placements.
	 * @param string $trigger      Where it has been triggered.
	 *
	 * @return string The rendered HTML.
	 */
	public static function render_manual_placement( int $placement_id, string $trigger, array $shortcode_atts = [] ): string {
		if ( ! $placement_id ) {
			return '';
		}

		$placement = adpresso_get_placement( $placement_id );
		if ( ! $placement ) {
			return '';
		}
		self::apply_shortcode_overrides( $placement, $shortcode_atts );

		$processed_data = Runtime::get_processed_data();
		$placement_data = $processed_data[ $placement_id ] ?? null;
		$item           = $placement_data['item'] ?? $placement->get_item();

		// Prepare debugging.
		$snapshot                            = RuntimeDebugger::build_snapshot( $placement, $item );
		$snapshot['execution']['trigger']    = $trigger;
		$snapshot['execution']['hook_fired'] = true;

		if ( $trigger === 'shortcode' && $placement->get_type() !== 'manual' ) {
			// Wir erlauben das Rendern von nicht-manuellen Placements via Shortcode (z.B. für A2 Takeover),
			// warnen aber im Debugger, da dies nicht der Standardweg ist.
			$snapshot['execution']['warning'] = __( 'Rendering a non-manual placement via shortcode', 'adpresso' );
		} elseif ( $trigger !== 'shortcode' && $placement->get_type() !== 'manual' ) {
			$snapshot['execution']['status']      = 'error';
			$snapshot['execution']['skip_reason'] = __( 'Wrong usage of manual placement', 'adpresso' );
			RuntimeDebugger::add_log_entry( $placement_id, $snapshot );
			RuntimeDebugger::mark_output_triggered( $placement_id );

			NotificationManager::get()->register( 'adpresso-manual-placement', __( 'Wrong usage of manual placement', 'adpresso' ), [
				'location' => 'admin_bar',
				'context'  => 'adpresso-notifications',
				'type'     => 'info',
			] );
			return '';
		}

		// RENDERING LOGIK
		if ( ! $placement_data ) {
			// Fallback-Loading for physical manual placements that haven't been processed yet.
			$item                    = $placement->get_item();
			$requires_frontend_logic = apply_filters( 'adpresso_requires_frontend_logic', $placement->requires_frontend_logic || ( $item && $item->requires_frontend_logic ), $placement, $item );

			if ( $requires_frontend_logic ) {
				$output                               = $placement->get_placeholder_html();
				$snapshot['execution']['output_mode'] = 'js';

				// We need to make sure, that virtual config is available here.
				$uid                                       = $placement->get_uid();
				$config                                    = $placement->frontend_config_data;
				$config['uid']                             = $uid;
				$config['item']                            = $item ? $item->frontend_config_data : null;
				FrontendHooks::$virtual_js_configs[ $uid ] = $config;
			} else {
				$renderer                             = PlacementRenderer::get_instance();
				$output                               = $renderer->render( $placement, '' );
				$snapshot['execution']['output_mode'] = 'fallback';
			}
		} else {
			$snapshot['execution']['output_mode'] = $placement_data['output_mode'] ?? 'unknown';

			if ( ! empty( $placement_data['skip_reason'] ) ) {
				$snapshot['execution']['skip_reason'] = $placement_data['skip_reason'];
				if ( $placement_data['output_mode'] === 'skipped' ) {
					$snapshot['execution']['status'] = 'skipped';
				}
			}

			$output = match ( $placement_data['output_mode'] ) {
				'ssr' => $placement->render_with_wrapper( $placement_data['content'] ),
				'js' => $placement->get_placeholder_html(),
				default => '',
			};
		}

		RuntimeDebugger::add_log_entry( $placement_id, $snapshot );
		RuntimeDebugger::mark_output_triggered( $placement_id );

		return $output;
	}

	/**
	 * Renders an ad or group with a virtual placement.
	 *
	 * @param Entity $entity  The Ad- or Group-Object.
	 * @param string $trigger The origin of the call (e.g. 'shortcode', 'manual_block').
	 *
	 * @return string The rendered HTML.
	 */
	public static function render_virtual_entity( Entity $entity, string $trigger, array $shortcode_atts = [] ): string {
		if ( ! ( $entity instanceof Ad || $entity instanceof Group ) ) {
			return '';
		}

		$prefix    = $entity instanceof Ad ? 'ad' : 'group';
		$placement = PlacementFactory::make_virtual( $prefix, $entity->get_id() );
		self::apply_shortcode_overrides( $placement, $shortcode_atts );
		$placement->processBackendData();
		$uid                                    = $placement->get_uid();
		$placement->frontend_config_data['uid'] = $uid;

		$context    = [
			'placement_id'  => $placement->get_id(),
			'placement' => $placement,
			'is_raw_output' => ! $placement->should_wrap(),
		];

		if ( ! $entity->can_be_displayed() ) {
			$entity->is_backend_valid = false;
			$entity->skip_reason      = 'Display once limit reached (Virtual Placement)';
		}

		$output = '';
		if ( $entity->is_backend_valid ) {
			$requires_frontend_logic = apply_filters( 'adpresso_requires_frontend_logic', $entity->requires_frontend_logic, $placement, $entity );

			if ( $requires_frontend_logic ) {
				$output = $placement->get_placeholder_html();
				// We need to make sure that virtual config is available here.
				FrontendHooks::$virtual_js_configs[ $uid ] = $placement->frontend_config_data;
				$entity->mark_as_rendered();
			} else {
				$renderer = PlacementRenderer::get_instance();
				try {
					$inner_content = $entity->get_type_object()->output( $entity, $context );
					$output        = $renderer->render( $placement, $inner_content );

					if ( ! empty( $inner_content ) ) {
						$entity->mark_as_rendered();
					}
				} catch ( \Exception $e ) {
					$output              = '';
					$entity->skip_reason = 'Rendering exception: ' . $e->getMessage();
				}
			}
		}

		$snapshot                             = RuntimeDebugger::build_snapshot( $placement, $entity );
		$snapshot['execution']['trigger']     = $trigger . '_virtual';
		$snapshot['execution']['output_mode'] = ( $requires_frontend_logic ?? $entity->requires_frontend_logic ) ? 'js' : 'ssr';
		$snapshot['execution']['hook_fired']  = true;

		RuntimeDebugger::add_log_entry( $uid, $snapshot );
		RuntimeDebugger::mark_output_triggered( $uid );

		return $output;
	}

	/**
	 * Sends the gathered virtual configs to the global JS object.
	 *
	 * @return void
	 */
	public function localize_virtual_configs(): void {
		if ( empty( self::$virtual_js_configs ) ) {
			return;
		}

		?>
		<script type="text/javascript" id="adpresso-virtual-configs">
			window.adpressoData = window.adpressoData || {};
			window.adpressoData.placementConfig = window.adpressoData.placementConfig || {};

			<?php
			// Merge the virtual configs with the existing ones.
			foreach ( self::$virtual_js_configs as $placement_id => $config ) {
				// Don't override existing configs.
				if ( ! isset( $config['id'] ) ) {
					$config['id'] = $placement_id;
				}
				echo 'window.adpressoData.placementConfig["' . esc_js( $placement_id ) . '"] = ' . wp_json_encode( $config ) . ';' . "\n";
			}
			?>
		</script>
		<?php
	}

	/**
	 * Wendet Shortcode-Attribute (Margin, Alignment, Inline) zur Laufzeit auf das Placement an.
	 */
	public static function apply_shortcode_overrides( Placement $placement, array $atts ): void {
		if ( empty( $atts ) ) {
			return;
		}

		if ( ! empty( $atts['class'] ) ) {
			$placement->classes_override = sanitize_text_field( $atts['class'] );
		}

		$css = [];
		if ( ! empty( $atts['margin'] ) ) {
			$css[] = 'margin: ' . esc_attr( $atts['margin'] ) . ' !important;';
		}

		if ( ! empty( $atts['align'] ) ) {
			$align = strtolower( sanitize_text_field( $atts['align'] ) );
			if ( $align === 'center' ) {
				$css[] = 'margin-left: auto !important; margin-right: auto !important; display: block !important;';
				$placement->classes_override .= ' adpresso-align-center';
			} elseif ( $align === 'left' ) {
				$css[] = 'float: left !important;';
				$placement->classes_override .= ' adpresso-align-left';
			} elseif ( $align === 'right' ) {
				$css[] = 'float: right !important;';
				$placement->classes_override .= ' adpresso-align-right';
			}
		}

		if ( ! empty( $css ) ) {
			$placement->css_override = implode( ' ', $css );
		}

		if ( isset( $atts['inline'] ) || in_array( 'inline', $atts, true ) ) {
			$placement->is_inline_override = true;
		}
	}
}