<?php
/**
 * Plugin bootstrap: wires all hooks.
 *
 * @package Mapsemble
 */

namespace Mapsemble;

use Mapsemble\Admin\BlockPreview;
use Mapsemble\Admin\DataEditorPage;
use Mapsemble\Admin\FirstRunNotice;
use Mapsemble\Admin\MapEditScreen;
use Mapsemble\Admin\Menu;
use Mapsemble\Admin\MetaBox;
use Mapsemble\Admin\SettingsPage;
use Mapsemble\Api\Client;
use Mapsemble\Geo\Coordinates;
use Mapsemble\PostType\MapPostType;

/**
 * Central plugin wiring.
 */
final class Plugin {

	/**
	 * Singleton instance.
	 *
	 * @var Plugin|null
	 */
	private static ?Plugin $instance = null;

	/**
	 * API client.
	 *
	 * @var Client
	 */
	private Client $api;

	/**
	 * Map config repository.
	 *
	 * @var MapConfigRepository
	 */
	private MapConfigRepository $maps;

	/**
	 * Coordinate storage.
	 *
	 * @var Coordinates
	 */
	private Coordinates $coordinates;

	/**
	 * Shared embed renderer.
	 *
	 * @var Embed
	 */
	private Embed $embed;

	/**
	 * Returns the shared plugin instance.
	 */
	public static function instance(): Plugin {
		if ( null === self::$instance ) {
			self::$instance = new self();
		}
		return self::$instance;
	}

	/**
	 * The account's maps as picker options, dated in the site's format.
	 *
	 * One place for the formatter, so the block editor and the map config
	 * screen label the same map the same way.
	 *
	 * @param array<array-key, mixed> $maps Remote maps keyed by id, oldest first.
	 * @return list<array{value: string, label: string, name: string}>
	 */
	public static function map_choices( array $maps ): array {
		return MapChoices::options(
			$maps,
			static fn ( int $ts ): string => (string) wp_date( (string) get_option( 'date_format' ), $ts )
		);
	}

	/**
	 * Returns the shared API client.
	 */
	public function api(): Client {
		return $this->api;
	}

	/**
	 * Returns the shared map config repository.
	 */
	public function maps(): MapConfigRepository {
		return $this->maps;
	}

	/**
	 * Returns the shared coordinate storage.
	 */
	public function coordinates(): Coordinates {
		return $this->coordinates;
	}

	/**
	 * Returns the shared embed renderer.
	 *
	 * The one thing a theme needs, and the reason it is public: without it the
	 * only way to put a map in a template is `do_shortcode()`. Prefer the
	 * `mapsemble_map()` template function, which guards against being called
	 * before the plugin has booted.
	 */
	public function embed(): Embed {
		return $this->embed;
	}

	/**
	 * Registers the Gutenberg block and its editor script.
	 *
	 * @param Embed $embed Shared embed renderer.
	 */
	private function register_block( Embed $embed ): void {
		// Registered on `init` because block.json names this handle as its
		// editorScript, so it has to exist by the time the block does. The
		// map list it needs is *not* built here: this runs on every request,
		// front end included, and listing the maps is a query.
		wp_register_script(
			'mapsemble-block-editor',
			plugins_url( 'assets/js/block-editor.js', MAPSEMBLE_PLUGIN_FILE ),
			array( 'wp-blocks', 'wp-element', 'wp-block-editor', 'wp-components', 'wp-i18n', 'wp-hooks', 'wp-api-fetch' ),
			MAPSEMBLE_VERSION,
			true
		);

		// Without this binding wp.i18n has no table for the domain and the
		// inspector stays English on a translated site.
		wp_set_script_translations( 'mapsemble-block-editor', 'mapsemble', MAPSEMBLE_PLUGIN_DIR . '/languages' );

		add_action( 'enqueue_block_editor_assets', array( $this, 'localize_block_editor' ) );

		register_block_type(
			MAPSEMBLE_PLUGIN_DIR . '/blocks/map',
			array(
				'render_callback' => static function ( array $attributes ) use ( $embed ): string {
					$args = array(
						'height'               => (string) ( $attributes['height'] ?? '' ),
						'scroll_capture'       => (string) ( $attributes['scrollCapture'] ?? '' ),
						'scroll_offset_top'    => (string) ( $attributes['scrollOffsetTop'] ?? '' ),
						'scroll_offset_bottom' => (string) ( $attributes['scrollOffsetBottom'] ?? '' ),
						// The default (true) says nothing; only the
						// opt-out reaches the widget.
						'fill_viewport'        => ( $attributes['fillViewport'] ?? true ) ? '' : 'false',
						'filters'              => (string) ( $attributes['filters'] ?? '' ),
					);

					// New selections store the Mapsemble map id; configId is
					// the pre-0.3 shape and keeps rendering unchanged. Such
					// a block stored no remoteMapId, so the attribute default
					// ('sample') fills it in — and must not outrank the
					// binding. Choosing the sample on one of those blocks
					// zeroes configId, so the two never genuinely coexist.
					// A block saved before 0.4.0 with nothing chosen at all
					// (no configId either) gets the same default and now
					// renders the sample where it used to render nothing.
					$remote    = (string) ( $attributes['remoteMapId'] ?? '' );
					$config_id = (int) ( $attributes['configId'] ?? 0 );
					if ( $config_id > 0 && 'sample' === $remote ) {
						$remote = '';
					}
					$inner = '' !== $remote
						? $embed->render_by_map_id( $remote, $args )
						: $embed->render( $config_id, $args );

					// The wrapper carries the block's classes — alignwide /
					// alignfull above all, which is what the theme widens —
					// so the alignment chosen in the editor reaches the page.
					// A visitor's HTML comment stays bare: an empty wrapper
					// would still take up layout space.
					if ( '' === $inner || str_starts_with( ltrim( $inner ), '<!--' ) ) {
						return $inner;
					}
					return sprintf( '<div %s>%s</div>', get_block_wrapper_attributes(), $inner );
				},
			)
		);
	}

