<?php
/**
 * Custom CSS.
 *
 * WordPress keeps its Additional CSS per theme: switch themes and the rules stay behind with
 * the old one. On a block theme the box itself has moved inside the Site Editor, several clicks
 * from anywhere. This is CSS that belongs to the site — it prints on whichever theme is active,
 * and it is edited from Appearance, where people look for it.
 *
 * Front end only, on purpose. Core's own Additional CSS is left alone and both can be used; this
 * one prints second, so at equal specificity the site-level rule wins over the per-theme one.
 *
 * @package Adminkeep
 */

namespace Adminkeep\Feature;

use Adminkeep\Feature;
use Adminkeep\Admin\CustomCssScreen;
use Adminkeep\Admin\LiveCssPanel;
use Adminkeep\Admin\RestController;

defined( 'ABSPATH' ) || exit;

/**
 * Site-level front-end CSS.
 */
class CustomCss implements Feature {

	/**
	 * Option holding the CSS. Its own row rather than a key in the settings array, so a
	 * stylesheet's worth of text does not ride along with every settings read and write.
	 */
	const OPTION = 'adminkeep_custom_css';

	/**
	 * wp_head priority. Core prints Additional CSS at 101.
	 */
	const HEAD_PRIORITY = 102;

	/**
	 * The editing screen, built on first use.
	 *
	 * @var CustomCssScreen|null
	 */
	private $screen = null;

	/**
	 * The front-end editing panel, built on first use.
	 *
	 * @var LiveCssPanel|null
	 */
	private $panel = null;

	/**
	 * Feature id.
	 *
	 * @return string
	 */
	public function id() {
		return 'custom_css';
	}

	/**
	 * Label.
	 *
	 * @return string
	 */
	public function label() {
		return __( 'Custom CSS', 'adminkeep' );
	}

	/**
	 * Description.
	 *
	 * @return string
	 */
	public function description() {
		return __( 'CSS that belongs to your site rather than to a theme. It stays when you switch themes, and you edit it from Appearance.', 'adminkeep' );
	}

	/**
	 * A word for what this feature is doing right now.
	 *
	 * @return string
	 */
	public function state_label() {
		return '' === trim( self::css() ) ? __( 'No CSS yet', 'adminkeep' ) : __( 'CSS active', 'adminkeep' );
	}

	/**
	 * Settings schema. The CSS itself is edited on its own screen; only the admin bar item is
	 * a setting.
	 *
	 * @return array
	 */
	public function settings_schema() {
		return array(
			// On by default, and a site that never saved it reads as on (see resolve()). An
			// unticked box saves as off.
			'admin_bar' => array(
				'type'    => 'bool',
				'default' => true,
			),
		);
	}

	/**
	 * Field labels.
	 *
	 * @param string $key Field key.
	 * @return string
	 */
	public function field_label( $key ) {
		switch ( $key ) {
			case 'admin_bar':
				return __( 'Show Edit CSS in the admin bar', 'adminkeep' );

			default:
				return '';
		}
	}

	/**
	 * Settings with their defaults filled in.
	 *
	 * @param array $settings Stored settings.
	 * @return array{admin_bar: bool}
	 */
	public static function resolve( array $settings ) {
		return array(
			'admin_bar' => ! isset( $settings['admin_bar'] ) || (bool) $settings['admin_bar'],
		);
	}

	/**
	 * What switching this on actually does.
	 *
	 * @return string[]
	 */
	public function how_it_works() {
		return array(
			__( 'Adds Appearance → Custom CSS, with the same code editor WordPress uses for its own CSS box.', 'adminkeep' ),
			__( 'Adds Edit CSS to the admin bar on your site: a code panel beside the page that restyles it as you type. You can hide the admin bar item and open the panel from Appearance → Custom CSS instead.', 'adminkeep' ),
			__( 'Prints your CSS on the front end of the site, on whichever theme is active. Switching themes does not lose it.', 'adminkeep' ),
			__( 'Your theme\'s own Additional CSS is left alone. Both can be used; this one prints second, so it wins when the two disagree.', 'adminkeep' ),
			__( 'Anything that looks like HTML is refused when you save, so a pasted snippet cannot break out of the style tag.', 'adminkeep' ),
			__( 'Switching this off stops the CSS printing and removes the menu item. The CSS itself is kept unless you delete the plugin with "Delete all Adminkeep data" switched on.', 'adminkeep' ),
		);
	}

	/**
	 * Where the settings panel sends you to do the actual work.
	 *
	 * @return array{url?: string, label?: string} Empty when this user could not open the screen.
	 */
	public function panel_link() {
		if ( ! CustomCssScreen::can_edit() ) {
			return array();
		}

		return array(
			'url'   => CustomCssScreen::url(),
			'label' => __( 'Edit CSS', 'adminkeep' ),
		);
	}

	/**
	 * The editing screen.
	 *
	 * @return CustomCssScreen
	 */
	public function screen() {
		if ( null === $this->screen ) {
			$this->screen = new CustomCssScreen();
		}

		return $this->screen;
	}

