<?php
namespace Relay\Files;

use Relay\Support\Paths;

/**
 * The site's root: WordPress' own folder (where wp-load.php is), whose files besides WordPress itself a backup can
 * hold, such as .htaccess, robots.txt, verification files and extra folders. WordPress' own files, wp-config.php,
 * wp-content and Relay's work folders never belong to it. Pull and push never use it (Groups::roots() has no root).
 */
final class RootFiles
{
    /** WordPress itself, and its own wp-content folder (also where wp-content lives elsewhere): never backed up, never written by a restore. */
    public const CORE = ['wp-admin', 'wp-includes', 'wp-content', 'index.php', 'wp-*.php', 'license.txt', 'readme.html', 'xmlrpc.php'];
    /** Rules a server reads, which can be specific to one host: a restore replaces them only when asked. */
    public const SERVER_SETTINGS = ['.htaccess', '.user.ini', 'php.ini', 'web.config'];
    /** The host's PHP error log and CGI folder: left out of backups, but an archive holding them is still accepted. */
    public const LEFT_OUT = ['error_log', 'cgi-bin'];

    public static function dir(): string
    {
        /** Lets tests (and unusual hosts) point the root at another folder. */
        return rtrim(wp_normalize_path((string) apply_filters('relay_root_dir', ABSPATH)), '/');
    }

    /**
     * Top-level root names that are never the root's own: WordPress' files, and the folders that hold wp-content,
     * another group or Relay's work folders (when they live inside the root).
     *
     * @return string[]
     */
    public static function never(array $roots): array
    {
        $names = self::CORE;
        $root = self::dir();
        foreach (array_merge(array_values($roots), [rtrim(wp_normalize_path(Paths::work_dir()), '/')]) as $path) {
            $path = rtrim(wp_normalize_path((string) $path), '/');
            if (strpos($path . '/', $root . '/') === 0 && $path !== $root) {
                $names[] = explode('/', substr($path, strlen($root) + 1))[0];
            }
        }
        return array_values(array_unique($names));
    }

    /** @param string[] $skip top-level items left out by choice */
    public static function excludes(array $roots, array $skip = []): Excludes
    {
        $names = array_merge(self::never($roots), self::LEFT_OUT, $skip);
        $patterns = array_values(array_filter($names, static fn ($n) => strpbrk($n, '*?') !== false));
        return new Excludes(true, array_values(array_diff($names, $patterns)), [], 'root/', $patterns);
    }

    public static function is_wordpress(string $dir): bool
    {
        return is_file($dir . '/wp-config.php') || is_file($dir . '/wp-load.php') || is_dir($dir . '/wp-includes');
    }

    public static function is_server_setting(string $name): bool
    {
        return in_array(strtolower($name), self::SERVER_SETTINGS, true);
    }

    /**
     * The root's own top-level items, sorted by name, with their sizes. Sizes are summed until $seconds run out;
     * an item not fully measured by then says "more". Another WordPress site is flagged and not measured.
     *
     * @return array<int, array{name: string, dir: bool, bytes: int, more: bool, wordpress: bool}>
     */
    public static function items(array $roots, float $seconds = 2.0): array
    {
        $root = self::dir();
        $excludes = self::excludes($roots);
        $deadline = microtime(true) + $seconds;
        $items = [];
        foreach (Inventory::top_level($root, $excludes) as $name) {
            $path = $root . '/' . $name;
            $dir = is_dir($path);
            $wordpress = $dir && self::is_wordpress($path);
            [$bytes, $more] = $wordpress ? [0, false] : self::size($path, $name, $excludes, $deadline);
            $items[] = ['name' => $name, 'dir' => $dir, 'bytes' => $bytes, 'more' => $more, 'wordpress' => $wordpress];
        }
        return $items;
    }

    /** @return string[] the items left out unless chosen: other WordPress sites */
    public static function default_skip(array $items): array
    {
        return array_column(array_filter($items, static fn ($i) => !empty($i['wordpress'])), 'name');
    }

    /** @return array{0: int, 1: bool} bytes, and whether time ran out before everything was counted */
    private static function size(string $path, string $name, Excludes $excludes, float $deadline): array
    {
        if (microtime(true) >= $deadline) {
            return [0, true];
        }
        if (!is_dir($path)) {
            return [is_file($path) ? (int) filesize($path) : 0, false];
        }
        $bytes = 0;
        $it = new \RecursiveIteratorIterator(new \RecursiveCallbackFilterIterator(
            new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS),
            static fn (\SplFileInfo $f) => !$f->isLink() && !$excludes->excluded($name . '/' . substr(wp_normalize_path($f->getPathname()), strlen($path) + 1))
        ));
        try {
            foreach ($it as $file) {
                if (microtime(true) >= $deadline) {
                    return [$bytes, true];
                }
                $bytes += $file->isFile() ? (int) $file->getSize() : 0;
            }
        } catch (\UnexpectedValueException $e) {
            return [$bytes, true]; // an unreadable folder: what was counted so far
        }
        return [$bytes, false];
    }
}