<?php
/**
 * Inyector del snippet en wp_footer.
 *
 * @package ChatBotWeb
 */

namespace ChatBotWeb;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * Encola el loader del widget en el frontend y protege la privacidad del visitante.
 */
final class Injector {

	/** Handle con el que se registra el loader en WordPress. */
	private const HANDLE = 'botpar-loader';

	/** Handle del CSS inline (ocultar en móviles). */
	private const STYLE_HANDLE = 'botpar-inline';

	private const DEFAULT_LOADER_URL = 'https://widget.botpar.com/loader.js';
	private const DEFAULT_API_BASE   = 'https://app.botpar.com';

	/**
	 * Instancia única.
	 *
	 * @var Injector|null
	 */
	private static ?Injector $instance = null;

	/**
	 * Atributos extra del tag del loader, calculados en enqueue() y aplicados en
	 * filter_script_tag().
	 *
	 * @var array<string, string>
	 */
	private array $script_attributes = array();

	/**
	 * Si la colocación explícita (shortcode o bloque) ya quedó agendada para el pie.
	 *
	 * @var bool
	 */
	private bool $placement_deferred = false;

	/**
	 * Devuelve la instancia única.
	 *
	 * @return Injector
	 */
	public static function instance(): Injector {
		if ( null === self::$instance ) {
			self::$instance = new self();
		}
		return self::$instance;
	}

	/**
	 * API base efectivo: el override del admin si lo hay, si no el default.
	 * Público porque Settings lo reusa para el test de conexión — así la constante
	 * vive en un solo lugar.
	 *
	 * @param array $opts Opciones ya mergeadas con los defaults.
	 * @return string URL sin barra final.
	 */
	public static function api_base( array $opts ): string {
		$base = isset( $opts['api_base'] ) ? trim( (string) $opts['api_base'] ) : '';
		return '' !== $base ? rtrim( $base, '/' ) : self::DEFAULT_API_BASE;
	}

	/**
	 * Registra los hooks del frontend.
	 *
	 * @return void
	 */
	public function boot(): void {
		// Prioridad 1 en template_redirect: la cacheabilidad hay que decidirla ANTES de que
		// salga la primera línea de HTML. En wp_footer los headers ya se enviaron.
		add_action( 'template_redirect', array( $this, 'maybe_prevent_cache' ), 1 );
		add_action( 'wp_enqueue_scripts', array( $this, 'enqueue' ) );
		add_filter( 'script_loader_tag', array( $this, 'filter_script_tag' ), 10, 2 );
		add_shortcode( 'botpar', array( $this, 'shortcode' ) );
		add_action( 'init', array( $this, 'register_block' ) );
	}

	/**
	 * Registra el bloque del editor, equivalente visual del shortcode.
	 *
	 * Es un bloque dinámico: no guarda nada en el contenido y el frontend lo resuelve
	 * PHP. `register_block_type()` acepta la ruta de un block.json desde WordPress 5.8,
	 * que es justo el piso declarado del plugin.
	 *
	 * @return void
	 */
	public function register_block(): void {
		$dir = CHAT_BOT_WEB_PLUGIN_DIR . 'blocks/widget';
		if ( ! file_exists( $dir . '/block.json' ) ) {
			return;
		}

		register_block_type( $dir, array( 'render_callback' => array( $this, 'render_block' ) ) );

		// Deja el JS del editor listo para traducirse. WordPress.org genera los archivos
		// de traducción del JavaScript automáticamente para los plugins que aloja.
		$handle = function_exists( 'generate_block_asset_handle' )
			? generate_block_asset_handle( 'botpar/widget', 'editorScript' )
			: 'botpar-widget-editor-script';
		wp_set_script_translations( $handle, 'botpar' );
	}

	/**
	 * Render del bloque en el frontend: encola el widget y no imprime nada.
	 *
	 * @return string
	 */
	public function render_block(): string {
		return $this->place_widget( 'bloque del editor' );
	}

