<?php
namespace Relay\Files;

/**
 * Paths left out of backups and migrations. Built-in rules match per path segment, case-insensitively, with
 * shell-style wildcards. User rules (spec §5.1) match the same way when they have no "/", and otherwise the
 * whole path as seen from wp-content (e.g. "uploads/2019/*"); a rule starting with "!" brings back what the
 * other rules leave out. Top-level names (Relay's own folders) are always left out.
 */
final class Excludes
{
    private const ALWAYS = ['.git', '.svn', '.hg', 'node_modules', '.DS_Store', 'Thumbs.db', '*.log', 'ai1wm-backups', 'updraft', 'backups-dup-*', 'backwpup-*', 'wpvividbackups'];
    /**
     * Plugins' working data in uploads and wp-content, which a copy of the site doesn't need: caches, logs, backups,
     * WordPress' update scratch folders, and data a plugin downloads again (Independent Analytics' location
     * database). In plugins/themes these names are often code (WP Rocket's inc/Engine/Cache, a plugin's logs/ view),
     * so they apply to uploads and other wp-content only. A job's "!" rule brings any of it back.
     */
    private const DATA_ONLY = ['cache', '*-cache', 'litespeed', 'logs', '*-logs', 'wflogs', 'wp-staging', 'upgrade', 'upgrade-temp-backup', 'iawp-geo-db.mmdb'];

    /** @var string[] */
    private array $patterns;
    /** @var string[] lower-cased top-level names excluded for this group */
    private array $top;
    /** @var string[] lower-cased top-level patterns excluded for this group, e.g. the root's "wp-*.php" */
    private array $top_patterns;
    /** @var string[] */
    private array $user = [];
    /** @var string[] */
    private array $include = [];
    private string $prefix;

    /**
     * @param string[] $top_level exact top-level names to exclude, e.g. Relay's own plugin folder
     * @param string[] $user user rules; "!rule" re-includes
     * @param string $prefix this group's folder as seen from wp-content, e.g. "uploads/" ("" for other content)
     * @param string[] $top_patterns top-level names to exclude by wildcard (kept apart, so exact names never act as patterns)
     */
    public function __construct(bool $data_group, array $top_level = [], array $user = [], string $prefix = '', array $top_patterns = [])
    {
        $this->patterns = array_map('strtolower', $data_group ? array_merge(self::ALWAYS, self::DATA_ONLY) : self::ALWAYS);
        $this->top = array_map('strtolower', $top_level);
        $this->top_patterns = array_map('strtolower', $top_patterns);
        foreach ($user as $rule) {
            $rule = strtolower(trim((string) $rule, " \t/"));
            if ($rule !== '' && $rule[0] === '!') {
                $rule = ltrim(substr($rule, 1), '/');
                if ($rule !== '') {
                    $this->include[] = $rule;
                }
            } elseif ($rule !== '') {
                $this->user[] = $rule;
            }
        }
        $this->prefix = strtolower($prefix);
    }

    public function excluded(string $rel): bool
    {
        $rel = strtolower($rel);
        $segments = explode('/', $rel);
        if (in_array($segments[0], $this->top, true)) {
            return true;
        }
        foreach ($this->top_patterns as $pattern) {
            if (fnmatch($pattern, $segments[0])) {
                return true;
            }
        }
        $path = $this->prefix . $rel;
        foreach ($this->include as $rule) {
            if (self::matches($rule, $path, $segments)) {
                return false;
            }
        }
        foreach ($segments as $segment) {
            foreach ($this->patterns as $pattern) {
                if (fnmatch($pattern, $segment)) {
                    return true;
                }
            }
        }
        foreach ($this->user as $rule) {
            if (self::matches($rule, $path, $segments)) {
                return true;
            }
        }
        return false;
    }

    private static function matches(string $rule, string $path, array $segments): bool
    {
        if (strpos($rule, '/') !== false) {
            return fnmatch($rule, $path) || fnmatch($rule . '/*', $path);
        }
        foreach ($segments as $segment) {
            if (fnmatch($rule, $segment)) {
                return true;
            }
        }
        return false;
    }
}