<?php
namespace Relay\Backups;

use Relay\Archive\Manifest;
use Relay\Files\Excludes;
use Relay\Files\Groups;
use Relay\Files\RootFiles;
use Relay\Multisite\Scope;
use Relay\Multisite\SubsiteFiles;
use Relay\Support\RelayError;

/**
 * The parts a backup holds (Manifest::PARTS), checked from the request and turned into the folders a backup job
 * scans. A job made without the setting holds what every backup held before 1.0: the database and wp-content.
 */
final class BackupParts
{
    public const LEGACY = ['database', 'themes', 'plugins', 'mu-plugins', 'uploads', 'other'];

    /** @return string[] every part except the root on a network (the root belongs to the whole network) */
    public static function offered(): array
    {
        return is_multisite() ? array_values(array_diff(Manifest::PARTS, ['root'])) : Manifest::PARTS;
    }

    /**
     * @param mixed $input null for every part offered
     * @return string[] in Manifest::PARTS order
     */
    public static function normalize($input): array
    {
        if ($input === null) {
            return self::offered();
        }
        $offered = self::offered();
        $chosen = is_array($input) ? array_values(array_unique(array_map('strval', $input))) : [];
        if ($chosen === [] || array_diff($chosen, $offered) !== []) {
            throw new RelayError(
                'backup.parts_invalid',
                /* translators: %s: the parts a backup can hold, e.g. "database, themes, plugins" */
                esc_html(sprintf(__('Choose at least one part to back up, from: %s.', 'siterelay'), implode(', ', $offered)))
            );
        }
        return array_values(array_intersect($offered, $chosen));
    }

    /**
     * @param mixed $input top-level root items to leave out
     * @return string[]
     */
    public static function skip_root($input): array
    {
        $names = [];
        foreach (is_array($input) ? $input : [] as $name) {
            $name = (string) $name;
            if ($name === '' || $name === '.' || $name === '..' || strlen($name) > 255 || strpbrk($name, "/\\\0") !== false) {
                throw new RelayError('backup.parts_invalid', esc_html__('Files in the site’s root are left out by name: a file or folder directly in it.', 'siterelay'));
            }
            $names[] = $name;
        }
        return array_values(array_unique($names));
    }

    /** @return string[] the parts a backup job holds */
    public static function contents(array $settings): array
    {
        return is_array($settings['contents'] ?? null) ? array_values($settings['contents']) : self::LEGACY;
    }

    /** @return array<string, string> the chosen file parts => their folders (the root's only off a network) */
    public static function roots(array $settings): array
    {
        $parts = self::contents($settings);
        $roots = array_intersect_key(Groups::roots(Scope::for_settings($settings)), array_flip($parts));
        if (in_array('root', $parts, true) && !is_multisite()) {
            $roots['root'] = RootFiles::dir();
        }
        return $roots;
    }

    /**
     * What each chosen part leaves out. Built from every group's folder, so "other" never takes in a folder that
     * belongs to a group that wasn't chosen.
     *
     * @return array<string, Excludes>
     */
    public static function excludes(array $settings, array $roots): array
    {
        $scope = Scope::for_settings($settings);
        $all = Groups::roots($scope);
        $out = array_intersect_key(Groups::excludes($all, [], SubsiteFiles::unchosen($scope, $all)), $roots);
        if (isset($roots['root'])) {
            $out['root'] = RootFiles::excludes($all, (array) ($settings['skip_root'] ?? []));
        }
        return $out;
    }
}