	/**
	 * Shortcode [botpar]: coloca el widget en esta página.
	 *
	 * Pensado para el modo de inserción manual. Como el admin lo puso a mano, gana sobre
	 * las exclusiones por ruta y por tipo de contenido, que son reglas de la colocación
	 * automática. Sí respeta "ocultar a usuarios logueados" (es sobre a quién se le
	 * muestra, no sobre dónde) y el filtro chat_bot_web_skip, que es la salida de
	 * emergencia para desarrolladores.
	 *
	 * Devuelve string vacío: no imprime nada en el contenido, sólo encola el widget.
	 * Encolar desde acá funciona porque el loader va al pie, que se imprime después.
	 *
	 * @return string
	 */
	public function shortcode(): string {
		return $this->place_widget( 'shortcode [botpar]' );
	}

	/**
	 * Colocación explícita del widget, compartida por el shortcode y el bloque.
	 *
	 * @param string $source De dónde vino la colocación, sólo para el log.
	 * @return string Siempre vacío: no imprime nada en el contenido.
	 */
	private function place_widget( string $source ): string {
		$opts = wp_parse_args( get_option( CHAT_BOT_WEB_OPTION, array() ), Settings::defaults() );

		if ( empty( $opts['public_key'] ) ) {
			Logger::log( 'Placement ignored: no public key configured.', array( 'source' => $source ) );
			return '';
		}
		if ( $this->hidden_for_audience( $opts ) ) {
			return '';
		}
		/** This filter is documented in includes/class-injector.php */
		if ( apply_filters( 'chat_bot_web_skip', false ) ) {
			return '';
		}

		Logger::log( 'Widget placed explicitly.', array( 'source' => $source ) );
		$this->defer_widget( $opts );

		return '';
	}

	/**
	 * Agenda el encolado del widget para el pie en vez de hacerlo acá mismo.
	 *
	 * Existe por una razón concreta. Desde WordPress 6.9, `WP_Block::render()` compara la
	 * cola de assets antes y después de renderizar cada bloque: si el bloque no imprimió
	 * nada, da por hecho que lo que encoló no le sirve a nadie y lo desencola. Nuestro
	 * bloque devuelve vacío A PROPÓSITO —el widget es un botón flotante que monta el loader
	 * al pie, no contenido dentro del artículo—, así que encolar durante su render hacía que
	 * WordPress revirtiera el encolado y el widget no apareciera. Se veía bien en el editor
	 * y el sitio publicado quedaba sin nada, en silencio.
	 *
	 * WordPress ofrece el filtro `enqueue_empty_block_content_assets` para esos casos, pero
	 * no alcanza: la reversión también la hacen los bloques CONTENEDORES, y el filtro recibe
	 * el nombre de cada uno. Habría que responder que sí por bloques ajenos, apagándole la
	 * optimización a otros plugins. Encolar fuera del render evita el problema entero, en
	 * cualquier nivel de anidamiento y sin depender de una versión de WordPress.
	 *
	 * Prioridad 0 en `wp_footer` porque `wp_print_footer_scripts` corre en la 20.
	 *
	 * @param array $opts Opciones ya mergeadas con los defaults.
	 * @return void
	 */
	private function defer_widget( array $opts ): void {
		if ( $this->placement_deferred ) {
			return;
		}
		$this->placement_deferred = true;

		add_action(
			'wp_footer',
			function () use ( $opts ) {
				$this->enqueue_widget( $opts );
			},
			0
		);
	}

