<?php
defined( 'ABSPATH' ) || exit;

/**
 * Module: TrackTor tag.
 *
 * Loads `{api base}/tracktor/v1/tag.js` on public pages once the site is
 * connected, using the existing site key. Off by default: connecting a
 * workspace never switches it on; an administrator enables it with one click
 * (enable()). A human choice is recorded the same way click protection
 * records its switch, in advisorppc_tracktor_user_choice, so nothing
 * automatic can undo a deliberate off. Hidden and inert while
 * ADVISORPPC_WORKSPACE is false.
 *
 * @package AdvisorPPC
 */
class AdvisorPPC_Tracktor {

	/** Remote tag script handle. */
	const HANDLE = 'advisorppc-tracktor';

	/** Local bridge script handle. */
	const BRIDGE_HANDLE = 'advisorppc-tracktor-bridge';

	/**
	 * Records that a human last decided whether TrackTor is on.
	 *
	 * Absent  nobody has ever touched the switch by hand
	 * 'on'    an administrator turned it on
	 * 'off'   an administrator turned it off, so nothing automatic may undo that
	 */
	const USER_CHOICE_OPTION = 'advisorppc_tracktor_user_choice';

	/** Path of the tag on the API host. */
	const TAG_PATH = '/tracktor/v1/tag.js';

	/**
	 * Whether init() already ran.
	 *
	 * @var bool
	 */
	private static $booted = false;

	/**
	 * True while this class is writing settings itself.
	 *
	 * @var bool
	 */
	private static $writing = false;

	/**
	 * Register hooks. Idempotent.
	 *
	 * @return void
	 */
	public static function init() {
		if ( self::$booted ) {
			return;
		}
		self::$booted = true;

		add_action( 'wp_enqueue_scripts', array( __CLASS__, 'enqueue' ), 8 );
		add_filter( 'script_loader_tag', array( __CLASS__, 'filter_script_tag' ), 10, 3 );
		add_action( 'wp_footer', array( __CLASS__, 'print_consume' ), 22 );

		add_filter( 'pre_update_option_' . self::settings_option_name(), array( __CLASS__, 'record_user_choice' ), 10, 2 );
	}

	/**
	 * The name of the settings option row.
	 *
	 * @return string
	 */
	private static function settings_option_name() {
		if ( defined( 'AdvisorPPC_Options::OPTION_KEY' ) ) {
			return (string) constant( 'AdvisorPPC_Options::OPTION_KEY' );
		}
		return 'advisorppc_settings';
	}

	/**
	 * Read the tracktor switch out of a settings array.
	 *
	 * @param mixed $settings Settings array, or anything else.
	 * @return bool|null Null when the array carries no opinion at all.
	 */
	private static function tracktor_flag( $settings ) {
		if ( ! is_array( $settings ) || empty( $settings['modules'] ) || ! is_array( $settings['modules'] ) ) {
			return null;
		}
		if ( ! array_key_exists( 'tracktor', $settings['modules'] ) ) {
			return null;
		}
		return ! empty( $settings['modules']['tracktor'] );
	}

