<?php
/**
 * Service details for the banner script.
 *
 * @package Consentfold
 */

declare(strict_types=1);

namespace Consentfold\Frontend;

use Consentfold\Blocking\ServiceRegistry;
use Consentfold\Consent\Categories;
use Consentfold\Settings\Repository;
use WP_REST_Request;
use WP_REST_Response;
use WP_REST_Server;

/**
 * What the browser needs to know about a service only once it acts on one: the name and provider a placeholder
 * shows and the cookie names a withdrawal deletes (docs/subsystems.md §5.2). They stay out of the inline config so
 * that every page does not carry them; the banner script fetches them from `consentfold/v1/services` the first
 * time it needs them. Blocking never waits for them: the rules the guard works with are in the config.
 *
 * The route is public and the same for every visitor. Its URL carries a hash of the answer (`v`), so the browser
 * and any CDN may keep the answer for a year: a change of the services gives a new URL. A request with another `v`
 * (a cached page printed before the change) gets the current answer, kept briefly.
 *
 * The answer is compiled once and stored in one autoloaded transient, with a hash of what it depends on: the
 * categories in effect and the plugin version, which ships the catalog. Saving the settings drops it, and so does
 * activating or deactivating a plugin or switching the theme (they change what `consentfold_services`
 * returns), see {@see ConfigBuilder::register()}.
 */
final class ServiceDetails {

	public const TRANSIENT = 'consentfold_service_details';
	public const NAMESPACE = 'consentfold/v1';
	public const ROUTE     = '/services';

	/**
	 * Settings repository.
	 *
	 * @var Repository
	 */
	private Repository $settings;

	/**
	 * Service and blocking rule registry.
	 *
	 * @var ServiceRegistry
	 */
	private ServiceRegistry $registry;

	/**
	 * Plugin version; a new release, with a new catalog, rebuilds the details.
	 *
	 * @var string
	 */
	private string $version;

	/**
	 * Constructor.
	 *
	 * @param Repository      $settings Settings repository.
	 * @param ServiceRegistry $registry Service and blocking rule registry.
	 * @param string          $version  Plugin version.
	 */
	public function __construct( Repository $settings, ServiceRegistry $registry, string $version ) {
		$this->settings = $settings;
		$this->registry = $registry;
		$this->version  = $version;
	}

	/**
	 * Hook the route.
	 */
	public function register(): void {
		add_action( 'rest_api_init', array( $this, 'register_route' ) );
	}

	/**
	 * Register the route.
	 */
	public function register_route(): void {
		register_rest_route(
			self::NAMESPACE,
			self::ROUTE,
			array(
				'methods'             => WP_REST_Server::READABLE,
				'callback'            => array( $this, 'serve' ),
				'permission_callback' => '__return_true', // Public data, the same for every visitor.
				'args'                => array(
					'v' => array(
						'type'    => 'string',
						'default' => '',
					),
				),
			)
		);
	}

	/**
	 * Delete the cached details.
	 */
	public function invalidate(): void {
		delete_transient( self::TRANSIENT );
	}

	/**
	 * The details and their version, from the cache when it is warm.
	 *
	 * @return array{version: string, services: array<string, array<string, mixed>>}
	 */
	public function get(): array {
		$hash   = md5( (string) wp_json_encode( array( array_keys( Categories::resolve( $this->settings->get() ) ), $this->version, ConfigBuilder::FORMAT ) ) );
		$cached = get_transient( self::TRANSIENT );

		if ( is_array( $cached ) && ( $cached['hash'] ?? null ) === $hash && is_string( $cached['version'] ?? null ) && is_array( $cached['services'] ?? null ) ) {
			return array(
				'version'  => $cached['version'],
				'services' => $cached['services'],
			);
		}

		$services = $this->registry->public_services();
		$version  = substr( md5( (string) wp_json_encode( $services ) ), 0, 12 );
		set_transient(
			self::TRANSIENT,
			array(
				'hash'     => $hash,
				'version'  => $version,
				'services' => $services,
			)
		);

		return array(
			'version'  => $version,
			'services' => $services,
		);
	}

	/**
	 * Where the browser fetches the details: a path on this site, so it works from whichever host serves the page.
	 */
	public function url(): string {
		return add_query_arg( 'v', $this->get()['version'], wp_make_link_relative( rest_url( self::NAMESPACE . self::ROUTE ) ) );
	}

	/**
	 * Answer the route with the details, cacheable.
	 *
	 * @param WP_REST_Request $request Request; `v` is the version from {@see self::url()}.
	 */
	public function serve( WP_REST_Request $request ): WP_REST_Response {
		$details  = $this->get();
		$response = new WP_REST_Response( $details['services'] );

		$response->header( 'Cache-Control', $request->get_param( 'v' ) === $details['version'] ? 'public, max-age=31536000, immutable' : 'public, max-age=300' );

		return $response;
	}
}