	/**
	 * Marca la respuesta como NO cacheable cuando va a llevar la identidad del visitante.
	 *
	 * Sin esto, un page cache (WP Rocket, LiteSpeed, W3TC, Cloudflare APO) puede guardar el
	 * HTML generado para el usuario A —con su email y su nombre dentro de
	 * `window.chatBotWebVisitor`— y servírselo al usuario B: el widget de B se
	 * auto-identificaría con la PII de A y `/api/widget/leads` terminaría creando o
	 * vinculando el contacto equivocado en el panel. El escapado JSON de `inject()` cubre el
	 * XSS, no esta fuga; son dos problemas distintos del mismo payload.
	 *
	 * A propósito es más amplio que `inject()`: acá sólo preguntamos "¿va a haber payload de
	 * identidad?" y no evaluamos ni la exclusión por path ni el filtro `chat_bot_web_skip`,
	 * que pueden depender de contexto que todavía no existe en template_redirect. El peor
	 * caso es marcar como no cacheable una página donde después no inyectamos nada: cuesta
	 * algo de performance, nunca correctitud. Ante la duda se protege la privacidad.
	 */
	public function maybe_prevent_cache(): void {
		if ( is_admin() ) {
			return;
		}

		$opts = wp_parse_args( get_option( CHAT_BOT_WEB_OPTION, array() ), Settings::defaults() );

		if ( empty( $opts['public_key'] ) || empty( $opts['identify_user'] ) ) {
			return;
		}
		if ( ! is_user_logged_in() ) {
			return;
		}

		// Constante que respetan WP Rocket, W3 Total Cache, WP Super Cache y Comet Cache
		// cuando deciden (en shutdown) si escriben el buffer a disco.
		if ( ! defined( 'DONOTCACHEPAGE' ) ) {
			// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedConstantFound -- Constante estandar del ecosistema WordPress, definida por los plugins de cache. Prefijarla no tendria ningun efecto.
			define( 'DONOTCACHEPAGE', true );
		}

		// LiteSpeed Cache usa su propia señal.
		// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- Hook propiedad de LiteSpeed Cache; el nombre lo define ese plugin, no este.
		do_action( 'litespeed_control_set_nocache', 'BotPar: HTML con identidad del visitante' );

		// Y los headers HTTP, para CDNs y proxies (Cloudflare, Varnish) que no conocen
		// ninguna de las dos señales anteriores.
		if ( ! headers_sent() ) {
			nocache_headers();
		}

		// Sin contexto: no se registra QUIÉN está logueado, solo que la página se marcó.
		Logger::log( 'Page marked as non-cacheable: it will carry visitor identity.' );
	}

	/**
	 * Encola el loader del widget y, si corresponde, la identidad del visitante.
	 *
	 * Se encola en vez de imprimir el `<script>` a mano: así el sitio conserva el control
	 * de dependencias, orden y deregistro, y se respeta la guideline de WordPress.org.
	 * Los atributos propios (`async`, `data-*`) los agrega `filter_script_tag()`, porque
	 * el parámetro `strategy` de `wp_enqueue_script()` recién existe en WP 6.3 y el piso
	 * soportado es 5.8.
	 *
	 * @return void
	 */
	public function enqueue(): void {
		if ( is_admin() ) {
			return;
		}

		$opts = wp_parse_args( get_option( CHAT_BOT_WEB_OPTION, array() ), Settings::defaults() );

		// Los motivos por los que el widget no aparece, en el orden en que se evalúan.
		// Con el modo diagnóstico activo, el log responde solo la pregunta de soporte
		// más frecuente.
		if ( empty( $opts['public_key'] ) ) {
			Logger::log( 'Widget skipped: no public key configured.' );
			return;
		}

		if ( 'manual' === $opts['insertion'] ) {
			// La colocación la decide el shortcode [botpar]; acá no hacemos nada.
			return;
		}

		if ( $this->hidden_for_audience( $opts ) ) {
			return;
		}

		if ( $this->is_post_type_excluded( $opts ) ) {
			Logger::log(
				'Widget skipped: the post type is excluded.',
				array( 'post_type' => (string) get_post_type() )
			);
			return;
		}

		if ( $this->is_path_excluded( $opts['excluded_paths'] ) ) {
			Logger::log(
				'Widget skipped: the path matches an exclusion rule.',
				array( 'path' => $this->current_path() )
			);
			return;
		}

		/**
		 * Filtro para skipear el widget en condiciones custom (ej: páginas legales).
		 *
		 * @param bool $skip Si es true, no se inyecta. Default false.
		 */
		if ( apply_filters( 'chat_bot_web_skip', false ) ) {
			Logger::log( 'Widget skipped: cancelled by the chat_bot_web_skip filter.' );
			return;
		}

		Logger::log(
			'Widget enqueued.',
			array(
				'backend' => self::api_base( $opts ),
				'path'    => $this->current_path(),
			)
		);

		$this->enqueue_widget( $opts );
	}

