<?php
/**
 * Plugin-level settings: the ones that belong to no single feature.
 *
 * @package Adminkeep
 */

namespace Adminkeep;

/**
 * A small typed schema over one non-feature key of the settings option.
 *
 * Feature settings live under the feature's id and are described by the feature's own schema.
 * The few settings that are about the plugin itself — whether the settings screen hides unused
 * features, and whether deleting the plugin deletes its data — live here, under `_plugin`, with
 * the same schema shape, so `wp adminkeep setting` can parse and list them the way
 * `wp adminkeep feature` does.
 *
 * `panel` marks a setting the Plugin settings panel shows and saves. Only those are written by a
 * save of that panel, so saving it can never reset a setting it does not show.
 *
 * A setting at its default is stored as nothing at all.
 */
class PluginSettings {

	/**
	 * The key inside the settings option. Underscored, like `_schema_version`, so it can never
	 * collide with a feature id.
	 */
	const KEY = '_plugin';

	/**
	 * Schema, in the shape feature settings use: type, default, and a line for the help.
	 *
	 * @return array<string, array>
	 */
	public static function schema() {
		return array(
			'hide_unused' => array(
				'type'        => 'bool',
				'default'     => false,
				'description' => 'Hide switched-off features from the settings screen nav. Same as the "Hide unused features" switch.',
			),
			// Off by default: deleting the plugin keeps its data, so a delete done to reinstall or
			// by mistake loses nothing. uninstall.php reads this straight from the option, since
			// the plugin is not loaded when WordPress runs it.
			'delete_data' => array(
				'type'        => 'bool',
				'default'     => false,
				'panel'       => true,
				'description' => 'Delete all Adminkeep data (settings, CSS, code, the email log, redirects) when the plugin is deleted. Off keeps it.',
			),
		);
	}

	/**
	 * Keys the Plugin settings panel shows and saves.
	 *
	 * @return string[]
	 */
	public static function panel_keys() {
		return array_keys( array_filter( self::schema(), static function ( $spec ) {
			return ! empty( $spec['panel'] );
		} ) );
	}

	/**
	 * Every setting, resolved against its default.
	 *
	 * @return array<string, mixed>
	 */
	public static function all() {
		$stored = Settings::get( self::KEY );
		$values = array();

		foreach ( self::schema() as $key => $spec ) {
			$values[ $key ] = array_key_exists( $key, $stored ) ? $stored[ $key ] : $spec['default'];
		}

		return $values;
	}

	/**
	 * One setting.
	 *
	 * @param string $key Setting key.
	 * @return mixed Its value, or null for an unknown key.
	 */
	public static function get( $key ) {
		$all = self::all();

		return array_key_exists( $key, $all ) ? $all[ $key ] : null;
	}

	/**
	 * Change one or more settings; everything not named is kept. The one writer for this key.
	 *
	 * Values are stored typed and only when they differ from the default, so an untouched
	 * install carries no `_plugin` entry at all.
	 *
	 * @param array<string, mixed> $changes Key => typed value. Unknown keys are ignored.
	 * @return void
	 */
	public static function set( array $changes ) {
		$schema = self::schema();
		$stored = Settings::get( self::KEY );

		foreach ( $changes as $key => $value ) {
			if ( ! isset( $schema[ $key ] ) ) {
				continue;
			}

			if ( $value === $schema[ $key ]['default'] ) {
				unset( $stored[ $key ] );
			} else {
				$stored[ $key ] = $value;
			}
		}

		Settings::update( self::KEY, $stored );
	}
}