	/**
	 * Hands the block editor the list of maps to choose from.
	 *
	 * Deferred to `enqueue_block_editor_assets` — which fires on the post
	 * editor, the widgets screen and the site editor, and nowhere else —
	 * because building it is a query and only an editor ever reads it.
	 */
	public function localize_block_editor(): void {
		$configs   = array();
		$site_maps = array();
		foreach ( $this->maps->all() as $config ) {
			$configs[] = array(
				// A string, because the editor compares option values as
				// strings; the attribute itself is the map's post id.
				'value' => (string) $config->id,
				'label' => '' !== $config->label ? $config->label : (string) $config->id,
			);
			if ( '' !== $config->map_id && ! $config->is_hosted() && ! isset( $site_maps[ $config->map_id ] ) ) {
				// The map picker's site-fed entries: bound site-fed maps,
				// keyed by their Mapsemble id. Free — no API call. One
				// entry per map id — two configs bound to one map are one
				// map to embed; the first (by title) names it.
				$site_maps[ $config->map_id ] = '' !== $config->label ? $config->label : $config->map_id;
			}
		}
		$site_map_ids = array_map( 'strval', array_keys( $site_maps ) );

		// The picker is one flat list, so the origin travels in the label,
		// and two maps built under one title get their short id, as
		// same-named account maps do. `name` stays plain for the canvas.
		$name_counts = array_count_values( $site_maps );
		$site_maps   = array_map(
			static function ( $map_id, string $name ) use ( $name_counts ): array {
				$map_id = (string) $map_id;
				$shown  = $name_counts[ $name ] > 1 ? $name . ' · ' . substr( $map_id, -4 ) : $name;
				return array(
					'value' => $map_id,
					'label' => sprintf(
						/* translators: %s: map name */
						__( '%s — built from this site', 'mapsemble' ),
						$shown
					),
					'name'  => $name,
				);
			},
			array_keys( $site_maps ),
			array_values( $site_maps )
		);

		// The account list ships to anyone who can open the block editor,
		// deliberately: a map id grants nothing — any published map embeds
		// by id from any page — and the labels are mild metadata. Without
		// credentials get_remote_maps() returns [] without a request.
		$remote_maps = array();
		foreach ( $this->api->get_remote_maps() as $id => $map ) {
			if ( in_array( (string) $id, $site_map_ids, true ) ) {
				// A bound map is listed as built from this site and keeps
				// the label this site gave it; listing it twice would make
				// it look like two different maps.
				continue;
			}
			$remote_maps[ $id ] = $map;
		}
		// Newest first, same-named maps told apart by date and short id.
		$account_maps = self::map_choices( $remote_maps );

		wp_localize_script(
			'mapsemble-block-editor',
			'mapsembleBlockEditor',
			array(
				'configs' => $configs,
				'embed'   => array(
					'sampleMapId'    => Embed::SAMPLE_MAP_ID,
					// The locale's own ", ", for lists the script words:
					// core already translates it, so no string of ours.
					'listSeparator'  => wp_get_list_item_separator(),
					'hasCredentials' => $this->api->has_credentials(),
					'siteMaps'       => $site_maps,
					'accountMaps'    => $account_maps,
					'listError'      => array() === $account_maps && $this->api->has_credentials()
						? $this->api->get_last_error()
						: '',
					// The still screenshot the canvas shows while no map of
					// yours is chosen (the sample included); a chosen map
					// previews live through livePreviewUrl below.
					'stillUrl'       => plugins_url( 'assets/images/map-preview.webp', MAPSEMBLE_PLUGIN_FILE ),
					// Where maps come from, for the advice under an empty
					// picker. From the classes, not written out, so a moved
					// screen cannot leave a dead link behind.
					'settingsUrl'    => SettingsPage::url(),
					'mapsUrl'        => MapPostType::list_url(),
					// The frame that shows a chosen map live, at the block's
					// width; the editor appends `&map=` and `&filters=`.
					'livePreviewUrl' => BlockPreview::url(),
				),
			)
		);
	}