	/**
	 * Indica si el widget está oculto para quien está mirando la página.
	 *
	 * Separado de las exclusiones por ubicación: esto es sobre A QUIÉN se le muestra, y
	 * por eso también aplica cuando el widget se coloca con el shortcode.
	 *
	 * @param array $opts Opciones ya mergeadas con los defaults.
	 * @return bool
	 */
	private function hidden_for_audience( array $opts ): bool {
		if ( ! empty( $opts['hide_for_logged_in'] ) && is_user_logged_in() ) {
			Logger::log( 'Widget skipped: hidden from logged-in users.' );
			return true;
		}
		return false;
	}

	/**
	 * Indica si el contenido actual es de un tipo excluido por el admin.
	 *
	 * @param array $opts Opciones ya mergeadas con los defaults.
	 * @return bool
	 */
	private function is_post_type_excluded( array $opts ): bool {
		$excluded = isset( $opts['excluded_post_types'] ) && is_array( $opts['excluded_post_types'] )
			? $opts['excluded_post_types']
			: array();

		if ( empty( $excluded ) || ! is_singular() ) {
			return false;
		}

		return in_array( (string) get_post_type(), $excluded, true );
	}

	/**
	 * Encola el loader y lo que lo acompaña. Idempotente.
	 *
	 * @param array $opts Opciones ya mergeadas con los defaults.
	 * @return void
	 */
	private function enqueue_widget( array $opts ): void {
		if ( wp_script_is( self::HANDLE, 'enqueued' ) ) {
			return;
		}

		// Versión null a propósito: el loader lo versiona el CDN del widget. Ponerle el
		// `?ver=` de WordPress lo ataría a la versión del PLUGIN, así que un loader nuevo
		// publicado en el CDN no llegaría a los sitios hasta que actualizaran el plugin —
		// justo lo contrario de lo que busca el sniff.
		// phpcs:ignore WordPress.WP.EnqueuedResourceParameters.MissingVersion -- Ver comentario: el versionado lo maneja el CDN, no WordPress.
		wp_enqueue_script( self::HANDLE, $this->resolve_loader_url(), array(), null, true );

		$this->script_attributes = array(
			'data-widget-id' => (string) $opts['public_key'],
			'data-api-base'  => self::api_base( $opts ),
		);

		$this->maybe_hide_on_mobile( $opts );

		$visitor = $this->build_visitor_payload( $opts );
		if ( null !== $visitor ) {
			// JSON embebido en <script>: JSON_HEX_TAG/JSON_HEX_AMP escapan < > & a \uXXXX
			// para que un display_name/email con "</script>" o "<!--" no pueda romper el
			// tag (XSS). La fuga de PII por cacheo la cubre maybe_prevent_cache(), aparte.
			// NO usar JSON_UNESCAPED_SLASHES acá.
			// El inline va 'before': es síncrono, así que la identidad ya está definida
			// cuando el loader (async) finalmente ejecuta.
			wp_add_inline_script(
				self::HANDLE,
				'window.chatBotWebVisitor = ' . wp_json_encode( $visitor, JSON_HEX_TAG | JSON_HEX_AMP | JSON_UNESCAPED_UNICODE ) . ';',
				'before'
			);
		}
	}

	/**
	 * Oculta el widget en pantallas chicas, con CSS.
	 *
	 * Deliberadamente NO se usa `wp_is_mobile()`: esa función decide en el servidor
	 * según el user agent, y con un plugin de caché activo el HTML generado para el
	 * primer visitante se le sirve a todos. El widget aparecería o desaparecería según
	 * quién cargó la página primero. Con CSS el HTML es idéntico para todos y decide el
	 * navegador, que además es quien sabe el ancho real de la ventana.
	 *
	 * @param array $opts Opciones ya mergeadas con los defaults.
	 * @return void
	 */
	private function maybe_hide_on_mobile( array $opts ): void {
		if ( empty( $opts['hide_on_mobile'] ) ) {
			return;
		}

		// Handle sin src: el patrón de WordPress para CSS sólo inline.
		wp_register_style( self::STYLE_HANDLE, false, array(), CHAT_BOT_WEB_VERSION );
		wp_enqueue_style( self::STYLE_HANDLE );
		wp_add_inline_style(
			self::STYLE_HANDLE,
			'@media (max-width:767px){#chat-bot-web-host{display:none!important}}'
		);

		Logger::log( 'Widget hidden on screens narrower than 768px (via CSS).' );
	}

