<?php
/**
 * The one place every action, filter and shortcode is registered.
 *
 * @package Acknowledgify
 */

namespace Acknowledgify\Includes;

use Acknowledgify\Admin\Settings;

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

/**
 * Hook registration.
 */
class Hooks {

	/**
	 * Register everything.
	 *
	 * @return void
	 */
	public static function init() {
		/*
		 * Migration runs on init rather than plugins_loaded because it calls
		 * translation functions, and calling those before init triggers the
		 * _load_textdomain_just_in_time notice added in WordPress 6.7. Priority
		 * 5 puts it ahead of the rewrite rule and well ahead of any output
		 * hook, so the first request after an update still renders correctly.
		 */
		add_action( 'init', array( __CLASS__, 'maybe_migrate_settings' ), 5 );

		add_action( 'init', array( __CLASS__, 'add_rewrite_rules' ) );
		add_filter( 'query_vars', array( __CLASS__, 'query_vars' ) );

		add_action( 'template_redirect', array( Humans_Txt::class, 'handle_humans_txt_redirect' ), 9 );
		add_action( 'template_redirect', array( Humans_Txt::class, 'output_humans_txt' ) );

		add_action( 'wp_head', array( Humans_Txt::class, 'add_humans_txt_link' ) );
		add_action( 'wp_head', array( Meta_Tags::class, 'add_meta_tags' ) );

		add_action( 'wp_footer', array( __CLASS__, 'footer_output' ) );
		add_shortcode( 'acknowledgify_madeby_footer', array( __CLASS__, 'footer_link_shortcode' ) );

		// Keep the memoised settings copy honest, and flush rewrite rules only
		// when the humans.txt route actually needs to change.
		add_action( 'add_option_' . ACKNOWLEDGIFY_OPTION, array( __CLASS__, 'on_option_added' ), 10, 2 );
		add_action( 'update_option_' . ACKNOWLEDGIFY_OPTION, array( __CLASS__, 'on_option_updated' ), 10, 2 );

		add_action( 'switch_blog', array( Helper::class, 'flush_cache' ) );
		add_action( 'switch_blog', array( Tokens::class, 'flush_cache' ) );

		if ( is_admin() ) {
			add_action( 'admin_init', array( __CLASS__, 'register_settings' ) );
			add_action( 'admin_enqueue_scripts', array( Settings::class, 'enqueue_admin_scripts' ) );
			add_action( 'admin_notices', array( Settings::class, 'render_admin_notices' ) );
			add_action( 'admin_post_' . ACKNOWLEDGIFY_EXPORT_ACTION, array( Settings::class, 'handle_export' ) );
			add_action( 'admin_post_' . ACKNOWLEDGIFY_IMPORT_ACTION, array( Settings::class, 'handle_import' ) );
		}
	}

	/**
	 * Bring the stored option up to the current schema version.
	 *
	 * Costs one read of an already-autoloaded, already-cached option and one
	 * integer comparison on requests where there is nothing to do.
	 *
	 * @return void
	 */
	public static function maybe_migrate_settings() {
		$settings = Helper::get_settings();

		if ( empty( $settings ) ) {
			return;
		}

		$version = isset( $settings['_schema_version'] ) ? (int) $settings['_schema_version'] : 1;

		if ( $version >= ACKNOWLEDGIFY_SCHEMA_VERSION ) {
			return;
		}

		update_option( ACKNOWLEDGIFY_OPTION, Helper::migrate( $settings ) );
		Helper::flush_cache();
	}

	/**
	 * Register the option with the Settings API.
	 *
	 * The sanitise callback must be a resolvable callable. This previously
	 * passed the bare string 'acknowledgify_sanitize_settings', which PHP
	 * resolves against the global namespace only; the function lived in
	 * Acknowledgify\Includes, so nothing was ever sanitised.
	 *
	 * @return void
	 */
	public static function register_settings() {
		register_setting(
			'acknowledgify_options_group',
			ACKNOWLEDGIFY_OPTION,
			array(
				'type'              => 'array',
				'sanitize_callback' => array( Settings::class, 'sanitize_settings' ),
				'show_in_rest'      => false,
			)
		);
	}

	/**
	 * Register the humans.txt rewrite rule.
	 *
	 * @return void
	 */
	public static function add_rewrite_rules() {
		Humans_Txt::add_rewrite_rules();
	}

	/**
	 * Register our query var.
	 *
	 * @param string[] $vars Public query vars.
	 * @return string[]
	 */
	public static function query_vars( $vars ) {
		return Humans_Txt::query_vars( $vars );
	}

	/**
	 * Auto-insert placement.
	 *
	 * @return void
	 */
	public static function footer_output() {
		Footer_Link::footer_output( 'auto_insert' );
	}

	/**
	 * Shortcode placement.
	 *
	 * @return string
	 */
	public static function footer_link_shortcode() {
		return Footer_Link::get_markup( 'shortcode' );
	}

	/**
	 * First save of the option.
	 *
	 * @param string $option Option name.
	 * @param mixed  $value  New value.
	 * @return void
	 */
	public static function on_option_added( $option, $value ) {
		Helper::flush_cache();

		if ( is_array( $value ) && ! empty( $value['enable_humans_txt'] ) ) {
			self::schedule_rewrite_flush();
		}
	}

	/**
	 * Subsequent saves of the option.
	 *
	 * @param mixed $old_value Previous value.
	 * @param mixed $value     New value.
	 * @return void
	 */
	public static function on_option_updated( $old_value, $value ) {
		Helper::flush_cache();

		$was = ( is_array( $old_value ) && ! empty( $old_value['enable_humans_txt'] ) ) ? 1 : 0;
		$now = ( is_array( $value ) && ! empty( $value['enable_humans_txt'] ) ) ? 1 : 0;

		if ( $was !== $now ) {
			self::schedule_rewrite_flush();
		}
	}

	/**
	 * Flush rewrite rules once, at the end of this request.
	 *
	 * Deferred to shutdown so the flush happens after the option write has
	 * settled, and so it cannot run more than once per request. This is the
	 * only path other than activation and deactivation that flushes; the rule
	 * itself is registered on every request by add_rewrite_rules(), which is
	 * cheap, but the stored rule set has to be regenerated when the route is
	 * turned on or off.
	 *
	 * @return void
	 */
	private static function schedule_rewrite_flush() {
		static $scheduled = false;

		if ( $scheduled ) {
			return;
		}

		$scheduled = true;

		add_action( 'shutdown', 'flush_rewrite_rules' );
	}
}