<?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 until you uninstall.', '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
	}
}