<?php
/**
 * Blocking settings REST route.
 *
 * @package Consentfold
 */

declare(strict_types=1);

namespace Consentfold\Admin;

use Consentfold\Blocking\ServiceRegistry;
use Consentfold\Settings\Defaults;
use Consentfold\Settings\InvalidSettingsException;
use Consentfold\Settings\Repository;
use Consentfold\Settings\Schema;
use WP_Error;
use WP_REST_Request;
use WP_REST_Response;
use WP_REST_Server;

/**
 * `consentfold/v1/admin/blocking`: reads and saves the `blocking` branch of the settings for the admin app.
 *
 * Only administrators pass the permission check; core verifies the REST nonce for cookie-authenticated requests and
 * treats a request without it as logged out. The document is validated by {@see \Consentfold\Settings\Schema}
 * through the repository. Fields the network admin locked are never written: the response reports them so the UI can
 * show them read-only. A rule cannot target `necessary`, which is always granted, so it would never block anything.
 */
final class BlockingRoute {

	public const NAMESPACE = 'consentfold/v1';
	public const ROUTE     = '/admin/blocking';

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

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

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

	/**
	 * 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(
				array(
					'methods'             => WP_REST_Server::READABLE,
					'callback'            => array( $this, 'get' ),
					'permission_callback' => array( $this, 'can_manage' ),
				),
				array(
					'methods'             => WP_REST_Server::EDITABLE,
					'callback'            => array( $this, 'save' ),
					'permission_callback' => array( $this, 'can_manage' ),
				),
			)
		);
	}

	/**
	 * Whether the current user may manage the plugin.
	 */
	public function can_manage(): bool {
		return current_user_can( Capabilities::MANAGE );
	}

	/**
	 * Current blocking settings.
	 */
	public function get(): WP_REST_Response {
		return new WP_REST_Response( $this->payload() );
	}

	/**
	 * Save the submitted blocking fields.
	 *
	 * @param WP_REST_Request $request Request whose JSON body holds a partial `blocking` object.
	 * @return WP_REST_Response|WP_Error
	 */
	public function save( WP_REST_Request $request ) {
		$body = $request->get_json_params();

		if ( ! is_array( $body ) ) {
			return new WP_Error( 'consentfold_invalid_body', __( 'Send the blocking settings as a JSON object.', 'consentfold' ), array( 'status' => 400 ) );
		}

		$locked   = $this->locked_fields();
		$site     = $this->settings->get_site();
		$blocking = array_merge(
			is_array( $site['blocking'] ?? null ) ? $site['blocking'] : array(),
			array_diff_key( $body, array_flip( $locked ) )
		);
		$document = array_merge( $site, array( 'blocking' => $blocking ) );
		unset( $document['schema_version'] ); // The repository carries it over.

		$errors = $this->settings->rule_category_errors( $document );

		// Validate before saving, so a document with any error saves nothing.
		try {
			Schema::validate( $document );
		} catch ( InvalidSettingsException $e ) {
			$errors += $e->errors();
		}

		if ( array() === $errors ) {
			$this->settings->set( $document );
		}

		if ( array() !== $errors ) {
			return new WP_Error(
				'consentfold_invalid_settings',
				__( 'The blocking settings are not valid.', 'consentfold' ),
				array(
					'status' => 400,
					'errors' => $errors,
				)
			);
		}

		return new WP_REST_Response( $this->payload() );
	}

	/**
	 * Effective blocking settings, the fields the network locked, the categories a rule may target and the services no category can grant.
	 *
	 * @return array{blocking: array<string, mixed>, locked: list<string>, categories: list<array{slug: string, label: string}>, unassigned_services: list<array{slug: string, name: string}>}
	 */
	private function payload(): array {
		$settings   = $this->settings->get();
		$categories = array();

		foreach ( $this->settings->rule_categories( $settings ) as $slug => $category ) {
			$categories[] = array(
				'slug'  => $slug,
				'label' => $category['label'],
			);
		}

		return array(
			'blocking'            => (array) $settings['blocking'],
			'locked'              => $this->locked_fields(),
			'categories'          => $categories,
			'unassigned_services' => $this->registry->unassigned_services(),
		);
	}

	/**
	 * Blocking fields the network locked, whether it locked the whole branch or one field.
	 *
	 * @return list<string>
	 */
	private function locked_fields(): array {
		$locked = array();

		foreach ( $this->settings->locked_keys() as $path ) {
			foreach ( array_keys( Defaults::all()['blocking'] ) as $field ) {
				if ( 'blocking' === $path || 0 === strpos( $path, 'blocking.' . $field ) ) {
					$locked[] = $field;
				}
			}
		}

		return array_values( array_unique( $locked ) );
	}
}