	/**
	 * Is this write an administrator submitting our own settings form?
	 *
	 * @return bool
	 */
	private static function is_admin_form_submission() {
		if ( ! is_admin() || empty( $_POST ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Missing -- presence test only; the settings class verifies the nonce on its own form.
			return false;
		}
		if ( ! current_user_can( 'manage_options' ) ) {
			return false;
		}
		return isset( $_POST[ self::settings_option_name() ] ); // phpcs:ignore WordPress.Security.NonceVerification.Missing -- presence test only.
	}

	/**
	 * Remember that a human moved the switch.
	 *
	 * @param mixed $value     Settings about to be written.
	 * @param mixed $old_value Settings currently stored.
	 * @return mixed The unmodified $value.
	 */
	public static function record_user_choice( $value, $old_value ) {
		if ( self::$writing || ! self::is_admin_form_submission() ) {
			return $value;
		}

		$new_on = self::tracktor_flag( $value );
		$old_on = self::tracktor_flag( $old_value );

		if ( null === $new_on || null === $old_on || $new_on === $old_on ) {
			return $value;
		}

		self::set_user_choice( $new_on ? 'on' : 'off' );

		return $value;
	}

	/**
	 * Record that the administrator switched TrackTor by hand.
	 *
	 * @param string $choice 'on' or 'off'. Anything else clears the record.
	 * @return bool
	 */
	public static function set_user_choice( $choice ) {
		if ( ! in_array( $choice, array( 'on', 'off' ), true ) ) {
			return delete_option( self::USER_CHOICE_OPTION );
		}

		if ( false === get_option( self::USER_CHOICE_OPTION, false ) ) {
			return add_option( self::USER_CHOICE_OPTION, $choice, '', false );
		}

		return update_option( self::USER_CHOICE_OPTION, $choice, false );
	}

	/**
	 * Whether the administrator has switched TrackTor by hand.
	 *
	 * @return string 'on', 'off', or '' when the choice was never made.
	 */
	public static function user_choice() {
		$choice = get_option( self::USER_CHOICE_OPTION, '' );

		return in_array( $choice, array( 'on', 'off' ), true ) ? $choice : '';
	}

	/**
	 * One-click enable by an administrator.
	 *
	 * The only code path that switches TrackTor on besides the settings form.
	 * Callers must have checked the nonce and manage_options already. Refuses
	 * while workspace features are off or the site is not connected, so a
	 * click can never arm the tag before Connect.
	 *
	 * @return bool Whether the module is on afterwards.
	 */
	public static function enable() {
		if ( ! class_exists( 'AdvisorPPC_Options' ) ) {
			return false;
		}
		if ( method_exists( 'AdvisorPPC_Options', 'workspace_enabled' ) && ! AdvisorPPC_Options::workspace_enabled() ) {
			return false;
		}
		if ( ! AdvisorPPC_Options::is_connected() ) {
			return false;
		}

		$modules = AdvisorPPC_Options::get( 'modules', array() );
		if ( ! is_array( $modules ) ) {
			$modules = array();
		}

		self::set_user_choice( 'on' );

		if ( empty( $modules['tracktor'] ) ) {
			$modules['tracktor'] = true;

			self::$writing = true;
			AdvisorPPC_Options::set( 'modules', $modules );
			self::$writing = false;
		}

		return true;
	}

	/**
	 * Read an option without hard-depending on the options class.
	 *
	 * @param string $key      Option key.
	 * @param mixed  $fallback Fallback.
	 * @return mixed
	 */
	private static function opt( $key, $fallback = null ) {
		if ( ! class_exists( 'AdvisorPPC_Options' ) ) {
			return $fallback;
		}
		return AdvisorPPC_Options::get( $key, $fallback );
	}

	/**
	 * A stored services-directory URL that passes the host allowlist.
	 *
	 * @param string $url Candidate URL.
	 * @return string Untrailingslashed https origin, or ''.
	 */
	public static function allowed_base( $url ) {
		$url = untrailingslashit( esc_url_raw( trim( (string) $url ) ) );

		if ( '' === $url || 0 !== strpos( $url, 'https://' ) ) {
			return '';
		}

		if ( ! class_exists( 'AdvisorPPC_Connect' ) || ! method_exists( 'AdvisorPPC_Connect', 'is_allowed_service_url' ) ) {
			return '';
		}

		if ( ! AdvisorPPC_Connect::is_allowed_service_url( $url ) ) {
			return '';
		}

		return $url;
	}

	/**
	 * API base for the tag: services.tracktor, else services.api, else
	 * ADVISORPPC_API_BASE. Every candidate is passed through
	 * AdvisorPPC_Connect::is_allowed_service_url(). An empty return means
	 * nothing may be enqueued.
	 *
	 * @return string Untrailingslashed https origin, or ''.
	 */
	public static function api_base() {
		$services = self::opt( 'services', array() );
		if ( ! is_array( $services ) ) {
			$services = array();
		}

		$candidates = array();

		foreach ( array( 'tracktor', 'api' ) as $key ) {
			if ( isset( $services[ $key ] ) && is_scalar( $services[ $key ] ) ) {
				$candidates[] = (string) $services[ $key ];
			}
		}

		if ( defined( 'ADVISORPPC_API_BASE' ) ) {
			$candidates[] = (string) ADVISORPPC_API_BASE;
		} else {
			$candidates[] = 'https://mcp.advisorppc.com';
		}

		foreach ( $candidates as $candidate ) {
			$allowed = self::allowed_base( $candidate );
			if ( '' !== $allowed ) {
				return $allowed;
			}
		}

		return '';
	}

	/**
	 * The public site key, validated. Safe to print.
	 *
	 * @return string Empty when unset or malformed.
	 */
	public static function site_key() {
		$key = '';
		if ( class_exists( 'AdvisorPPC_Options' ) && method_exists( 'AdvisorPPC_Options', 'get_site_key' ) ) {
			$key = AdvisorPPC_Options::get_site_key();
		} else {
			$key = self::opt( 'site_key', '' );
		}
		if ( ! is_string( $key ) ) {
			return '';
		}
		$key = trim( $key );
		return preg_match( '/^[A-Za-z0-9_\-]{8,128}$/', $key ) ? $key : '';
	}

	/**
	 * Remote tag URL for this site.
	 *
	 * @return string Empty when the API base is unknown or refused.
	 */
	public static function script_url() {
		$base = self::api_base();
		if ( '' === $base ) {
			return '';
		}
		return $base . self::TAG_PATH;
	}

	/**
	 * Current Consent Mode, through the consent module when it is loaded.
	 *
	 * @return string 'off', 'basic' or 'advanced'.
	 */
	private static function consent_mode() {
		if ( class_exists( 'AdvisorPPC_Consent' ) && method_exists( 'AdvisorPPC_Consent', 'mode' ) ) {
			return AdvisorPPC_Consent::mode();
		}
		if ( class_exists( 'AdvisorPPC_Options' ) && method_exists( 'AdvisorPPC_Options', 'consent_mode' ) ) {
			return AdvisorPPC_Options::consent_mode();
		}
		$mode = (string) self::opt( 'consent_mode', 'off' );
		return in_array( $mode, array( 'off', 'basic', 'advanced' ), true ) ? $mode : 'off';
	}

	/**
	 * Consent Mode mapped onto the tag's data-consent attribute.
	 *
	 * `implied` only when Consent Mode is off. In basic mode the tag is held
	 * back by the consent gate (gate_signals()) and still told consent is
	 * required, so it never treats an unanswered banner as a yes.
	 *
	 * @return string 'required' or 'implied'.
	 */
	public static function consent_attr() {
		return 'off' === self::consent_mode() ? 'implied' : 'required';
	}

	/**
	 * Consent signals that must be granted before the tag may run, in the
	 * same terms AdvisorPPC_Tags uses for Google's tags: basic mode holds the
	 * script back until analytics_storage is granted; advanced mode lets the
	 * tag load and apply consent itself; off gates nothing.
	 *
	 * @return string Comma separated signals, empty when not gated.
	 */
	public static function gate_signals() {
		return 'basic' === self::consent_mode() ? 'analytics_storage' : '';
	}

	/**
	 * Value of data-auto-forms: false when the plugin's own forms module is capturing
	 * submissions, otherwise true.
	 *
	 * @return string 'true' or 'false'.
	 */
	public static function auto_forms_attr() {
		$forms = false;
		if ( class_exists( 'AdvisorPPC_Options' ) && method_exists( 'AdvisorPPC_Options', 'module_enabled' ) ) {
			$forms = (bool) AdvisorPPC_Options::module_enabled( 'forms' );
		} else {
			$modules = self::opt( 'modules', array() );
			$forms   = is_array( $modules ) && ! empty( $modules['forms'] );
		}

		return $forms ? 'false' : 'true';
	}

	/**
	 * Attributes printed on the remote tag script.
	 *
	 * @return array<string,string>
	 */
	public static function script_attributes() {
		return array(
			'data-site-key'   => self::site_key(),
			'data-consent'    => self::consent_attr(),
			'data-auto-forms' => self::auto_forms_attr(),
		);
	}

	/**
	 * Is the module switched on in settings?
	 *
	 * Absent from a stored modules map means off: a site that connected
	 * before this module existed does not start loading a new script on
	 * upgrade. module_enabled() also returns false while workspace features
	 * are off.
	 *
	 * @return bool
	 */
	public static function is_enabled() {
		if ( class_exists( 'AdvisorPPC_Options' ) && method_exists( 'AdvisorPPC_Options', 'module_enabled' ) ) {
			return (bool) AdvisorPPC_Options::module_enabled( 'tracktor' );
		}
		return false;
	}

	/**
	 * Front-end request test, shared with the click-ID module when present.
	 *
	 * @return bool
	 */
	public static function should_load() {
		if ( class_exists( 'AdvisorPPC_ClickIDs' ) && method_exists( 'AdvisorPPC_ClickIDs', 'should_load' ) ) {
			return (bool) AdvisorPPC_ClickIDs::should_load();
		}
		return ! is_admin();
	}

	/**
	 * Switched on, connected, holding a usable site key, and on a public page.
	 *
	 * @return bool
	 */
	public static function is_active() {
		if ( class_exists( 'AdvisorPPC_Options' ) && method_exists( 'AdvisorPPC_Options', 'workspace_enabled' ) && ! AdvisorPPC_Options::workspace_enabled() ) {
			return false;
		}
		if ( ! self::is_enabled() ) {
			return false;
		}
		if ( ! self::should_load() ) {
			return false;
		}
		if ( class_exists( 'AdvisorPPC_Options' ) && method_exists( 'AdvisorPPC_Options', 'is_connected' ) ) {
			if ( ! AdvisorPPC_Options::is_connected() ) {
				return false;
			}
		} elseif ( ! self::opt( 'connected', false ) ) {
			return false;
		}
		if ( '' === self::site_key() ) {
			return false;
		}
		if ( '' === self::api_base() ) {
			return false;
		}
		return true;
	}

	/**
	 * Plugin URL for a bundled asset.
	 *
	 * @param string $relative Path relative to the plugin root.
	 * @return string
	 */
	private static function asset_url( $relative ) {
		if ( class_exists( 'AdvisorPPC_Consent' ) && method_exists( 'AdvisorPPC_Consent', 'asset_url' ) ) {
			return AdvisorPPC_Consent::asset_url( $relative );
		}
		if ( defined( 'ADVISORPPC_PLUGIN_URL' ) ) {
			return ADVISORPPC_PLUGIN_URL . ltrim( $relative, '/' );
		}
		return plugin_dir_url( __DIR__ ) . ltrim( $relative, '/' );
	}

	/**
	 * Asset cache-busting version.
	 *
	 * @return string
	 */
	private static function asset_version() {
		if ( class_exists( 'AdvisorPPC_Consent' ) && method_exists( 'AdvisorPPC_Consent', 'asset_version' ) ) {
			return AdvisorPPC_Consent::asset_version();
		}
		return defined( 'ADVISORPPC_VERSION' ) ? ADVISORPPC_VERSION : '0.1.0';
	}

	/**
	 * Enqueue the remote tag and the local bridge. Once per page, front end
	 * only, never in wp-admin, never before Connect.
	 *
	 * @return void
	 */
	public static function enqueue() {
		if ( ! self::is_active() ) {
			return;
		}

		$src = self::script_url();
		if ( '' === $src ) {
			return;
		}

		if ( function_exists( 'wp_script_is' ) && wp_script_is( self::HANDLE, 'enqueued' ) ) {
			return;
		}

		$tag_deps = array();
		if ( class_exists( 'AdvisorPPC_Consent' ) ) {
			$tag_deps[] = AdvisorPPC_Consent::HANDLE;
		}

		wp_enqueue_script(
			self::HANDLE,
			$src,
			$tag_deps,
			null, // phpcs:ignore WordPress.WP.EnqueuedResourceParameters.MissingVersion -- remote tag versioned by the service.
			array(
				'in_footer' => false,
				'strategy'  => 'async',
			)
		);

		$gate = self::gate_signals();
		if ( '' !== $gate && class_exists( 'AdvisorPPC_Consent' ) ) {
			AdvisorPPC_Consent::register_gated( self::HANDLE, $gate );
		}

		$bridge_deps = array( self::HANDLE );
		if ( class_exists( 'AdvisorPPC_Consent' ) ) {
			$bridge_deps[] = AdvisorPPC_Consent::HANDLE;
		}

		wp_enqueue_script(
			self::BRIDGE_HANDLE,
			self::asset_url( 'public/js/tracktor-bridge.js' ),
			$bridge_deps,
			self::asset_version(),
			array(
				'in_footer' => false,
			)
		);

		$pending = 'advisorppc_pending';
		if ( class_exists( 'AdvisorPPC_Tags' ) && defined( 'AdvisorPPC_Tags::PENDING_COOKIE' ) ) {
			$pending = (string) constant( 'AdvisorPPC_Tags::PENDING_COOKIE' );
		}

		$config = array(
			'pendingCookie' => $pending,
		);

		if ( '' !== $gate && class_exists( 'AdvisorPPC_Consent' ) ) {
			AdvisorPPC_Consent::register_gated( self::BRIDGE_HANDLE, $gate );
		}

		wp_add_inline_script(
			self::BRIDGE_HANDLE,
			'window.advisorppcTracktorCfg = ' . wp_json_encode( $config ) . ';',
			'before'
		);
	}

	/**
	 * Add data-site-key, data-consent and data-auto-forms to the remote tag.
	 *
	 * @param string $tag    Full script tag markup.
	 * @param string $handle Script handle.
	 * @param string $src    Script source URL.
	 * @return string
	 */
	public static function filter_script_tag( $tag, $handle, $src = '' ) { // phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter.FoundAfterLastUsed -- WP passes $src; the handle is the discriminator.
		if ( self::HANDLE !== $handle ) {
			return $tag;
		}

		if ( false !== strpos( $tag, 'data-site-key=' ) ) {
			return $tag;
		}

		$extra = '';
		foreach ( self::script_attributes() as $name => $value ) {
			$extra .= ' ' . $name . '="' . esc_attr( $value ) . '"';
		}

		$replaced = preg_replace( '/<script\b/', '<script' . $extra, $tag, 1 );

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

	/**
	 * Drain browser events printed after footer scripts (wp_footer 21).
	 *
	 * AdvisorPPC_Tags::print_events writes window.advisorppcQueue at priority
	 * 21. The bridge, loaded in the head, installs a setter for that name;
	 * this late call covers a browser that could not define the setter.
	 *
	 * @return void
	 */
	public static function print_consume() {
		if ( ! self::is_active() ) {
			return;
		}

		$js = 'if (window.advisorppcTracktor && window.advisorppcTracktor.consume) { window.advisorppcTracktor.consume(); }';

		if ( function_exists( 'wp_print_inline_script_tag' ) ) {
			wp_print_inline_script_tag( $js, array( 'id' => 'advisorppc-tracktor-consume-js' ) );
			return;
		}

		echo '<script id="advisorppc-tracktor-consume-js">' . $js . '</script>'; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- literal JS, no user input.
	}
}

add_action( 'advisorppc_loaded', array( 'AdvisorPPC_Tracktor', 'init' ) );