<?php
/**
 * This site's half of the one-click connect handshake with Mapsemble.
 *
 * @package Mapsemble
 */

namespace Mapsemble;

use Mapsemble\Api\Client;

/**
 * Owns the connect state and turns an approval on Mapsemble into credentials.
 *
 * Two callers need exactly the same thing to happen — the settings page's
 * "Finish connecting" fallback and the AJAX check its script polls — and
 * "happen" here means writing credentials into the settings option. Kept in
 * one place so the two cannot drift into storing subtly different things.
 * Port of the Drupal module's MapsembleConnect service.
 */
final class Connect {

	/**
	 * Option holding the in-flight connect attempt: `{state, created}`.
	 */
	public const STATE_OPTION = 'mapsemble_connect_state';

	/**
	 * How long a connect attempt stays resumable, in seconds.
	 *
	 * Matches the ten minutes Mapsemble keeps an approved credential for, so
	 * the two halves cannot disagree about whether an attempt is still alive.
	 */
	public const TTL = 600;

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

	/**
	 * Constructor.
	 *
	 * @param Client $api API client.
	 */
	public function __construct( Client $api ) {
		$this->api = $api;
	}

	/**
	 * Whether this site already holds credentials, from wherever.
	 */
	public function is_connected(): bool {
		return $this->api->has_credentials();
	}

	/**
	 * Whether the credentials come from wp-config.php constants.
	 *
	 * Connecting writes the option, and the constants outrank it — so on such
	 * a site the button would "succeed" and change nothing visible.
	 */
	public function credentials_are_constants(): bool {
		return defined( 'MAPSEMBLE_CLIENT_ID' ) || defined( 'MAPSEMBLE_CLIENT_SECRET' );
	}

	/**
	 * The state for the current connect attempt, generating one if needed.
	 *
	 * Kept in an option rather than in the form, because the value has to
	 * survive the round trip through Mapsemble in another tab and every
	 * re-render of the settings page in between. Regenerated once spent or
	 * stale, so an abandoned attempt cannot be resumed later by whoever
	 * still holds the old link.
	 */
	public function pending_state(): string {
		$pending = $this->stored();
		if ( '' !== $pending['state'] ) {
			return $pending['state'];
		}

		// Hex because Mapsemble validates the shape, and 32 bytes because the
		// state is the only thing standing between a stranger and this
		// account's client secret.
		$state = bin2hex( random_bytes( 32 ) );
		$value = array(
			'state'   => $state,
			'created' => time(),
		);
		// Autoload off: a bearer for the secret has no business being loaded
		// on every front-end request.
		update_option( self::STATE_OPTION, $value, false );

		return $state;
	}

	/**
	 * The URL a site admin approves this site at.
	 *
	 * @param string $site_url This site's URL, shown on the approval page so
	 *                         the person approving can see who is asking.
	 */
	public function approval_url( string $site_url ): string {
		return $this->api->get_app_base() . '/wordpress/connect?' . http_build_query(
			array(
				'state' => $this->pending_state(),
				'site'  => $site_url,
			)
		);
	}

	/**
	 * Collects credentials waiting on Mapsemble and stores them.
	 *
	 * @return bool True when credentials were collected and saved. False means
	 *              nothing is waiting yet, which is the ordinary answer while
	 *              the admin is still on the Mapsemble page — not an error.
	 */
	public function collect(): bool {
		$state = $this->stored()['state'];
		if ( '' === $state ) {
			return false;
		}

		$credentials = $this->api->collect_connected_credentials( $state );
		if ( null === $credentials ) {
			return false;
		}

		$saved = get_option( 'mapsemble_settings', array() );
		$saved = is_array( $saved ) ? $saved : array();
		update_option(
			'mapsemble_settings',
			array_merge(
				$saved,
				array(
					// The same treatment a manual save gives the pair: the id
					// is plain text, the secret is opaque and only trimmed.
					'client_id'     => sanitize_text_field( $credentials['client_id'] ),
					'client_secret' => trim( $credentials['client_secret'] ),
				)
			)
		);

		// The caches belong to whichever account the previous credentials
		// named — the same reason a manual save drops them. The state is
		// spent: Mapsemble has already dropped its side.
		Client::forget_account_caches();
		delete_option( self::STATE_OPTION );

		return true;
	}

	/**
	 * Whether an admin could plausibly be mid-approval right now.
	 */
	public function has_pending_attempt(): bool {
		return '' !== $this->stored()['state'];
	}

	/**
	 * The stored attempt, normalised; the empty shape once it has expired.
	 *
	 * The TTL is applied here, in the one reader, so that "is there an
	 * attempt" and "which state is current" can never disagree: a stale
	 * attempt is no attempt, to every caller.
	 *
	 * @return array{state: string, created: int}
	 */
	private function stored(): array {
		$none    = array(
			'state'   => '',
			'created' => 0,
		);
		$pending = get_option( self::STATE_OPTION );
		if ( ! is_array( $pending ) ) {
			return $none;
		}
		$created = (int) ( $pending['created'] ?? 0 );
		if ( $created + self::TTL <= time() ) {
			return $none;
		}
		return array(
			'state'   => (string) ( $pending['state'] ?? '' ),
			'created' => $created,
		);
	}
}