	/**
	 * Agrega `async` y los `data-*` al tag del loader.
	 *
	 * @param string $tag    HTML completo del `<script>`.
	 * @param string $handle Handle del script que WordPress está por imprimir.
	 * @return string
	 */
	public function filter_script_tag( $tag, $handle ): string {
		if ( self::HANDLE !== $handle || empty( $this->script_attributes ) ) {
			return (string) $tag;
		}

		$tag = (string) $tag;

		$extra = 'async';
		foreach ( $this->script_attributes as $name => $value ) {
			$extra .= sprintf( ' %s="%s"', $name, esc_attr( $value ) );
		}

		// Ojo: cuando el script tiene inline data, WordPress le pasa a este filtro el
		// BLOQUE ENTERO — el <script> del inline "before" primero y recién después el del
		// src. Tomar el primer "<script " le colgaba los atributos al inline y dejaba al
		// loader sin async ni data-*, es decir sin cargar el widget. Por eso el lookahead:
		// sólo matchea la apertura del tag que efectivamente tiene src.
		$patched = preg_replace_callback(
			'#<script\s(?=[^>]*\bsrc=)#',
			static function () use ( $extra ) {
				return '<script ' . $extra . ' ';
			},
			$tag,
			1
		);

		return is_string( $patched ) ? $patched : $tag;
	}

	/**
	 * URL del loader, con filtro para self-hosters o staging.
	 *
	 * @return string
	 */
	private function resolve_loader_url(): string {
		/**
		 * Permite overridear el URL del loader (útil para self-hosters o staging).
		 *
		 * @param string $url URL default del loader.
		 */
		return apply_filters( 'chat_bot_web_loader_url', self::DEFAULT_LOADER_URL );
	}

	/**
	 * Identidad del usuario logueado, si el admin activó el auto-identify.
	 *
	 * @param array $opts Opciones ya mergeadas con los defaults.
	 * @return array|null Null si no corresponde mandar identidad.
	 */
	private function build_visitor_payload( array $opts ): ?array {
		if ( empty( $opts['identify_user'] ) ) {
			return null;
		}
		if ( ! is_user_logged_in() ) {
			return null;
		}
		$user = wp_get_current_user();
		if ( ! $user || ! $user->exists() ) {
			return null;
		}
		return array(
			'email' => $user->user_email,
			'name'  => $user->display_name,
		);
	}

	/**
	 * Indica si la URL actual coincide con alguna de las rutas excluidas por el admin.
	 *
	 * @param string $raw Textarea de rutas, una por línea.
	 * @return bool
	 */
	private function is_path_excluded( string $raw ): bool {
		$raw = trim( $raw );
		if ( '' === $raw ) {
			return false;
		}

		$current = $this->current_path();
		$lines   = preg_split( '/\r\n|\r|\n/', $raw );
		if ( ! is_array( $lines ) ) {
			return false;
		}

		foreach ( $lines as $line ) {
			$pattern = trim( $line );
			if ( '' === $pattern ) {
				continue;
			}
			if ( $this->path_matches( $current, $pattern ) ) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Path de la request actual, sin query string.
	 *
	 * @return string
	 */
	private function current_path(): string {
		$uri = isset( $_SERVER['REQUEST_URI'] )
			? sanitize_text_field( wp_unslash( $_SERVER['REQUEST_URI'] ) )
			: '/';

		$parsed = wp_parse_url( $uri, PHP_URL_PATH );
		return is_string( $parsed ) ? $parsed : '/';
	}

	/**
	 * Compara el path actual contra un patrón, con `*` como comodín final.
	 *
	 * @param string $current Path de la request.
	 * @param string $pattern Patrón cargado por el admin.
	 * @return bool
	 */
	private function path_matches( string $current, string $pattern ): bool {
		if ( '' === $pattern ) {
			return false;
		}
		if ( substr( $pattern, -1 ) === '*' ) {
			$prefix            = rtrim( substr( $pattern, 0, -1 ), '/' );
			$cur               = rtrim( $current, '/' );
			$prefix_with_slash = $prefix . '/';
			return $prefix === $cur || strpos( $cur, $prefix_with_slash ) === 0;
		}
		return rtrim( $current, '/' ) === rtrim( $pattern, '/' );
	}
}