	/**
	 * Suggests privacy policy text under Settings > Privacy > Policy Guide.
	 *
	 * Runs on admin_init because wp_add_privacy_policy_content() refuses to
	 * be called any earlier.
	 */
	public function add_privacy_policy_content(): void {
		// The host the widget actually loads from: a self-hosted or staging
		// base must be disclosed as itself, not as app.mapsemble.com.
		$host = (string) wp_parse_url( $this->api->get_app_base(), PHP_URL_HOST );

		$content = '<p class="privacy-policy-tutorial">'
			. esc_html__( 'Suggested text for pages that embed a Mapsemble map.', 'mapsemble' )
			. '</p>'
			. '<p>'
			. sprintf(
				/* translators: %s: host name the map widget is loaded from, e.g. app.mapsemble.com. */
				esc_html__( 'Pages on this site that contain an interactive map load the map widget from %s, a service operated by Mapsemble. When such a page is opened, the visitor\'s IP address and the identifier of the map being shown are transmitted to and visible to the Mapsemble service, in the same way as for any other resource loaded from a third-party server.', 'mapsemble' ),
				esc_html( $host )
			)
			. '</p>'
			. '<p>'
			. sprintf(
				/* translators: %s: URL of the Mapsemble privacy policy. */
				esc_html__( 'Mapsemble\'s own privacy policy is available at %s.', 'mapsemble' ),
				'<a href="https://www.mapsemble.com/privacy">https://www.mapsemble.com/privacy</a>'
			)
			. '</p>';

		wp_add_privacy_policy_content( 'Mapsemble', wp_kses_post( $content ) );
	}

	/**
	 * Hooks everything up. Called once on plugins_loaded.
	 */
	public function init(): void {
		$this->api         = new Client();
		$this->maps        = new MapConfigRepository();
		$this->coordinates = new Coordinates( $this->maps );

		// Registered outside is_admin(): the post type has to exist on the
		// front end and in REST requests too, not only in wp-admin.
		( new MapPostType( $this->maps, $this->api ) )->register();

		// Same reason: the block editor saves posts through the REST API,
		// where is_admin() is false.
		( new MetaBox( $this->maps, $this->coordinates, $this->api ) )->register();

		$acf = new AcfIntegration( $this->maps, $this->coordinates );
		// After plugins_loaded so ACF's functions exist when present.
		add_action( 'init', array( $acf, 'register' ), 5 );

		( new MetaKeysSource( $this->coordinates ) )->register();

		// Registered here rather than inside the REST closure: the ordering
		// gates itself on the `mapsemble_entropy` query var, and any code
		// running the feed query outside a REST request needs it too.
		( new Feed\EntropyOrder() )->register();

		// Registered on every request, not only REST ones: the saves and term
		// edits that invalidate the feed cache happen in wp-admin.
		$feed_cache = new Feed\ResponseCache( $this->maps );
		$feed_cache->register();

		add_action(
			'rest_api_init',
			function () use ( $feed_cache ): void {
				$feed_query = new Feed\FeedQuery();
				( new Rest\FeaturesController( $this->maps, $feed_query, $feed_cache ) )->register_routes();
				( new Rest\FeatureController( $this->maps, new CardRenderer(), $feed_query, $feed_cache ) )->register_routes();
				( new Rest\FilterOptionsController( $this->maps, new Feed\FilterOptions(), $feed_cache ) )->register_routes();
				( new Rest\GeocodeController( $this->api ) )->register_routes();
				( new Rest\MapFiltersController( $this->api, $this->maps ) )->register_routes();
			}
		);

		$this->embed = new Embed( $this->api, $this->maps );
		$embed       = $this->embed;
		( new Shortcode( $embed ) )->register();
		// Front end and admin both: the editor's frame is served on the
		// front end, the heartbeat that re-signs its URL runs in admin-ajax.
		( new BlockPreview( $embed ) )->register();
		add_action( 'init', fn () => $this->register_block( $embed ) );

		// admin_init only ever fires in wp-admin, so this needs no is_admin()
		// guard of its own.
		add_action( 'admin_init', array( $this, 'add_privacy_policy_content' ) );

		if ( is_admin() ) {
			( new Menu() )->register();
			( new DataEditorPage( $this->api, $this->maps ) )->register();
			( new SettingsPage( $this->api, new Connect( $this->api ) ) )->register();
			( new MapEditScreen( $this->api, $this->maps, $this->coordinates, $acf ) )->register();
			( new FirstRunNotice( $this->api ) )->register();
		}
	}
}