<?php
/**
 * File integrity monitoring: the directories a scan may read.
 *
 * @package ActivityLog404
 */

namespace ActivityLog404\Integrity;

defined( 'ABSPATH' ) || exit;

/**
 * The four roots a scan reads -- core (ABSPATH), plugins, themes, uploads --
 * each resolved ONCE to its real path, and the confinement check every read
 * goes through.
 *
 * Confinement: a file is read only when its real path lies inside the real
 * path of the root it was reached from. The walk never descends into a
 * symlinked directory at all (a link can point anywhere, including back up
 * the tree), and a symlinked FILE is read only when it resolves inside its
 * root. On a standard install every root lies under ABSPATH; a site that
 * moved wp-content elsewhere (WP_CONTENT_DIR) is read there, because that is
 * where WordPress itself loads its plugins from -- the roots are WordPress's
 * own configured directories, never a path a request supplies.
 *
 * A value object rather than constants read in place so the tests can point
 * a scan at a fixture tree (tests/Integration/Integrity).
 */
final class Roots {

	public const CORE    = 'core';
	public const PLUGINS = 'plugins';
	public const THEMES  = 'themes';
	public const UPLOADS = 'uploads';

	/** @var array<string, string> Root key => real path with a trailing slash ('' when unusable). */
	private array $paths;

	/**
	 * @param array<string, string> $paths Root key => directory.
	 */
	public function __construct( array $paths ) {
		$this->paths = array();
		foreach ( array( self::CORE, self::PLUGINS, self::THEMES, self::UPLOADS ) as $key ) {
			$real                = isset( $paths[ $key ] ) && '' !== $paths[ $key ] ? realpath( $paths[ $key ] ) : false;
			$this->paths[ $key ] = is_string( $real ) && is_dir( $real ) ? rtrim( $real, '/' ) . '/' : '';
		}
	}

	/** The site's own directories. */
	public static function from_wordpress(): self {
		$uploads = wp_upload_dir( null, false );

		return new self(
			array(
				self::CORE    => ABSPATH,
				self::PLUGINS => WP_PLUGIN_DIR,
				self::THEMES  => get_theme_root(),
				self::UPLOADS => (string) $uploads['basedir'],
			)
		);
	}

	/**
	 * A root's real path with a trailing slash, or '' when it does not exist.
	 *
	 * @param string $key Root key.
	 */
	public function path( string $key ): string {
		return $this->paths[ $key ] ?? '';
	}

	/**
	 * The absolute path of a file or directory under a root, or null when
	 * it is outside the root once resolved, or the relative path is unsafe.
	 * Does not require the path to exist; when it exists, its real path is
	 * what is checked.
	 *
	 * @param string $key      Root key.
	 * @param string $relative Path within the root ('' for the root itself).
	 */
	public function resolve( string $key, string $relative ): ?string {
		$root = $this->path( $key );
		if ( '' === $root ) {
			return null;
		}

		if ( '' === $relative ) {
			return $root;
		}

		if ( ! Comparison::is_safe_relative( $relative ) ) {
			return null;
		}

		$absolute = $root . $relative;
		if ( ! file_exists( $absolute ) && ! is_link( $absolute ) ) {
			return $absolute;
		}

		$real = realpath( $absolute );
		if ( ! is_string( $real ) ) {
			return null; // A dangling link.
		}

		return $this->inside( $key, $real ) ? $absolute : null;
	}

	/**
	 * Whether a real path lies inside a root.
	 *
	 * @param string $key  Root key.
	 * @param string $real A real path.
	 */
	public function inside( string $key, string $real ): bool {
		$root = $this->path( $key );

		return '' !== $root && ( rtrim( $real, '/' ) . '/' === $root || 0 === strpos( $real, $root ) );
	}

	/**
	 * How the screen names a path: relative to ABSPATH when the root is
	 * inside it (`wp-content/plugins/akismet/akismet.php`), otherwise the
	 * root's name in brackets (`[plugins]/akismet/akismet.php`). Never the
	 * server's absolute path.
	 *
	 * @param string $key      Root key.
	 * @param string $relative Path within the root.
	 */
	public function display( string $key, string $relative ): string {
		$core = $this->path( self::CORE );
		$root = $this->path( $key );

		if ( '' !== $core && '' !== $root && 0 === strpos( $root, $core ) ) {
			return substr( $root, strlen( $core ) ) . $relative;
		}

		return '[' . $key . ']/' . $relative;
	}
}