genshin-appsample-map-mark-all.user.js

// ==UserScript==
// @name         Genshin Appsample Map - Mark All Found
// @namespace    https://github.com/Deses/userscripts
// @version      5.4
// @description  Bulk-mark markers as Found in batched Firestore writes. Pick the categories you want to process, per map area. Only markers the site itself lets you mark are offered.
// @author       Deses
// @match        https://genshin-impact-map.appsample.com/*
// @icon         https://genshin-impact-map.appsample.com/favicon.ico
// @license      BSD-3-Clause
// @grant        none
// @run-at       document-idle
// @updateURL    https://raw.githubusercontent.com/Deses/userscripts/refs/heads/main/genshin-appsample-map-mark-all.user.js
// @downloadURL  https://raw.githubusercontent.com/Deses/userscripts/refs/heads/main/genshin-appsample-map-mark-all.user.js
// ==/UserScript==

(function () {
  'use strict';

  const VERSION = '5.4';

  const MARKER_URL    = 'https://game-data.lemonapi.com/gim/markers_all.v5.json';
  const FIRESTORE_API = 'https://firestore.googleapis.com/v1/';
  const FIRESTORE_DOC = 'projects/genshin-impact/databases/(default)/documents';
  const TOKEN_URL     = 'https://securetoken.googleapis.com/v1/token';
  const STORAGE_OPTS   = 'gim_am_opts_v5';
  const STORAGE_BACKUP = 'gim_am_backup_v5';

  // The site only shows the "Mark as found" button on markers of level 5 or higher.
  const MIN_MARKABLE_LEVEL = 5;
  // The site wrongly lets you mark these, but they are not collectibles and they respawn.
  // Hunter's Ray, Armored Crab, Blubberbeast, Healing Spot, Jellyfish.
  const NOT_COLLECTIBLE_TYPES = new Set(['o341', 'o363', 'o364', 'o367', 'o370']);
  const CATEGORY_IDS = ['featured', 'chest', 'hiddenchest', 'collection', 'guide'];
  const RETRYABLE_STATUS = new Set([409, 429, 500, 503]);

  const I18N = {
    en: {
      autoHideFound: 'Hide found markers automatically',
      selectIncomplete: 'Select incomplete types',
      loading: 'Loading...',
      area: 'Area:',
      batchSize: 'Batch size',
      delayMs: 'Delay ms',
      markSelected: 'Mark selected ({n})',
      unmarkSelected: 'Unmark selected ({n})',
      stop: 'Stop',
      fixInvalid: 'Fix invalid marks ({n})',
      restoreBackup: 'Restore backup',
      refresh: 'Refresh',
      reloadPage: 'Reload page',
      verbose: 'Verbose',
      signedIn: 'Signed in:',
      yes: 'yes',
      signInFirst: 'NO - sign in on the site first',
      markable: 'Markable markers:',
      markableOf: '{n} of {total}',
      foundInAccount: 'Found in your account:',
      invalidMarks: 'Invalid marks:',
      openMarkersTab: 'Open the markers tab of the site so its categories can be read.',
      confirmUnmark: 'Mark {n} selected markers as NOT found?',
      confirmRestore: 'Restore your found list to the backup from {time} ({n} markers)?',
      confirmFix: 'Remove {n} marks the site does not allow?',
      fetchingMarkers: 'Fetching master markers file...',
      loadedMarkers: 'Loaded {n} markers.',
      retrying: 'Firestore answered {status}, retrying in {s}s.',
      readFoundFailed: 'Could not read your found markers: {msg}',
      loadFailed: 'Could not load the marker data: {msg}',
      layoutFailed: 'Could not read the categories of {name}.',
      noBackup: 'No backup saved yet.',
      restoring: 'Restoring backup: +{add}, -{remove}.',
      noInvalid: 'No invalid marks in your account.',
      alreadyRunning: 'Already running.',
      nothingToDo: 'Nothing to do.',
      opStart: '{op}: {n} markers in {b} batches.',
      opStopped: 'Stopped at {done}/{total}.',
      opDone: '{op} done: {n} markers.',
      reloadNeeded: 'The map could not refresh itself. Reload the page to see the new state.',
      opFailed: '{op} failed: {msg}',
      stopRequested: 'Stop requested.',
      refreshed: 'Account state refreshed.',
      panelMissing: 'The site panel did not appear. Open the markers tab and press Refresh.',
      saveOptsFailed: 'Could not save options: {msg}',
      saveBackupFailed: 'Could not save the backup: {msg}',
      batchCommitted: 'Batch committed ({done}/{total}).',
      opMark: 'Mark',
      opUnmark: 'Unmark',
      opRestoreAdd: 'Restore (add)',
      opRestoreRemove: 'Restore (remove)',
      opFix: 'Fix invalid marks',
      mapFallback: 'map {mid}',
    },
    es: {
      autoHideFound: 'Ocultar marcadores encontrados automáticamente',
      selectIncomplete: 'Seleccionar tipos incompletos',
      loading: 'Cargando...',
      area: 'Área:',
      batchSize: 'Tamaño de lote',
      delayMs: 'Pausa (ms)',
      markSelected: 'Marcar selección ({n})',
      unmarkSelected: 'Desmarcar selección ({n})',
      stop: 'Parar',
      fixInvalid: 'Corregir marcas inválidas ({n})',
      restoreBackup: 'Restaurar copia',
      refresh: 'Actualizar',
      reloadPage: 'Recargar página',
      verbose: 'Detallado',
      signedIn: 'Sesión iniciada:',
      yes: 'sí',
      signInFirst: 'NO - inicia sesión en la web primero',
      markable: 'Marcadores tachables:',
      markableOf: '{n} de {total}',
      foundInAccount: 'Encontrados en tu cuenta:',
      invalidMarks: 'Marcas inválidas:',
      openMarkersTab: 'Abre la pestaña de marcadores de la web para poder leer sus categorías.',
      confirmUnmark: '¿Marcar {n} marcadores seleccionados como NO encontrados?',
      confirmRestore: '¿Restaurar tu lista de encontrados a la copia del {time} ({n} marcadores)?',
      confirmFix: '¿Quitar {n} marcas que la web no permite?',
      fetchingMarkers: 'Descargando el fichero maestro de marcadores...',
      loadedMarkers: 'Cargados {n} marcadores.',
      retrying: 'Firestore respondió {status}, reintentando en {s} s.',
      readFoundFailed: 'No se pudieron leer tus marcadores encontrados: {msg}',
      loadFailed: 'No se pudieron cargar los datos de marcadores: {msg}',
      layoutFailed: 'No se pudieron leer las categorías de {name}.',
      noBackup: 'Aún no hay ninguna copia guardada.',
      restoring: 'Restaurando copia: +{add}, -{remove}.',
      noInvalid: 'No hay marcas inválidas en tu cuenta.',
      alreadyRunning: 'Ya hay una operación en marcha.',
      nothingToDo: 'No hay nada que hacer.',
      opStart: '{op}: {n} marcadores en {b} lotes.',
      opStopped: 'Detenido en {done}/{total}.',
      opDone: '{op} terminado: {n} marcadores.',
      reloadNeeded: 'El mapa no pudo actualizarse solo. Recarga la página para ver el nuevo estado.',
      opFailed: '{op} falló: {msg}',
      stopRequested: 'Parada solicitada.',
      refreshed: 'Estado de la cuenta actualizado.',
      panelMissing: 'El panel de la web no apareció. Abre la pestaña de marcadores y pulsa Actualizar.',
      saveOptsFailed: 'No se pudieron guardar las opciones: {msg}',
      saveBackupFailed: 'No se pudo guardar la copia: {msg}',
      batchCommitted: 'Lote confirmado ({done}/{total}).',
      opMark: 'Marcar',
      opUnmark: 'Desmarcar',
      opRestoreAdd: 'Restaurar (añadir)',
      opRestoreRemove: 'Restaurar (quitar)',
      opFix: 'Corregir marcas inválidas',
      mapFallback: 'mapa {mid}',
    },
    fr: {
      autoHideFound: 'Masquer automatiquement les marqueurs trouvés',
      selectIncomplete: 'Sélectionner les types incomplets',
      loading: 'Chargement...',
      area: 'Zone :',
      batchSize: 'Taille du lot',
      delayMs: 'Pause (ms)',
      markSelected: 'Marquer la sélection ({n})',
      unmarkSelected: 'Démarquer la sélection ({n})',
      stop: 'Arrêter',
      fixInvalid: 'Corriger les marques invalides ({n})',
      restoreBackup: 'Restaurer la sauvegarde',
      refresh: 'Actualiser',
      reloadPage: 'Recharger la page',
      verbose: 'Détaillé',
      signedIn: 'Connecté :',
      yes: 'oui',
      signInFirst: 'NON - connectez-vous d\'abord sur le site',
      markable: 'Marqueurs cochables :',
      markableOf: '{n} sur {total}',
      foundInAccount: 'Trouvés dans votre compte :',
      invalidMarks: 'Marques invalides :',
      openMarkersTab: 'Ouvrez l\'onglet des marqueurs du site pour lire ses catégories.',
      confirmUnmark: 'Marquer {n} marqueurs sélectionnés comme NON trouvés ?',
      confirmRestore: 'Restaurer votre liste de trouvés à la sauvegarde du {time} ({n} marqueurs) ?',
      confirmFix: 'Retirer {n} marques que le site n\'autorise pas ?',
      fetchingMarkers: 'Téléchargement du fichier principal des marqueurs...',
      loadedMarkers: '{n} marqueurs chargés.',
      retrying: 'Firestore a répondu {status}, nouvel essai dans {s} s.',
      readFoundFailed: 'Impossible de lire vos marqueurs trouvés : {msg}',
      loadFailed: 'Impossible de charger les données des marqueurs : {msg}',
      layoutFailed: 'Impossible de lire les catégories de {name}.',
      noBackup: 'Aucune sauvegarde enregistrée.',
      restoring: 'Restauration de la sauvegarde : +{add}, -{remove}.',
      noInvalid: 'Aucune marque invalide dans votre compte.',
      alreadyRunning: 'Déjà en cours.',
      nothingToDo: 'Rien à faire.',
      opStart: '{op} : {n} marqueurs en {b} lots.',
      opStopped: 'Arrêté à {done}/{total}.',
      opDone: '{op} terminé : {n} marqueurs.',
      reloadNeeded: 'La carte n\'a pas pu se mettre à jour seule. Rechargez la page pour voir le nouvel état.',
      opFailed: '{op} a échoué : {msg}',
      stopRequested: 'Arrêt demandé.',
      refreshed: 'État du compte actualisé.',
      panelMissing: 'Le panneau du site n\'est pas apparu. Ouvrez l\'onglet des marqueurs et cliquez sur Actualiser.',
      saveOptsFailed: 'Impossible d\'enregistrer les options : {msg}',
      saveBackupFailed: 'Impossible d\'enregistrer la sauvegarde : {msg}',
      batchCommitted: 'Lot validé ({done}/{total}).',
      opMark: 'Marquer',
      opUnmark: 'Démarquer',
      opRestoreAdd: 'Restauration (ajout)',
      opRestoreRemove: 'Restauration (retrait)',
      opFix: 'Corriger les marques invalides',
      mapFallback: 'carte {mid}',
    },
    de: {
      autoHideFound: 'Gefundene Marker automatisch ausblenden',
      selectIncomplete: 'Unvollständige Typen auswählen',
      loading: 'Lädt...',
      area: 'Gebiet:',
      batchSize: 'Stapelgröße',
      delayMs: 'Pause (ms)',
      markSelected: 'Auswahl markieren ({n})',
      unmarkSelected: 'Markierung der Auswahl aufheben ({n})',
      stop: 'Stopp',
      fixInvalid: 'Ungültige Markierungen korrigieren ({n})',
      restoreBackup: 'Sicherung wiederherstellen',
      refresh: 'Aktualisieren',
      reloadPage: 'Seite neu laden',
      verbose: 'Ausführlich',
      signedIn: 'Angemeldet:',
      yes: 'ja',
      signInFirst: 'NEIN - zuerst auf der Seite anmelden',
      markable: 'Markierbare Marker:',
      markableOf: '{n} von {total}',
      foundInAccount: 'In deinem Konto gefunden:',
      invalidMarks: 'Ungültige Markierungen:',
      openMarkersTab: 'Öffne den Marker-Tab der Seite, damit die Kategorien gelesen werden können.',
      confirmUnmark: '{n} ausgewählte Marker als NICHT gefunden markieren?',
      confirmRestore: 'Deine Fundliste auf die Sicherung vom {time} ({n} Marker) zurücksetzen?',
      confirmFix: '{n} Markierungen entfernen, die die Seite nicht erlaubt?',
      fetchingMarkers: 'Marker-Hauptdatei wird geladen...',
      loadedMarkers: '{n} Marker geladen.',
      retrying: 'Firestore antwortete {status}, neuer Versuch in {s} s.',
      readFoundFailed: 'Deine gefundenen Marker konnten nicht gelesen werden: {msg}',
      loadFailed: 'Die Markerdaten konnten nicht geladen werden: {msg}',
      layoutFailed: 'Die Kategorien von {name} konnten nicht gelesen werden.',
      noBackup: 'Noch keine Sicherung gespeichert.',
      restoring: 'Sicherung wird wiederhergestellt: +{add}, -{remove}.',
      noInvalid: 'Keine ungültigen Markierungen in deinem Konto.',
      alreadyRunning: 'Läuft bereits.',
      nothingToDo: 'Nichts zu tun.',
      opStart: '{op}: {n} Marker in {b} Stapeln.',
      opStopped: 'Bei {done}/{total} gestoppt.',
      opDone: '{op} fertig: {n} Marker.',
      reloadNeeded: 'Die Karte konnte sich nicht selbst aktualisieren. Lade die Seite neu, um den neuen Stand zu sehen.',
      opFailed: '{op} fehlgeschlagen: {msg}',
      stopRequested: 'Stopp angefordert.',
      refreshed: 'Kontostatus aktualisiert.',
      panelMissing: 'Das Seitenpanel ist nicht erschienen. Öffne den Marker-Tab und klicke auf Aktualisieren.',
      saveOptsFailed: 'Optionen konnten nicht gespeichert werden: {msg}',
      saveBackupFailed: 'Die Sicherung konnte nicht gespeichert werden: {msg}',
      batchCommitted: 'Stapel übernommen ({done}/{total}).',
      opMark: 'Markieren',
      opUnmark: 'Markierung aufheben',
      opRestoreAdd: 'Wiederherstellen (hinzufügen)',
      opRestoreRemove: 'Wiederherstellen (entfernen)',
      opFix: 'Ungültige Markierungen korrigieren',
      mapFallback: 'Karte {mid}',
    },
    pt: {
      autoHideFound: 'Ocultar marcadores encontrados automaticamente',
      selectIncomplete: 'Selecionar tipos incompletos',
      loading: 'A carregar...',
      area: 'Área:',
      batchSize: 'Tamanho do lote',
      delayMs: 'Pausa (ms)',
      markSelected: 'Marcar seleção ({n})',
      unmarkSelected: 'Desmarcar seleção ({n})',
      stop: 'Parar',
      fixInvalid: 'Corrigir marcas inválidas ({n})',
      restoreBackup: 'Restaurar cópia',
      refresh: 'Atualizar',
      reloadPage: 'Recarregar página',
      verbose: 'Detalhado',
      signedIn: 'Sessão iniciada:',
      yes: 'sim',
      signInFirst: 'NÃO - inicie sessão no site primeiro',
      markable: 'Marcadores marcáveis:',
      markableOf: '{n} de {total}',
      foundInAccount: 'Encontrados na sua conta:',
      invalidMarks: 'Marcas inválidas:',
      openMarkersTab: 'Abra o separador de marcadores do site para ler as suas categorias.',
      confirmUnmark: 'Marcar {n} marcadores selecionados como NÃO encontrados?',
      confirmRestore: 'Restaurar a sua lista de encontrados para a cópia de {time} ({n} marcadores)?',
      confirmFix: 'Remover {n} marcas que o site não permite?',
      fetchingMarkers: 'A descarregar o ficheiro mestre de marcadores...',
      loadedMarkers: '{n} marcadores carregados.',
      retrying: 'O Firestore respondeu {status}, nova tentativa em {s} s.',
      readFoundFailed: 'Não foi possível ler os seus marcadores encontrados: {msg}',
      loadFailed: 'Não foi possível carregar os dados dos marcadores: {msg}',
      layoutFailed: 'Não foi possível ler as categorias de {name}.',
      noBackup: 'Ainda não há nenhuma cópia guardada.',
      restoring: 'A restaurar cópia: +{add}, -{remove}.',
      noInvalid: 'Não há marcas inválidas na sua conta.',
      alreadyRunning: 'Já está a decorrer.',
      nothingToDo: 'Nada a fazer.',
      opStart: '{op}: {n} marcadores em {b} lotes.',
      opStopped: 'Parado em {done}/{total}.',
      opDone: '{op} concluído: {n} marcadores.',
      reloadNeeded: 'O mapa não conseguiu atualizar-se sozinho. Recarregue a página para ver o novo estado.',
      opFailed: '{op} falhou: {msg}',
      stopRequested: 'Paragem pedida.',
      refreshed: 'Estado da conta atualizado.',
      panelMissing: 'O painel do site não apareceu. Abra o separador de marcadores e prima Atualizar.',
      saveOptsFailed: 'Não foi possível guardar as opções: {msg}',
      saveBackupFailed: 'Não foi possível guardar a cópia: {msg}',
      batchCommitted: 'Lote confirmado ({done}/{total}).',
      opMark: 'Marcar',
      opUnmark: 'Desmarcar',
      opRestoreAdd: 'Restaurar (adicionar)',
      opRestoreRemove: 'Restaurar (remover)',
      opFix: 'Corrigir marcas inválidas',
      mapFallback: 'mapa {mid}',
    },
    id: {
      autoHideFound: 'Sembunyikan penanda yang ditemukan otomatis',
      selectIncomplete: 'Pilih tipe yang belum lengkap',
      loading: 'Memuat...',
      area: 'Area:',
      batchSize: 'Ukuran batch',
      delayMs: 'Jeda (ms)',
      markSelected: 'Tandai pilihan ({n})',
      unmarkSelected: 'Batalkan tanda pilihan ({n})',
      stop: 'Berhenti',
      fixInvalid: 'Perbaiki tanda tidak valid ({n})',
      restoreBackup: 'Pulihkan cadangan',
      refresh: 'Segarkan',
      reloadPage: 'Muat ulang halaman',
      verbose: 'Rinci',
      signedIn: 'Sudah masuk:',
      yes: 'ya',
      signInFirst: 'TIDAK - masuk dulu di situs',
      markable: 'Penanda yang bisa ditandai:',
      markableOf: '{n} dari {total}',
      foundInAccount: 'Ditemukan di akunmu:',
      invalidMarks: 'Tanda tidak valid:',
      openMarkersTab: 'Buka tab penanda di situs agar kategorinya bisa dibaca.',
      confirmUnmark: 'Tandai {n} penanda terpilih sebagai BELUM ditemukan?',
      confirmRestore: 'Pulihkan daftar temuanmu ke cadangan tanggal {time} ({n} penanda)?',
      confirmFix: 'Hapus {n} tanda yang tidak diizinkan situs?',
      fetchingMarkers: 'Mengunduh berkas utama penanda...',
      loadedMarkers: '{n} penanda dimuat.',
      retrying: 'Firestore menjawab {status}, mencoba lagi dalam {s} dtk.',
      readFoundFailed: 'Tidak bisa membaca penanda yang kamu temukan: {msg}',
      loadFailed: 'Tidak bisa memuat data penanda: {msg}',
      layoutFailed: 'Tidak bisa membaca kategori {name}.',
      noBackup: 'Belum ada cadangan tersimpan.',
      restoring: 'Memulihkan cadangan: +{add}, -{remove}.',
      noInvalid: 'Tidak ada tanda tidak valid di akunmu.',
      alreadyRunning: 'Sedang berjalan.',
      nothingToDo: 'Tidak ada yang dikerjakan.',
      opStart: '{op}: {n} penanda dalam {b} batch.',
      opStopped: 'Berhenti di {done}/{total}.',
      opDone: '{op} selesai: {n} penanda.',
      reloadNeeded: 'Peta tidak bisa memperbarui diri. Muat ulang halaman untuk melihat keadaan baru.',
      opFailed: '{op} gagal: {msg}',
      stopRequested: 'Permintaan berhenti dikirim.',
      refreshed: 'Status akun diperbarui.',
      panelMissing: 'Panel situs tidak muncul. Buka tab penanda lalu tekan Segarkan.',
      saveOptsFailed: 'Tidak bisa menyimpan opsi: {msg}',
      saveBackupFailed: 'Tidak bisa menyimpan cadangan: {msg}',
      batchCommitted: 'Batch tersimpan ({done}/{total}).',
      opMark: 'Tandai',
      opUnmark: 'Batalkan tanda',
      opRestoreAdd: 'Pulihkan (tambah)',
      opRestoreRemove: 'Pulihkan (hapus)',
      opFix: 'Perbaiki tanda tidak valid',
      mapFallback: 'peta {mid}',
    },
    ru: {
      autoHideFound: 'Автоматически скрывать найденные маркеры',
      selectIncomplete: 'Выбрать незавершённые типы',
      loading: 'Загрузка...',
      area: 'Область:',
      batchSize: 'Размер пакета',
      delayMs: 'Пауза (мс)',
      markSelected: 'Отметить выбранное ({n})',
      unmarkSelected: 'Снять отметку с выбранного ({n})',
      stop: 'Стоп',
      fixInvalid: 'Исправить недопустимые отметки ({n})',
      restoreBackup: 'Восстановить копию',
      refresh: 'Обновить',
      reloadPage: 'Перезагрузить страницу',
      verbose: 'Подробно',
      signedIn: 'Вход выполнен:',
      yes: 'да',
      signInFirst: 'НЕТ - сначала войдите на сайте',
      markable: 'Отмечаемые маркеры:',
      markableOf: '{n} из {total}',
      foundInAccount: 'Найдено в вашем аккаунте:',
      invalidMarks: 'Недопустимые отметки:',
      openMarkersTab: 'Откройте вкладку маркеров на сайте, чтобы прочитать категории.',
      confirmUnmark: 'Отметить {n} выбранных маркеров как НЕ найденные?',
      confirmRestore: 'Восстановить список найденного из копии от {time} ({n} маркеров)?',
      confirmFix: 'Удалить {n} отметок, которые сайт не допускает?',
      fetchingMarkers: 'Загрузка основного файла маркеров...',
      loadedMarkers: 'Загружено маркеров: {n}.',
      retrying: 'Firestore ответил {status}, повтор через {s} с.',
      readFoundFailed: 'Не удалось прочитать ваши найденные маркеры: {msg}',
      loadFailed: 'Не удалось загрузить данные маркеров: {msg}',
      layoutFailed: 'Не удалось прочитать категории: {name}.',
      noBackup: 'Копия ещё не сохранена.',
      restoring: 'Восстановление копии: +{add}, -{remove}.',
      noInvalid: 'В вашем аккаунте нет недопустимых отметок.',
      alreadyRunning: 'Уже выполняется.',
      nothingToDo: 'Делать нечего.',
      opStart: '{op}: маркеров {n}, пакетов {b}.',
      opStopped: 'Остановлено на {done}/{total}.',
      opDone: '{op} завершено: маркеров {n}.',
      reloadNeeded: 'Карта не смогла обновиться сама. Перезагрузите страницу, чтобы увидеть новое состояние.',
      opFailed: '{op} не удалось: {msg}',
      stopRequested: 'Запрошена остановка.',
      refreshed: 'Состояние аккаунта обновлено.',
      panelMissing: 'Панель сайта не появилась. Откройте вкладку маркеров и нажмите Обновить.',
      saveOptsFailed: 'Не удалось сохранить настройки: {msg}',
      saveBackupFailed: 'Не удалось сохранить копию: {msg}',
      batchCommitted: 'Пакет записан ({done}/{total}).',
      opMark: 'Отметить',
      opUnmark: 'Снять отметку',
      opRestoreAdd: 'Восстановление (добавить)',
      opRestoreRemove: 'Восстановление (убрать)',
      opFix: 'Исправить недопустимые отметки',
      mapFallback: 'карта {mid}',
    },
    zh: {
      autoHideFound: '自动隐藏已找到的标点',
      selectIncomplete: '选择未完成的类型',
      loading: '加载中...',
      area: '区域：',
      batchSize: '批次大小',
      delayMs: '间隔（毫秒）',
      markSelected: '标记所选（{n}）',
      unmarkSelected: '取消标记所选（{n}）',
      stop: '停止',
      fixInvalid: '修复无效标记（{n}）',
      restoreBackup: '恢复备份',
      refresh: '刷新',
      reloadPage: '重新加载页面',
      verbose: '详细',
      signedIn: '已登录：',
      yes: '是',
      signInFirst: '否 - 请先在网站上登录',
      markable: '可标记的标点：',
      markableOf: '{n} / {total}',
      foundInAccount: '账号中已找到：',
      invalidMarks: '无效标记：',
      openMarkersTab: '请打开网站的标点标签页，以便读取其分类。',
      confirmUnmark: '将所选的 {n} 个标点标记为未找到？',
      confirmRestore: '将已找到列表恢复到 {time} 的备份（{n} 个标点）？',
      confirmFix: '移除 {n} 个网站不允许的标记？',
      fetchingMarkers: '正在获取标点主文件...',
      loadedMarkers: '已加载 {n} 个标点。',
      retrying: 'Firestore 返回 {status}，{s} 秒后重试。',
      readFoundFailed: '无法读取你已找到的标点：{msg}',
      loadFailed: '无法加载标点数据：{msg}',
      layoutFailed: '无法读取 {name} 的分类。',
      noBackup: '尚未保存任何备份。',
      restoring: '正在恢复备份：+{add}，-{remove}。',
      noInvalid: '你的账号中没有无效标记。',
      alreadyRunning: '正在运行。',
      nothingToDo: '无需处理。',
      opStart: '{op}：{n} 个标点，共 {b} 批。',
      opStopped: '已在 {done}/{total} 处停止。',
      opDone: '{op}完成：{n} 个标点。',
      reloadNeeded: '地图无法自动刷新。请重新加载页面以查看新状态。',
      opFailed: '{op}失败：{msg}',
      stopRequested: '已请求停止。',
      refreshed: '账号状态已刷新。',
      panelMissing: '网站面板未出现。请打开标点标签页并点击刷新。',
      saveOptsFailed: '无法保存选项：{msg}',
      saveBackupFailed: '无法保存备份：{msg}',
      batchCommitted: '批次已提交（{done}/{total}）。',
      opMark: '标记',
      opUnmark: '取消标记',
      opRestoreAdd: '恢复（添加）',
      opRestoreRemove: '恢复（移除）',
      opFix: '修复无效标记',
      mapFallback: '地图 {mid}',
    },
    ja: {
      autoHideFound: '発見済みマーカーを自動で非表示',
      selectIncomplete: '未完了のタイプを選択',
      loading: '読み込み中...',
      area: 'エリア:',
      batchSize: 'バッチサイズ',
      delayMs: '間隔（ms）',
      markSelected: '選択をマーク（{n}）',
      unmarkSelected: '選択のマークを解除（{n}）',
      stop: '停止',
      fixInvalid: '無効なマークを修正（{n}）',
      restoreBackup: 'バックアップを復元',
      refresh: '更新',
      reloadPage: 'ページを再読み込み',
      verbose: '詳細',
      signedIn: 'ログイン済み:',
      yes: 'はい',
      signInFirst: 'いいえ - 先にサイトでログインしてください',
      markable: 'マーク可能なマーカー:',
      markableOf: '{n} / {total}',
      foundInAccount: 'アカウントの発見済み:',
      invalidMarks: '無効なマーク:',
      openMarkersTab: 'カテゴリを読み取るため、サイトのマーカータブを開いてください。',
      confirmUnmark: '選択した {n} 件のマーカーを未発見にしますか？',
      confirmRestore: '発見済みリストを {time} のバックアップ（{n} 件）に復元しますか？',
      confirmFix: 'サイトが許可していないマーク {n} 件を削除しますか？',
      fetchingMarkers: 'マーカーのマスターファイルを取得中...',
      loadedMarkers: '{n} 件のマーカーを読み込みました。',
      retrying: 'Firestore が {status} を返しました。{s} 秒後に再試行します。',
      readFoundFailed: '発見済みマーカーを読み取れませんでした: {msg}',
      loadFailed: 'マーカーデータを読み込めませんでした: {msg}',
      layoutFailed: '{name} のカテゴリを読み取れませんでした。',
      noBackup: 'バックアップはまだ保存されていません。',
      restoring: 'バックアップを復元中: +{add}、-{remove}。',
      noInvalid: 'アカウントに無効なマークはありません。',
      alreadyRunning: 'すでに実行中です。',
      nothingToDo: '対象がありません。',
      opStart: '{op}: {n} 件を {b} バッチで処理します。',
      opStopped: '{done}/{total} で停止しました。',
      opDone: '{op}が完了: {n} 件。',
      reloadNeeded: 'マップを自動更新できませんでした。新しい状態を見るにはページを再読み込みしてください。',
      opFailed: '{op}に失敗しました: {msg}',
      stopRequested: '停止を要求しました。',
      refreshed: 'アカウントの状態を更新しました。',
      panelMissing: 'サイトのパネルが表示されませんでした。マーカータブを開いて更新を押してください。',
      saveOptsFailed: '設定を保存できませんでした: {msg}',
      saveBackupFailed: 'バックアップを保存できませんでした: {msg}',
      batchCommitted: 'バッチを書き込みました（{done}/{total}）。',
      opMark: 'マーク',
      opUnmark: 'マーク解除',
      opRestoreAdd: '復元（追加）',
      opRestoreRemove: '復元（削除）',
      opFix: '無効なマークを修正',
      mapFallback: 'マップ {mid}',
    },
    ko: {
      autoHideFound: '찾은 마커 자동 숨기기',
      selectIncomplete: '미완료 유형 선택',
      loading: '불러오는 중...',
      area: '지역:',
      batchSize: '배치 크기',
      delayMs: '간격(ms)',
      markSelected: '선택 항목 표시({n})',
      unmarkSelected: '선택 항목 표시 해제({n})',
      stop: '중지',
      fixInvalid: '잘못된 표시 수정({n})',
      restoreBackup: '백업 복원',
      refresh: '새로고침',
      reloadPage: '페이지 다시 불러오기',
      verbose: '상세',
      signedIn: '로그인됨:',
      yes: '예',
      signInFirst: '아니요 - 먼저 사이트에서 로그인하세요',
      markable: '표시 가능한 마커:',
      markableOf: '{n} / {total}',
      foundInAccount: '계정에서 찾음:',
      invalidMarks: '잘못된 표시:',
      openMarkersTab: '카테고리를 읽을 수 있도록 사이트의 마커 탭을 여세요.',
      confirmUnmark: '선택한 마커 {n}개를 찾지 않음으로 표시할까요?',
      confirmRestore: '찾은 목록을 {time} 백업({n}개 마커)으로 복원할까요?',
      confirmFix: '사이트에서 허용하지 않는 표시 {n}개를 제거할까요?',
      fetchingMarkers: '마커 마스터 파일을 가져오는 중...',
      loadedMarkers: '마커 {n}개를 불러왔습니다.',
      retrying: 'Firestore가 {status}을(를) 반환했습니다. {s}초 후 다시 시도합니다.',
      readFoundFailed: '찾은 마커를 읽을 수 없습니다: {msg}',
      loadFailed: '마커 데이터를 불러올 수 없습니다: {msg}',
      layoutFailed: '{name}의 카테고리를 읽을 수 없습니다.',
      noBackup: '저장된 백업이 아직 없습니다.',
      restoring: '백업 복원 중: +{add}, -{remove}.',
      noInvalid: '계정에 잘못된 표시가 없습니다.',
      alreadyRunning: '이미 실행 중입니다.',
      nothingToDo: '할 일이 없습니다.',
      opStart: '{op}: 마커 {n}개, {b}개 배치.',
      opStopped: '{done}/{total}에서 중지됨.',
      opDone: '{op} 완료: 마커 {n}개.',
      reloadNeeded: '지도가 스스로 갱신되지 못했습니다. 새 상태를 보려면 페이지를 다시 불러오세요.',
      opFailed: '{op} 실패: {msg}',
      stopRequested: '중지를 요청했습니다.',
      refreshed: '계정 상태를 새로고침했습니다.',
      panelMissing: '사이트 패널이 나타나지 않았습니다. 마커 탭을 열고 새로고침을 누르세요.',
      saveOptsFailed: '옵션을 저장할 수 없습니다: {msg}',
      saveBackupFailed: '백업을 저장할 수 없습니다: {msg}',
      batchCommitted: '배치 기록 완료({done}/{total}).',
      opMark: '표시',
      opUnmark: '표시 해제',
      opRestoreAdd: '복원(추가)',
      opRestoreRemove: '복원(제거)',
      opFix: '잘못된 표시 수정',
      mapFallback: '지도 {mid}',
    },
  };

  let lang = 'en';

  function detectLang() {
    const control = document.getElementById('select-lang')?.closest('.MuiFormControl-root');
    const code = control?.querySelector('input.MuiSelect-nativeInput')?.value || document.documentElement.lang;
    const base = String(code || '').toLowerCase().split('-')[0];
    return I18N[base] ? base : 'en';
  }

  function t(key, vars = {}) {
    const template = I18N[lang]?.[key] ?? I18N.en[key] ?? key;
    return template.replace(/\{(\w+)\}/g, (_, name) => vars[name] ?? '');
  }

  let rows        = [];
  let rowById     = new Map();
  let idsByMidType = new Map();
  let found       = new Set();
  let layouts     = {};
  let mapOptions  = [];
  let selectedMid = null;
  let selected    = new Set();
  let collapsedCats = new Set();
  let autoHideFound = false;
  let syncLock    = 0;
  let switching   = false;
  let lastTypeSelected = null;
  let pullTimer   = null;
  let reloadCount = 0;
  let session     = null;
  let signedIn    = false;
  let busy        = false;
  let stopFlag    = false;
  let verbose     = false;

  const isMarkable = row => row.level >= MIN_MARKABLE_LEVEL && !NOT_COLLECTIBLE_TYPES.has(row.type);
  const sleep = ms => new Promise(r => setTimeout(r, ms));
  const $ = id => document.getElementById(id);

  async function waitFor(fn, timeoutMs = 30000, stepMs = 150) {
    const start = Date.now();
    while (Date.now() - start < timeoutMs) {
      const value = fn();
      if (value) {
        return value;
      }
      await sleep(stepMs);
    }
    return null;
  }

  function log(msg, level = 'info') {
    if (level === 'error') {
      console.error('[AutoMark]', msg);
    } else {
      console.log('[AutoMark]', msg);
    }
    const el = $('am-log');
    if (!el) {
      return;
    }
    const line = document.createElement('div');
    line.textContent = `${new Date().toLocaleTimeString()} ${msg}`;
    if (level === 'error') {
      line.className = 'am-err';
    }
    el.appendChild(line);
    el.scrollTop = el.scrollHeight;
    while (el.children.length > 300) {
      el.removeChild(el.firstChild);
    }
  }

  function vlog(msg) {
    if (verbose) {
      log(msg);
    }
  }

  function loadOpts() {
    try {
      return JSON.parse(localStorage.getItem(STORAGE_OPTS) || '{}');
    } catch (e) {
      return {};
    }
  }

  function saveOpts() {
    const opts = {
      mid:      selectedMid,
      selected: [...selected],
      collapsed: [...collapsedCats],
      autoHideFound,
      batch:    Number($('am-batch').value),
      delay:    Number($('am-delay').value),
    };
    try {
      localStorage.setItem(STORAGE_OPTS, JSON.stringify(opts));
    } catch (e) {
      log(t('saveOptsFailed', { msg: e.message }), 'error');
    }
  }

  // -- auth and Firestore -----------------------------------------------------
  function readAuthRecord() {
    return new Promise((resolve, reject) => {
      const open = indexedDB.open('firebaseLocalStorageDb');
      open.onerror = () => reject(open.error);
      open.onsuccess = () => {
        const db = open.result;
        if (!db.objectStoreNames.contains('firebaseLocalStorage')) {
          db.close();
          resolve(null);
          return;
        }
        const query = db.transaction('firebaseLocalStorage').objectStore('firebaseLocalStorage').getAll();
        query.onerror = () => {
          db.close();
          reject(query.error);
        };
        query.onsuccess = () => {
          db.close();
          const row = query.result.find(r => String(r.fbase_key).startsWith('firebase:authUser:'));
          if (!row) {
            resolve(null);
            return;
          }
          resolve({
            apiKey: row.fbase_key.split(':')[2],
            uid: row.value.uid,
            refreshToken: row.value.stsTokenManager.refreshToken,
            accessToken: row.value.stsTokenManager.accessToken,
            expirationTime: row.value.stsTokenManager.expirationTime,
          });
        };
      };
    });
  }

  async function getSession() {
    if (session && session.expirationTime - Date.now() > 60000) {
      return session;
    }
    const record = await readAuthRecord();
    if (!record) {
      throw new Error('Not signed in');
    }
    if (record.expirationTime - Date.now() > 60000) {
      session = record;
      return session;
    }
    const res = await fetch(`${TOKEN_URL}?key=${record.apiKey}`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: record.refreshToken }),
    });
    if (!res.ok) {
      throw new Error(`Token refresh failed (${res.status})`);
    }
    const json = await res.json();
    session = { ...record, accessToken: json.id_token, expirationTime: Date.now() + Number(json.expires_in) * 1000 };
    return session;
  }

  async function firestoreFetch(url, init = {}) {
    for (let attempt = 0; ; attempt++) {
      const s = await getSession();
      const res = await fetch(url, {
        ...init,
        headers: { Authorization: `Bearer ${s.accessToken}`, 'Content-Type': 'application/json' },
      });
      if (res.ok || res.status === 404) {
        return res;
      }
      if (!RETRYABLE_STATUS.has(res.status) || attempt >= 5) {
        throw new Error(`Firestore ${res.status}: ${(await res.text()).slice(0, 200)}`);
      }
      const wait = 1000 * 2 ** attempt;
      log(t('retrying', { status: res.status, s: wait / 1000 }));
      await sleep(wait);
    }
  }

  async function readFound() {
    const s = await getSession();
    const res = await firestoreFetch(`${FIRESTORE_API}${FIRESTORE_DOC}/users/${s.uid}`);
    if (res.status === 404) {
      return new Set();
    }
    const json = await res.json();
    const values = json.fields?.markerIds?.arrayValue?.values ?? [];
    return new Set(values.map(v => v.stringValue));
  }

  async function commitIds(op, ids) {
    const s = await getSession();
    const body = {
      writes: [{
        transform: {
          document: `${FIRESTORE_DOC}/users/${s.uid}`,
          fieldTransforms: [{ fieldPath: 'markerIds', [op]: { values: ids.map(id => ({ stringValue: id })) } }],
        },
      }],
    };
    await firestoreFetch(`${FIRESTORE_API}${FIRESTORE_DOC}:commit`, { method: 'POST', body: JSON.stringify(body) });
  }

  async function refreshFound() {
    try {
      found = await readFound();
      signedIn = true;
    } catch (e) {
      signedIn = false;
      if (e.message !== 'Not signed in') {
        log(t('readFoundFailed', { msg: e.message }), 'error');
      }
    }
    renderAll();
  }

  // -- marker data ------------------------------------------------------------
  async function loadMarkers() {
    log(t('fetchingMarkers'));
    const res = await fetch(MARKER_URL, { credentials: 'omit' });
    const json = await res.json();
    const idIdx    = json.headers.indexOf('id');
    const typeIdx  = json.headers.indexOf('type');
    const midIdx   = json.headers.indexOf('mid');
    const levelIdx = json.headers.indexOf('level');
    rows = json.data.map(r => ({ id: String(r[idIdx]), type: r[typeIdx], mid: r[midIdx], level: r[levelIdx] }));
    rowById = new Map(rows.map(r => [r.id, r]));
    idsByMidType = new Map();
    for (const r of rows) {
      if (!isMarkable(r)) {
        continue;
      }
      const key = `${r.mid}|${r.type}`;
      if (!idsByMidType.has(key)) {
        idsByMidType.set(key, []);
      }
      idsByMidType.get(key).push(r.id);
    }
    log(t('loadedMarkers', { n: rows.length }));
  }

  // -- reading names, order and maps from the site's own panel -----------------
  function mapSelectRoot() {
    return document.querySelector('.MapSelectorIcon')?.closest('.MuiInputBase-root');
  }

  function currentMapMid() {
    const value = mapSelectRoot()?.querySelector('input.MuiSelect-nativeInput')?.value;
    return value ? Number(value) : null;
  }

  function openMapSelect() {
    const trigger = mapSelectRoot()?.querySelector('[role="combobox"], [role="button"], .MuiSelect-select');
    if (!trigger) {
      return false;
    }
    trigger.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, button: 0 }));
    return true;
  }

  async function readMapOptions() {
    if (!openMapSelect()) {
      return [];
    }
    const first = await waitFor(() => document.querySelector('li[role="option"][data-value]'), 3000);
    if (!first) {
      return [];
    }
    const options = [...document.querySelectorAll('li[role="option"][data-value]')].map(li => ({
      mid:  Number(li.dataset.value),
      name: li.textContent.trim(),
    }));
    const current = document.querySelector(`li[role="option"][data-value="${currentMapMid()}"]`);
    (current || first).click();
    await waitFor(() => !document.querySelector('li[role="option"][data-value]'), 3000);
    return options;
  }

  function cleanName(text) {
    return String(text || '').replace(/ /g, ' ').trim();
  }

  function readLayoutFromDom() {
    const cats = [];
    for (const id of CATEGORY_IDS) {
      const host = $(`marker-cat-${id}`);
      if (!host) {
        continue;
      }
      const types = [...host.querySelectorAll('button[data-testid^="btn-o"]')].map(btn => ({
        oid:  btn.dataset.testid.slice(4),
        name: cleanName(btn.querySelector(':scope > span:not(.MuiButton-icon):not(.MuiTouchRipple-root)')?.textContent || btn.title),
        icon: btn.querySelector('img')?.src || '',
      }));
      cats.push({ id, label: cleanName(host.querySelector('span.uppercase')?.textContent) || id, types });
    }
    return cats;
  }

  async function captureLayout(mid) {
    const cats = readLayoutFromDom();
    if (!cats.some(c => c.types.length)) {
      return false;
    }
    layouts[mid] = cats;
    return true;
  }

  async function switchSiteMap(mid) {
    if (currentMapMid() === mid) {
      return true;
    }
    const sidebarItem = document.querySelector(`.MapSidebarMenu li:has(img[src$="/icons/map-${mid}.png"])`);
    if (sidebarItem) {
      sidebarItem.click();
    } else {
      if (!openMapSelect()) {
        return false;
      }
      const option = await waitFor(() => document.querySelector(`li[role="option"][data-value="${mid}"]`), 3000);
      if (!option) {
        return false;
      }
      option.click();
    }
    const switched = await waitFor(() => currentMapMid() === mid, 5000);
    await sleep(800);
    return !!switched;
  }

  async function selectArea(mid) {
    switching = true;
    selectedMid = mid;
    try {
      if (!(await switchSiteMap(mid)) || !(await captureLayout(mid))) {
        log(t('layoutFailed', { name: mapName(mid) }), 'error');
      }
      await reconcileWithSite();
    } finally {
      switching = false;
    }
    saveOpts();
    renderAll();
  }

  async function followSiteMap(mid) {
    switching = true;
    selectedMid = mid;
    try {
      await sleep(800);
      await captureLayout(mid);
      await reconcileWithSite();
    } finally {
      switching = false;
    }
    saveOpts();
    renderAll();
  }

  // -- two-way sync with the site's own type toggles and hide-found switch -----
  function siteTypeSelected() {
    return window._store?.getState?.()?.marker?.typeSelected ?? null;
  }

  function layoutTypeIds() {
    return (layouts[selectedMid] || []).flatMap(c => c.types.map(x => x.oid)).filter(oid => idsOf(oid).length > 0);
  }

  async function pushToSite(oids) {
    syncLock++;
    try {
      const siteState = siteTypeSelected() || {};
      let clicks = 0;
      for (const oid of oids) {
        if (selected.has(oid) === (siteState[oid] === true)) {
          continue;
        }
        document.querySelector(`button[data-testid="btn-${oid}"]`)?.click();
        clicks++;
        if (clicks % 10 === 0) {
          await sleep(0);
        }
      }
      await sleep(250);
    } finally {
      syncLock--;
      if (syncLock === 0) {
        lastTypeSelected = siteTypeSelected();
      }
    }
  }

  function pullFromSite() {
    const siteState = siteTypeSelected();
    if (!siteState || syncLock > 0 || switching) {
      return;
    }
    for (const oid of layoutTypeIds()) {
      setSelected(oid, siteState[oid] === true);
    }
    saveOpts();
    renderCategories();
    renderButtons();
  }

  async function reconcileWithSite() {
    const siteState = siteTypeSelected();
    if (!siteState) {
      return;
    }
    const oids = layoutTypeIds();
    for (const oid of oids) {
      if (siteState[oid] === true) {
        selected.add(oid);
      }
    }
    await pushToSite(oids);
  }

  function startStoreSync() {
    if (!window._store?.subscribe) {
      return;
    }
    lastTypeSelected = siteTypeSelected();
    window._store.subscribe(() => {
      const siteState = siteTypeSelected();
      if (siteState === lastTypeSelected) {
        return;
      }
      lastTypeSelected = siteState;
      if (syncLock === 0 && !switching) {
        clearTimeout(pullTimer);
        pullTimer = setTimeout(pullFromSite, 150);
      }
    });
  }

  function hideFoundInput() {
    const inputs = document.querySelectorAll('.d-block > .pt-2 input.MuiSwitch-input');
    return inputs.length ? inputs[inputs.length - 1] : null;
  }

  function setHideFoundSwitch(on) {
    const input = hideFoundInput();
    if (input && input.checked !== on) {
      input.click();
    }
  }

  async function pollSite() {
    if (busy || switching) {
      return;
    }
    if (autoHideFound) {
      setHideFoundSwitch(true);
    }
    const mid = currentMapMid();
    if (mid != null && mid !== selectedMid && mapOptions.length) {
      await followSiteMap(mid);
    }
  }

  function mapName(mid) {
    return mapOptions.find(o => o.mid === mid)?.name || t('mapFallback', { mid });
  }

  function typeName(oid) {
    for (const mid of Object.keys(layouts)) {
      for (const cat of layouts[mid]) {
        const t = cat.types.find(x => x.oid === oid);
        if (t) {
          return t.name;
        }
      }
    }
    return oid;
  }

  // -- selection helpers ------------------------------------------------------
  function idsOf(oid) {
    return idsByMidType.get(`${selectedMid}|${oid}`) || [];
  }

  function poolFor(wantFound) {
    const ids = [];
    for (const oid of selected) {
      for (const id of idsOf(oid)) {
        if (found.has(id) === wantFound) {
          ids.push(id);
        }
      }
    }
    return ids;
  }

  function invalidMarks() {
    return [...found].filter(id => {
      const row = rowById.get(id);
      return row && !isMarkable(row);
    });
  }

  // -- operations -------------------------------------------------------------
  function saveBackup() {
    try {
      localStorage.setItem(STORAGE_BACKUP, JSON.stringify({ uid: session?.uid, time: new Date().toISOString(), ids: [...found] }));
    } catch (e) {
      log(t('saveBackupFailed', { msg: e.message }), 'error');
    }
  }

  function loadBackup() {
    try {
      return JSON.parse(localStorage.getItem(STORAGE_BACKUP) || 'null');
    } catch (e) {
      return null;
    }
  }

  function setProgress(done, total) {
    const pct = total > 0 ? Math.round(done / total * 100) : 0;
    $('am-bar').style.width = `${pct}%`;
    $('am-bar-lbl').textContent = total > 0 ? `${done} / ${total}  (${pct}%)` : '';
  }

  async function writeInBatches(op, ids, label, keepBackup = false) {
    if (busy) {
      log(t('alreadyRunning'));
      return;
    }
    if (!ids.length) {
      log(t('nothingToDo'));
      return;
    }
    busy = true;
    stopFlag = false;
    let committed = false;
    renderButtons();
    try {
      await refreshFound();
      if (!keepBackup) {
        saveBackup();
      }
      const batch = Math.max(1, Number($('am-batch').value) || 500);
      const delay = Math.max(0, Number($('am-delay').value) || 0);
      log(t('opStart', { op: label, n: ids.length, b: Math.ceil(ids.length / batch) }));
      let done = 0;
      setProgress(0, ids.length);
      for (let i = 0; i < ids.length; i += batch) {
        if (stopFlag) {
          log(t('opStopped', { done, total: ids.length }));
          break;
        }
        const chunk = ids.slice(i, i + batch);
        await commitIds(op, chunk);
        committed = true;
        for (const id of chunk) {
          if (op === 'appendMissingElements') {
            found.add(id);
          } else {
            found.delete(id);
          }
        }
        done += chunk.length;
        setProgress(done, ids.length);
        vlog(t('batchCommitted', { done, total: ids.length }));
        if (i + batch < ids.length && delay > 0) {
          await sleep(delay);
        }
      }
      if (done === ids.length) {
        log(t('opDone', { op: label, n: done }));
      }
    } catch (e) {
      log(t('opFailed', { op: label, msg: e.message }), 'error');
    } finally {
      busy = false;
      await refreshFound();
      if (committed && !(await refreshSiteFoundState())) {
        log(t('reloadNeeded'), 'error');
      }
      renderButtons();
    }
  }

  function findFoundLoader() {
    let webpackRequire;
    window.webpackChunk_N_E?.push([[Symbol('auto-mark')], {}, r => {
      webpackRequire = r;
    }]);
    if (!webpackRequire?.m) {
      return null;
    }
    const moduleId = Object.keys(webpackRequire.m).find(id => String(webpackRequire.m[id]).includes('firestore.marker_loaded'));
    if (moduleId === undefined) {
      return null;
    }
    return Object.values(webpackRequire(moduleId)).find(v => typeof v === 'function' && String(v).includes('firestore.marker_loaded')) ?? null;
  }

  async function refreshSiteFoundState() {
    try {
      const loader = findFoundLoader();
      if (!loader) {
        return false;
      }
      const s = await getSession();
      // The site caches the loaded user by uid string. Slashes at the ends keep the same Firestore path
      // but make the string differ from the cached one, which forces a real reload.
      const variants = [`${s.uid}/`, `/${s.uid}`, `/${s.uid}/`];
      await loader(variants[reloadCount++ % variants.length]);
      return true;
    } catch (e) {
      log(e.message, 'error');
      return false;
    }
  }

  async function restoreBackup() {
    const backup = loadBackup();
    if (!backup) {
      log(t('noBackup'), 'error');
      return;
    }
    if (!confirm(t('confirmRestore', { time: backup.time, n: backup.ids.length }))) {
      return;
    }
    await refreshFound();
    const wanted = new Set(backup.ids);
    const toAdd = backup.ids.filter(id => !found.has(id));
    const toRemove = [...found].filter(id => !wanted.has(id));
    log(t('restoring', { add: toAdd.length, remove: toRemove.length }));
    if (toAdd.length) {
      await writeInBatches('appendMissingElements', toAdd, t('opRestoreAdd'), true);
    }
    if (toRemove.length) {
      await writeInBatches('removeAllFromArray', toRemove, t('opRestoreRemove'), true);
    }
  }

  function fixInvalidMarks() {
    const invalid = invalidMarks();
    if (!invalid.length) {
      log(t('noInvalid'));
      return;
    }
    const perType = {};
    for (const id of invalid) {
      const oid = rowById.get(id).type;
      perType[oid] = (perType[oid] || 0) + 1;
    }
    const summary = Object.entries(perType).map(([oid, n]) => `${typeName(oid)}: ${n}`).join('\n');
    if (!confirm(`${t('confirmFix', { n: invalid.length })}\n\n${summary}`)) {
      return;
    }
    writeInBatches('removeAllFromArray', invalid, t('opFix'));
  }

  // -- UI ---------------------------------------------------------------------
  const HIDE_CSS = `
    [id^="pc-br-300x250-gim-"], [id^="pc-br-300x250-gim-"] iframe, avp-player-ui,
    .MapRightbar_Main > div:has(> [id^="pc-br2-nc-gim-"]), #ncmp__tool{display:none !important}
  `;

  const CSS = `
    #am-panel{position:fixed;bottom:100px;right:10px;z-index:2147483647;background:#1e1e2e;color:#cdd6f4;
      font:12px monospace;width:360px;border-radius:8px;box-shadow:0 4px 20px rgba(0,0,0,.7);
      border:1px solid #45475a;display:flex;flex-direction:column;max-height:calc(100vh - 120px)}
    #am-panel button{border:none;border-radius:5px;padding:6px;cursor:pointer;font-weight:bold;color:#1e1e2e}
    #am-panel button:disabled{opacity:.45;cursor:default}
    #am-header{background:#313244;padding:8px 12px;cursor:move;display:flex;justify-content:space-between;
      align-items:center;border-radius:8px 8px 0 0}
    #am-body{padding:10px;overflow-y:auto}
    #am-status{background:#181825;border-radius:5px;padding:7px;margin-bottom:8px;font-size:11px;color:#a6adc8;line-height:1.5}
    #am-panel select,#am-panel input[type=number]{width:100%;background:#313244;border:1px solid #45475a;color:#cdd6f4;
      border-radius:4px;padding:3px;box-sizing:border-box}
    #am-cats{background:#181825;border-radius:4px;padding:4px 6px;margin:8px 0;max-height:300px;overflow-y:auto}
    #am-cats .am-cat-head{display:flex;align-items:center;justify-content:space-between;padding:3px 0;color:#f9e2af;font-weight:bold}
    #am-cats .am-cat-head label{flex:1}
    #am-cats .am-cat-head button{width:22px;padding:0;background:#313244;color:#cdd6f4}
    #am-cats [hidden]{display:none}
    #am-cats label{display:flex;align-items:center;gap:6px;line-height:1.7;cursor:pointer}
    #am-cats label img{width:18px;height:18px}
    #am-cats .am-name{flex:1}
    #am-cats .am-count{color:#6c7086}
    .am-row{display:flex;gap:6px;margin-bottom:6px}
    .am-err{color:#f38ba8}
    #am-log{background:#181825;border-radius:4px;height:110px;overflow-y:auto;padding:5px 7px;font-size:10px;
      color:#bac2de;line-height:1.5}
  `;

  function buildUI() {
    if ($('am-panel')) {
      return;
    }
    const style = document.createElement('style');
    style.textContent = CSS + HIDE_CSS;
    document.head.appendChild(style);

    const panel = document.createElement('div');
    panel.id = 'am-panel';
    panel.innerHTML = `
      <div id="am-header">
        <span style="font-weight:bold;color:#cba6f7">Auto-Mark v${VERSION}</span>
        <span>
          <span id="am-min" style="cursor:pointer;font-size:16px;margin-right:6px">v</span>
          <span id="am-close" style="cursor:pointer;font-size:14px;color:#f38ba8">x</span>
        </span>
      </div>
      <div id="am-body">
        <div id="am-status" data-i18n="loading"></div>

        <button id="am-incomplete" style="width:100%;background:#94e2d5;margin-bottom:8px" data-i18n="selectIncomplete"></button>

        <label style="color:#a6adc8" data-i18n="area"></label>
        <select id="am-area"></select>

        <div id="am-cats"></div>

        <div class="am-row">
          <div style="flex:1"><label style="color:#a6adc8" data-i18n="batchSize"></label>
            <input id="am-batch" type="number" min="1" max="2000" value="500"/></div>
          <div style="flex:1"><label style="color:#a6adc8" data-i18n="delayMs"></label>
            <input id="am-delay" type="number" min="0" max="10000" value="1500"/></div>
        </div>

        <label style="display:flex;align-items:center;gap:6px;color:#a6adc8;margin-bottom:6px">
          <input id="am-autohide" type="checkbox"/><span data-i18n="autoHideFound"></span></label>

        <div class="am-row">
          <button id="am-mark" style="flex:2;background:#a6e3a1"></button>
          <button id="am-unmark" style="flex:2;background:#cba6f7"></button>
          <button id="am-stop" style="flex:1;background:#f38ba8" data-i18n="stop"></button>
        </div>
        <div class="am-row">
          <button id="am-fix" style="flex:1;background:#f9e2af"></button>
          <button id="am-restore" style="flex:1;background:#fab387" data-i18n="restoreBackup"></button>
        </div>
        <div class="am-row">
          <button id="am-refresh" style="flex:1;background:#89dceb" data-i18n="refresh"></button>
          <button id="am-reload" style="flex:1;background:#74c7ec" data-i18n="reloadPage"></button>
          <label style="display:flex;align-items:center;gap:4px;color:#a6adc8">
            <input id="am-verbose" type="checkbox"/><span data-i18n="verbose"></span></label>
        </div>

        <div style="background:#313244;border-radius:4px;height:8px;margin-bottom:3px">
          <div id="am-bar" style="height:8px;width:0%;background:#cba6f7;border-radius:4px;transition:width .15s"></div>
        </div>
        <div id="am-bar-lbl" style="font-size:10px;color:#6c7086;text-align:right;margin-bottom:5px"></div>
        <div id="am-log"></div>
      </div>`;
    document.body.appendChild(panel);
    makeDraggable(panel, $('am-header'));

    let mini = false;
    $('am-min').onclick = () => {
      mini = !mini;
      $('am-body').style.display = mini ? 'none' : 'block';
      $('am-min').textContent = mini ? '>' : 'v';
    };
    $('am-close').onclick = () => panel.remove();

    $('am-area').onchange = e => selectArea(Number(e.target.value));
    $('am-cats').onchange = onCategoryChange;
    $('am-cats').onclick = e => {
      const catId = e.target.dataset.toggle;
      if (!catId) {
        return;
      }
      if (collapsedCats.has(catId)) {
        collapsedCats.delete(catId);
      } else {
        collapsedCats.add(catId);
      }
      saveOpts();
      renderCategories();
    };
    $('am-mark').onclick = () => writeInBatches('appendMissingElements', poolFor(false), t('opMark'));
    $('am-unmark').onclick = () => {
      const ids = poolFor(true);
      if (ids.length && confirm(t('confirmUnmark', { n: ids.length }))) {
        writeInBatches('removeAllFromArray', ids, t('opUnmark'));
      }
    };
    $('am-incomplete').onclick = () => {
      const oids = layoutTypeIds();
      for (const oid of oids) {
        setSelected(oid, idsOf(oid).some(id => !found.has(id)));
      }
      saveOpts();
      renderCategories();
      renderButtons();
      pushToSite(oids);
    };
    $('am-stop').onclick = () => {
      stopFlag = true;
      log(t('stopRequested'));
    };
    $('am-fix').onclick = fixInvalidMarks;
    $('am-restore').onclick = restoreBackup;
    $('am-refresh').onclick = async () => {
      await refreshFound();
      log(t('refreshed'));
    };
    $('am-reload').onclick = () => location.reload();
    $('am-verbose').onchange = e => {
      verbose = e.target.checked;
    };
    $('am-autohide').onchange = e => {
      autoHideFound = e.target.checked;
      setHideFoundSwitch(autoHideFound);
      saveOpts();
    };
    document.addEventListener('change', e => {
      if (e.target === hideFoundInput() && e.target.checked !== autoHideFound) {
        autoHideFound = e.target.checked;
        $('am-autohide').checked = autoHideFound;
        saveOpts();
      }
    }, true);
    $('am-batch').onchange = saveOpts;
    $('am-delay').onchange = saveOpts;

    const saved = loadOpts();
    if (saved.batch) {
      $('am-batch').value = saved.batch;
    }
    if (saved.delay != null) {
      $('am-delay').value = saved.delay;
    }
    selected = new Set(saved.selected || []);
    collapsedCats = new Set(saved.collapsed || []);
    autoHideFound = saved.autoHideFound === true;
    $('am-autohide').checked = autoHideFound;
    selectedMid = saved.mid ?? null;
  }

  function onCategoryChange(e) {
    const target = e.target;
    if (target.dataset.cat) {
      const oids = [];
      for (const cb of $('am-cats').querySelectorAll(`input[data-in-cat="${target.dataset.cat}"]`)) {
        cb.checked = target.checked;
        setSelected(cb.dataset.type, target.checked);
        oids.push(cb.dataset.type);
      }
      pushToSite(oids);
    } else if (target.dataset.type) {
      setSelected(target.dataset.type, target.checked);
      syncCategoryBox(target.dataset.inCat);
      pushToSite([target.dataset.type]);
    }
    saveOpts();
    renderButtons();
  }

  function setSelected(oid, on) {
    if (on) {
      selected.add(oid);
    } else {
      selected.delete(oid);
    }
  }

  function syncCategoryBox(catId) {
    const box = $('am-cats').querySelector(`input[data-cat="${catId}"]`);
    const items = [...$('am-cats').querySelectorAll(`input[data-in-cat="${catId}"]`)];
    if (!box || !items.length) {
      return;
    }
    const checked = items.filter(i => i.checked).length;
    box.checked = checked === items.length;
    box.indeterminate = checked > 0 && checked < items.length;
  }

  function renderAreas() {
    const sel = $('am-area');
    if (!sel) {
      return;
    }
    sel.innerHTML = '';
    for (const o of mapOptions) {
      const opt = document.createElement('option');
      opt.value = o.mid;
      opt.textContent = o.name;
      sel.appendChild(opt);
    }
    if (selectedMid != null) {
      sel.value = String(selectedMid);
    }
  }

  function renderCategories() {
    const host = $('am-cats');
    if (!host) {
      return;
    }
    const scrollTop = host.scrollTop;
    host.innerHTML = '';
    const layout = layouts[selectedMid];
    if (!layout) {
      host.textContent = t('openMarkersTab');
      return;
    }
    for (const cat of layout) {
      const types = cat.types.filter(t => idsOf(t.oid).length > 0);
      if (!types.length) {
        continue;
      }
      const section = document.createElement('div');
      const collapsed = collapsedCats.has(cat.id);
      const head = document.createElement('div');
      head.className = 'am-cat-head';
      const headLabel = document.createElement('label');
      const box = document.createElement('input');
      box.type = 'checkbox';
      box.dataset.cat = cat.id;
      const title = document.createElement('span');
      title.textContent = cat.label;
      headLabel.append(box, title);
      const toggle = document.createElement('button');
      toggle.dataset.toggle = cat.id;
      toggle.textContent = collapsed ? '+' : '-';
      head.append(headLabel, toggle);
      section.appendChild(head);
      const body = document.createElement('div');
      body.hidden = collapsed;
      section.appendChild(body);
      for (const t of types) {
        const ids = idsOf(t.oid);
        const foundCount = ids.filter(id => found.has(id)).length;
        const label = document.createElement('label');
        const cb = document.createElement('input');
        cb.type = 'checkbox';
        cb.dataset.type = t.oid;
        cb.dataset.inCat = cat.id;
        cb.checked = selected.has(t.oid);
        const img = document.createElement('img');
        img.src = t.icon;
        const name = document.createElement('span');
        name.className = 'am-name';
        name.textContent = t.name;
        const count = document.createElement('span');
        count.className = 'am-count';
        count.textContent = `${foundCount}/${ids.length}`;
        label.append(cb, img, name, count);
        body.appendChild(label);
      }
      host.appendChild(section);
      syncCategoryBox(cat.id);
    }
    host.scrollTop = scrollTop;
  }

  function renderStatus() {
    const el = $('am-status');
    if (!el) {
      return;
    }
    const markable = rows.filter(isMarkable).length;
    const invalid = invalidMarks().length;
    el.innerHTML =
      `<div><b style="color:#f9e2af">${t('signedIn')}</b> ${signedIn ? t('yes') : `<span class="am-err">${t('signInFirst')}</span>`}</div>` +
      `<div><b style="color:#f9e2af">${t('markable')}</b> ${t('markableOf', { n: markable, total: rows.length })}</div>` +
      `<div><b style="color:#f9e2af">${t('foundInAccount')}</b> ${signedIn ? found.size : '-'}</div>` +
      `<div><b style="color:#f9e2af">${t('invalidMarks')}</b> ${signedIn ? invalid : '-'}</div>`;
  }

  function renderButtons() {
    const ready = signedIn && !busy && selectedMid != null;
    const pending = poolFor(false).length;
    const done = poolFor(true).length;
    $('am-mark').disabled = !ready || pending === 0;
    $('am-mark').textContent = t('markSelected', { n: pending });
    $('am-unmark').disabled = !ready || done === 0;
    $('am-unmark').textContent = t('unmarkSelected', { n: done });
    $('am-stop').disabled = !busy;
    $('am-incomplete').disabled = !signedIn || busy || selectedMid == null;
    $('am-fix').disabled = !signedIn || busy || invalidMarks().length === 0;
    $('am-fix').textContent = t('fixInvalid', { n: signedIn ? invalidMarks().length : 0 });
    $('am-restore').disabled = !signedIn || busy || !loadBackup();
  }

  function applyStaticTexts() {
    for (const el of document.querySelectorAll('#am-panel [data-i18n]')) {
      el.textContent = t(el.dataset.i18n);
    }
  }

  function renderAll() {
    applyStaticTexts();
    renderStatus();
    renderAreas();
    renderCategories();
    renderButtons();
  }

  function makeDraggable(el, handle) {
    handle.addEventListener('mousedown', e => {
      if (e.target.id === 'am-min' || e.target.id === 'am-close') {
        return;
      }
      e.preventDefault();
      const ox = e.clientX - el.offsetLeft;
      const oy = e.clientY - el.offsetTop;
      const move = e2 => {
        el.style.left = `${e2.clientX - ox}px`;
        el.style.top = `${e2.clientY - oy}px`;
        el.style.right = 'auto';
        el.style.bottom = 'auto';
      };
      const up = () => {
        document.removeEventListener('mousemove', move);
        document.removeEventListener('mouseup', up);
      };
      document.addEventListener('mousemove', move);
      document.addEventListener('mouseup', up);
    });
  }

  async function onLanguageChange() {
    const detected = detectLang();
    if (detected === lang || busy) {
      return;
    }
    lang = detected;
    await sleep(1000);
    mapOptions = await readMapOptions();
    await captureLayout(currentMapMid());
    renderAll();
  }

  // -- boot -------------------------------------------------------------------
  async function init() {
    console.log(`[AutoMark] init, version ${VERSION}`);
    lang = detectLang();
    buildUI();
    try {
      await loadMarkers();
    } catch (e) {
      log(t('loadFailed', { msg: e.message }), 'error');
      return;
    }
    const panelReady = await waitFor(() => $('marker-cat-featured') && mapSelectRoot(), 60000);
    if (!panelReady) {
      log(t('panelMissing'), 'error');
    } else {
      mapOptions = await readMapOptions();
      const mid = currentMapMid();
      await captureLayout(mid);
      if (selectedMid == null || !mapOptions.some(o => o.mid === selectedMid)) {
        selectedMid = mid;
        await reconcileWithSite();
      } else if (selectedMid !== mid) {
        await selectArea(selectedMid);
      } else {
        await reconcileWithSite();
      }
      startStoreSync();
    }
    await refreshFound();
    setInterval(async () => {
      if (!signedIn && !busy) {
        await refreshFound();
      }
    }, 5000);
    setInterval(onLanguageChange, 2000);
    setInterval(pollSite, 1000);
  }

  init();
})();