	/**
	 * The front-end editing panel.
	 *
	 * @return LiveCssPanel
	 */
	public function panel() {
		if ( null === $this->panel ) {
			$this->panel = new LiveCssPanel();
		}

		return $this->panel;
	}

	/**
	 * Register hooks.
	 *
	 * @param array $settings Stored settings.
	 * @return void
	 */
	public function boot( array $settings ) {
		$resolved = self::resolve( $settings );

		add_action( 'wp_head', array( $this, 'print_css' ), self::HEAD_PRIORITY );
		add_action( 'rest_api_init', array( $this, 'register_rest_route' ) );

		if ( is_admin() ) {
			$this->screen()->boot();
		} else {
			$this->panel()->boot( $resolved['admin_bar'] );
		}
	}

	/**
	 * The stored CSS.
	 *
	 * @return string
	 */
	public static function css() {
		$css = get_option( self::OPTION, '' );

		return is_string( $css ) ? $css : '';
	}

	/**
	 * Check CSS the way core checks its own Additional CSS: no markup.
	 *
	 * @param string $css Raw CSS.
	 * @return true|\WP_Error
	 */
	public static function validate( $css ) {
		if ( preg_match( '#</?\w+#', $css ) ) {
			return new \WP_Error( 'adminkeep_css_markup', __( 'Markup is not allowed in CSS. Remove anything that looks like an HTML tag and save again.', 'adminkeep' ) );
		}

		return true;
	}

	/**
	 * Store CSS. The one writer: the screen, `wp adminkeep css set` and the REST route all save
	 * through here, so what counts as valid and how it is stored cannot drift between them.
	 *
	 * @param string $css Raw CSS.
	 * @return string|\WP_Error The CSS as stored, or why it was refused. Nothing is written on refusal.
	 */
	public static function save( $css ) {
		$css = str_replace( "\r\n", "\n", (string) $css );

		$valid = self::validate( $css );

		if ( is_wp_error( $valid ) ) {
			return $valid;
		}

		update_option( self::OPTION, $css, true );

		return $css;
	}

	/**
	 * Register GET and POST /adminkeep/v1/custom-css.
	 *
	 * Application passwords authenticate REST requests only, so this route is what lets the CSS be
	 * updated on a site reachable over HTTP but not over SSH.
	 *
	 * @return void
	 */
	public function register_rest_route() {
		register_rest_route(
			RestController::NAMESPACE_V1,
			'/custom-css',
			array(
				array(
					'methods'             => \WP_REST_Server::READABLE,
					'callback'            => array( $this, 'rest_get' ),
					'permission_callback' => array( $this, 'rest_can_edit' ),
				),
				array(
					'methods'             => \WP_REST_Server::EDITABLE,
					'callback'            => array( $this, 'rest_save' ),
					'permission_callback' => array( $this, 'rest_can_edit' ),
					'args'                => array(
						'css' => array(
							'type'              => 'string',
							'required'          => true,
							// Named explicitly: in a hand-written args array the type alone is not
							// enforced, and an array or number would otherwise reach the callback.
							'validate_callback' => 'rest_validate_request_arg',
						),
					),
				),
			)
		);
	}

	/**
	 * The screen's gate: edit_theme_options and edit_css together.
	 *
	 * @return bool|\WP_Error
	 */
	public function rest_can_edit() {
		if ( CustomCssScreen::can_edit() ) {
			return true;
		}

		return new \WP_Error(
			'adminkeep_css_forbidden',
			__( 'You are not allowed to edit CSS on this site.', 'adminkeep' ),
			array( 'status' => rest_authorization_required_code() )
		);
	}

	/**
	 * GET: the stored CSS, byte for byte.
	 *
	 * @return \WP_REST_Response
	 */
	public function rest_get() {
		return rest_ensure_response( array( 'css' => self::css() ) );
	}

	/**
	 * POST: replace the stored CSS.
	 *
	 * Refused CSS is a 400 carrying the same message the screen shows, and the stored CSS is left
	 * as it was.
	 *
	 * @param \WP_REST_Request $request Request.
	 * @return \WP_REST_Response|\WP_Error
	 */
	public function rest_save( $request ) {
		$saved = self::save( (string) $request->get_param( 'css' ) );

		if ( is_wp_error( $saved ) ) {
			$saved->add_data( array( 'status' => 400 ) );

			return $saved;
		}

		return rest_ensure_response( array( 'css' => $saved ) );
	}

	/**
	 * Print the CSS into the head.
	 *
	 * @return void
	 */
	public function print_css() {
		$css = trim( self::css() );

		// With the panel open the tag is printed even when empty: it is what the preview writes
		// into, and keeping it here keeps the preview at the same place in the cascade.
		if ( '' === $css && ! LiveCssPanel::is_open() ) {
			return;
		}

		// CSS cannot be HTML-escaped without corrupting it (child combinators, quoted strings).
		// Stripping tags is what core does for Additional CSS; markup was already refused on save.
		echo '<style id="adminkeep-custom-css">' . "\n" . wp_strip_all_tags( $css ) . "\n" . '</style>' . "\n"; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
	}
}