// Backup with restic. System > Configuration > Backup (admins): status, actions, settings, jobs and snapshots.
// E-Mail > Restore (admins, domain admins): snapshot, a tree of its domains and mailboxes (also deleted ones), the
// restore modal, the restores. Both pages share the job details modal. Texts from lang.backup. Loaded via $js_minifier.
var mailcowBackup = (function($) {
  'use strict';

  var POLL_MS = 5000;
  var COMPONENTS = ['mails', 'imap_acl', 'aliases', 'groups', 'sender_acl', 'mail_policies', 'retention_rules', 'filters',
    'sieve_activate', 'spam', 'bcc', 'syncjobs', 'app_passwords', 'tfa', 'sogo', 'settings', 'password'];
  // unchecked for existing targets, preselected when everything to restore was deleted
  var RISKY = ['tfa', 'app_passwords', 'retention_rules', 'sieve_activate'];
  // overwrite current values; for deleted targets SOGo is a normal item and settings/password are not sent
  var OVERWRITE = ['sogo', 'settings', 'password'];
  // existing targets: only the mails by default
  var EXISTING_DEFAULT = ['mails'];
  // items that need the mails, not in snapshots without them (RESTIC_BACKUP_MODE=config, as JobService::MAIL_COMPONENTS)
  var MAIL_COMPONENTS = ['mails', 'imap_acl', 'sogo', 'sieve_activate'];
  var BACKUP_MODES = ['all', 'data', 'config'];
  // domain admin ACL an item needs (as JobService::COMPONENT_ACL)
  var COMPONENT_ACL = {groups: 'mailbox_groups', mail_policies: 'mail_policies', retention_rules: 'retention', filters: 'filters',
    sieve_activate: 'filters', spam: 'spam_policy', bcc: 'bcc_maps', syncjobs: 'syncjobs', app_passwords: 'app_passwds'};
  // the restore of the dovecot container (mails, IMAP ACLs, Sieve) cannot be cancelled while it runs
  var DOVECOT_STEPS = ['mails', 'mails_running'];
  var SECRETS = ['password', 's3_secret_key', 'rest_password'];
  // value of a password field while its secret is stored: shown as dots, never sent
  var SECRET_MASK = '************';
  var JOB_TYPES = ['backup', 'check', 'prune', 'init'];
  var STATE_CLASS = {queued: 'bg-secondary', running: 'bg-info text-black', done: 'bg-success', failed: 'bg-danger', cancelled: 'bg-warning text-black'};
  var RESULT_COUNTS = ['added', 'skipped', 'errors'];
  // a scheduled backup is overdue this long after the longest gap of the schedule (26 hours for one backup a day)
  var STALE_MARGIN = 2 * 3600;
  // entries of the schedule (as SettingsService::MAX_SCHEDULE)
  var MAX_SCHEDULE = 24;
  // weekdays in the order of the form, 0 = Sunday
  var WEEKDAYS = [1, 2, 3, 4, 5, 6, 0];
  // errors of a job that could not open the repository
  var REPO_ERROR = /unable to open|wrong (repository )?password|does not exist|host key|connection refused|no such host|could not resolve|timed? ?out|permission denied|repository/i;

  // lang.backup of the page, '' if missing
  function L(key) {
    var src = (typeof lang !== 'undefined' && lang && lang.backup) ? lang.backup : {};
    return (src[key] !== undefined && src[key] !== null) ? src[key] : '';
  }
  function esc(s) {
    return escapeHtml(s === null || s === undefined ? '' : String(s));
  }
  // replaces %s (and %1$s) one after the other, like vsprintf in the PHP alert box
  function fill(text) {
    var args = Array.prototype.slice.call(arguments, 1), next = 0;
    return String(text).replace(/%(?:(\d+)\$)?s/g, function(match, pos) {
      var value = pos ? args[pos - 1] : args[next++];
      return (value === undefined || value === null) ? '' : String(value);
    });
  }
  function pad(n) {
    return (n < 10 ? '0' : '') + n;
  }
  function now() {
    return Math.floor(Date.now() / 1000);
  }
  function pageLang() {
    return document.documentElement.lang || undefined;
  }
  // the time zone of mailcow (TZ in mailcow.conf), so times match the schedule and the "Restored <time>" folders
  function timeZone() {
    return (typeof backup_timezone !== 'undefined' && backup_timezone) ? backup_timezone : undefined;
  }
  function formatWith(ts, options) {
    options = $.extend({hourCycle: 'h23'}, options);
    try {
      return new Intl.DateTimeFormat(pageLang(), $.extend({timeZone: timeZone()}, options)).format(new Date(ts * 1000));
    } catch (e) {
      return new Date(ts * 1000).toLocaleString(undefined, options);
    }
  }
  // date and time in the language of the page, like mailcow's DATETIME_FORMAT without seconds
  function formatTime(ts) {
    return ts ? formatWith(ts, {year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'}) : '';
  }
  // a period: the end without the date when it is the same day
  function formatPeriod(from, to) {
    var day = {year: 'numeric', month: '2-digit', day: '2-digit'};
    if (!to) return formatTime(from);
    return formatTime(from) + ' – ' + (formatWith(from, day) === formatWith(to, day) ? formatWith(to, {hour: '2-digit', minute: '2-digit'}) : formatTime(to));
  }
  // without the year: status line
  function formatShort(ts) {
    return ts ? formatWith(ts, {month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'}) : '';
  }
  // "vor 9 Std." / "9 hr. ago"
  function relative(ts) {
    var diff = ts - now(), abs = Math.abs(diff), unit = 'second', value = diff;
    if (abs >= 86400) { unit = 'day'; value = Math.round(diff / 86400); }
    else if (abs >= 3600) { unit = 'hour'; value = Math.round(diff / 3600); }
    else if (abs >= 60) { unit = 'minute'; value = Math.round(diff / 60); }
    try {
      return new Intl.RelativeTimeFormat(pageLang(), {numeric: 'auto', style: 'short'}).format(value, unit);
    } catch (e) {
      return abs < 120 ? fill(L('seconds_ago'), abs) : fill(L('minutes_ago'), Math.round(abs / 60));
    }
  }
  // name of the folder the dovecot runner restores into: "Restored YYYY-MM-DD HH:MM", snapshot time in the time zone of mailcow
  function folderName(ts) {
    var d = new Date(ts * 1000), parts = {};
    try {
      new Intl.DateTimeFormat('en-GB', {timeZone: timeZone(), hourCycle: 'h23',
        year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'}).formatToParts(d).forEach(function(part) {
        parts[part.type] = part.value;
      });
      return 'Restored ' + parts.year + '-' + parts.month + '-' + parts.day + ' ' + parts.hour + ':' + parts.minute;
    } catch (e) {
      return 'Restored ' + d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()) + ' ' + pad(d.getHours()) + ':' + pad(d.getMinutes());
    }
  }
  function formatSize(bytes) {
    if (bytes === null || bytes === undefined || bytes === '' || isNaN(bytes)) return '';
    bytes = Number(bytes);
    if (Math.abs(bytes) < 1024) return bytes + ' B';
    var units = ['KiB', 'MiB', 'GiB', 'TiB', 'PiB'], i = -1;
    do {
      bytes /= 1024;
      i++;
    } while (Math.abs(bytes) >= 1024 && i < units.length - 1);
    try {
      return bytes.toLocaleString(pageLang(), {minimumFractionDigits: 1, maximumFractionDigits: 1}) + ' ' + units[i];
    } catch (e) {
      return bytes.toFixed(1) + ' ' + units[i];
    }
  }
  function formatDuration(seconds) {
    if (seconds === null || seconds === undefined || seconds < 0) return '';
    seconds = Math.round(seconds);
    var h = Math.floor(seconds / 3600), m = Math.floor(seconds % 3600 / 60), s = seconds % 60;
    return (h ? h + ' h ' : '') + (h || m ? m + ' min ' : '') + (h ? '' : s + ' s');
  }
  function firstLine(text, max) {
    text = String(text || '').split('\n')[0];
    return text.length > max ? text.substr(0, max) + '…' : text;
  }
  function urlHost(url) {
    try {
      return new URL(url).host;
    } catch (e) {
      return url || '';
    }
  }

  function typeLabel(type) {
    return L('type_' + type) || type;
  }
  function componentLabel(component) {
    return L('component_' + component) || component;
  }
  function isActive(job) {
    return job.state === 'queued' || job.state === 'running';
  }
  function isCancellable(job) {
    // domain admins cancel only restores domain admins requested (JobService::cancel)
    if (typeof role !== 'undefined' && role === 'domainadmin' && (job.params || {}).requested_role !== 'domainadmin') return false;
    return job.state === 'queued' || (job.state === 'running' && !(job.type === 'restore' && DOVECOT_STEPS.indexOf(job.step) !== -1));
  }
  function stepText(job) {
    return job.step ? (L('step_' + job.step) || job.step) : '';
  }
  function stateBadge(job) {
    var html = '<span class="badge ' + (STATE_CLASS[job.state] || 'bg-secondary') + '">' + esc(L('state_' + job.state) || job.state) + '</span>';
    if (job.state === 'running' && job.step) html += ' <span class="small text-muted">' + esc(stepText(job)) + '</span>';
    return html;
  }
  // domain admins see "Administrator" for restores an admin requested
  function requestedBy(job) {
    if (job.requested_by === 'schedule') return L('requested_schedule');
    if (typeof role !== 'undefined' && role === 'domainadmin' && (job.params || {}).requested_role === 'admin') return L('requested_admin');
    return job.requested_by;
  }
  function jobDuration(job) {
    return job.started ? formatDuration((job.finished || now()) - job.started) : '';
  }
  // label of a setting in messages: the field name of the form
  function settingLabel(name) {
    if (/^keep_/.test(name)) return L('keep') + ': ' + L(name);
    return L(name) || name;
  }

  // json_api.php answers with all messages of the session since the last page load: only the new ones are shown
  var seenMessages = 0;
  function messageText(message) {
    var msg = $.isArray(message.msg) ? message.msg.slice() : [message.msg];
    var key = msg.shift();
    var texts = (message.type === 'success') ? lang_success : lang_danger;
    var text = (texts && texts[key] !== undefined) ? texts[key] : String(key);
    // singular and plural of the number of mailboxes
    if (key === 'backup_restore_added' && L('restore_added_one')) text = (msg[1] == 1) ? L('restore_added_one') : L('restore_added_many');
    msg = $.map(msg, function(param) {
      if (key === 'backup_job_added' || key === 'backup_job_active') return L('type_' + param) || param;
      if (key === 'backup_component_denied' || key === 'backup_components_invalid' || key === 'backup_component_requires') return param ? componentLabel(param) : param;
      if (key === 'backup_setting_invalid') return settingLabel(param);
      return param;
    });
    return fill.apply(null, [text].concat(msg));
  }
  function showMessages(res) {
    var list = $.isArray(res) ? res : (res ? [res] : []);
    var fresh = (list.length > seenMessages) ? list.slice(seenMessages) : list;
    seenMessages = list.length;
    var ok = fresh.length > 0;
    $.each(fresh, function(i, message) {
      if (!message || typeof message !== 'object') return;
      var type = (message.type === 'success' || message.type === 'warning') ? message.type : 'danger';
      if (type !== 'success') ok = false;
      mailcow_alert_box(esc(messageText(message)), type);
    });
    return {ok: ok, messages: fresh};
  }
  // POST with a JSON body (the shape json_api.php expects for add, edit and delete); done(ok, messages)
  function post(path, body, done, $button) {
    if ($button) $button.prop('disabled', true);
    $.ajax({
      type: 'POST',
      url: '/api/v1/' + path,
      contentType: 'application/json',
      dataType: 'json',
      data: JSON.stringify(body),
      success: function(res) {
        var result = showMessages(res);
        if (done) done(result.ok, result.messages);
      },
      error: function() {
        mailcow_alert_box(esc(L('load_error')), 'danger');
        if (done) done(false, []);
      },
      complete: function() {
        if ($button) $button.prop('disabled', false);
      }
    });
  }
  function getJson(path, done) {
    return $.ajax({type: 'GET', url: '/api/v1/get/' + path, dataType: 'json', cache: false, success: done});
  }
  // a failed list load is reported once per list (the lists reload while jobs run)
  var reported = {};
  function tableError(id) {
    return function(xhr, status) {
      // a reload cancels the request before it
      if (status === 'abort' || (xhr && xhr.readyState === 0)) return;
      if (!reported[id]) mailcow_alert_box(esc(L('load_error')), 'danger');
      reported[id] = true;
    };
  }
  function reloadTable(selector) {
    if ($.fn.DataTable.isDataTable(selector)) $(selector).DataTable().ajax.reload(null, false);
  }
  // calls back each time the element becomes visible (tab or card opened)
  function onVisible(selector, callback) {
    var element = document.querySelector(selector);
    if (element === null || typeof IntersectionObserver === 'undefined') return;
    new IntersectionObserver(function(entries) {
      entries.forEach(function(entry) {
        if (entry.intersectionRatio > 0) callback(element);
      });
    }).observe(element);
  }
  // small lists: table and pages only, 10 rows
  function tableOptions(options, empty) {
    return $.extend({
      responsive: true,
      processing: false,
      serverSide: false,
      stateSave: false,
      pageLength: 10,
      dom: "tr<'d-flex justify-content-end mt-2'p>",
      language: empty ? $.extend({}, lang_datatables, {emptyTable: empty}) : lang_datatables
    }, options);
  }
  // mailcow's empty first column: the responsive control (+) does not cover a value
  function placeholderColumn() {
    return {title: '', data: null, defaultContent: '', orderable: false, searchable: false, responsivePriority: 1};
  }
  function actionColumn() {
    return {title: '', data: 'action', orderable: false, searchable: false, defaultContent: '', className: 'dt-sm-head-hidden dt-data-w100 dtr-col-md dt-text-right', responsivePriority: 2};
  }
  // a DataTable with new data (local data, not ajax)
  function setTable(selector, options, data) {
    if ($.fn.DataTable.isDataTable(selector)) {
      $(selector).DataTable().clear().rows.add(data).draw(false);
    } else {
      $(selector).DataTable($.extend({data: data}, options));
    }
    $(selector).DataTable().columns.adjust().responsive.recalc();
  }
  // DataTables: the formatted value for display, the raw one for sorting
  function renderTime(data, type) {
    return (type === 'display' || type === 'filter') ? esc(formatTime(data)) : data;
  }
  function renderSize(data, type) {
    return (type === 'display' || type === 'filter') ? esc(formatSize(data)) : data;
  }

  // ---- restore jobs: what, where, result ----

  function restoreMailboxes(job) {
    var params = job.params || {};
    return $.isArray(params.mailboxes) ? params.mailboxes : [];
  }
  // what a restore writes into; short: a single mailbox without the word "Mailbox" (list column)
  function restoreTarget(job, short) {
    var params = job.params || {}, mailboxes = restoreMailboxes(job);
    if (params.scope === 'domain') return fill(L('restore_target_domain'), params.domain || job.domain);
    if (!mailboxes.length) return job.domain || '';
    if (mailboxes.length === 1) return short ? mailboxes[0] : fill(L('restore_target_mailbox'), mailboxes[0]);
    return fill(L('restore_target_mailboxes'), mailboxes.length, mailboxes.slice(0, 3).join(', ') + (mailboxes.length > 3 ? ', …' : ''));
  }
  function restoreSnapshot(job) {
    var params = job.params || {}, result = job.result || {}, snapshot = result.snapshot || {};
    var id = String(snapshot.short_id || params.snapshot || '').substr(0, 8);
    var time = params.snapshot_time ? formatTime(params.snapshot_time) : (snapshot.time || '');
    return time ? time + ' · ' + id : id;
  }
  // per mailbox: {component: {added, skipped, errors, ...}, error: "..."}
  function restoreResults(job) {
    var result = job.result || {};
    return (result.mailboxes && typeof result.mailboxes === 'object') ? result.mailboxes : {};
  }
  // results of the domain level: the domain itself (a deleted domain created from the backup) and its aliases
  // (scope domain), each {added, skipped, errors, ...}
  function restoreDomainResults(job) {
    var result = job.result || {};
    return $.grep([['domain', result.domain], ['aliases', result.aliases]], function(part) {
      return part[1] && typeof part[1] === 'object' && !$.isArray(part[1]);
    });
  }
  function restoreTotals(job) {
    var totals = {added: 0, skipped: 0, errors: 0, any: false};
    $.each(restoreDomainResults(job), function(i, part) {
      totals.any = true;
      totals.added += parseInt(part[1].added, 10) || 0;
      totals.skipped += parseInt(part[1].skipped, 10) || 0;
      totals.errors += $.isArray(part[1].errors) ? part[1].errors.length : 0;
    });
    $.each(restoreResults(job), function(user, entry) {
      if (!entry || typeof entry !== 'object') return;
      totals.any = true;
      if (entry.error) totals.errors++;
      $.each(entry, function(key, value) {
        if (!value || typeof value !== 'object' || $.isArray(value)) return;
        totals.added += parseInt(value.added, 10) || 0;
        totals.skipped += parseInt(value.skipped, 10) || 0;
        totals.errors += $.isArray(value.errors) ? value.errors.length : 0;
      });
    });
    return totals;
  }
  function restoreSummary(job) {
    var totals = restoreTotals(job), html = '';
    if (totals.any) html = esc(fill(L('result_summary'), totals.added, totals.skipped));
    else if (!job.error) html = '<span class="text-muted">' + esc(L(isActive(job) ? 'result_none' : 'result_empty')) + '</span>';
    if (totals.errors) html += ' <span class="text-danger">' + esc(fill(L('result_errors'), totals.errors)) + '</span>';
    return html;
  }
  function jobComponents(job) {
    return (job.params && $.isArray(job.params.components)) ? job.params.components : [];
  }
  function componentsText(job) {
    return $.map(jobComponents(job), function(c) { return componentLabel(c); }).join(', ');
  }
  // the items the requester could choose: all for admins, those of his ACL (stored with the job) for domain admins
  function choosable(job) {
    var params = job.params || {}, acl = params.acl;
    return $.grep(COMPONENTS, function(c) {
      return params.requested_role !== 'domainadmin' || !acl || !COMPONENT_ACL[c] || acl[COMPONENT_ACL[c]] == 1;
    });
  }
  // "all items", or one or two labels and "+ n more"
  function componentsShort(job) {
    var components = jobComponents(job);
    if (choosable(job).every(function(c) { return components.indexOf(c) !== -1; })) return L('all_items');
    if (components.length <= 2) return $.map(components, componentLabel).join(', ');
    return componentLabel(components[0]) + ' ' + fill(L('more_items'), components.length - 1);
  }
  // list cell and details: the short form, the full list as tooltip
  function componentsCell(job, cls) {
    if (!jobComponents(job).length) return '';
    return '<span class="' + (cls === undefined ? 'small text-muted' : cls) + '" title="' + esc(componentsText(job)) + '">' + esc(componentsShort(job)) + '</span>';
  }
  function extraValue(value) {
    if ($.isArray(value)) return value.join(', ');
    if (value && typeof value === 'object') {
      return $.map(value, function(v, k) { return k + ': ' + (typeof v === 'object' ? JSON.stringify(v) : v); }).join(', ');
    }
    return String(value);
  }
  function errorList(errors, cls) {
    if (!errors || !errors.length) return '';
    return '<ul class="mb-0 ps-3 small text-break ' + (cls === undefined ? 'text-danger' : cls) + '">' +
      $.map(errors, function(error) { return '<li>' + esc(error) + '</li>'; }).join('') + '</ul>';
  }
  // a further value of an item result, shown after its name: translated, without the empty ones and zeros
  function resultExtra(key, value) {
    // created: the mailbox row counts it as added
    if (key === 'created' || value === null || value === '' || value === 0 || value === '0' || ($.isArray(value) && !value.length)) return null;
    if (key === 'note') return esc(L('result_note_' + value) || String(value));
    return esc((L('result_' + key) || key) + ': ' + extraValue(value));
  }
  // the item results of a mailbox in their order: the creation of a deleted mailbox first, then the items
  function entryParts(entry) {
    var keys = $.grep(['mailbox'].concat(COMPONENTS), function(c) { return entry[c] !== undefined; });
    $.each(entry, function(key) {
      if (key !== 'error' && keys.indexOf(key) === -1) keys.push(key);
    });
    return $.map(keys, function(key) { return [[key, entry[key]]]; });
  }
  function partCounts(parts) {
    var counts = {added: 0, skipped: 0, errors: 0};
    $.each(parts, function(i, part) {
      var value = part[1];
      if (!value || typeof value !== 'object' || $.isArray(value)) return;
      counts.added += parseInt(value.added, 10) || 0;
      counts.skipped += parseInt(value.skipped, 10) || 0;
      counts.errors += $.isArray(value.errors) ? value.errors.length : 0;
    });
    return counts;
  }
  // the items of an entry: a row for each with something to tell, its errors right below it; the others in one line
  function resultBody(parts) {
    var rows = '', unchanged = [];
    $.each(parts, function(i, part) {
      var key = part[0], value = part[1];
      if (!value || typeof value !== 'object' || $.isArray(value)) {
        rows += '<tr><td>' + esc(L('result_' + key) || key) + '</td><td colspan="2" class="text-break">' + esc(extraValue(value)) + '</td></tr>';
        return;
      }
      var errors = $.isArray(value.errors) ? value.errors : [];
      var extras = $.map(value, function(v, k) { return RESULT_COUNTS.indexOf(k) !== -1 ? null : resultExtra(k, v); });
      if (!(parseInt(value.added, 10) || 0) && !(parseInt(value.skipped, 10) || 0) && !errors.length && !extras.length) {
        unchanged.push(componentLabel(key));
        return;
      }
      rows += '<tr><td class="text-break">' + esc(componentLabel(key)) + (extras.length ? '<span class="text-muted"> · ' + extras.join(' · ') + '</span>' : '') + '</td><td class="num">' + esc(value.added === undefined ? '' : value.added) + '</td>' +
        '<td class="num">' + esc(value.skipped === undefined ? '' : value.skipped) + '</td></tr>';
      $.each(errors, function(j, text) {
        rows += '<tr><td colspan="3" class="text-danger text-break ps-3"><i class="bi bi-arrow-return-right me-1"></i>' + esc(text) + '</td></tr>';
      });
    });
    var html = '';
    if (rows) {
      html += '<table class="table table-sm table-borderless mb-0"><thead><tr class="text-muted"><th class="fw-normal">' + esc(L('component')) + '</th>' +
        '<th class="fw-normal num">' + esc(L('added')) + '</th><th class="fw-normal num">' + esc(L('skipped')) + '</th></tr></thead><tbody>' + rows + '</tbody></table>';
    }
    if (unchanged.length) html += '<div class="text-muted mt-1">' + esc(fill(L('result_unchanged'), unchanged.join(', '))) + '</div>';
    return html;
  }
  // one entry to open: state, name and counts in its line; entries with errors come open
  function resultEntry(entry) {
    var counts = partCounts(entry.parts), line, icon;
    if (entry.missing) {
      line = '<span class="text-muted">' + esc(L(entry.missing)) + '</span>';
      icon = 'bi-hourglass-split text-muted';
    } else if (entry.failed) {
      line = '<span class="text-danger text-break">' + esc(entry.error || fill(L('result_errors'), counts.errors)) + '</span>';
      icon = 'bi-exclamation-triangle-fill text-danger';
    } else {
      line = '<span class="text-muted">' + esc(fill(L('result_summary'), counts.added, counts.skipped)) + '</span>';
      icon = 'bi-check-circle-fill text-success';
    }
    return '<details' + (entry.failed ? ' open' : '') + '><summary class="d-flex align-items-center gap-2 px-2 py-1">' +
      '<i class="bi bi-chevron-right small"></i><i class="bi ' + icon + '"></i><span class="fw-semibold text-break">' + esc(entry.title) + '</span>' +
      '<span class="ms-auto small text-end">' + line + '</span></summary>' +
      (entry.missing ? '' : '<div class="small px-2 pb-2 backup-result-body">' + resultBody(entry.parts) + '</div>') + '</details>';
  }
  function restoreResultList(job) {
    if (!restoreTotals(job).any) return '';
    var results = restoreResults(job), users = restoreMailboxes(job).slice(), entries = [], domainParts = restoreDomainResults(job);
    $.each(results, function(user) {
      if (users.indexOf(user) === -1) users.push(user);
    });
    if (domainParts.length) {
      entries.push({title: fill(L('restore_target_domain_short'), (job.params || {}).domain || job.domain), parts: domainParts, error: ''});
    }
    $.each(users, function(i, user) {
      var entry = results[user], known = !!entry && typeof entry === 'object';
      entries.push({title: user, parts: known ? entryParts(entry) : [], error: known ? (entry.error || '') : '',
        missing: known ? '' : (isActive(job) ? 'result_none' : 'result_empty')});
    });
    var failed = 0;
    $.each(entries, function(i, entry) {
      entry.failed = !entry.missing && (!!entry.error || partCounts(entry.parts).errors > 0);
      entry.order = (entry.failed ? 0 : 1) * 100000 + i;
      if (entry.failed && entry.title.indexOf('@') !== -1) failed++;
    });
    // those with errors first
    entries.sort(function(a, b) { return a.order - b.order; });
    var totals = restoreTotals(job);
    var overview = [fill(L('result_mailboxes'), users.length)].concat(failed ? [fill(L('result_failed'), failed)] : [])
      .concat([fill(L('result_summary'), totals.added, totals.skipped)]);
    return '<h5 class="mt-3 fs-6 fw-semibold">' + esc(L('result')) + '</h5>' +
      '<div class="small text-muted mb-2">' + esc(overview.join(' · ')) + '</div>' +
      '<div class="rounded mb-3 backup-result">' + $.map(entries, resultEntry).join('') + '</div>';
  }

  // ---- other jobs ----

  function jobSummary(job) {
    if (job.type === 'restore') return restoreSummary(job);
    var result = job.result || {}, parts = [];
    if (job.type === 'backup' && result.summary) {
      parts.push(fill(L('summary_backup'), String(result.snapshot || '').substr(0, 8), formatSize(result.summary.data_added)));
    }
    if (job.type === 'check' && result.subset) parts.push(fill(L('summary_check'), result.subset));
    if (job.type === 'init' && job.state === 'done') parts.push(result.created ? L('summary_created') : L('connection_ok'));
    if ((job.type === 'prune' || job.type === 'init') && result.snapshots !== undefined) parts.push(fill(L('summary_snapshots'), result.snapshots));
    var html = esc(parts.join(' · '));
    if ($.isArray(result.warnings) && result.warnings.length) {
      html += '<div class="small"><i class="bi bi-exclamation-triangle-fill text-warning"></i> ' + esc(L('warnings') + ': ' + result.warnings.length) + '</div>';
    }
    return html;
  }
  function errorCell(job) {
    return job.error ? '<div class="small text-danger" title="' + esc(job.error) + '">' + esc(firstLine(job.error, 160)) + '</div>' : '';
  }
  function detailsButton(job) {
    return '<a href="#" class="btn btn-xs btn-xs-lg btn-secondary backup-job-details" data-job="' + esc(job.id) + '"><i class="bi bi-card-text"></i> ' + esc(L('details')) + '</a>';
  }
  function cancelButton(job) {
    return '<a href="#" class="btn btn-xs btn-xs-lg btn-danger backup-job-cancel-row" data-job="' + esc(job.id) + '" data-state="' + esc(job.state) + '"><i class="bi bi-x-circle"></i> ' + esc(L('cancel')) + '</a>';
  }
  function jobActions(job) {
    return '<div class="btn-group">' + detailsButton(job) + (isCancellable(job) ? cancelButton(job) : '') + '</div>';
  }

  // ---- job details modal ----

  var jobId = null;
  var jobTimer = null;
  function dlRow(label, html) {
    return '<dt class="col-sm-3">' + esc(label) + '</dt><dd class="col-sm-9 text-break">' + html + '</dd>';
  }
  function jobDetails(job) {
    var params = job.params || {}, html = '<dl class="row mb-3">';
    html += dlRow(L('state'), stateBadge(job) + (job.requested_by ? ' <span class="small text-muted ms-1">' + esc(fill(L('requested_by_short'), requestedBy(job))) + '</span>' : ''));
    html += dlRow(L('time'), esc(job.started ? formatPeriod(job.started, job.finished) + ' (' + jobDuration(job) + ')' : formatTime(job.created)));
    if (job.type === 'restore') {
      html += dlRow(L('snapshot'), esc(restoreSnapshot(job)));
      html += dlRow(L('scope'), esc(restoreTarget(job)));
      html += dlRow(L('components'), componentsCell(job, ''));
      if ($.isArray(params.components) && params.components.indexOf('mails') !== -1) {
        html += dlRow(L('mail_target'), esc(params.mail_target === 'original' ? L('mail_target_original_short')
          : (params.snapshot_time ? fill(L('mail_target_folder_named'), folderName(params.snapshot_time)) : L('mail_target_folder_short'))));
      }
      var created = [];
      if (params.create_domain == 1) created.push(fill(L('restore_target_domain_short'), params.domain || job.domain));
      if ($.isArray(params.create_mailboxes) && params.create_mailboxes.length) created.push(params.create_mailboxes.join(', '));
      if (created.length) html += dlRow(L('created_from_backup'), esc(created.join(', ')));
    } else {
      var summary = jobSummary(job);
      if (summary) html += dlRow(L('result'), summary);
    }
    html += '</dl>';
    if (job.error) {
      html += '<div class="alert alert-danger"><b>' + esc(L('error')) + '</b><pre class="mb-0 mt-1 p-0 small text-wrap text-break text-reset bg-transparent border-0">' + esc(job.error) + '</pre></div>';
    }
    var result = job.result || {};
    if (job.type === 'restore') {
      html += restoreResultList(job);
    } else {
      if ($.isArray(result.warnings) && result.warnings.length) {
        html += '<div class="alert alert-warning"><b>' + esc(L('warnings')) + '</b>' + errorList(result.warnings, '') + '</div>';
      }
      if (job.result) {
        html += '<details class="mb-3"><summary>' + esc(L('result')) + '</summary><pre class="small rounded p-2 mt-2 text-wrap text-break backup-pre">' +
          esc(JSON.stringify(job.result, null, 2)) + '</pre></details>';
      }
    }
    html += '<h5 class="mt-3 fs-6 fw-semibold">' + esc(L('log')) + '</h5>' +
      '<pre class="small rounded p-2 mb-0 backup-pre backup-job-log" style="max-height:24rem;overflow:auto;white-space:pre-wrap;word-break:break-word">' +
      (job.log ? esc(job.log) : '<span class="text-muted">' + esc(L('log_empty')) + '</span>') + '</pre>';
    return html;
  }
  function loadJob() {
    clearTimeout(jobTimer);
    var id = jobId, $modal = $('#backupJobModal');
    if (id === null) return;
    getJson('backup-job/' + encodeURIComponent(id), function(job) {
      if (id !== jobId) return;
      if (!job || !job.id) {
        $modal.find('.backup-job-body').html('<p class="text-danger">' + esc(L('load_error')) + '</p>');
        return;
      }
      var $log = $modal.find('.backup-job-log'), atEnd = !$log.length || ($log[0].scrollHeight - $log.scrollTop() - $log.outerHeight() < 20);
      $modal.find('.modal-title').text(fill(L('job'), job.id) + ' · ' + typeLabel(job.type));
      $modal.find('.backup-job-body').html(jobDetails(job));
      $modal.find('.backup-job-cancel').toggleClass('d-none', !isCancellable(job)).data('state', job.state);
      $modal.find('.backup-job-refresh').toggleClass('d-none', !isActive(job));
      if (atEnd) {
        $log = $modal.find('.backup-job-log');
        $log.scrollTop($log[0].scrollHeight);
      }
      if (isActive(job)) jobTimer = setTimeout(loadJob, POLL_MS);
    }).fail(function() {
      $modal.find('.backup-job-body').html('<p class="text-danger">' + esc(L('load_error')) + '</p>');
    });
  }
  function showJob(id) {
    jobId = parseInt(id, 10);
    var $modal = $('#backupJobModal');
    $modal.find('.modal-title').text(fill(L('job'), jobId));
    $modal.find('.backup-job-body').html('<p class="text-muted">' + esc(lang_footer.loading) + '</p>');
    $modal.find('.backup-job-cancel, .backup-job-refresh').addClass('d-none');
    $modal.modal('show');
    loadJob();
  }
  function cancelJob(id, state, $button) {
    if (state === 'running' && !confirm(L('cancel_running_confirm'))) return;
    post('delete/backup-job', [parseInt(id, 10)], function() {
      refreshAfterChange();
      if (jobId !== null) loadJob();
    }, $button);
  }
  // after a job was queued or cancelled (on the admin page the status reloads the job list)
  function refreshAfterChange() {
    reloadTable('#backup_restores_table');
    if ($('#backup_status').length) loadStatus();
  }

  // ---- System > Configuration > Backup: status ----

  var statusTimer = null;
  var lastActive = null;
  var lastStatus = null;
  var settingsCache = null;
  function alertLine(type, icon, html, buttons) {
    return '<div class="alert alert-' + type + ' py-2 px-3 mb-2 small d-flex flex-wrap align-items-center gap-2">' +
      '<span class="flex-grow-1">' + icon + html + '</span>' + (buttons ? '<span class="btn-group">' + buttons + '</span>' : '') + '</div>';
  }
  // the target in one line: "SFTP backup.example.org"
  function targetText(target) {
    var s = settingsCache || {};
    switch (target) {
      case 's3': return 'S3 ' + [s.s3_bucket, urlHost(s.s3_endpoint)].filter(Boolean).join(' @ ');
      case 'sftp': return 'SFTP ' + (s.sftp_host || '');
      case 'rest': return 'REST ' + urlHost(s.rest_url);
      case 'local': return L('target_local') + (s.local_path ? ': ' + s.local_path : '');
    }
    return '';
  }
  function renderStatus(s) {
    var jobs = s.jobs || {}, active = s.active || [], alerts = '', t = now();
    lastStatus = s;
    // the newest finished job of the repository: when it could not open the repository, nothing is green
    var latest = null;
    $.each(JOB_TYPES, function(i, type) {
      var job = jobs[type];
      if (job && (job.state === 'done' || job.state === 'failed') && (!latest || (job.finished || 0) > (latest.finished || 0))) latest = job;
    });
    var repoFailed = !!(latest && latest.state === 'failed' && REPO_ERROR.test(latest.error || ''));
    var failed = $.grep(JOB_TYPES, function(type) { return jobs[type] && jobs[type].state === 'failed'; });
    var stale = !!(s.enabled && s.last_success && t - s.last_success > (s.schedule_gap || 86400) + STALE_MARGIN);
    var healthy = s.runner_ok && s.configured && s.initialized && s.last_success && !repoFailed && !failed.length && !stale && !(s.secrets_error && s.secrets_error !== '0') &&
      !(s.mode && BACKUP_MODES.indexOf(s.mode) === -1);
    var icon = healthy ? '<i class="bi bi-check-circle-fill text-success"></i> ' : (s.configured ? '<i class="bi bi-exclamation-triangle-fill text-warning"></i> '
      : '<i class="bi bi-dash-circle text-muted"></i> ');
    var line = s.last_success ? fill(L('status_last'), formatShort(s.last_success), relative(s.last_success)) : L('status_never');
    line += ' · ' + (s.next_run ? fill(L('status_next'), formatShort(s.next_run)) : L('status_schedule_off'));
    var facts = [];
    if (s.repo_size !== null && s.repo_size !== undefined) facts.push(formatSize(s.repo_size));
    if (s.snapshots) facts.push(fill(L(s.snapshots == 1 ? 'status_snapshot' : 'status_snapshots'), s.snapshots));
    if (s.configured && s.target) facts.push(targetText(s.target));
    if (s.mode === 'data' || s.mode === 'config') facts.push(L('mode_' + s.mode));
    $('#backup_status .backup-status-summary').html('<div class="fw-semibold">' + icon + esc(line) + '</div>' +
      (facts.length ? '<div class="small text-muted">' + esc(facts.join(' · ')) + '</div>' : ''));

    if (!s.configured) {
      alerts += '<div class="alert alert-info py-2 px-3 mb-2 small"><b>' + esc(L('first_run')) + '</b><ol class="mb-0 ps-3">' +
        $.map([1, 2, 3, 4, 5], function(n) { return '<li>' + esc(L('first_run_' + n)) + '</li>'; }).join('') + '</ol></div>';
    }
    if (!s.runner_ok) {
      alerts += alertLine('danger', '<i class="bi bi-x-circle-fill"></i> ', esc(s.runner_seen ? fill(L('runner_missing'), formatTime(s.runner_seen)) : L('runner_never')));
    }
    var secretsError = !!(s.secrets_error && s.secrets_error !== '0');
    if (secretsError) alerts += alertLine('danger', '<i class="bi bi-key-fill"></i> ', esc(L('secrets_error')));
    if (s.mode && BACKUP_MODES.indexOf(s.mode) === -1) alerts += alertLine('danger', '<i class="bi bi-x-circle-fill"></i> ', esc(fill(L('mode_invalid'), s.mode)));
    if (s.configured && !s.password_confirmed) alerts += alertLine('warning', '<i class="bi bi-exclamation-triangle-fill"></i> ', esc(L('password_unconfirmed')));
    var testing = active.some(function(job) { return job.type === 'init'; });
    if (s.configured && !s.initialized && !testing && !repoFailed) {
      alerts += alertLine('warning', '<i class="bi bi-exclamation-triangle-fill"></i> ', esc(L('repo_not_tested')));
    }
    if (stale) alerts += alertLine('warning', '<i class="bi bi-exclamation-triangle-fill"></i> ', esc(fill(L('status_stale'), relative(s.last_success))));
    $.each(active, function(i, job) {
      var what = job.state === 'running' ? (stepText(job) || L('state_running')) + (job.started ? ', ' + jobDuration(job) : '') : L('state_queued');
      alerts += alertLine('info', (job.state === 'running' ? '<span class="spinner-border spinner-border-sm me-1" role="status"></span>' : '<i class="bi bi-hourglass-split"></i> '),
        esc(fill(L('active_line'), typeLabel(job.type), job.id, what)) + (job.type === 'restore' ? ' <span class="text-muted">' + esc(restoreTarget(job, true)) + '</span>' : ''),
        detailsButton(job) + (isCancellable(job) ? cancelButton(job) : ''));
    });
    $.each(failed, function(i, type) {
      var job = jobs[type];
      alerts += alertLine('danger', '<i class="bi bi-x-circle-fill"></i> ', esc(fill(L('failed_line'), typeLabel(type), job.id)) +
        (job.error ? ': ' + esc(firstLine(job.error, 200)) : ''), detailsButton(job));
    });
    $('#backup_status_alerts').html(alerts);

    // backups and maintenance once the repository is set up and tested; one job of each type at a time
    var ready = !!(s.configured && s.initialized);
    var busy = function(type) { return active.some(function(job) { return job.type === type; }); };
    $('#backup_status .backup-job-request').each(function() {
      var type = $(this).data('type'), off = (type === 'init' ? !s.configured : !ready) || busy(type);
      if ($(this).is('a')) $(this).toggleClass('disabled', off).attr('aria-disabled', off ? 'true' : null);
      else $(this).prop('disabled', off);
    });
    $('#backup_status .backup-maintenance').prop('disabled', !ready);
  }
  function loadStatus() {
    clearTimeout(statusTimer);
    getJson('backup-status', function(status) {
      status = status || {};
      renderStatus(status);
      var active = (status.active || []).length;
      if (active || (lastActive !== null && active !== lastActive)) loadJobs();
      if (lastActive && !active) {
        loadSnapshotList();
        loadRunnerFields();
      }
      lastActive = active;
      if (active) statusTimer = setTimeout(loadStatus, POLL_MS);
    }).fail(function() {
      $('#backup_status .backup-status-summary').html('<span class="text-danger">' + esc(L('load_error')) + '</span>');
      if (lastActive) statusTimer = setTimeout(loadStatus, POLL_MS);
    });
  }
  function requestJob($button) {
    var type = $button.data('type');
    if ($button.hasClass('disabled') || $button.prop('disabled')) return;
    if (type === 'prune' && !confirm(L('prune_confirm'))) return;
    post('add/backup-job', {type: type}, function() {
      refreshAfterChange();
    }, $button.is('button') ? $button : null);
  }

  // ---- System > Configuration > Backup: settings ----

  function showTarget() {
    var target = $('#backup_target').val();
    $('#backup_settings .backup-target').each(function() {
      $(this).toggleClass('d-none', $(this).data('target') !== target);
    });
  }
  function toggleFts() {
    var $index = $('#backup_settings input[name="include_index"]');
    $('#backup_settings input[name="include_fts"]').prop('disabled', !$index.is(':checked'));
  }
  // values the runner writes: SSH key, host key; stored secrets as dots (a typed value stays)
  function fillRunnerFields(s) {
    var $form = $('#backup_settings');
    settingsCache = $.extend(settingsCache || {}, s);
    $.each(SECRETS, function(i, name) {
      var set = s[name + '_set'] == 1, $input = $form.find('input[name="' + name + '"]');
      $input.attr('placeholder', set ? L('secret_keep') : '').data('stored', set);
      if ($input.data('masked') || $input.val() === '') $input.val(set ? SECRET_MASK : '').data('masked', set);
    });
    showScope(s.state_backup_mode || '');
    $('#backup_sftp_public_key').val(s.sftp_public_key || '');
    $form.find('.backup-key-missing').toggleClass('d-none', !!s.sftp_public_key);
    $form.find('.backup-host-key').toggleClass('d-none', !s.sftp_host_key).find('code').text(s.sftp_host_key || '');
    if (lastStatus) renderStatus(lastStatus);
  }
  // RESTIC_BACKUP_MODE as the runner reported it: what the backups hold and what not
  function showScope(mode) {
    var $scope = $('#backup_settings .backup-scope'), known = BACKUP_MODES.indexOf(mode) !== -1;
    $scope.find('.backup-scope-title').toggleClass('text-danger', !!mode && !known)
      .text(!mode ? L('scope_unknown') : (known ? L('scope_' + mode) : fill(L('mode_invalid'), mode)));
    $scope.find('.backup-scope-var').text(known ? 'RESTIC_BACKUP_MODE=' + mode : '');
    $.each(['in', 'out'], function(i, part) {
      var text = known ? L('scope_' + mode + '_' + part) : '';
      $scope.find('.backup-scope-' + part).toggleClass('d-none', !text).find('span').text(text);
    });
  }
  function fillSettings(s) {
    var $form = $('#backup_settings');
    $form.find('input[name]:not([type="hidden"]), select[name]').each(function() {
      var $el = $(this), name = $el.attr('name'), value = s[name];
      if (SECRETS.indexOf(name) !== -1) {
        $el.val('').attr('type', 'password').data('masked', false);
      } else if ($el.is(':checkbox')) {
        $el.prop('checked', value == 1);
      } else if ($el.is('select')) {
        $el.selectpicker('val', (value === null || value === undefined) ? '' : String(value));
      } else if (name === 'max_unused') {
        $el.val(parseInt(value, 10) || 0);
      } else {
        $el.val((value === null || value === undefined) ? '' : value);
      }
    });
    // the confirmation is for the stored password: typing a new one asks for it again
    $form.find('input[name="password_confirmed"]').data('stored', s.password_confirmed == 1);
    $form.find('.backup-password-confirm').removeClass('text-danger');
    $form.find('.backup-password-change').addClass('d-none');
    $form.find('.inputMissingAttr').removeClass('inputMissingAttr');
    drawSchedule($.isArray(s.schedule) ? s.schedule : []);
    fillRunnerFields(s);
    showTarget();
    toggleFts();
  }
  // schedule: entries of weekdays and a time ("Mo, We – 12:00"), the row above the list adds one
  function scheduleText(entry) {
    var days = (entry.days.length === 7) ? L('schedule_daily') : $.map(WEEKDAYS, function(day) {
      return (entry.days.indexOf(day) !== -1) ? L('weekday_' + day).slice(0, 2) : null;
    }).join(', ');
    return fill(L('schedule_entry'), days, entry.time);
  }
  function scheduleEntries() {
    return $('#backup_settings .backup-schedule-list li').map(function() { return $(this).data('entry'); }).get();
  }
  function drawSchedule(entries) {
    var $form = $('#backup_settings'), $list = $form.find('.backup-schedule-list').empty(), perDay = {};
    $.each(entries, function(i, entry) {
      $('<li class="mb-1"><span></span><button type="button" class="btn btn-link btn-sm p-0 ms-2 align-baseline text-reset backup-schedule-remove" title="' +
        esc(L('schedule_remove')) + '" aria-label="' + esc(L('schedule_remove')) + '"><i class="bi bi-x-lg"></i></button></li>')
        .data('entry', entry).find('span').text(scheduleText(entry)).end().appendTo($list);
      $.each(entry.days, function(j, day) { perDay[day] = (perDay[day] || 0) + 1; });
    });
    $list.toggleClass('d-none', !entries.length);
    $form.find('.backup-schedule-none').toggleClass('d-none', entries.length > 0);
    $form.find('.backup-schedule-add').prop('disabled', entries.length >= MAX_SCHEDULE);
    // hourly snapshots only matter with several backups a day (or when set)
    var several = Object.keys(perDay).some(function(day) { return perDay[day] > 1; });
    $form.find('.backup-keep-hourly').toggleClass('d-none', !several && !(parseInt($('#backup_keep_hourly').val(), 10) > 0));
  }
  // the weekdays and time of the new row as an entry (mark: highlight what is missing); whether one was added
  function addScheduleEntry(mark) {
    var $new = $('#backup_settings .backup-schedule-new'), time = ($new.find('.backup-schedule-time').val() || '').slice(0, 5);
    var days = $new.find('.backup-schedule-days input:checked').map(function() { return parseInt(this.value, 10); }).get()
      .sort(function(a, b) { return a - b; });
    if (mark) {
      $new.find('label.btn').toggleClass('inputMissingAttr', !days.length);
      $new.find('.backup-schedule-time').toggleClass('inputMissingAttr', !time);
    }
    if (!days.length || !time) return false;
    var entries = scheduleEntries(), key = JSON.stringify({days: days, time: time});
    if (!entries.some(function(entry) { return JSON.stringify(entry) === key; })) entries.push({days: days, time: time});
    drawSchedule(entries);
    $new.find('.backup-schedule-days input').prop('checked', false);
    $new.find('.backup-schedule-time').val('');
    return true;
  }
  function loadSettings() {
    getJson('backup-settings', function(s) {
      fillSettings(s || {});
    }).fail(function() {
      mailcow_alert_box(esc(L('load_error')), 'danger');
    });
  }
  function loadRunnerFields() {
    getJson('backup-settings', function(s) {
      fillRunnerFields(s || {});
    });
  }
  // the fields of the chosen target and the general ones; the other targets keep their stored values
  function collectSettings() {
    var target = $('#backup_target').val(), attr = {};
    $('#backup_settings').find('input[name]:not([type="hidden"]), select[name]').each(function() {
      var $el = $(this), name = $el.attr('name'), $section = $el.closest('.backup-target');
      if ($section.length && $section.data('target') !== target) return;
      if ($el.is(':checkbox')) {
        attr[name] = $el.is(':checked') ? '1' : '0';
      } else if (SECRETS.indexOf(name) !== -1) {
        if ($el.val() !== '' && !$el.data('masked')) attr[name] = $el.val();
      } else if (name === 'max_unused') {
        attr[name] = $el.val() + '%';
      } else {
        attr[name] = $el.val();
      }
    });
    var $form = $('#backup_settings');
    attr.schedule = scheduleEntries();
    return attr;
  }
  function saveSettings($button) {
    // weekdays and time filled in but not added yet: they are meant to be part of the schedule
    addScheduleEntry(false);
    var $form = $('#backup_settings'), attr = collectSettings();
    $form.find('.inputMissingAttr').removeClass('inputMissingAttr');
    $form.find('.backup-password-confirm').removeClass('text-danger');
    if ((attr.password || attr.enabled === '1') && attr.password_confirmed !== '1') {
      $form.find('.backup-password-confirm').addClass('text-danger');
      $form.find('input[name="password_confirmed"]').focus();
      mailcow_alert_box(esc(lang_danger.backup_password_not_confirmed || L('password_confirmed')), 'danger');
      return;
    }
    post('edit/backup-settings', {items: ['settings'], attr: attr}, function(ok, messages) {
      $.each(messages, function(i, message) {
        var msg = $.isArray(message.msg) ? message.msg : [message.msg];
        if (msg[0] === 'backup_setting_invalid') {
          var $field = $form.find('[name="' + msg[1] + '"]').add($form.find('[data-setting="' + msg[1] + '"]').find('input[type="time"], label.btn'))
            .addClass('inputMissingAttr');
          // a field of the collapsed section: open it
          if ($field.closest('#backup_advanced').length) $('#backup_advanced').collapse('show');
        }
        if (msg[0] === 'backup_password_too_short') $form.find('[name="password"]').addClass('inputMissingAttr');
        // secrets are encrypted with the key of the backup container: it must have run once
        if (msg[0] === 'backup_secrets_key_missing') $form.find('.backup-secret').filter(function() { return this.value !== '' && !$(this).data('masked'); }).addClass('inputMissingAttr');
        if (msg[0] === 'backup_password_not_confirmed') $form.find('.backup-password-confirm').addClass('text-danger');
      });
      if (ok) {
        loadSettings();
        loadStatus();
      }
    }, $button);
  }
  function generatePassword() {
    var chars = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789', bytes = new Uint32Array(32), password = '';
    window.crypto.getRandomValues(bytes);
    for (var i = 0; i < bytes.length; i++) password += chars.charAt(bytes[i] % chars.length);
    return password;
  }
  function copyField(selector) {
    var $field = $(selector), value = $field.val();
    if (!value) return;
    var done = function() {
      mailcow_alert_box(esc((typeof lang !== 'undefined' && lang.copy_to_clipboard) || L('copy')), 'success');
    };
    if (navigator.clipboard && window.isSecureContext) {
      navigator.clipboard.writeText(value).then(done);
    } else {
      $field.trigger('select');
      if (document.execCommand('copy')) done();
    }
  }

  // ---- System > Configuration > Backup: jobs and snapshots (sections hidden while empty) ----

  function loadJobs() {
    getJson('backup-jobs/200', function(json) {
      // restores are listed on E-Mail > Restore
      var jobs = $.grep($.isArray(json) ? json : [], function(job) { return job.type !== 'restore'; });
      var $section = $('#tab-config-backup .backup-jobs-section').toggleClass('d-none', !jobs.length);
      if (!jobs.length) return;
      $.each(jobs, function(i, job) {
        job.type_display = esc(typeLabel(job.type)) + (job.requested_by && job.requested_by !== 'schedule'
          ? '<div class="small text-muted">' + esc(fill(L('manual_by'), job.requested_by)) + '</div>' : '');
        job.state_display = stateBadge(job);
        job.time = job.started || job.created;
        job.duration_display = esc(jobDuration(job));
        job.result_display = jobSummary(job) + errorCell(job);
        job.action = jobActions(job);
      });
      if ($section.is(':visible')) setTable('#backup_jobs_table', tableOptions({
        order: [[3, 'desc']],
        columns: [
          placeholderColumn(),
          {title: L('type'), data: 'type_display', defaultContent: '', responsivePriority: 2},
          {title: L('state'), data: 'state_display', defaultContent: '', responsivePriority: 1},
          {title: L('time'), data: 'time', defaultContent: '', render: renderTime, responsivePriority: 3},
          {title: L('duration'), data: 'duration_display', defaultContent: '', responsivePriority: 5},
          {title: L('result'), data: 'result_display', defaultContent: '', responsivePriority: 4},
          actionColumn()
        ]
      }, L('jobs_none')), jobs);
    }).fail(tableError('backup_jobs_table'));
  }
  function loadSnapshotList() {
    getJson('backup-snapshots', function(list) {
      list = $.isArray(list) ? list : [];
      $('#tab-config-backup .backup-snapshots-section').toggleClass('d-none', !list.length);
      $('#tab-config-backup .backup-snapshot-count').text(list.length);
      if (!list.length) return;
      var host = (typeof backup_hostname !== 'undefined') ? backup_hostname : '';
      var other = list.some(function(snapshot) { return snapshot.hostname && host && snapshot.hostname !== host; });
      $.each(list, function(i, snapshot) {
        var summary = snapshot.summary || {}, domains = $.isArray(snapshot.domains) ? snapshot.domains : null;
        snapshot.id_display = '<code title="' + esc(snapshot.id) + '">' + esc(snapshot.short_id || String(snapshot.id).substr(0, 8)) + '</code>' +
          (modeText(snapshot) ? ' <span class="small text-muted">' + esc(modeText(snapshot)) + '</span>' : '');
        snapshot.domains_display = domains ? '<span title="' + esc(domains.join(', ')) + '">' + esc(domains.length) + '</span>' : '–';
        snapshot.host_display = esc(snapshot.hostname || '');
        snapshot.size = summary.total_bytes_processed;
        snapshot.added = summary.data_added;
      });
      var options = tableOptions({
        order: [[1, 'desc']],
        columns: [
          placeholderColumn(),
          {title: L('time'), data: 'time', defaultContent: '', render: renderTime, responsivePriority: 1},
          {title: L('id'), data: 'id_display', defaultContent: '', responsivePriority: 2},
          {title: L('domains'), data: 'domains_display', defaultContent: '', responsivePriority: 3},
          {title: L('size'), data: 'size', defaultContent: '', render: renderSize, responsivePriority: 4},
          {title: L('data_added'), data: 'added', defaultContent: '', render: renderSize, responsivePriority: 4},
          {title: L('hostname'), data: 'host_display', defaultContent: '', visible: other, responsivePriority: 5}
        ]
      }, L('snapshots_none'));
      if ($.fn.DataTable.isDataTable('#backup_snapshots_table')) $('#backup_snapshots_table').DataTable().column(6).visible(other);
      setTable('#backup_snapshots_table', options, list);
    }).fail(tableError('backup_snapshots_table'));
  }

  // ---- E-Mail > Restore: the restores ----

  var restoresTimer = null;
  // while restores are queued or running: reload the list when it is visible
  function pollRestores() {
    if ($('#backup_restores_table').is(':visible')) reloadTable('#backup_restores_table');
    else restoresTimer = setTimeout(pollRestores, POLL_MS);
  }
  function drawRestores() {
    if ($.fn.DataTable.isDataTable('#backup_restores_table')) {
      $('#backup_restores_table').DataTable().columns.adjust().responsive.recalc();
      return;
    }
    $('#backup_restores_table').DataTable(tableOptions({
      order: [[1, 'desc']],
      ajax: {
        type: 'GET',
        url: '/api/v1/get/backup-jobs/500/restore',
        dataSrc: function(json) {
          if (!$.isArray(json)) return [];
          var jobs = $.grep(json, function(job) { return job.type === 'restore'; });
          $.each(jobs, function(i, job) {
            job.state_display = stateBadge(job);
            job.target_display = esc(restoreTarget(job, true)) + '<div>' + componentsCell(job) + '</div>';
            job.snapshot_display = esc(restoreSnapshot(job));
            job.requested_display = esc(requestedBy(job));
            job.result_display = restoreSummary(job) + errorCell(job);
            job.action = jobActions(job);
          });
          updateActiveRestores(jobs);
          clearTimeout(restoresTimer);
          if (jobs.some(isActive)) restoresTimer = setTimeout(pollRestores, POLL_MS);
          return jobs;
        },
        error: tableError('backup_restores_table')
      },
      columns: [
        placeholderColumn(),
        {title: L('id'), data: 'id', defaultContent: '', responsivePriority: 3},
        {title: L('state'), data: 'state_display', defaultContent: '', responsivePriority: 1},
        {title: L('mailboxes'), data: 'target_display', defaultContent: '', responsivePriority: 2},
        {title: L('snapshot'), data: 'snapshot_display', defaultContent: '', responsivePriority: 5},
        {title: L('result'), data: 'result_display', defaultContent: '', responsivePriority: 4},
        {title: L('requested_by'), data: 'requested_display', defaultContent: '', responsivePriority: 6},
        {title: L('created'), data: 'created', defaultContent: '', render: renderTime, responsivePriority: 5},
        actionColumn()
      ]
    }, L('restores_none')));
  }

  // ---- E-Mail > Restore: snapshot, tree of its domains and mailboxes, selection, restore modal ----

  // rows rendered per step ("show more"), so the page stays small for big snapshots
  var CHUNK = 200;
  var SUMMARY_MAX = 10;
  var SEARCH_MIN = 2;
  // snapshot: chosen id; snapshots: id => snapshot; available: the snapshot has a content list; domains: its domains
  // (rows of get/backup-snapshot-content); nodes: domain => {info, index, expanded, loading, failed, mailboxes (null until
  // loaded), known: username => mailbox, shown}; shownDomains: domain rows rendered; term/search: the server search and
  // its result; onlyDeleted: filter; selection: {domain, scope: domain|mailbox, mailboxes: {username: true}} or null;
  // replaced: the domain whose selection was replaced; active: restores queued or running (domain => {all, users});
  // target: what the modal restores; deletedOnly: everything in the modal target was deleted
  var tree = {snapshot: null, snapshots: {}, available: 1, domains: [], nodes: {}, shownDomains: CHUNK, term: '', search: null, onlyDeleted: false,
    selection: null, replaced: null, notice: null, active: {}, activeIds: [], activeKey: '', target: null, deletedOnly: false, seq: 0, loaded: false};
  var searchTimer = null;
  var searchRequest = null;

  function isAdmin() {
    return typeof role !== 'undefined' && role === 'admin';
  }
  function pageHint(type, html) {
    $('#backup_restore_page .backup-restore-hints').html(html ? '<div class="alert alert-' + type + '">' + html + '</div>' : '');
  }
  function settingsLink(text) {
    return ' <a href="/admin/system#tab-config-backup">' + esc(text) + '</a>';
  }
  function deletedBadge() {
    return '<span class="badge bg-danger">' + esc(L('status_deleted')) + '</span>';
  }
  function restoringBadge() {
    return '<span class="badge bg-info text-black">' + esc(L('status_restoring')) + '</span>';
  }

  function loadSnapshots() {
    if (typeof backup_configured !== 'undefined' && !backup_configured) {
      pageHint('warning', esc(L(isAdmin() ? 'not_configured' : 'not_configured_da')) + (isAdmin() ? settingsLink(L('to_backup_settings')) : ''));
      setSnapshotOptions([]);
      return;
    }
    getJson('backup-snapshots', function(list) {
      list = $.isArray(list) ? list : [];
      list.sort(function(a, b) { return b.time - a.time; });
      setSnapshotOptions(list);
      if (!list.length) {
        pageHint('info', esc(L('no_snapshots_any')) + (isAdmin() ? settingsLink(L('no_snapshots_backup_now')) : ''));
        return;
      }
      selectSnapshot(list[0].id);
    }).fail(function() {
      pageHint('danger', esc(L('load_error')));
    });
  }
  // the options are rebuilt and bootstrap-select is built anew: its refresh repeats the list and shows hidden options
  function setSnapshotOptions(list) {
    var $select = $('#backup_restore_snapshot');
    tree.snapshots = {};
    $select.selectpicker('destroy');
    $select.empty();
    $.each(list, function(i, snapshot) {
      tree.snapshots[snapshot.id] = snapshot;
      $select.append($('<option></option>').val(snapshot.id).text(formatTime(snapshot.time) + ' · ' + relative(snapshot.time))
        .attr('data-subtext', (snapshot.short_id || String(snapshot.id).substr(0, 8)) + (snapshot.mode === 'config' ? ' · ' + modeText(snapshot) : '')));
    });
    $select.prop('disabled', !list.length);
    $select.selectpicker({styleBase: 'btn btn-xs-lg', noneSelectedText: lang_footer.nothing_selected, showSubtext: true});
  }
  // what a snapshot lacks (RESTIC_BACKUP_MODE), '' for complete ones
  function modeText(snapshot) {
    return (snapshot.mode === 'data' || snapshot.mode === 'config') ? L('snapshot_mode_' + snapshot.mode) : '';
  }
  function noMails() {
    var snapshot = tree.snapshots[tree.snapshot];
    return !!(snapshot && snapshot.mode === 'config');
  }
  function snapshotLabel(snapshot) {
    return formatTime(snapshot.time) + ' · ' + (snapshot.short_id || String(snapshot.id).substr(0, 8));
  }

  function treeBody() {
    return $('#backup_tree tbody');
  }
  function treeMessage(text, cls) {
    treeBody().html('<tr class="backup-tree-message"><td colspan="4" class="' + (cls || 'text-muted') + '">' + esc(text) + '</td></tr>');
  }
  // keep: reload after a restore finished (expanded domains stay expanded, the selection stays)
  function selectSnapshot(id, keep) {
    var $panel = $('#backup_restore_page .backup-tree-panel').removeClass('d-none');
    var expanded = keep ? $.grep(Object.keys(tree.nodes), function(name) { return tree.nodes[name].expanded; }) : [];
    tree.snapshot = id;
    if (keep && tree.selection) {
      // states changed (deleted mailboxes may exist now): a kept selection would restore with the old states
      tree.selection = null;
      tree.replaced = null;
      tree.notice = L('selection_reset');
      updateChecks();
    }
    if (!keep) {
      tree.domains = [];
      tree.nodes = {};
      tree.selection = null;
      tree.replaced = null;
      tree.shownDomains = CHUNK;
      tree.search = null;
      tree.term = '';
      $panel.find('.backup-tree-search').val('');
      $panel.find('.backup-content-note').empty();
      treeMessage(lang_footer.loading);
      updateChecks();
    }
    getJson('backup-snapshot-content/' + encodeURIComponent(id), function(content) {
      if (tree.snapshot !== id) return;
      if (!content || !$.isArray(content.domains)) {
        treeMessage(L('load_error'), 'text-danger');
        return;
      }
      tree.available = (content.available === undefined) ? 1 : content.available;
      // domain admins never get deleted domains (the API leaves them out as well)
      tree.domains = $.grep(content.domains, function(d) { return isAdmin() || d.exists == 1; });
      tree.domains.sort(function(a, b) { return String(a.domain).localeCompare(String(b.domain)); });
      tree.nodes = {};
      $.each(tree.domains, function(i, d) {
        tree.nodes[d.domain] = {info: d, index: i, expanded: false, loading: false, failed: false, mailboxes: null, known: {}, shown: CHUNK};
      });
      $panel.find('.backup-content-note').html(tree.available == 1 ? '' : '<div class="alert alert-info">' + esc(L('content_unavailable')) + '</div>');
      tree.loaded = true;
      // one domain (typical for domain admins): open at once
      if (tree.domains.length === 1 && !keep) expanded = [tree.domains[0].domain];
      $.each(expanded, function(i, name) {
        var node = tree.nodes[name];
        if (node) {
          node.expanded = true;
          loadMailboxes(node);
        }
      });
      if (tree.term.length >= SEARCH_MIN) runSearch();
      else renderTree();
    }).fail(function() {
      if (tree.snapshot === id) treeMessage(L('load_error'), 'text-danger');
    });
  }

  // ---- tree rows ----

  function domainVisible(node) {
    return !tree.onlyDeleted || node.info.exists != 1 || node.info.missing > 0;
  }
  function mailboxVisible(m) {
    return !tree.onlyDeleted || m.exists != 1;
  }
  // a deleted domain can only be restored as a whole, and only from a snapshot with a content list
  function domainRestorable(node) {
    return node.info.exists == 1 || tree.available == 1;
  }
  function mailboxesSelectable(node) {
    return node.info.exists == 1;
  }
  function restoringDomain(node) {
    var active = tree.active[node.info.domain];
    return !!(active && active.all);
  }
  function restoringMailbox(node, m) {
    var active = tree.active[node.info.domain];
    return !!(active && (active.all || active.users[m.username]));
  }
  function restoreRowButton(label, disabled) {
    return '<button type="button" class="btn btn-xs btn-xs-lg btn-secondary text-nowrap backup-tree-restore" title="' + esc(fill(L('restore_item'), label)) +
      '" aria-label="' + esc(fill(L('restore_item'), label)) + '"' + (disabled ? ' disabled' : '') + '><i class="bi bi-clock-history"></i><span class="d-none d-sm-inline"> ' + esc(L('restore')) + '</span></button>';
  }
  function domainCount(d) {
    if (d.mailboxes === null || d.mailboxes === undefined) return '';
    return d.missing > 0 ? fill(L('count_deleted'), d.mailboxes, d.missing) : String(d.mailboxes);
  }
  function domainRowHtml(node) {
    var d = node.info, count = domainCount(d), restoring = restoringDomain(node), id = 'backup_tree_c' + (++tree.seq);
    var badges = (d.exists != 1 ? deletedBadge() : '') + (restoring ? ' ' + restoringBadge() : '');
    return '<tr class="backup-tree-domain" data-index="' + node.index + '" style="cursor:pointer">' +
      '<td><div class="d-flex align-items-center gap-1">' +
      '<button type="button" class="btn btn-link p-0 text-reset d-inline-flex align-items-center justify-content-center flex-shrink-0 backup-tree-toggle" style="width:2rem;height:2rem;min-width:32px;min-height:32px" aria-expanded="' +
      (node.expanded ? 'true' : 'false') + '" aria-label="' + esc(fill(L(node.expanded ? 'collapse' : 'expand'), d.domain)) + '"><i class="bi bi-chevron-' + (node.expanded ? 'down' : 'right') + '"></i></button>' +
      '<input type="checkbox" class="form-check-input mt-0 flex-shrink-0 backup-tree-check" id="' + id + '"' + (domainRestorable(node) && !restoring ? '' : ' disabled') + '>' +
      '<label class="text-break mb-0 ms-1 fw-semibold" for="' + id + '">' + esc(d.domain) + '</label>' +
      (badges ? '<span class="d-md-none ms-1">' + badges + '</span>' : '') + (count ? '<span class="d-sm-none small text-muted ms-1">· ' + esc(count) + '</span>' : '') + '</div></td>' +
      '<td class="d-none d-md-table-cell">' + badges + '</td>' +
      '<td class="d-none d-sm-table-cell text-nowrap">' + esc(count) + '</td>' +
      '<td class="text-end">' + (domainRestorable(node) ? restoreRowButton(d.domain, restoring) : '') + '</td></tr>';
  }
  function childRow(node, html, cls) {
    return '<tr class="backup-tree-child" data-index="' + node.index + '"><td colspan="4" class="small ' + (cls || 'text-muted') + '" style="padding-left:2.75rem">' + html + '</td></tr>';
  }
  function mailboxRowHtml(node, m) {
    var selectable = mailboxesSelectable(node), restoring = restoringMailbox(node, m), id = 'backup_tree_c' + (++tree.seq);
    var badges = (m.exists != 1 ? deletedBadge() : '') + (restoring ? ' ' + restoringBadge() : '');
    node.known[m.username] = m;
    return '<tr class="backup-tree-mailbox" data-index="' + node.index + '" data-user="' + esc(m.username) + '">' +
      '<td style="padding-left:2.75rem"><div class="d-flex align-items-center gap-2">' +
      '<input type="checkbox" class="form-check-input mt-0 flex-shrink-0 backup-tree-check" id="' + id + '"' + (selectable && !restoring ? '' : ' disabled') + '>' +
      '<label class="text-break mb-0" for="' + id + '">' + esc(m.username) + (m.name ? ' <span class="small text-muted">' + esc(m.name) + '</span>' : '') + '</label>' +
      (badges ? '<span class="d-md-none">' + badges + '</span>' : '') + '</div></td>' +
      '<td class="d-none d-md-table-cell">' + badges + '</td>' +
      '<td class="d-none d-sm-table-cell"></td>' +
      '<td class="text-end">' + (selectable ? restoreRowButton(m.username, restoring) : '') + '</td></tr>';
  }
  // the mailboxes a domain shows: the search hits or its loaded mailboxes, with the filter
  function shownMailboxes(node) {
    var list = tree.search ? (node.hits || []) : node.mailboxes;
    return list ? $.grep(list, mailboxVisible) : null;
  }
  function childRowsHtml(node) {
    if (node.loading && !tree.search) return childRow(node, '<span class="spinner-border spinner-border-sm me-1" role="status"></span>' + esc(lang_footer.loading));
    if (node.failed && !tree.search) return childRow(node, esc(L('load_error')), 'text-danger');
    var list = shownMailboxes(node);
    if (list === null) return '';
    var html = mailboxesSelectable(node) ? '' : childRow(node, '<i class="bi bi-info-circle"></i> ' + esc(L('deleted_domain_children')));
    if (!list.length) return html + childRow(node, esc(L(tree.term || tree.onlyDeleted ? 'no_matches' : 'no_mailboxes')));
    $.each(list.slice(0, node.shown), function(i, m) {
      html += mailboxRowHtml(node, m);
    });
    if (list.length > node.shown) {
      html += childRow(node, '<button type="button" class="btn btn-xs btn-xs-lg btn-outline-secondary backup-tree-more">' +
        esc(fill(L('show_more'), Math.min(CHUNK, list.length - node.shown), list.length - node.shown)) + '</button>');
    }
    return html;
  }
  // the domains shown: search hits or all, with the filter
  function shownDomains() {
    if (tree.search) {
      return $.map(tree.search.domains, function(hit) {
        var node = tree.nodes[hit.domain];
        if (!node) return null;
        node.hits = $.isArray(hit.mailboxes) ? hit.mailboxes : [];
        $.each(node.hits, function(i, m) { node.known[m.username] = m; });
        return domainVisible(node) ? node : null;
      });
    }
    return $.grep($.map(tree.domains, function(d) { return tree.nodes[d.domain]; }), domainVisible);
  }
  function renderTree() {
    var nodes = shownDomains(), html = '';
    $.each(nodes.slice(0, tree.shownDomains), function(i, node) {
      // search results show their hits right away
      html += domainRowHtml(node) + ((node.expanded || tree.search) ? childRowsHtml(node) : '');
    });
    if (nodes.length > tree.shownDomains) {
      html += '<tr class="backup-tree-child"><td colspan="4"><button type="button" class="btn btn-xs btn-xs-lg btn-outline-secondary backup-tree-more-domains">' +
        esc(fill(L('show_more_domains'), Math.min(CHUNK, nodes.length - tree.shownDomains), nodes.length - tree.shownDomains)) + '</button></td></tr>';
    }
    if (tree.search && tree.search.truncated) html += '<tr class="backup-tree-child"><td colspan="4" class="small text-muted"><i class="bi bi-info-circle"></i> ' + esc(L('search_truncated')) + '</td></tr>';
    if (!tree.domains.length) treeMessage(L('no_domains'));
    else if (!nodes.length) treeMessage(L('no_matches'));
    else treeBody().html(html);
    updateChecks();
  }
  // the domain row and its mailbox rows anew; the focus stays on the same control of the row
  function renderDomain(node, focusIndex) {
    var $row = treeBody().find('tr.backup-tree-domain[data-index="' + node.index + '"]');
    if (!$row.length) return;
    var $focus = $(document.activeElement), control = null;
    if ($focus.closest('tr').is($row)) {
      control = $focus.hasClass('backup-tree-toggle') ? '.backup-tree-toggle' : ($focus.hasClass('backup-tree-check') ? '.backup-tree-check'
        : ($focus.hasClass('backup-tree-restore') ? '.backup-tree-restore' : null));
    }
    treeBody().find('tr.backup-tree-child[data-index="' + node.index + '"], tr.backup-tree-mailbox[data-index="' + node.index + '"]').remove();
    $row.replaceWith(domainRowHtml(node) + ((node.expanded || tree.search) ? childRowsHtml(node) : ''));
    updateChecks();
    var $new = treeBody().find('tr.backup-tree-domain[data-index="' + node.index + '"]');
    if (control) $new.find(control).trigger('focus');
    // "show more": the first new mailbox
    if (focusIndex !== undefined) treeBody().find('tr.backup-tree-mailbox[data-index="' + node.index + '"]').eq(focusIndex).find('.backup-tree-check').trigger('focus');
  }
  function nodeOf($el) {
    var d = tree.domains[parseInt($el.closest('tr').data('index'), 10)];
    return d ? tree.nodes[d.domain] : null;
  }
  function mailboxOf($el, node) {
    return node ? node.known[$el.closest('tr').attr('data-user')] || null : null;
  }
  function toggleDomain(node) {
    if (tree.search) return;
    node.expanded = !node.expanded;
    if (node.expanded && node.mailboxes === null && !node.loading) loadMailboxes(node);
    renderDomain(node);
  }
  function loadMailboxes(node, done) {
    var id = tree.snapshot;
    node.loading = true;
    node.failed = false;
    getJson('backup-snapshot-content/' + encodeURIComponent(id) + '/' + encodeURIComponent(node.info.domain), function(res) {
      if (tree.snapshot !== id) return;
      node.loading = false;
      node.mailboxes = (res && $.isArray(res.mailboxes)) ? res.mailboxes : [];
      node.mailboxes.sort(function(a, b) { return String(a.username).localeCompare(String(b.username)); });
      $.each(node.mailboxes, function(i, m) { node.known[m.username] = m; });
      if (done) done();
      renderDomain(node);
      updateChecks();
    }).fail(function() {
      if (tree.snapshot !== id) return;
      node.loading = false;
      node.failed = true;
      renderDomain(node);
    });
  }

  // ---- search in the snapshot (server side, also in collapsed domains) ----

  function runSearch() {
    var term = tree.term, id = tree.snapshot;
    if (searchRequest) searchRequest.abort();
    if (term.length < SEARCH_MIN) {
      tree.search = null;
      renderTree();
      return;
    }
    treeMessage(lang_footer.loading);
    // nginx decodes the path and passes it in ?query= of json_api.php as it is: "&", "+" and "%" are encoded twice
    searchRequest = getJson('backup-snapshot-search/' + encodeURIComponent(id) + '/' + encodeURIComponent(encodeURIComponent(term)), function(res) {
      if (tree.snapshot !== id || tree.term !== term) return;
      tree.search = {domains: (res && $.isArray(res.domains)) ? res.domains : [], truncated: res && res.truncated ? 1 : 0};
      tree.shownDomains = CHUNK;
      renderTree();
    });
    searchRequest.fail(function(xhr, status) {
      if (status !== 'abort' && tree.term === term) treeMessage(L('load_error'), 'text-danger');
    });
  }

  // ---- selection: one domain, either the whole domain or some of its mailboxes ----

  function setSelection(selection, replaced) {
    var old = tree.selection;
    tree.notice = null;
    tree.replaced = (old && selection && old.domain !== selection.domain) ? old.domain : (replaced || null);
    tree.selection = selection;
    updateChecks();
  }
  function selectedMailboxes() {
    var sel = tree.selection;
    return (sel && sel.scope === 'mailbox') ? Object.keys(sel.mailboxes) : [];
  }
  // all mailboxes of the domain ticked one by one
  function allTicked() {
    var sel = tree.selection, node = sel ? tree.nodes[sel.domain] : null;
    if (!node || sel.scope !== 'mailbox' || !node.mailboxes || !node.mailboxes.length) return false;
    return node.mailboxes.every(function(m) { return sel.mailboxes[m.username] || restoringMailbox(node, m); });
  }
  function updateChecks() {
    var sel = tree.selection;
    treeBody().find('tr.backup-tree-domain').each(function() {
      var node = nodeOf($(this)), mine = !!(node && sel && sel.domain === node.info.domain);
      $(this).find('.backup-tree-check').prop('checked', mine && sel.scope === 'domain').prop('indeterminate', mine && sel.scope === 'mailbox');
    });
    treeBody().find('tr.backup-tree-mailbox').each(function() {
      var node = nodeOf($(this)), m = mailboxOf($(this), node), mine = !!(m && sel && sel.domain === node.info.domain);
      $(this).find('.backup-tree-check').prop('checked', mine && (sel.scope === 'domain' || !!sel.mailboxes[m.username]));
    });
    updateToolbar();
  }
  function updateToolbar() {
    var sel = tree.selection, $page = $('#backup_restore_page'), text = L('selection_none'), count = selectedMailboxes().length, hint = '';
    if (sel && sel.scope === 'domain') text = fill(L('selected_domain'), sel.domain);
    else if (sel) text = fill(L(count === 1 ? 'selected_mailbox_in' : 'selected_mailboxes_in'), count, sel.domain);
    $page.find('.backup-selection-text').text(text);
    $page.find('.backup-selection-clear').toggleClass('d-none', !sel);
    $page.find('.backup-selection-restore').prop('disabled', !sel);
    if (tree.replaced) hint = '<i class="bi bi-exclamation-triangle-fill text-warning"></i> ' + esc(fill(L('selection_replaced'), tree.replaced));
    else if (tree.notice) hint = '<i class="bi bi-info-circle"></i> ' + esc(tree.notice);
    else if (allTicked()) hint = '<i class="bi bi-info-circle"></i> ' + esc(L('all_ticked')) +
      ' <button type="button" class="btn btn-link btn-sm p-0 align-baseline backup-select-domain">' + esc(L('select_whole_domain')) + '</button>';
    $page.find('.backup-selection-hint').toggleClass('d-none', !hint).html(hint);
  }
  function checkDomain(node, checked) {
    setSelection(checked ? {domain: node.info.domain, scope: 'domain', mailboxes: {}} : null);
  }
  function checkMailbox(node, m, checked) {
    var sel = tree.selection, domain = node.info.domain, set = {};
    if (sel && sel.domain === domain && sel.scope === 'domain') {
      // unchecking a mailbox of a whole-domain selection keeps the other mailboxes of the domain (all of them loaded first)
      if (node.mailboxes === null) {
        loadMailboxes(node, function() { checkMailbox(node, m, checked); });
        return;
      }
      $.each(node.mailboxes, function(i, other) {
        if (other.username !== m.username && !restoringMailbox(node, other)) set[other.username] = true;
      });
    } else {
      if (sel && sel.domain === domain) set = $.extend({}, sel.mailboxes);
      if (checked) set[m.username] = true;
      else delete set[m.username];
    }
    setSelection(Object.keys(set).length ? {domain: domain, scope: 'mailbox', mailboxes: set} : null);
  }

  // ---- restores in progress: rows marked, reloaded when they are done ----

  function updateActiveRestores(jobs) {
    var active = {}, ids = [];
    $.each(jobs, function(i, job) {
      if (!isActive(job)) return;
      var params = job.params || {}, domain = params.domain || job.domain;
      ids.push(job.id);
      if (!domain) return;
      active[domain] = active[domain] || {all: false, users: {}};
      if (params.scope === 'domain') active[domain].all = true;
      $.each(restoreMailboxes(job), function(j, user) { active[domain].users[user] = true; });
    });
    var finished = tree.activeIds.some(function(id) { return ids.indexOf(id) === -1; }), key = JSON.stringify(active);
    tree.activeIds = ids;
    if (key === tree.activeKey && !finished) return;
    tree.active = active;
    tree.activeKey = key;
    if (!tree.loaded) return;
    // "deleted" turns into "exists" when a restore created the mailbox or domain
    if (finished) selectSnapshot(tree.snapshot, true);
    else if (tree.term.length >= SEARCH_MIN) renderTree();
    else renderTree();
  }

  // ---- restore modal ----

  function domainTarget(node) {
    return {scope: 'domain', domain: node.info.domain, node: node};
  }
  function mailboxesTarget(node, usernames) {
    return {scope: 'mailbox', domain: node.info.domain, node: node,
      mailboxes: $.map(usernames, function(u) { return node.known[u] || {username: u, exists: 1}; })};
  }
  function selectionTarget() {
    var sel = tree.selection, node = sel ? tree.nodes[sel.domain] : null;
    if (!node) return null;
    return sel.scope === 'domain' ? domainTarget(node) : mailboxesTarget(node, selectedMailboxes());
  }
  function createdBadge() {
    return ' <span class="badge bg-warning text-black">' + esc(L('will_be_created')) + '</span>';
  }
  // number of mailboxes a restore covers (domain: those of the snapshot)
  function targetCount(target) {
    return target.scope === 'domain' ? (target.node.info.mailboxes || 0) : target.mailboxes.length;
  }
  function openRestore(target) {
    var $modal = $('#backupRestoreModal'), snapshot = tree.snapshots[tree.snapshot], html = '', deleted, deletedOnly, title;
    if (!target) return;
    tree.target = target;
    tree.replaced = null;
    updateToolbar();
    if (target.scope === 'domain') {
      var d = target.node.info;
      deleted = d.exists != 1 || d.missing > 0;
      deletedOnly = d.exists != 1 || (d.mailboxes > 0 && d.missing >= d.mailboxes);
      title = fill(L('modal_title_domain'), d.domain);
      html += '<div class="fw-bold">' + esc(fill(L('restore_target_domain'), d.domain)) + (d.exists != 1 ? createdBadge() : '') + '</div>';
      if (d.mailboxes !== null && d.mailboxes !== undefined) {
        var count = (d.mailboxes == 1) ? L(d.missing > 0 ? 'target_count_one_deleted' : 'target_count_one')
          : (d.missing > 0 ? fill(L('target_count'), d.mailboxes, d.missing) : fill(L('target_count_all'), d.mailboxes));
        html += '<div class="small text-muted">' + esc(count) + '</div>';
      }
    } else {
      var gone = $.grep(target.mailboxes, function(m) { return m.exists != 1; }).length;
      deleted = gone > 0;
      deletedOnly = gone === target.mailboxes.length;
      if (target.mailboxes.length === 1) {
        title = fill(L('modal_title_mailbox'), target.mailboxes[0].username);
        html += '<div class="fw-bold">' + esc(fill(L('restore_target_mailbox'), target.mailboxes[0].username)) + (gone ? createdBadge() : '') + '</div>';
      } else {
        title = fill(L('modal_title_mailboxes'), target.mailboxes.length, target.domain);
        html += '<div class="fw-bold">' + esc(fill(L('restore_target_mailboxes_of'), target.mailboxes.length, target.domain)) + '</div>';
        html += '<ul class="mb-0 small">' + $.map(target.mailboxes.slice(0, SUMMARY_MAX), function(m) {
          return '<li>' + esc(m.username) + (m.exists != 1 ? createdBadge() : '') + '</li>';
        }).join('') + (target.mailboxes.length > SUMMARY_MAX ? '<li class="text-muted">' + esc(fill(L('and_more'), target.mailboxes.length - SUMMARY_MAX)) + '</li>' : '') + '</ul>';
      }
    }
    $modal.find('.modal-title').text(title);
    $modal.find('.backup-restore-subtitle').text(L('snapshot_label') + ': ' + (snapshot ? snapshotLabel(snapshot) : tree.snapshot));
    $modal.find('.backup-restore-summary').html(html);
    $modal.find('.backup-create-note').toggleClass('d-none', !deleted);
    setOverwriteMode(deletedOnly);
    applyDefaults(deletedOnly);
    updateFolderName();
    restoreError('');
    $modal.modal('show');
  }
  function updateFolderName() {
    var snapshot = tree.snapshots[tree.snapshot];
    $('#backup_restore_form .backup-folder-name').text(snapshot ? folderName(snapshot.time) : L('mail_target_folder_name'));
  }
  // everything deleted: nothing to overwrite, SOGo is a normal item, settings and password are not sent
  function setOverwriteMode(deletedOnly) {
    var $form = $('#backup_restore_form'), $sogo = $form.find('.backup-sogo-item'), $label = $sogo.find('label');
    tree.deletedOnly = deletedOnly;
    if (deletedOnly) $form.find('.backup-sogo-normal').append($sogo);
    else $form.find('.backup-overwrite > p').after($sogo);
    $form.find('.backup-sogo-normal').toggleClass('d-none', !deletedOnly);
    $form.find('.backup-overwrite').toggleClass('d-none', deletedOnly);
    $sogo.find('.backup-sogo-note').toggleClass('d-none', deletedOnly);
    $label.text(deletedOnly ? $label.data('normal') : $label.data('overwrite'));
    $form.find('.backup-component[value="settings"], .backup-component[value="password"]').prop('disabled', deletedOnly);
  }
  // existing targets: only the mails into a separate folder; everything deleted: all items, mails into their folders
  function applyDefaults(deletedOnly) {
    $('#backup_restore_form .backup-component').each(function() {
      var key = this.value;
      var on = deletedOnly ? (OVERWRITE.indexOf(key) === -1 || key === 'sogo') : EXISTING_DEFAULT.indexOf(key) !== -1;
      $(this).prop('checked', on && !(noMails() && MAIL_COMPONENTS.indexOf(key) !== -1));
    });
    $('#backup_restore_form input[name="mail_target"][value="' + (deletedOnly ? 'original' : 'folder') + '"]').prop('checked', true);
    toggleSubOptions();
  }
  function checkedOverwrite() {
    if (tree.deletedOnly) return [];
    return $('#backup_restore_form .backup-overwrite .backup-component:checked:enabled').map(function() { return this.value; }).get();
  }
  // sub-items (Sieve activation) need their item; the mail target needs the mails; overwriting turns the button red
  function toggleSubOptions() {
    var $form = $('#backup_restore_form'), missing = noMails();
    $form.find('.backup-no-mail-note').toggleClass('d-none', !missing);
    $.each(MAIL_COMPONENTS, function(i, key) {
      var $item = $form.find('.backup-component[value="' + key + '"]');
      if (missing) $item.prop('checked', false);
      $item.prop('disabled', missing).closest('.form-check').toggleClass('text-muted', missing);
    });
    $form.find('.backup-component[data-parent]').each(function() {
      var parent = $form.find('.backup-component[value="' + $(this).data('parent') + '"]');
      var off = !parent.is(':checked') || (missing && MAIL_COMPONENTS.indexOf(this.value) !== -1);
      $(this).prop('disabled', off).closest('.form-check').toggleClass('text-muted', off);
    });
    var mails = $form.find('.backup-component[value="mails"]').is(':checked');
    $form.find('input[name="mail_target"]').prop('disabled', !mails);
    $form.find('.backup-mail-target').toggleClass('text-muted', !mails);
    var $submit = $form.find('.backup-restore-submit'), over = checkedOverwrite().length > 0;
    $submit.toggleClass('btn-danger', over).toggleClass('btn-success', !over).find('span').text($submit.data(over ? 'overwrite' : 'normal'));
  }
  function restoreError(text) {
    $('#backup_restore_form .backup-restore-error').toggleClass('d-none', !text).text(text || '');
  }
  function queuedAlert(id) {
    $('#backup_restore_page .backup-restore-queued').html('<div class="alert alert-success alert-dismissible py-2 small">' +
      '<i class="bi bi-check-circle-fill"></i> ' + esc(fill(L('queued_inline'), id)) +
      ' <a href="#" class="backup-job-details" data-job="' + esc(id) + '">' + esc(L('details')) + '</a>' +
      '<button type="button" class="btn-close btn-sm" data-bs-dismiss="alert" aria-label="' + esc(L('close')) + '"></button></div>');
  }
  function submitRestore($button) {
    var $form = $('#backup_restore_form'), target = tree.target;
    var components = $form.find('.backup-component:checked:enabled').map(function() { return this.value; }).get();
    restoreError('');
    if (!target || !tree.snapshot) return;
    if (!components.length) {
      restoreError(L('no_components'));
      return;
    }
    var over = checkedOverwrite();
    if (over.length && !confirm(fill(L('overwrite_confirm'), $.map(over, function(c) { return L('overwrite_short_' + c) || c; }).join(', '), targetCount(target)))) return;
    var body = {snapshot: tree.snapshot, scope: target.scope, domain: target.domain, components: components,
      mail_target: $form.find('input[name="mail_target"]:checked').val() || 'folder'};
    if (target.scope === 'mailbox') body.mailboxes = $.map(target.mailboxes, function(m) { return m.username; });
    post('add/backup-restore', body, function(ok, messages) {
      if (ok) {
        $.each(messages, function(i, message) {
          if ($.isArray(message.msg) && message.msg[0] === 'backup_restore_added') queuedAlert(message.msg[1]);
        });
        $('#backupRestoreModal').modal('hide');
        setSelection(null);
        reloadTable('#backup_restores_table');
        return;
      }
      var errors = $.grep(messages, function(m) { return m && m.type !== 'success'; });
      restoreError(errors.length ? messageText(errors[0]) : L('load_error'));
    }, $button);
  }
  // the sticky toolbar below mailcow's sticky navbar
  function stickToolbar() {
    $('#backup_restore_page .backup-tree-toolbar').css('top', ($('nav.navbar.sticky-top').outerHeight() || 0) + 'px');
  }

  $(document).ready(function() {
    // mailcow's handler for page forms (button text "loading", no second submit, F5 off) is not for these AJAX forms
    $('#backup_settings, #backup_restore_form').off('submit');
    // job details and cancel: both pages
    $(document).on('click', '.backup-job-details', function(e) {
      e.preventDefault();
      showJob($(this).data('job'));
    });
    $(document).on('click', '.backup-job-cancel-row', function(e) {
      e.preventDefault();
      cancelJob($(this).data('job'), $(this).data('state'), $(this));
    });
    $('#backupJobModal').on('click', '.backup-job-cancel', function(e) {
      e.preventDefault();
      if (jobId !== null) cancelJob(jobId, $(this).data('state'), $(this));
    }).on('click', '.backup-job-refresh', function(e) {
      e.preventDefault();
      loadJob();
    }).on('hidden.bs.modal', function() {
      clearTimeout(jobTimer);
      jobId = null;
    });
    // "+"/"-" of the collapsible sections
    $(document).on('show.bs.collapse hide.bs.collapse', '#backup_advanced, #backup_snapshots_collapse', function(e) {
      if (e.target !== this) return;
      $('[data-bs-target="#' + this.id + '"] i').toggleClass('bi-plus-square', e.type === 'hide').toggleClass('bi-dash-square', e.type === 'show');
    }).on('shown.bs.collapse', '#backup_snapshots_collapse', function() {
      if ($.fn.DataTable.isDataTable('#backup_snapshots_table')) $('#backup_snapshots_table').DataTable().columns.adjust().responsive.recalc();
    });

    // admin: System > Configuration > Backup
    if ($('#tab-config-backup').length) {
      var loaded = false, listsLoaded = 0;
      onVisible('#backup_status', function() {
        if (!loaded) loadSettings();
        loaded = true;
        loadStatus();
        // the lists again when the tab is shown, not on every scroll
        if (now() - listsLoaded >= 10) {
          listsLoaded = now();
          loadJobs();
          loadSnapshotList();
        }
      });
      // links to the tab (e.g. from E-Mail > Restore)
      if (window.location.hash === '#tab-config-backup') {
        setTimeout(function() {
          $('[data-bs-target="#tab-config-backup"]').first().trigger('click');
          // phones: the tabs are collapsible cards
          $('#collapse-tab-config-backup').collapse('show');
        }, 0);
      }
      $('#backup_target').on('change', showTarget);
      $('#backup_settings input[name="include_index"]').on('change', toggleFts);
      $('#backup_settings').on('click', '.backup-schedule-add', function(e) {
        e.preventDefault();
        addScheduleEntry(true);
      }).on('keydown', '.backup-schedule-new input', function(e) {
        // Enter adds the entry instead of saving the form
        if (e.key === 'Enter') {
          e.preventDefault();
          addScheduleEntry(true);
        }
      }).on('change', '.backup-schedule-new input', function() {
        $(this).removeClass('inputMissingAttr').closest('.backup-schedule-new').find('label.btn').removeClass('inputMissingAttr');
      }).on('click', '.backup-schedule-remove', function(e) {
        e.preventDefault();
        $(this).closest('li').remove();
        drawSchedule(scheduleEntries());
      });
      // a stored secret: empty while focused (typing replaces it), dots again when left empty
      $('#backup_settings .backup-secret').on('focus', function() {
        if ($(this).data('masked')) $(this).val('').data('masked', false);
      }).on('input', function() {
        $(this).data('masked', false);
      }).on('blur', function() {
        if ($(this).data('stored') && $(this).val() === '') $(this).val(SECRET_MASK).data('masked', true);
      });
      $('#backup_settings input[name="password"]').on('input', function() {
        var $confirm = $('#backup_settings input[name="password_confirmed"]');
        if ($confirm.data('stored')) $confirm.prop('checked', false).data('stored', false);
        // a new password only works for a new, empty repository
        $('#backup_settings .backup-password-change').toggleClass('d-none', !($(this).data('stored') && $(this).val() !== ''));
      });
      $('#backup_settings').on('submit', function(e) {
        e.preventDefault();
        saveSettings($(this).find('.backup-settings-save'));
      });
      $('#backup_settings .backup-password-generate').on('click', function(e) {
        e.preventDefault();
        $('#backup_password').attr('type', 'text').val(generatePassword()).trigger('input');
      });
      $('#tab-config-backup').on('click', '.backup-copy', function(e) {
        e.preventDefault();
        copyField($(this).data('copy'));
      }).on('click', '.backup-job-request', function(e) {
        e.preventDefault();
        requestJob($(this));
      });
      $('#tab-config-backup .backup-refresh').on('click', function(e) {
        e.preventDefault();
        loadStatus();
        loadRunnerFields();
        loadJobs();
        loadSnapshotList();
      });
    }

    // E-Mail > Restore
    if ($('#backup_restore_page').length) {
      stickToolbar();
      $(window).on('resize', stickToolbar);
      loadSnapshots();
      drawRestores();
      $('#backup_restore_snapshot').on('change', function() {
        if ($(this).val() && $(this).val() !== tree.snapshot) selectSnapshot($(this).val());
      });
      var $tree = $('#backup_tree tbody');
      $tree.on('click', '.backup-tree-toggle', function(e) {
        e.preventDefault();
        e.stopPropagation();
        var node = nodeOf($(this));
        if (node) toggleDomain(node);
      }).on('click', '.backup-tree-more', function(e) {
        e.preventDefault();
        e.stopPropagation();
        var node = nodeOf($(this));
        if (node) {
          var first = node.shown;
          node.shown += CHUNK;
          renderDomain(node, first);
        }
      }).on('click', '.backup-tree-more-domains', function(e) {
        e.preventDefault();
        e.stopPropagation();
        var first = tree.shownDomains;
        tree.shownDomains += CHUNK;
        renderTree();
        treeBody().find('tr.backup-tree-domain').eq(first).find('.backup-tree-toggle').trigger('focus');
      }).on('click', '.backup-tree-restore', function(e) {
        e.preventDefault();
        e.stopPropagation();
        var node = nodeOf($(this)), m = $(this).closest('tr').hasClass('backup-tree-mailbox') ? mailboxOf($(this), node) : null;
        if (node) openRestore(m ? mailboxesTarget(node, [m.username]) : domainTarget(node));
      }).on('change', '.backup-tree-check', function() {
        var $row = $(this).closest('tr'), node = nodeOf($row);
        if (!node) return;
        if ($row.hasClass('backup-tree-domain')) checkDomain(node, this.checked);
        else checkMailbox(node, mailboxOf($row, node), this.checked);
      }).on('click', 'tr', function(e) {
        // mailcow selects a row's checkbox on a click into the row: the tree handles its rows itself
        e.stopPropagation();
        if ($(e.target).closest('input, label, button, a').length) return;
        var $row = $(this), node = nodeOf($row);
        if (!node) return;
        if ($row.hasClass('backup-tree-domain')) toggleDomain(node);
        else if ($row.hasClass('backup-tree-mailbox')) {
          var $check = $row.find('.backup-tree-check');
          if (!$check.prop('disabled')) $check.trigger('click');
        }
      });
      $('#backup_restore_page').on('input', '.backup-tree-search', function() {
        var value = String($(this).val()).trim().toLowerCase().replace(/\//g, '');
        clearTimeout(searchTimer);
        searchTimer = setTimeout(function() {
          tree.term = value;
          tree.replaced = null;
          runSearch();
        }, 300);
      }).on('change', '.backup-tree-deleted', function() {
        tree.onlyDeleted = this.checked;
        tree.shownDomains = CHUNK;
        renderTree();
      }).on('click', '.backup-selection-clear', function(e) {
        e.preventDefault();
        setSelection(null);
      }).on('click', '.backup-select-domain', function(e) {
        e.preventDefault();
        var sel = tree.selection;
        if (sel) setSelection({domain: sel.domain, scope: 'domain', mailboxes: {}});
      }).on('click', '.backup-selection-restore', function(e) {
        e.preventDefault();
        openRestore(selectionTarget());
      }).on('click', '.backup-table-refresh', function(e) {
        e.preventDefault();
        reloadTable('#' + $(this).data('table'));
      });
      $('#backup_restore_form').on('change', '.backup-component', toggleSubOptions).on('submit', function(e) {
        e.preventDefault();
        submitRestore($(this).find('.backup-restore-submit'));
      });
    }
  });

  return {
    showJob: showJob
  };
})(jQuery);