fork/replay-manager-for-slippi

git clone https://git.julia.blue/fork/replay-manager-for-slippi

Nicoletslp-enforcer v2.3.268c0e0e

2.3.7
116.0 KiB3364 linesraw
1import { MemoryRouter as Router, Routes, Route } from 'react-router-dom';
2import {
3  createRef,
4  RefObject,
5  useCallback,
6  useEffect,
7  useMemo,
8  useRef,
9  useState,
10} from 'react';
11import {
12  Alert,
13  AppBar,
14  Avatar,
15  Backdrop,
16  Box,
17  Button,
18  Checkbox,
19  CircularProgress,
20  Dialog,
21  DialogActions,
22  DialogContent,
23  DialogTitle,
24  Divider,
25  FormControl,
26  IconButton,
27  InputBase,
28  InputLabel,
29  List,
30  ListItem,
31  ListItemButton,
32  ListItemText,
33  MenuItem,
34  Paper,
35  Select,
36  Stack,
37  Toolbar,
38  Tooltip,
39  Typography,
40} from '@mui/material';
41import {
42  ArrowDownward,
43  ArrowUpward,
44  Backup,
45  Close,
46  DeleteForever,
47  DeleteForeverOutlined,
48  Edit,
49  Eject,
50  FolderOpen,
51  HourglassTop,
52  NotificationsActive,
53  Refresh,
54  Search,
55} from '@mui/icons-material';
56import styled from '@emotion/styled';
57import { format } from 'date-fns';
58import { GlobalHotKeys } from 'react-hotkeys';
59import {
60  SlugType,
61  Tournament as ParryggTournament,
62  MatchResult,
63} from '@parry-gg/client';
64import {
65  AdminedTournament,
66  ChallongeMatchItem,
67  ChallongeTournament,
68  Context,
69  ContextPlayers,
70  ContextScore,
71  ContextSlot,
72  CopyHostFormat,
73  CopyHostOrClient,
74  CopySettings,
75  EnforcerSetting,
76  GuideState,
77  Id,
78  InvalidReplay,
79  Mode,
80  OfflineModeStatus,
81  Output,
82  PlayerOverrides,
83  RendererOfflineModeTournament,
84  Replay,
85  ReportSettings,
86  SelectedSetChain,
87  Set,
88  SlpDownloadStatus,
89  StartggSet,
90  State,
91  Stream,
92  Tournament,
93} from '../common/types';
94import { DraggableChip, DroppableChip } from './DragAndDrop';
95import ReplayList, { SkewReplay } from './ReplayList';
96import CopyControls from './CopyControls';
97import SetControls from './SetControls';
98import ErrorDialog from './ErrorDialog';
99import Settings from './Settings';
100import ManualReport from './ManualReport';
101import {
102  calledColor,
103  characterColorIndexLength,
104  characterNames,
105  frameMsDivisor,
106  stageNames,
107  startedColor,
108} from '../common/constants';
109import ManualBar from './ManualBar';
110import GuidedDialog from './GuidedDialog';
111import StartggTournamentForm from './StartggTournamentForm';
112import ChallongeTournamentForm from './ChallongeTournamentForm';
113import ParryggTournamentForm from './ParryggTournamentForm';
114import ResetSet from './ResetSet';
115import AssignStream from './AssignStream';
116import getCharacterIcon from './getCharacterIcon';
117import RightColumn from './RightColumn';
118import { WindowEvent } from './setWindowEventListener';
119import SlpDownloadModal from './SlpDownloadModal';
120import { assertInteger, assertString } from '../common/asserts';
121import OfflineModeConnection from './OfflineModeConnection';
122
123const ENFORCER_VERSION = '2.3.2';
124
125const Bottom = styled(Paper)`
126  height: 147px;
127`;
128
129const BottomColumns = styled(Stack)`
130  box-sizing: border-box;
131  height: 100%;
132  padding: 8px;
133`;
134
135const TopColumns = styled(Stack)`
136  flex-grow: 1;
137  max-height: calc(100% - 147px);
138  padding: 0 8px;
139`;
140
141const TopColumn = styled(Stack)`
142  flex-shrink: 1;
143  overflow-y: scroll;
144  padding: 64px 0 8px;
145  scroll-padding-top: 64px;
146`;
147
148const AppBarSection = styled(Stack)`
149  flex-shrink: 1;
150  padding: 8px;
151`;
152
153const EMPTY_SET: Set = {
154  id: 0,
155  sggId: null,
156  state: State.PENDING,
157  round: 0,
158  fullRoundText: '',
159  winnerId: null,
160  entrant1Id: 0,
161  entrant1Participants: [
162    {
163      id: 0,
164      displayName: '',
165      prefix: '',
166      pronouns: '',
167    },
168  ],
169  entrant1Score: null,
170  entrant2Id: 0,
171  entrant2Participants: [
172    {
173      id: 0,
174      displayName: '',
175      prefix: '',
176      pronouns: '',
177    },
178  ],
179  entrant2Score: null,
180  gameScores: [],
181  stream: null,
182  station: null,
183  ordinal: null,
184  wasReported: false,
185  updatedAtMs: 0,
186  completedAtMs: 0,
187};
188
189const EMPTY_SELECTED_SET_CHAIN: SelectedSetChain = {
190  event: undefined,
191  phase: undefined,
192  phaseGroup: undefined,
193};
194
195function hasTimeSkew(replays: Replay[]) {
196  if (replays.length < 2) {
197    return false;
198  }
199
200  for (let i = 0; i < replays.length - 1; i += 1) {
201    const firstMs = replays[i].startAt.getTime();
202    const secondMs = replays[i + 1].startAt.getTime();
203    if (secondMs - firstMs > 3600000) {
204      return true;
205    }
206  }
207  return false;
208}
209
210function applyAllReplaysSelected(allReplays: Replay[], selected: boolean) {
211  allReplays
212    .filter((replay) => replay.invalidReasons.length === 0)
213    .forEach((replay) => {
214      replay.selected = selected;
215    });
216}
217
218function Hello() {
219  const [slpDownloadStatus, setSlpDownloadStatus] = useState<SlpDownloadStatus>(
220    { status: 'idle' },
221  );
222
223  useEffect(() => {
224    const handler = (_event: any, status: SlpDownloadStatus) => {
225      setSlpDownloadStatus(status);
226    };
227    window.electron.onSlpDownloadStatus(handler);
228  }, []);
229
230  const [errors, setErrors] = useState<string[]>([]);
231  const [errorDialogOpen, setErrorDialogOpen] = useState(false);
232  const showErrorDialog = (messages: string[]) => {
233    setErrors(messages);
234    setErrorDialogOpen(true);
235  };
236
237  // settings
238  const [mode, setMode] = useState<Mode>(Mode.STARTGG);
239  const [enforcerSetting, setEnforcerSetting] = useState(EnforcerSetting.NONE);
240  const [vlerkMode, setVlerkMode] = useState(false);
241  const [vlerkModeExternalId, setVlerkModeExternalId] = useState(-1);
242  const [vlerkModeColorIndex, setVlerkModeColorIndex] = useState(-1);
243  const [vlerkModeFilterLastIndex, setVlerkModeFilterLastIndex] = useState(0);
244  const [vlerkModeFilterNotFound, setVlerkModeFilterNotFound] = useState(false);
245  const [guidedMode, setGuidedMode] = useState(false);
246  const [fileNameFormat, setFileNameFormat] = useState('');
247  const [folderNameFormat, setFolderNameFormat] = useState('');
248  const [smuggleCostumeIndex, setSmuggleCostumeIndex] = useState(false);
249  const [appVersion, setAppVersion] = useState('');
250  const [latestAppVersion, setLatestAppVersion] = useState('');
251  const [hideCopyButton, setHideCopyButton] = useState(false);
252  const [copySettings, setCopySettings] = useState<CopySettings>({
253    output: Output.FILES,
254    writeContext: false,
255    writeDisplayNames: false,
256    writeFileNames: false,
257    writeStartTimes: false,
258  });
259  const [reportSettings, setReportSettings] = useState<ReportSettings>({
260    alsoCopy: false,
261    alsoDelete: false,
262  });
263  const [adminedTournaments, setAdminedTournaments] = useState<
264    AdminedTournament[]
265  >([]);
266  const [gettingAdminedTournaments, setGettingAdminedTournaments] =
267    useState(true);
268
269  // initial state
270  const [dir, setDir] = useState('');
271  const [dirInit, setDirInit] = useState(false);
272  const [isUsb, setIsUsb] = useState(false);
273  const [copyDir, setCopyDir] = useState('');
274  const [host, setHost] = useState<CopyHostOrClient>({
275    name: '',
276    address: '',
277  });
278  const [hostFormat, setHostFormat] = useState<CopyHostFormat>({
279    fileNameFormat: '',
280    folderNameFormat: '',
281  });
282  const [useLAN, setUseLAN] = useState(false);
283  const [selectedSet, setSelectedSet] = useState<Set>(EMPTY_SET);
284  const [selectedSetChain, setSelectedSetChain] = useState(
285    EMPTY_SELECTED_SET_CHAIN,
286  );
287  const [startggTournament, setStartggTournament] = useState<Tournament>({
288    slug: '',
289    name: '',
290    location: '',
291    events: [],
292    stations: [],
293    streams: [],
294  });
295  const [challongeTournaments, setChallongeTournaments] = useState(
296    new Map<string, ChallongeTournament>(),
297  );
298  const [selectedChallongeTournament, setSelectedChallongeTournament] =
299    useState({ name: '', slug: '', tournamentType: '' });
300  const [parryggTournament, setParryggTournament] =
301    useState<ParryggTournament.AsObject>();
302  const parryggSlug = useMemo(
303    () =>
304      parryggTournament?.slugsList.find(
305        (slug) => slug.type === SlugType.SLUG_TYPE_PRIMARY,
306      )?.slug || '',
307    [parryggTournament],
308  );
309  const [offlineModeStatus, setOfflineModeStatus] = useState<OfflineModeStatus>(
310    {
311      addressOrHost: '',
312      error: '',
313    },
314  );
315  const [offlineModeTournament, setOfflineModeTournament] =
316    useState<RendererOfflineModeTournament>({
317      id: 0,
318      name: '',
319      slug: '',
320      location: '',
321      events: [],
322      participants: [],
323      stations: [],
324      streams: [],
325    });
326  const [manualNames, setManualNames] = useState<string[]>([]);
327  const [undoSubdir, setUndoSubdir] = useState('');
328  const tournamentSet = useMemo(
329    () =>
330      (mode === Mode.STARTGG && startggTournament.slug.length > 0) ||
331      (mode === Mode.CHALLONGE && challongeTournaments.size > 0) ||
332      (mode === Mode.PARRYGG && parryggSlug.length > 0) ||
333      (mode === Mode.OFFLINE_MODE &&
334        offlineModeStatus.addressOrHost.length > 0 &&
335        offlineModeStatus.error.length === 0) ||
336      (mode === Mode.MANUAL && manualNames.length > 0),
337    [
338      challongeTournaments,
339      manualNames.length,
340      mode,
341      offlineModeStatus,
342      parryggSlug,
343      startggTournament,
344    ],
345  );
346  const copyDirSet = useMemo(() => copyDir.length > 0, [copyDir]);
347  const guidedDialogOpen = useMemo(
348    () => guidedMode && (!tournamentSet || !copyDirSet),
349    [copyDirSet, guidedMode, tournamentSet],
350  );
351  useEffect(() => {
352    const inner = async () => {
353      const appVersionPromise = window.electron.getVersion();
354      const modePromise = window.electron.getMode();
355      const useLANPromise = window.electron.getUseLAN();
356      const enforcerSettingPromise = window.electron.getEnforcerSetting();
357      const vlerkModePromise = window.electron.getVlerkMode();
358      const guidedModePromise = window.electron.getGuidedMode();
359      const fileNameFormatPromise = window.electron.getFileNameFormat();
360      const folderNameFormatPromise = window.electron.getFolderNameFormat();
361      const smuggleCostumeIndexPromise =
362        window.electron.getSmuggleCostumeIndex();
363      const hideCopyButtonPromise = window.electron.getHideCopyButton();
364      const copySettingsPromise = window.electron.getCopySettings();
365      const reportSettingsPromise = window.electron.getReportSettings();
366
367      // initial state
368      const replaysDirPromise = window.electron.getReplaysDir();
369      const copyDirPromise = window.electron.getCopyDir();
370      const hostPromise = window.electron.getCopyHost();
371      const hostFormatPromise = window.electron.getCopyHostFormat();
372      const tournamentPromise = window.electron.getCurrentTournament();
373      const selectedSetPromise = window.electron.getSelectedSet();
374      const selectedSetChainPromise = window.electron.getSelectedSetChain();
375      const challongeTournamentsPromise =
376        window.electron.getCurrentChallongeTournaments();
377      const selectedChallongeTournamentPromise =
378        window.electron.getSelectedChallongeTournament();
379      const selectedParryggTournamentPromise =
380        window.electron.getCurrentParryggTournament();
381      const offlineModeStatusPromise = window.electron.getOfflineModeStatus();
382      const offlineModeTournamentPromise =
383        window.electron.getCurrentOfflineModeTournament();
384      const manualNamesPromise = window.electron.getManualNames();
385      const undoSubdirPromise = window.electron.getUndoSubdir();
386
387      // req network
388      const latestAppVersionPromise = window.electron.getLatestVersion();
389      const tournamentsPromise = window.electron.getTournaments();
390
391      setAppVersion(await appVersionPromise);
392      setMode(await modePromise);
393      setUseLAN(await useLANPromise);
394      setEnforcerSetting(await enforcerSettingPromise);
395      setFileNameFormat(await fileNameFormatPromise);
396      setFolderNameFormat(await folderNameFormatPromise);
397      setVlerkMode(await vlerkModePromise);
398      setGuidedMode(await guidedModePromise);
399      setSmuggleCostumeIndex(await smuggleCostumeIndexPromise);
400      setHideCopyButton(await hideCopyButtonPromise);
401      setCopySettings(await copySettingsPromise);
402      setReportSettings(await reportSettingsPromise);
403
404      // initial state
405      const replaysDir = await replaysDirPromise;
406      setDir(replaysDir);
407      setDirInit(replaysDir.length > 0);
408      setCopyDir(await copyDirPromise);
409      setHost(await hostPromise);
410      setHostFormat(await hostFormatPromise);
411      const currentTournament = await tournamentPromise;
412      if (currentTournament) {
413        setStartggTournament(currentTournament);
414      }
415      const initSelectedSet = await selectedSetPromise;
416      if (initSelectedSet) {
417        setSelectedSet(initSelectedSet);
418      }
419      const initSelectedSetChain = await selectedSetChainPromise;
420      const { event, phase, phaseGroup } = initSelectedSetChain;
421      setSelectedSetChain({
422        event,
423        phase,
424        phaseGroup,
425      });
426      setChallongeTournaments(await challongeTournamentsPromise);
427      const initSelectedChallongeTournament =
428        await selectedChallongeTournamentPromise;
429      if (initSelectedChallongeTournament) {
430        setSelectedChallongeTournament(initSelectedChallongeTournament);
431      }
432      const initSelectedParryggTournament =
433        await selectedParryggTournamentPromise;
434      if (initSelectedParryggTournament) {
435        setParryggTournament(initSelectedParryggTournament);
436      }
437      setOfflineModeStatus(await offlineModeStatusPromise);
438      setOfflineModeTournament(await offlineModeTournamentPromise);
439      setManualNames(await manualNamesPromise);
440      setUndoSubdir(await undoSubdirPromise);
441
442      // req network
443      const errorMessages: string[] = [];
444      try {
445        setLatestAppVersion(await latestAppVersionPromise);
446      } catch (e: any) {
447        errorMessages.push(
448          `Unable to check for updates: ${e instanceof Error ? e.message : e}`,
449        );
450      }
451      try {
452        setAdminedTournaments(await tournamentsPromise);
453      } catch (e: any) {
454        errorMessages.push(
455          `Unable to fetch admined tournaments: ${
456            e instanceof Error ? e.message : e
457          }`,
458        );
459      }
460      setGettingAdminedTournaments(false);
461      if (errorMessages.length > 0) {
462        showErrorDialog(errorMessages);
463      }
464    };
465    inner();
466  }, []);
467
468  const stations = useMemo(() => {
469    if (mode === Mode.STARTGG) {
470      return startggTournament.stations;
471    }
472    if (mode === Mode.OFFLINE_MODE) {
473      return offlineModeTournament.stations;
474    }
475    return [];
476  }, [mode, offlineModeTournament.stations, startggTournament.stations]);
477  const streams = useMemo(() => {
478    if (mode === Mode.STARTGG) {
479      return startggTournament.streams;
480    }
481    if (mode === Mode.OFFLINE_MODE) {
482      return offlineModeTournament.streams;
483    }
484    return [];
485  }, [mode, offlineModeTournament.streams, startggTournament.streams]);
486
487  useEffect(() => {
488    window.electron.onCopyHost(async (event, newHost) => {
489      if (!newHost.address) {
490        const fileNameFormatPromise = window.electron.getFileNameFormat();
491        const folderNameFormatPromise = window.electron.getFolderNameFormat();
492        const copySettingsPromise = window.electron.getCopySettings();
493        const enforcerSettingPromise = window.electron.getEnforcerSetting();
494        const smuggleCostumeIndexPromise =
495          window.electron.getSmuggleCostumeIndex();
496        setFileNameFormat(await fileNameFormatPromise);
497        setFolderNameFormat(await folderNameFormatPromise);
498        setCopySettings(await copySettingsPromise);
499        setEnforcerSetting(await enforcerSettingPromise);
500        setSmuggleCostumeIndex(await smuggleCostumeIndexPromise);
501        setHostFormat({ fileNameFormat: '', folderNameFormat: '' });
502      }
503      setHost(newHost);
504    });
505    window.electron.onCopyHostFormat((event, newHostFormat) => {
506      if (newHostFormat.fileNameFormat) {
507        setFileNameFormat(newHostFormat.fileNameFormat);
508      }
509      if (newHostFormat.folderNameFormat) {
510        setFolderNameFormat(newHostFormat.folderNameFormat);
511      }
512      if (newHostFormat.copySettings !== undefined) {
513        setCopySettings({ ...newHostFormat.copySettings, output: Output.ZIP });
514      }
515      if (newHostFormat.enforcerSetting !== undefined) {
516        setEnforcerSetting(newHostFormat.enforcerSetting);
517      }
518      if (newHostFormat.smuggleCostumeIndex !== undefined) {
519        setSmuggleCostumeIndex(newHostFormat.smuggleCostumeIndex);
520      }
521      setHostFormat(newHostFormat);
522    });
523    window.electron.onOfflineModeStatus((event, newOfflineModeStatus) => {
524      setOfflineModeStatus(newOfflineModeStatus);
525    });
526  }, []);
527
528  const [batchActives, setBatchActives] = useState<
529    [
530      { active: boolean; teamI: number },
531      { active: boolean; teamI: number },
532      { active: boolean; teamI: number },
533      { active: boolean; teamI: number },
534    ]
535  >([
536    { active: false, teamI: -1 },
537    { active: false, teamI: -1 },
538    { active: false, teamI: -1 },
539    { active: false, teamI: -1 },
540  ]);
541  const numBatchActive = batchActives.filter(
542    (batchActive) => batchActive.active,
543  ).length;
544  const [overrides, setOverrides] = useState<
545    [PlayerOverrides, PlayerOverrides, PlayerOverrides, PlayerOverrides]
546  >([
547    {
548      displayName: '',
549      entrantId: 0,
550      participantId: 0,
551      prefix: '',
552      pronouns: '',
553    },
554    {
555      displayName: '',
556      entrantId: 0,
557      participantId: 0,
558      prefix: '',
559      pronouns: '',
560    },
561    {
562      displayName: '',
563      entrantId: 0,
564      participantId: 0,
565      prefix: '',
566      pronouns: '',
567    },
568    {
569      displayName: '',
570      entrantId: 0,
571      participantId: 0,
572      prefix: '',
573      pronouns: '',
574    },
575  ]);
576  const resetOverrides = () => {
577    setOverrides([
578      {
579        displayName: '',
580        entrantId: 0,
581        participantId: 0,
582        prefix: '',
583        pronouns: '',
584      },
585      {
586        displayName: '',
587        entrantId: 0,
588        participantId: 0,
589        prefix: '',
590        pronouns: '',
591      },
592      {
593        displayName: '',
594        entrantId: 0,
595        participantId: 0,
596        prefix: '',
597        pronouns: '',
598      },
599      {
600        displayName: '',
601        entrantId: 0,
602        participantId: 0,
603        prefix: '',
604        pronouns: '',
605      },
606    ]);
607  };
608  const [dq, setDq] = useState({ displayName: '', entrantId: 0 });
609  const resetDq = useCallback(() => {
610    setDq({ displayName: '', entrantId: 0 });
611  }, []);
612
613  // Replay list
614  const [allReplaysSelected, setAllReplaysSelected] = useState(true);
615  const [dirDeleteDialogOpen, setDirDeleteDialogOpen] = useState(false);
616  const [dirDeleting, setDirDeleting] = useState(false);
617  const [dirExists, setDirExists] = useState(true);
618  const [replays, setReplays] = useState<Replay[]>([]);
619  const [replayRefs, setReplayRefs] = useState<RefObject<HTMLDivElement>[]>([]);
620  const [invalidReplays, setInvalidReplays] = useState<InvalidReplay[]>([]);
621  const [gettingReplays, setGettingReplays] = useState(false);
622  let hasRemainingReplays = false;
623  const selectedReplays: Replay[] = [];
624  replays.forEach((replay) => {
625    if (replay.selected) {
626      selectedReplays.push(replay);
627      hasRemainingReplays = false;
628    } else {
629      hasRemainingReplays = true;
630    }
631  });
632  const getNewBatchActives = (newReplays: Replay[]) => {
633    const isPlayerArr: [boolean, boolean, boolean, boolean] =
634      newReplays.length > 0
635        ? newReplays
636            .map(
637              (replay) =>
638                replay.players.map(
639                  (player) =>
640                    player.playerType === 0 || player.playerType === 1,
641                ) as [boolean, boolean, boolean, boolean],
642            )
643            .reduce(
644              (accArr, curArr) => [
645                accArr[0] && curArr[0],
646                accArr[1] && curArr[1],
647                accArr[2] && curArr[2],
648                accArr[3] && curArr[3],
649              ],
650              [true, true, true, true],
651            )
652        : [false, false, false, false];
653    const teamIndiciesArr = [
654      new Map<number, boolean>(),
655      new Map<number, boolean>(),
656      new Map<number, boolean>(),
657      new Map<number, boolean>(),
658    ];
659    newReplays.forEach((replay) => {
660      const teamIdsSeen: number[] = [];
661      for (let i = 0; i < 4; i += 1) {
662        const { teamId } = replay.players[i];
663        if (teamId === 0 || teamId === 1 || teamId === 2) {
664          const teamI = teamIdsSeen.indexOf(teamId);
665          if (teamI === -1) {
666            teamIndiciesArr[i].set(teamIdsSeen.length, true);
667            teamIdsSeen.push(teamId);
668          } else {
669            teamIndiciesArr[i].set(teamI, true);
670          }
671        } else {
672          teamIndiciesArr[i].set(-1, true);
673        }
674      }
675    });
676    const teamsConsistent = teamIndiciesArr.every(
677      (teamIndicies) => teamIndicies.size === 1,
678    );
679    return isPlayerArr.map((isPlayer, i) => ({
680      active: teamsConsistent && isPlayer,
681      teamI: teamsConsistent ? Array.from(teamIndiciesArr[i].keys())[0] : -1,
682    })) as [
683      { active: boolean; teamI: number },
684      { active: boolean; teamI: number },
685      { active: boolean; teamI: number },
686      { active: boolean; teamI: number },
687    ];
688  };
689  const [replayLoadCount, setReplayLoadCount] = useState(0);
690  const copyControlsRef = useRef<HTMLDivElement | null>(null);
691  useEffect(() => {
692    if (copyControlsRef.current) {
693      copyControlsRef.current.scrollIntoView(false);
694    }
695  }, [replayLoadCount]);
696  const [skewDetected, setSkewDetected] = useState(false);
697  const [skewDialogOpen, setSkewDialogOpen] = useState(false);
698  const [wasDeleted, setWasDeleted] = useState(false);
699  const chooseDir = async () => {
700    setGettingReplays(true);
701    const newDir = await window.electron.chooseReplaysDir();
702    if (newDir && newDir !== dir) {
703      const {
704        replays: newReplays,
705        invalidReplays: newInvalidReplays,
706        replayLoadCount: newReplayLoadCount,
707      } = await window.electron.getReplaysInDir();
708      setAllReplaysSelected(true);
709      applyAllReplaysSelected(newReplays, true);
710      setBatchActives(
711        getNewBatchActives(newReplays.filter((replay) => replay.selected)),
712      );
713      setDir(newDir);
714      setIsUsb(false);
715      setDirExists(true);
716      setDirInit(false);
717      resetOverrides();
718      const skew = hasTimeSkew(newReplays);
719      setSkewDetected(skew);
720      if (skew && !vlerkMode) {
721        setSkewDialogOpen(true);
722      }
723      setReplays(newReplays);
724      setReplayLoadCount(newReplayLoadCount);
725      setInvalidReplays(newInvalidReplays);
726      if (newInvalidReplays.length > 0) {
727        showErrorDialog(
728          newInvalidReplays.map(
729            (invalidReplay) =>
730              `${invalidReplay.fileName}: ${invalidReplay.invalidReason}`,
731          ),
732        );
733      }
734      setReplayRefs(vlerkMode ? newReplays.map(() => createRef()) : []);
735      setWasDeleted(false);
736    }
737    setGettingReplays(false);
738  };
739
740  const setManualNamesOuter = async (names: string[]) => {
741    setManualNames(names);
742    await window.electron.setManualNames(names);
743  };
744  const [manualDialogOpen, setManualDialogOpen] = useState(false);
745
746  const [guideState, setGuideState] = useState(GuideState.NONE);
747  const [guideBackdropOpen, setGuideBackdropOpen] = useState(false);
748  const [confirmedCopySettings, setConfirmedCopySettings] = useState(false);
749  const guideActive =
750    guidedMode && tournamentSet && copyDirSet && confirmedCopySettings;
751  const refreshReplays = useCallback(
752    async (triggerGuide?: boolean) => {
753      let newReplays: Replay[] = [];
754      let newInvalidReplays: InvalidReplay[] = [];
755      setGettingReplays(true);
756      try {
757        const res = await window.electron.getReplaysInDir();
758        newReplays = res.replays;
759        newInvalidReplays = res.invalidReplays;
760        setReplayLoadCount(res.replayLoadCount);
761        setDirExists(true);
762        if (triggerGuide && newReplays.length > 0) {
763          setGuideState(
764            mode === Mode.MANUAL ? GuideState.PLAYERS : GuideState.SET,
765          );
766          if (guideActive) {
767            setGuideBackdropOpen(true);
768          }
769        }
770      } catch (e: any) {
771        setDirExists(false);
772        setGuideBackdropOpen(false);
773        setGuideState(GuideState.NONE);
774      }
775      setAllReplaysSelected(true);
776      applyAllReplaysSelected(newReplays, true);
777      setBatchActives(
778        getNewBatchActives(newReplays.filter((replay) => replay.selected)),
779      );
780      setDirInit(false);
781      resetOverrides();
782      const skew = hasTimeSkew(newReplays);
783      setSkewDetected(skew);
784      if (skew && !vlerkMode) {
785        setSkewDialogOpen(true);
786      }
787      setReplays(newReplays);
788      setInvalidReplays(newInvalidReplays);
789      if (newInvalidReplays.length > 0) {
790        showErrorDialog(
791          newInvalidReplays.map(
792            (invalidReplay) =>
793              `${invalidReplay.fileName}: ${invalidReplay.invalidReason}`,
794          ),
795        );
796      }
797      setReplayRefs(vlerkMode ? newReplays.map(() => createRef()) : []);
798      setGettingReplays(false);
799    },
800    [guideActive, mode, vlerkMode],
801  );
802
803  const wouldDeleteCopyDir =
804    dir.length > 0 && copyDir.length > 0 && dir === copyDir;
805  const [ejecting, setEjecting] = useState(false);
806  const [ejected, setEjected] = useState(false);
807  const deleteDir = async () => {
808    if (!dir || wouldDeleteCopyDir) {
809      return;
810    }
811
812    setDirDeleting(true);
813    setEjecting(true);
814    try {
815      setEjected(await window.electron.deleteReplaysDir());
816      setWasDeleted(true);
817      await refreshReplays();
818    } finally {
819      setDirDeleting(false);
820      setEjecting(false);
821    }
822  };
823  const deleteSelected = async () => {
824    if (!dir || wouldDeleteCopyDir) {
825      return;
826    }
827
828    setDirDeleting(true);
829    try {
830      await window.electron.deleteSelectedReplays(
831        selectedReplays.map((selectedReplay) => selectedReplay.filePath),
832      );
833      await refreshReplays();
834    } finally {
835      setDirDeleting(false);
836    }
837  };
838  const deleteUndo = async () => {
839    if (!dir || !undoSubdir || wouldDeleteCopyDir) {
840      return;
841    }
842
843    setDirDeleting(true);
844    try {
845      setDir(await window.electron.deleteUndoSrcDst());
846      setUndoSubdir('');
847      refreshReplays(true);
848    } finally {
849      setDirDeleting(false);
850    }
851  };
852  const onPlayerOverride = () => {
853    setReplays(Array.from(replays));
854  };
855  const onReplayClick = (index: number) => {
856    const newReplays = Array.from(replays);
857    newReplays[index].selected = !newReplays[index].selected;
858    const newBatchActives = getNewBatchActives(
859      newReplays.filter((replay) => replay.selected),
860    );
861
862    const newOverrides = Array.from(overrides) as [
863      PlayerOverrides,
864      PlayerOverrides,
865      PlayerOverrides,
866      PlayerOverrides,
867    ];
868    for (let i = 0; i < 4; i += 1) {
869      if (batchActives[i].active && !newBatchActives[i].active) {
870        newOverrides[i] = {
871          displayName: '',
872          entrantId: 0,
873          participantId: 0,
874          prefix: '',
875          pronouns: '',
876        };
877      }
878    }
879
880    if (newReplays[index].selected) {
881      newReplays[index].players.forEach((player, i) => {
882        player.playerOverrides = { ...newOverrides[i] };
883      });
884    } else {
885      newReplays[index].players.forEach((player) => {
886        player.playerOverrides = {
887          displayName: '',
888          entrantId: 0,
889          participantId: 0,
890          prefix: '',
891          pronouns: '',
892        };
893      });
894    }
895
896    setBatchActives(newBatchActives);
897    setOverrides(newOverrides);
898    setReplays(newReplays);
899    resetDq();
900  };
901  useEffect(() => {
902    window.electron.onTournament(
903      (
904        e,
905        {
906          selectedSet: newSelectedSet,
907          startggTournament: newTournament,
908          challongeTournaments: newChallongeTournaments,
909          parryggTournament: newParryggTournament,
910          offlineModeTournament: newOfflineModeTournament,
911        },
912      ) => {
913        if (newSelectedSet) {
914          setSelectedSet(newSelectedSet);
915        }
916        if (newTournament) {
917          if (tournamentSet && copyDirSet && confirmedCopySettings) {
918            setGuideBackdropOpen(false);
919          }
920          setStartggTournament(newTournament);
921        }
922        if (newChallongeTournaments) {
923          if (tournamentSet && copyDirSet && confirmedCopySettings) {
924            setGuideBackdropOpen(false);
925          }
926          setChallongeTournaments(newChallongeTournaments);
927        }
928        if (newParryggTournament) {
929          if (tournamentSet && copyDirSet && confirmedCopySettings) {
930            setGuideBackdropOpen(false);
931          }
932          setParryggTournament(newParryggTournament);
933        }
934        if (newOfflineModeTournament) {
935          if (tournamentSet && copyDirSet && confirmedCopySettings) {
936            setGuideBackdropOpen(false);
937          }
938          setOfflineModeTournament(newOfflineModeTournament);
939        }
940      },
941      selectedSet.id,
942    );
943  }, [confirmedCopySettings, copyDirSet, selectedSet, tournamentSet]);
944
945  useEffect(() => {
946    window.electron.onUsb((e, newDir, newIsUsb) => {
947      if (!undoSubdir) {
948        setDir(newDir);
949        setIsUsb(newIsUsb);
950        setWasDeleted(false);
951        refreshReplays(true);
952        setEjected(false);
953      }
954    });
955  }, [refreshReplays, undoSubdir]);
956
957  const availablePlayers: PlayerOverrides[] = [];
958  selectedSet.entrant1Participants.forEach((participant) => {
959    availablePlayers.push({
960      displayName: participant.displayName,
961      entrantId: selectedSet.entrant1Id,
962      participantId: participant.id,
963      prefix: participant.prefix,
964      pronouns: participant.pronouns,
965    });
966  });
967  selectedSet.entrant2Participants.forEach((participant) => {
968    availablePlayers.push({
969      displayName: participant.displayName,
970      entrantId: selectedSet.entrant1Id,
971      participantId: participant.id,
972      prefix: participant.prefix,
973      pronouns: participant.pronouns,
974    });
975  });
976
977  const [slugDialogOpen, setSlugDialogOpen] = useState(false);
978  const [parryggSlugDialogOpen, setParryggSlugDialogOpen] = useState(false);
979  const [gettingTournament, setGettingTournament] = useState(false);
980
981  // Challonge tournament view
982  const getChallongeTournament = async (maybeSlug: string) => {
983    if (!maybeSlug) {
984      return;
985    }
986
987    setGettingTournament(true);
988    try {
989      await window.electron.getChallongeTournament(maybeSlug);
990    } catch (e: any) {
991      showErrorDialog([e.toString()]);
992    } finally {
993      setGettingTournament(false);
994    }
995  };
996
997  const getParryggTournament = async (
998    maybeSlug: string,
999    initial: boolean = false,
1000  ) => {
1001    if (!maybeSlug) {
1002      return;
1003    }
1004
1005    setGettingTournament(true);
1006    try {
1007      await window.electron.getParryggTournament(
1008        maybeSlug,
1009        initial && vlerkMode,
1010      );
1011      if (parryggSlug !== maybeSlug) {
1012        setSelectedSet(EMPTY_SET);
1013        setSelectedSetChain(EMPTY_SELECTED_SET_CHAIN);
1014        await window.electron.setSelectedSetChain('', '', '');
1015      }
1016    } catch (e: any) {
1017      showErrorDialog([e.toString()]);
1018    } finally {
1019      setGettingTournament(false);
1020    }
1021  };
1022
1023  const findOtherPlayer = (
1024    entrantId: Id,
1025    participantId: Id,
1026  ): PlayerOverrides => {
1027    const isEntrant1 = entrantId === selectedSet.entrant1Id;
1028    const isTeams = selectedSet.entrant1Participants.length > 1;
1029    if (isEntrant1 && isTeams) {
1030      const participantToCheck = selectedSet.entrant1Participants.find(
1031        (participant) => participant.id !== participantId,
1032      );
1033      if (participantToCheck) {
1034        return {
1035          displayName: participantToCheck.displayName,
1036          entrantId: selectedSet.entrant1Id,
1037          participantId: participantToCheck.id,
1038          prefix: participantToCheck.prefix,
1039          pronouns: participantToCheck.pronouns,
1040        };
1041      }
1042    } else if (!isEntrant1 && isTeams) {
1043      const participantToCheck = selectedSet.entrant2Participants.find(
1044        (participant) => participant.id !== participantId,
1045      );
1046      if (participantToCheck) {
1047        return {
1048          displayName: participantToCheck.displayName,
1049          entrantId: selectedSet.entrant2Id,
1050          participantId: participantToCheck.id,
1051          prefix: participantToCheck.prefix,
1052          pronouns: participantToCheck.pronouns,
1053        };
1054      }
1055    } else if (isEntrant1 && !isTeams) {
1056      return {
1057        displayName: selectedSet.entrant2Participants[0].displayName,
1058        entrantId: selectedSet.entrant2Id,
1059        participantId: selectedSet.entrant2Participants[0].id,
1060        prefix: selectedSet.entrant2Participants[0].prefix,
1061        pronouns: selectedSet.entrant2Participants[0].pronouns,
1062      };
1063    } else if (!isEntrant1 && !isTeams) {
1064      return {
1065        displayName: selectedSet.entrant1Participants[0].displayName,
1066        entrantId: selectedSet.entrant1Id,
1067        participantId: selectedSet.entrant1Participants[0].id,
1068        prefix: selectedSet.entrant1Participants[0].prefix,
1069        pronouns: selectedSet.entrant1Participants[0].pronouns,
1070      };
1071    }
1072    return {
1073      displayName: '',
1074      entrantId: 0,
1075      participantId: 0,
1076      prefix: '',
1077      pronouns: '',
1078    };
1079  };
1080
1081  // for click-assigning set participants
1082  const [selectedChipData, setSelectedChipData] = useState<PlayerOverrides>({
1083    displayName: '',
1084    entrantId: 0,
1085    participantId: 0,
1086    prefix: '',
1087    pronouns: '',
1088  });
1089  const resetSelectedChipData = () => {
1090    setSelectedChipData({
1091      displayName: '',
1092      entrantId: 0,
1093      participantId: 0,
1094      prefix: '',
1095      pronouns: '',
1096    });
1097  };
1098
1099  // batch chips
1100  const onClickOrDrop = (
1101    displayName: string,
1102    entrantId: Id,
1103    participantId: Id,
1104    prefix: string,
1105    pronouns: string,
1106    index: number,
1107  ) => {
1108    const newOverrides = Array.from(overrides) as [
1109      PlayerOverrides,
1110      PlayerOverrides,
1111      PlayerOverrides,
1112      PlayerOverrides,
1113    ];
1114    newOverrides[index] = {
1115      displayName,
1116      entrantId,
1117      participantId,
1118      prefix,
1119      pronouns,
1120    };
1121    newOverrides.forEach((override, i) => {
1122      if (
1123        i !== index &&
1124        override.entrantId === entrantId &&
1125        override.participantId === participantId
1126      ) {
1127        override.displayName = '';
1128        override.entrantId = 0;
1129        override.participantId = 0;
1130        override.prefix = '';
1131        override.pronouns = '';
1132      }
1133    });
1134
1135    // pigeonhole remaining player if possible
1136    if (numBatchActive === availablePlayers.length) {
1137      const { teamI } = batchActives[index];
1138      const isTeams = availablePlayers.length === 4 && teamI !== -1;
1139
1140      // find if there's exactly one hole to pigeon
1141      const elligibleIndicies: number[] = [];
1142      for (let i = 0; i < 4; i += 1) {
1143        if (
1144          batchActives[i].active &&
1145          (!isTeams || batchActives[i].teamI === teamI) &&
1146          newOverrides[i].participantId !== participantId
1147        ) {
1148          elligibleIndicies.push(i);
1149        }
1150      }
1151      if (elligibleIndicies.length === 1) {
1152        const otherPlayer = findOtherPlayer(entrantId, participantId);
1153        if (otherPlayer.entrantId && otherPlayer.participantId) {
1154          newOverrides[elligibleIndicies[0]] = otherPlayer;
1155          newOverrides.forEach((override, i) => {
1156            if (
1157              i !== elligibleIndicies[0] &&
1158              override.entrantId === otherPlayer.entrantId &&
1159              override.participantId === otherPlayer.participantId
1160            ) {
1161              override.displayName = '';
1162              override.entrantId = 0;
1163              override.participantId = 0;
1164              override.prefix = '';
1165              override.pronouns = '';
1166            }
1167          });
1168        }
1169      }
1170    }
1171
1172    selectedReplays.forEach((replay) => {
1173      replay.players[index].playerOverrides = { ...newOverrides[index] };
1174      replay.players.forEach((otherPlayer) => {
1175        if (
1176          otherPlayer.port === replay.players[index].port ||
1177          (otherPlayer.playerType !== 0 && otherPlayer.playerType !== 1)
1178        ) {
1179          return;
1180        }
1181        if (
1182          otherPlayer.playerOverrides.displayName === displayName &&
1183          otherPlayer.playerOverrides.entrantId
1184        ) {
1185          otherPlayer.playerOverrides.displayName = '';
1186          otherPlayer.playerOverrides.entrantId = 0;
1187          otherPlayer.playerOverrides.participantId = 0;
1188          otherPlayer.playerOverrides.prefix = '';
1189          otherPlayer.playerOverrides.pronouns = '';
1190        }
1191      });
1192      for (let i = 0; i < 4; i += 1) {
1193        replay.players[i].playerOverrides = { ...newOverrides[i] };
1194      }
1195    });
1196    setOverrides(newOverrides);
1197    resetDq();
1198    resetSelectedChipData();
1199  };
1200  const batchChip = (index: number) => {
1201    const { active } = batchActives[index];
1202    return (
1203      <DroppableChip
1204        active={active}
1205        label={overrides[index].displayName || `P${index + 1} (all games)`}
1206        outlined={active}
1207        selectedChipData={selectedChipData}
1208        style={{ width: '25%' }}
1209        onClickOrDrop={(
1210          displayName: string,
1211          entrantId: Id,
1212          participantId: Id,
1213          prefix: string,
1214          pronouns: string,
1215        ) =>
1216          onClickOrDrop(
1217            displayName,
1218            entrantId,
1219            participantId,
1220            prefix,
1221            pronouns,
1222            index,
1223          )
1224        }
1225      />
1226    );
1227  };
1228
1229  const getStartggTournament = async (
1230    maybeSlug: string,
1231    initial: boolean = false,
1232  ) => {
1233    if (!maybeSlug) {
1234      return;
1235    }
1236
1237    setGettingTournament(true);
1238    try {
1239      await window.electron.getStartggTournament(
1240        maybeSlug,
1241        initial && vlerkMode,
1242      );
1243      if (startggTournament.slug !== maybeSlug) {
1244        setSelectedSet(EMPTY_SET);
1245        setSelectedSetChain(EMPTY_SELECTED_SET_CHAIN);
1246        await window.electron.setSelectedSetChain(0, 0, 0);
1247      }
1248    } catch (e: any) {
1249      showErrorDialog([e.toString()]);
1250    } finally {
1251      setGettingTournament(false);
1252    }
1253  };
1254
1255  // set controls
1256  const selectSet = (set: Set) => {
1257    const newOverrides: [
1258      PlayerOverrides,
1259      PlayerOverrides,
1260      PlayerOverrides,
1261      PlayerOverrides,
1262    ] = [
1263      {
1264        displayName: '',
1265        entrantId: 0,
1266        participantId: 0,
1267        prefix: '',
1268        pronouns: '',
1269      },
1270      {
1271        displayName: '',
1272        entrantId: 0,
1273        participantId: 0,
1274        prefix: '',
1275        pronouns: '',
1276      },
1277      {
1278        displayName: '',
1279        entrantId: 0,
1280        participantId: 0,
1281        prefix: '',
1282        pronouns: '',
1283      },
1284      {
1285        displayName: '',
1286        entrantId: 0,
1287        participantId: 0,
1288        prefix: '',
1289        pronouns: '',
1290      },
1291    ];
1292    selectedReplays.forEach((replay) => {
1293      replay.players.forEach((player, i) => {
1294        player.playerOverrides = { ...newOverrides[i] };
1295      });
1296    });
1297    const newReplays = Array.from(replays);
1298    setSelectedSet(set);
1299    setOverrides(newOverrides);
1300    setReplays(newReplays);
1301  };
1302
1303  const [callingSet, setCallingSet] = useState(false);
1304  const callSet = async (originalSet: Set) => {
1305    setCallingSet(true);
1306    try {
1307      if (mode === Mode.STARTGG) {
1308        await window.electron.callSet(originalSet);
1309      } else if (mode === Mode.OFFLINE_MODE) {
1310        await window.electron.callOfflineModeSet(assertInteger(originalSet.id));
1311      }
1312    } catch (e: any) {
1313      showErrorDialog([e.toString()]);
1314    } finally {
1315      setCallingSet(false);
1316    }
1317  };
1318
1319  const [startingSet, setStartingSet] = useState(false);
1320  const startSet = async (originalSet: Set) => {
1321    setStartingSet(true);
1322    try {
1323      if (mode === Mode.STARTGG) {
1324        await window.electron.startSet(originalSet);
1325      } else if (mode === Mode.CHALLONGE) {
1326        await window.electron.startChallongeSet(
1327          selectedChallongeTournament.slug,
1328          assertString(originalSet.id),
1329        );
1330      } else if (mode === Mode.PARRYGG) {
1331        await window.electron.startParryggSet(assertString(originalSet.id));
1332      } else if (mode === Mode.OFFLINE_MODE) {
1333        await window.electron.startOfflineModeSet(
1334          assertInteger(originalSet.id),
1335        );
1336      }
1337    } catch (e: any) {
1338      showErrorDialog([e.toString()]);
1339    } finally {
1340      setStartingSet(false);
1341    }
1342  };
1343
1344  const reportStartggSet = useCallback(
1345    async (set: StartggSet, originalSet: Set) => {
1346      const updatedSet =
1347        originalSet.state === State.COMPLETED
1348          ? await window.electron.updateSet(set)
1349          : await window.electron.reportSet(set, originalSet);
1350      resetDq();
1351      return updatedSet;
1352    },
1353    [resetDq],
1354  );
1355  const reportChallongeSet = useCallback(
1356    async (matchId: string, items: ChallongeMatchItem[]) => {
1357      const updatedSet = await window.electron.reportChallongeSet(
1358        matchId,
1359        items,
1360      );
1361      resetDq();
1362      return updatedSet;
1363    },
1364    [resetDq],
1365  );
1366  const reportParryggSet = useCallback(
1367    async (result: MatchResult.AsObject, originalSet: Set) => {
1368      const updatedSet = await window.electron.reportParryggSet(
1369        assertString(originalSet.id),
1370        result,
1371      );
1372      resetDq();
1373      return updatedSet;
1374    },
1375    [resetDq],
1376  );
1377  const reportOfflineModeSet = useCallback(
1378    async (set: StartggSet) => {
1379      const updatedSet = await window.electron.reportOfflineModeSet(
1380        assertInteger(set.setId),
1381        assertInteger(set.winnerId),
1382        set.isDQ,
1383        set.gameData,
1384      );
1385      resetDq();
1386      return updatedSet;
1387    },
1388    [resetDq],
1389  );
1390
1391  // copy
1392  type NameObj = {
1393    characterName: string;
1394    displayName: string;
1395    entrantId: Id;
1396    participantId: Id;
1397    nametag: string;
1398  };
1399  type NamesObj = {
1400    characterNames: Map<string, number>;
1401    displayName: string;
1402    entrantId: Id;
1403    participantId: Id;
1404    nametags: Map<string, number>;
1405  };
1406  type CombinedNameObj = {
1407    characterNames: string[];
1408    displayName: string;
1409    entrantId: Id;
1410    participantId: Id;
1411    nametags: string[];
1412  };
1413
1414  const [isCopying, setIsCopying] = useState(false);
1415  const [copyError, setCopyError] = useState('');
1416  const [copyErrorDialogOpen, setCopyErrorDialogOpen] = useState(false);
1417  const [copySuccess, setCopySuccess] = useState('');
1418
1419  const onCopy = async (
1420    updatedSetFields?: {
1421      id: Id;
1422      sggId: number | null;
1423      completedAtMs: number;
1424      stream: Stream | null;
1425    },
1426    violators?: {
1427      checkNames: Map<string, boolean>;
1428      displayName: string;
1429      entrantId: Id;
1430    }[],
1431  ) => {
1432    setIsCopying(true);
1433
1434    let offsetMs = 0;
1435    let startDate = selectedReplays[0].startAt;
1436    if (copySettings.writeStartTimes && undoSubdir.length === 0) {
1437      const lastReplay = selectedReplays[selectedReplays.length - 1];
1438      const lastStartMs = lastReplay.startAt.getTime();
1439      const completedMs =
1440        (updatedSetFields
1441          ? updatedSetFields.completedAtMs
1442          : selectedSet.completedAtMs) || Date.now();
1443      offsetMs =
1444        completedMs -
1445        lastStartMs -
1446        Math.round((lastReplay.lastFrame + 124) / frameMsDivisor);
1447      startDate = new Date(selectedReplays[0].startAt.getTime() + offsetMs);
1448    }
1449
1450    let fileNames = selectedReplays.map((replay) => replay.fileName);
1451    let subdir = '';
1452    let context: Context | undefined;
1453    if (
1454      copySettings.writeFileNames ||
1455      copySettings.output === Output.FOLDER ||
1456      copySettings.output === Output.ZIP
1457    ) {
1458      let allEntrantIdsSet = true;
1459      const nameObjs = selectedReplays.map((replay) =>
1460        replay.players.map((player): NameObj => {
1461          if (player.playerType === 0 || player.playerType === 1) {
1462            if (!player.playerOverrides.entrantId) {
1463              allEntrantIdsSet = false;
1464            }
1465            return {
1466              characterName: characterNames.get(player.externalCharacterId)!,
1467              displayName:
1468                player.playerOverrides.displayName || player.displayName,
1469              entrantId: player.playerOverrides.entrantId,
1470              participantId: player.playerOverrides.participantId,
1471              nametag: player.nametag,
1472            };
1473          }
1474          return {
1475            characterName: '',
1476            displayName: '',
1477            entrantId: 0,
1478            participantId: 0,
1479            nametag: '',
1480          };
1481        }),
1482      );
1483
1484      const nameObjToPlayerOnly = (nameObj: NameObj) => {
1485        if (nameObj.displayName) {
1486          return nameObj.displayName;
1487        }
1488        if (nameObj.nametag) {
1489          return nameObj.nametag;
1490        }
1491        return nameObj.characterName;
1492      };
1493      const combinedNameObjToPlayerOnly = (
1494        combinedNameObj: CombinedNameObj,
1495      ) => {
1496        if (combinedNameObj.displayName) {
1497          return combinedNameObj.displayName;
1498        }
1499        if (combinedNameObj.nametags.length > 0) {
1500          return combinedNameObj.nametags.join(', ');
1501        }
1502        return combinedNameObj.characterNames.join(', ');
1503      };
1504      const nameObjToPlayerChar = (nameObj: NameObj) => {
1505        if (nameObj.displayName) {
1506          return `${nameObj.displayName} (${nameObj.characterName})`;
1507        }
1508        if (nameObj.nametag) {
1509          return `${nameObj.characterName} (${nameObj.nametag})`;
1510        }
1511        return nameObj.characterName;
1512      };
1513      const combinedNameObjToPlayerChar = (
1514        combinedNameObj: CombinedNameObj,
1515      ) => {
1516        if (combinedNameObj.displayName) {
1517          return `${
1518            combinedNameObj.displayName
1519          } (${combinedNameObj.characterNames.join(', ')})`;
1520        }
1521        if (combinedNameObj.nametags.length > 0) {
1522          return `${combinedNameObj.characterNames.join(
1523            ', ',
1524          )} (${combinedNameObj.nametags.join(', ')})`;
1525        }
1526        return combinedNameObj.characterNames.join(', ');
1527      };
1528      const entrant1CombinedNameObjs: CombinedNameObj[] = [];
1529      const entrant2CombinedNameObjs: CombinedNameObj[] = [];
1530
1531      let roundShort = '';
1532      const regex = /([A-Z]|[0-9])/g;
1533      let regexRes = regex.exec(selectedSet.fullRoundText);
1534      while (regexRes) {
1535        roundShort += regexRes[0];
1536        regexRes = regex.exec(selectedSet.fullRoundText);
1537      }
1538      const roundLong = String(selectedSet.fullRoundText);
1539      if (
1540        copySettings.output === Output.FOLDER ||
1541        copySettings.output === Output.ZIP
1542      ) {
1543        const namesObjs: NamesObj[] = nameObjs[0].map((nameObj) => ({
1544          characterNames: new Map([[nameObj.characterName, 0]]),
1545          displayName: nameObj.displayName,
1546          entrantId: nameObj.entrantId,
1547          participantId: nameObj.participantId,
1548          nametags: new Map([[nameObj.nametag, 0]]),
1549        }));
1550        if (allEntrantIdsSet) {
1551          for (let i = 1; i < nameObjs.length; i += 1) {
1552            for (let j = 0; j < nameObjs[i].length; j += 1) {
1553              const nameObj = nameObjs[i][j];
1554              const existingNamesObj = namesObjs.find(
1555                (namesObj) =>
1556                  namesObj.entrantId === nameObj.entrantId &&
1557                  namesObj.participantId === nameObj.participantId,
1558              )!;
1559              if (
1560                nameObj.characterName &&
1561                !existingNamesObj.characterNames.has(nameObj.characterName)
1562              ) {
1563                existingNamesObj.characterNames.set(nameObj.characterName, i);
1564              }
1565              if (
1566                nameObj.nametag &&
1567                !existingNamesObj.nametags.has(nameObj.nametag)
1568              ) {
1569                existingNamesObj.nametags.set(nameObj.nametag, i);
1570              }
1571            }
1572          }
1573        } else {
1574          for (let i = 1; i < nameObjs.length; i += 1) {
1575            for (let j = 0; j < nameObjs[i].length; j += 1) {
1576              const nameObj = nameObjs[i][j];
1577              if (nameObj.characterName) {
1578                namesObjs[j].displayName = nameObj.displayName;
1579                namesObjs[j].entrantId = nameObj.entrantId;
1580                if (!namesObjs[j].characterNames.has(nameObj.characterName)) {
1581                  namesObjs[j].characterNames.set(nameObj.characterName, i);
1582                }
1583              }
1584              if (
1585                nameObj.nametag &&
1586                !namesObjs[i].nametags.has(nameObj.nametag)
1587              ) {
1588                namesObjs[i].nametags.set(nameObj.nametag, j);
1589              }
1590            }
1591          }
1592        }
1593        const combinedNameObjs: CombinedNameObj[] = namesObjs
1594          .map((namesObj) => ({
1595            displayName: namesObj.displayName,
1596            entrantId: namesObj.entrantId,
1597            participantId: namesObj.participantId,
1598            characterNames: [...namesObj.characterNames.entries()]
1599              .sort(([, a], [, b]) => a - b)
1600              .map((entry) => entry[0]),
1601            nametags: [...namesObj.nametags.entries()]
1602              .sort(([, a], [, b]) => a - b)
1603              .map((entry) => entry[0]),
1604          }))
1605          .filter((nameObj) =>
1606            nameObj.characterNames.some((characterName) => characterName),
1607          );
1608
1609        selectedSet.entrant1Participants.forEach((participant) => {
1610          const combinedNameObj = combinedNameObjs.find(
1611            (cbn) => cbn.participantId === participant.id,
1612          );
1613          if (combinedNameObj) {
1614            entrant1CombinedNameObjs.push(combinedNameObj);
1615          }
1616        });
1617        selectedSet.entrant2Participants.forEach((participant) => {
1618          const combinedNameObj = combinedNameObjs.find(
1619            (cbn) => cbn.participantId === participant.id,
1620          );
1621          if (combinedNameObj) {
1622            entrant2CombinedNameObjs.push(combinedNameObj);
1623          }
1624        });
1625
1626        const playersOnly = `${entrant1CombinedNameObjs
1627          .map(combinedNameObjToPlayerOnly)
1628          .join(' + ')} vs ${entrant2CombinedNameObjs
1629          .map(combinedNameObjToPlayerOnly)
1630          .join(' + ')}`;
1631        const playersChars = `${entrant1CombinedNameObjs
1632          .map(combinedNameObjToPlayerChar)
1633          .join(' + ')} vs ${entrant2CombinedNameObjs
1634          .map(combinedNameObjToPlayerChar)
1635          .join(' + ')}`;
1636        const singlesChars =
1637          combinedNameObjs.length === 4 ? playersOnly : playersChars;
1638        subdir = String(folderNameFormat);
1639        subdir = subdir.replace('{date}', format(startDate, 'yyyyMMdd'));
1640        subdir = subdir.replace('{time}', format(startDate, 'HHmm'));
1641        subdir = subdir.replace('{roundShort}', roundShort);
1642        subdir = subdir.replace('{roundLong}', roundLong);
1643        subdir = subdir.replace('{games}', selectedReplays.length.toString(10));
1644        // do last in case tournament/event/phase/phase group names contain template strings LOL
1645        if (mode === Mode.STARTGG) {
1646          subdir = subdir.replace('{tournamentName}', startggTournament.name);
1647          subdir = subdir.replace('{tournamentSlug}', startggTournament.slug);
1648        } else if (mode === Mode.CHALLONGE) {
1649          subdir = subdir.replace(
1650            '{tournamentName}',
1651            selectedChallongeTournament.name,
1652          );
1653          subdir = subdir.replace(
1654            '{tournamentSlug}',
1655            selectedChallongeTournament.slug,
1656          );
1657        } else if (mode === Mode.PARRYGG) {
1658          subdir = subdir.replace(
1659            '{tournamentName}',
1660            parryggTournament?.name || '',
1661          );
1662          subdir = subdir.replace('{tournamentSlug}', parryggSlug || '');
1663        } else if (mode === Mode.OFFLINE_MODE) {
1664          subdir = subdir.replace(
1665            '{tournamentName}',
1666            offlineModeTournament.name,
1667          );
1668          subdir = subdir.replace(
1669            '{tournamentSlug}',
1670            offlineModeTournament.slug,
1671          );
1672        }
1673        if (
1674          mode === Mode.STARTGG ||
1675          mode === Mode.PARRYGG ||
1676          mode === Mode.OFFLINE_MODE
1677        ) {
1678          subdir = subdir.replace(
1679            '{event}',
1680            selectedSetChain.event?.name ?? '',
1681          );
1682          subdir = subdir.replace(
1683            '{phase}',
1684            selectedSetChain.phase?.name ?? '',
1685          );
1686          subdir = subdir.replace(
1687            '{phaseGroup}',
1688            selectedSetChain.phaseGroup?.name ?? '',
1689          );
1690          let phaseOrEvent = '';
1691          if (selectedSetChain.phase?.hasSiblings) {
1692            phaseOrEvent = selectedSetChain.phase.name;
1693          } else if (selectedSetChain.event) {
1694            phaseOrEvent = selectedSetChain.event.name;
1695          }
1696          subdir = subdir.replace('{phaseOrEvent}', phaseOrEvent);
1697        }
1698        // do last in case player names contain template strings LOL
1699        subdir = subdir.replace('{playersOnly}', playersOnly);
1700        subdir = subdir.replace('{playersChars}', playersChars);
1701        subdir = subdir.replace('{singlesChars}', singlesChars);
1702      }
1703
1704      if (copySettings.writeFileNames) {
1705        fileNames = nameObjs.map((game, i) => {
1706          const { stageId, startAt } = selectedReplays[i];
1707          const writeStartDate =
1708            copySettings.writeStartTimes && undoSubdir.length === 0
1709              ? new Date(startAt.getTime() + offsetMs)
1710              : startAt;
1711          const time = format(writeStartDate, 'HHmmss');
1712          const names = game.filter((nameObj) => nameObj.characterName);
1713          const playersOnly = names.map(nameObjToPlayerOnly).join(', ');
1714          const playersChars = names.map(nameObjToPlayerChar).join(', ');
1715          const singlesChars =
1716            nameObjs.length === 4 ? playersOnly : playersChars;
1717
1718          let fileName = `{ordinal}${fileNameFormat}`;
1719          fileName = fileName.replace(
1720            '{date}',
1721            format(writeStartDate, 'yyyyMMdd'),
1722          );
1723          fileName = fileName.replace('{time}', time);
1724          fileName = fileName.replace('{roundShort}', roundShort);
1725          fileName = fileName.replace('{roundLong}', roundLong);
1726          fileName = fileName.replace('{stage}', stageNames.get(stageId) || '');
1727          fileName = fileName.replace(
1728            '{ordinal}',
1729            copySettings.output === Output.FILES ? time : (i + 1).toString(10),
1730          );
1731          // do last in case player names contain template strings LOL
1732          fileName = fileName.replace('{playersOnly}', playersOnly);
1733          fileName = fileName.replace('{playersChars}', playersChars);
1734          fileName = fileName.replace('{singlesChars}', singlesChars);
1735          return `${fileName}.slp`;
1736        });
1737      }
1738
1739      if (
1740        copySettings.writeContext &&
1741        (copySettings.output === Output.FOLDER ||
1742          copySettings.output === Output.ZIP)
1743      ) {
1744        let canWriteContext = true;
1745        const scores: ContextScore[] = [];
1746        const gameScores = [0, 0];
1747        selectedReplays.forEach((replay) => {
1748          const slots: ContextSlot[] = [];
1749          const usedK = new Map<number, boolean>();
1750          for (let j = 0; j < 2; j += 1) {
1751            slots[j] = {
1752              displayNames: [],
1753              ports: [],
1754              prefixes: [],
1755              pronouns: [],
1756              score: gameScores[j],
1757            };
1758            let teamId: number | undefined;
1759            for (let k = 0; k < replay.players.length; k += 1) {
1760              const player = replay.players[k];
1761              if (
1762                (player.playerType === 0 || player.playerType === 1) &&
1763                !usedK.has(k) &&
1764                (teamId === undefined || teamId === player.teamId)
1765              ) {
1766                const displayName =
1767                  player.playerOverrides.displayName || player.displayName;
1768                if (!displayName) {
1769                  canWriteContext = false;
1770                }
1771                slots[j].displayNames.push(displayName);
1772                slots[j].ports.push(player.port);
1773                slots[j].prefixes.push(player.playerOverrides.prefix);
1774                slots[j].pronouns.push(player.playerOverrides.pronouns);
1775                if (player.isWinner) {
1776                  gameScores[j] += 1;
1777                }
1778                usedK.set(k, true);
1779                if (replay.isTeams) {
1780                  if (teamId === undefined) {
1781                    teamId = player.teamId;
1782                  }
1783                } else {
1784                  break;
1785                }
1786              }
1787            }
1788          }
1789          scores.push({ slots: [slots[0], slots[1]] });
1790        });
1791        const lastScore = scores[scores.length - 1];
1792        const finalScore: ContextScore = {
1793          slots: [
1794            {
1795              displayNames: lastScore.slots[0].displayNames,
1796              ports: lastScore.slots[0].ports,
1797              prefixes: lastScore.slots[0].prefixes,
1798              pronouns: lastScore.slots[0].pronouns,
1799              score: gameScores[0],
1800            },
1801            {
1802              displayNames: lastScore.slots[1].displayNames,
1803              ports: lastScore.slots[1].ports,
1804              prefixes: lastScore.slots[1].prefixes,
1805              pronouns: lastScore.slots[1].pronouns,
1806              score: gameScores[1],
1807            },
1808          ],
1809        };
1810        if (canWriteContext) {
1811          const contextPlayers: ContextPlayers = {
1812            entrant1: entrant1CombinedNameObjs.map((cbn) => ({
1813              name: cbn.displayName,
1814              characters: cbn.characterNames,
1815            })),
1816            entrant2: entrant2CombinedNameObjs.map((cbn) => ({
1817              name: cbn.displayName,
1818              characters: cbn.characterNames,
1819            })),
1820          };
1821          context = {
1822            bestOf: Math.max(gameScores[0], gameScores[1]) * 2 - 1,
1823            durationMs: selectedReplays
1824              .map((replay) =>
1825                Math.ceil((replay.lastFrame + 124) / frameMsDivisor),
1826              )
1827              .reduce((prev, curr) => prev + curr, 0),
1828            scores,
1829            finalScore,
1830            players: contextPlayers,
1831            startMs: startDate.getTime(),
1832          };
1833
1834          const setId = updatedSetFields ? updatedSetFields.id : selectedSet.id;
1835          const sggId = updatedSetFields
1836            ? updatedSetFields.sggId
1837            : selectedSet.sggId;
1838          if (setId) {
1839            if (mode === Mode.STARTGG) {
1840              context.startgg = {
1841                tournament: {
1842                  name: startggTournament.name,
1843                  location: startggTournament.location,
1844                },
1845                event: selectedSetChain.event!,
1846                phase: selectedSetChain.phase!,
1847                phaseGroup: selectedSetChain.phaseGroup!,
1848                set: {
1849                  id: sggId,
1850                  internalId: setId,
1851                  fullRoundText: selectedSet.fullRoundText,
1852                  ordinal: selectedSet.ordinal,
1853                  round: selectedSet.round,
1854                  stream: updatedSetFields
1855                    ? updatedSetFields.stream
1856                    : selectedSet.stream,
1857                },
1858              };
1859            } else if (mode === Mode.CHALLONGE) {
1860              context.challonge = {
1861                tournament: {
1862                  name: selectedChallongeTournament.name,
1863                  slug: selectedChallongeTournament.slug,
1864                  tournamentType: selectedChallongeTournament.tournamentType,
1865                },
1866                set: {
1867                  id: typeof setId === 'string' ? setId : undefined,
1868                  fullRoundText: selectedSet.fullRoundText,
1869                  ordinal: selectedSet.ordinal,
1870                  round: selectedSet.round,
1871                  stream: updatedSetFields
1872                    ? updatedSetFields.stream
1873                    : selectedSet.stream,
1874                },
1875              };
1876            } else if (mode === Mode.PARRYGG) {
1877              context.startgg = {
1878                tournament: {
1879                  name: parryggTournament?.name || '',
1880                  location: parryggTournament?.venueAddress || '',
1881                },
1882                event: selectedSetChain.event!,
1883                phase: selectedSetChain.phase!,
1884                phaseGroup: selectedSetChain.phaseGroup!,
1885                set: {
1886                  id: sggId,
1887                  internalId: setId,
1888                  fullRoundText: selectedSet.fullRoundText,
1889                  ordinal: selectedSet.ordinal,
1890                  round: selectedSet.round,
1891                  stream: updatedSetFields
1892                    ? updatedSetFields.stream
1893                    : selectedSet.stream,
1894                },
1895              };
1896            } else if (mode === Mode.OFFLINE_MODE) {
1897              context.startgg = {
1898                tournament: {
1899                  name: offlineModeTournament.name,
1900                  location: offlineModeTournament.location,
1901                },
1902                event: selectedSetChain.event!,
1903                phase: selectedSetChain.phase!,
1904                phaseGroup: selectedSetChain.phaseGroup!,
1905                set: {
1906                  id: sggId,
1907                  internalId: setId,
1908                  fullRoundText: selectedSet.fullRoundText,
1909                  ordinal: selectedSet.ordinal,
1910                  round: selectedSet.round,
1911                  stream: updatedSetFields
1912                    ? updatedSetFields.stream
1913                    : selectedSet.stream,
1914                },
1915              };
1916            }
1917          }
1918        }
1919      }
1920    }
1921
1922    let startTimes: string[] = [];
1923    if (copySettings.writeStartTimes && undoSubdir.length === 0) {
1924      startTimes = selectedReplays.map((replay) =>
1925        new Date(replay.startAt.getTime() + offsetMs).toISOString(),
1926      );
1927    }
1928    try {
1929      await window.electron.writeReplays(
1930        fileNames,
1931        copySettings.output,
1932        selectedReplays,
1933        startTimes,
1934        subdir,
1935        copySettings.writeDisplayNames,
1936        context,
1937      );
1938      if (violators && violators.length > 0) {
1939        const vsStr = `${selectedSet.entrant1Participants
1940          .map((participant) => participant.displayName)
1941          .join('/')} vs ${selectedSet.entrant2Participants
1942          .map((participant) => participant.displayName)
1943          .join('/')}`;
1944        let poolName = '';
1945        if (
1946          mode === Mode.STARTGG ||
1947          mode === Mode.PARRYGG ||
1948          mode === Mode.OFFLINE_MODE
1949        ) {
1950          poolName = selectedSetChain.phaseGroup?.name ?? '';
1951        } else if (mode === Mode.CHALLONGE) {
1952          poolName = selectedChallongeTournament.name;
1953        }
1954        await window.electron.appendEnforcerResult(
1955          violators
1956            .map(
1957              ({ checkNames, displayName, entrantId }) =>
1958                `${entrantId},${displayName},${Array.from(checkNames.keys())
1959                  .sort()
1960                  .join('|')},${poolName},${
1961                  selectedSet.fullRoundText
1962                },${vsStr}`,
1963            )
1964            .join('\n')
1965            .concat('\n'),
1966        );
1967      }
1968      setCopySuccess('Success!');
1969      setTimeout(() => setCopySuccess(''), 5000);
1970    } finally {
1971      setIsCopying(false);
1972    }
1973  };
1974
1975  const [undoDialogOpen, setUndoDialogOpen] = useState(false);
1976  const [gettingReportedSubdirs, setGettingReportedSubdirs] = useState(false);
1977  const [reportedSubdirs, setReportedSubdirs] = useState<string[]>([]);
1978
1979  const superKey = window.electron.isMac ? 'CMD' : 'CTRL';
1980
1981  return (
1982    <>
1983      <SlpDownloadModal
1984        status={slpDownloadStatus}
1985        onClose={async () => {
1986          setSlpDownloadStatus({ status: 'idle' });
1987        }}
1988      />
1989      <AppBar position="fixed" color="inherit">
1990        <Toolbar disableGutters variant="dense">
1991          <AppBarSection flexGrow={1} minWidth={600}>
1992            <Stack alignItems="center" direction="row">
1993              <Tooltip
1994                arrow
1995                title={
1996                  allReplaysSelected
1997                    ? 'Deselect all replays'
1998                    : 'Select all replays'
1999                }
2000              >
2001                <Checkbox
2002                  checked={allReplaysSelected}
2003                  onClick={() => {
2004                    const newAllReplaysSelected = !allReplaysSelected;
2005                    setAllReplaysSelected(newAllReplaysSelected);
2006                    applyAllReplaysSelected(replays, newAllReplaysSelected);
2007                    replays.forEach((replay) => {
2008                      replay.players.forEach((player) => {
2009                        player.playerOverrides = {
2010                          displayName: '',
2011                          entrantId: 0,
2012                          participantId: 0,
2013                          prefix: '',
2014                          pronouns: '',
2015                        };
2016                      });
2017                    });
2018                    resetOverrides();
2019                    setBatchActives(
2020                      getNewBatchActives(
2021                        replays.filter((replay) => replay.selected),
2022                      ),
2023                    );
2024                    setReplays(Array.from(replays));
2025                  }}
2026                />
2027              </Tooltip>
2028              <InputBase
2029                disabled
2030                size="small"
2031                value={
2032                  undoSubdir
2033                    ? `Fixing ${undoSubdir}`
2034                    : dir || 'Set replays folder...'
2035                }
2036                style={{ flexGrow: 1 }}
2037              />
2038              {ejected && <Typography variant="body2">Ejected!</Typography>}
2039              {undoSubdir &&
2040                (gettingReplays ? (
2041                  <CircularProgress size="24px" style={{ margin: '9px' }} />
2042                ) : (
2043                  <Tooltip arrow title="Cancel">
2044                    <IconButton
2045                      onClick={async () => {
2046                        setDir(await window.electron.setUndoSubdir(''));
2047                        setUndoSubdir('');
2048                        refreshReplays(true);
2049                      }}
2050                    >
2051                      <Close />
2052                    </IconButton>
2053                  </Tooltip>
2054                ))}
2055              {!undoSubdir && (
2056                <>
2057                  {dir && (
2058                    <Tooltip arrow title="Eject (if USB)">
2059                      <IconButton
2060                        disabled={ejecting}
2061                        onClick={async () => {
2062                          setEjecting(true);
2063                          try {
2064                            setEjected(await window.electron.maybeEject());
2065                          } finally {
2066                            setEjecting(false);
2067                          }
2068                        }}
2069                      >
2070                        <Eject />
2071                      </IconButton>
2072                    </Tooltip>
2073                  )}
2074                  {dir &&
2075                    dirExists &&
2076                    !gettingReplays &&
2077                    (replays.length > 0 || invalidReplays.length > 0) &&
2078                    (isUsb ? (
2079                      <>
2080                        <Tooltip
2081                          arrow
2082                          title={
2083                            wouldDeleteCopyDir
2084                              ? 'Would delete copy folder'
2085                              : 'Delete replays folder and eject'
2086                          }
2087                        >
2088                          <div>
2089                            <IconButton
2090                              disabled={wouldDeleteCopyDir}
2091                              onClick={() => setDirDeleteDialogOpen(true)}
2092                            >
2093                              <DeleteForeverOutlined />
2094                            </IconButton>
2095                          </div>
2096                        </Tooltip>
2097                        <Dialog
2098                          open={dirDeleteDialogOpen}
2099                          onClose={() => {
2100                            setDirDeleteDialogOpen(false);
2101                          }}
2102                        >
2103                          <DialogTitle>Delete Replays Folder?</DialogTitle>
2104                          <DialogContent>
2105                            <Alert severity="warning">
2106                              {replays.length} replays{' '}
2107                              {invalidReplays.length > 0
2108                                ? `(and ${invalidReplays.length} invalid replays) `
2109                                : ''}
2110                              will be deleted! (And the drive will be ejected if
2111                              applicable)
2112                            </Alert>
2113                          </DialogContent>
2114                          <DialogActions>
2115                            <Button
2116                              disabled={dirDeleting}
2117                              endIcon={
2118                                dirDeleting ? (
2119                                  <CircularProgress size="24px" />
2120                                ) : (
2121                                  <DeleteForever />
2122                                )
2123                              }
2124                              onClick={async () => {
2125                                try {
2126                                  await deleteDir();
2127                                  setGuideState(GuideState.NONE);
2128                                } catch (e: any) {
2129                                  showErrorDialog([
2130                                    e instanceof Error ? e.message : e,
2131                                  ]);
2132                                } finally {
2133                                  setDirDeleteDialogOpen(false);
2134                                }
2135                              }}
2136                              variant="contained"
2137                            >
2138                              Delete
2139                            </Button>
2140                          </DialogActions>
2141                        </Dialog>
2142                      </>
2143                    ) : (
2144                      <Tooltip
2145                        arrow
2146                        title={
2147                          wouldDeleteCopyDir
2148                            ? 'Would delete copy folder'
2149                            : 'Delete selected replays'
2150                        }
2151                      >
2152                        <div>
2153                          <IconButton
2154                            disabled={
2155                              selectedReplays.length === 0 ||
2156                              wouldDeleteCopyDir ||
2157                              dirDeleting
2158                            }
2159                            onClick={() => deleteSelected()}
2160                          >
2161                            <DeleteForeverOutlined />
2162                          </IconButton>
2163                        </div>
2164                      </Tooltip>
2165                    ))}
2166                  {dir && !gettingReplays && (
2167                    <Tooltip arrow title="Refresh replays">
2168                      <IconButton onClick={() => refreshReplays()}>
2169                        <Refresh />
2170                      </IconButton>
2171                    </Tooltip>
2172                  )}
2173                  {gettingReplays ? (
2174                    <CircularProgress size="24px" style={{ margin: '9px' }} />
2175                  ) : (
2176                    <Tooltip arrow title="Set replays folder">
2177                      <IconButton onClick={chooseDir}>
2178                        <FolderOpen />
2179                      </IconButton>
2180                    </Tooltip>
2181                  )}
2182                </>
2183              )}
2184            </Stack>
2185          </AppBarSection>
2186          <Divider
2187            flexItem
2188            orientation="vertical"
2189            style={{ marginTop: 8, marginBottom: 8 }}
2190          />
2191          <AppBarSection width={300}>
2192            {mode === Mode.STARTGG && (
2193              <Stack direction="row">
2194                <InputBase
2195                  disabled
2196                  size="small"
2197                  value={startggTournament.slug || 'Set start.gg tournament...'}
2198                  style={{ flexGrow: 1 }}
2199                />
2200                <Tooltip arrow title="Refresh tournament and all descendants">
2201                  <div>
2202                    <IconButton
2203                      disabled={gettingTournament}
2204                      onClick={() =>
2205                        getStartggTournament(startggTournament.slug)
2206                      }
2207                    >
2208                      {gettingTournament ? (
2209                        <CircularProgress size="24px" />
2210                      ) : (
2211                        <Refresh />
2212                      )}
2213                    </IconButton>
2214                  </div>
2215                </Tooltip>
2216                <Tooltip arrow title="Set start.gg tournament">
2217                  <IconButton
2218                    aria-label="Set start.gg tournament"
2219                    onClick={() => setSlugDialogOpen(true)}
2220                  >
2221                    <Edit />
2222                  </IconButton>
2223                </Tooltip>
2224                <Dialog
2225                  open={slugDialogOpen}
2226                  onClose={() => {
2227                    setSlugDialogOpen(false);
2228                  }}
2229                >
2230                  <StartggTournamentForm
2231                    gettingAdminedTournaments={gettingAdminedTournaments}
2232                    adminedTournaments={adminedTournaments}
2233                    gettingTournament={gettingTournament}
2234                    getAdminedTournaments={async () => {
2235                      setGettingAdminedTournaments(true);
2236                      try {
2237                        setAdminedTournaments(
2238                          await window.electron.getTournaments(),
2239                        );
2240                      } catch (e: unknown) {
2241                        showErrorDialog([
2242                          `Unable to fetch admined tournaments: ${
2243                            e instanceof Error ? e.message : e
2244                          }`,
2245                        ]);
2246                      }
2247                      setGettingAdminedTournaments(false);
2248                    }}
2249                    getTournament={getStartggTournament}
2250                    close={() => {
2251                      setSlugDialogOpen(false);
2252                    }}
2253                  />
2254                </Dialog>
2255              </Stack>
2256            )}
2257            {mode === Mode.CHALLONGE && (
2258              <Stack direction="row">
2259                <InputBase
2260                  disabled
2261                  size="small"
2262                  value="Add Challonge tournament..."
2263                  style={{ flexGrow: 1 }}
2264                />
2265                <Tooltip arrow title="Add Challonge tournament">
2266                  <IconButton
2267                    aria-label="Add Challonge tournament"
2268                    onClick={() => setSlugDialogOpen(true)}
2269                  >
2270                    <Edit />
2271                  </IconButton>
2272                </Tooltip>
2273                <Dialog
2274                  open={slugDialogOpen}
2275                  onClose={() => {
2276                    setSlugDialogOpen(false);
2277                  }}
2278                >
2279                  <ChallongeTournamentForm
2280                    gettingAdminedTournaments={gettingAdminedTournaments}
2281                    adminedTournaments={adminedTournaments}
2282                    gettingTournament={gettingTournament}
2283                    getAdminedTournaments={async () => {
2284                      setGettingAdminedTournaments(true);
2285                      try {
2286                        setAdminedTournaments(
2287                          await window.electron.getTournaments(),
2288                        );
2289                      } catch (e: unknown) {
2290                        showErrorDialog([
2291                          `Unable to fetch admined tournaments: ${
2292                            e instanceof Error ? e.message : e
2293                          }`,
2294                        ]);
2295                      }
2296                      setGettingAdminedTournaments(false);
2297                    }}
2298                    getTournament={getChallongeTournament}
2299                    close={() => {
2300                      setSlugDialogOpen(false);
2301                    }}
2302                  />
2303                </Dialog>
2304              </Stack>
2305            )}
2306            {mode === Mode.PARRYGG && (
2307              <Stack direction="row">
2308                <InputBase
2309                  disabled
2310                  size="small"
2311                  value={parryggSlug || 'Set parry.gg tournament...'}
2312                  style={{ flexGrow: 1 }}
2313                />
2314                <Tooltip arrow title="Refresh tournament and all descendants">
2315                  <div>
2316                    <IconButton
2317                      disabled={gettingTournament}
2318                      onClick={() => getParryggTournament(parryggSlug)}
2319                    >
2320                      {gettingTournament ? (
2321                        <CircularProgress size="24px" />
2322                      ) : (
2323                        <Refresh />
2324                      )}
2325                    </IconButton>
2326                  </div>
2327                </Tooltip>
2328                <Tooltip arrow title="Set parry.gg tournament">
2329                  <IconButton
2330                    aria-label="Set parry.gg tournament"
2331                    onClick={() => setParryggSlugDialogOpen(true)}
2332                  >
2333                    <Edit />
2334                  </IconButton>
2335                </Tooltip>
2336                <Dialog
2337                  open={parryggSlugDialogOpen}
2338                  onClose={() => {
2339                    setParryggSlugDialogOpen(false);
2340                  }}
2341                >
2342                  <ParryggTournamentForm
2343                    gettingAdminedTournaments={gettingAdminedTournaments}
2344                    adminedTournaments={adminedTournaments}
2345                    gettingTournament={gettingTournament}
2346                    getAdminedTournaments={async () => {
2347                      setGettingAdminedTournaments(true);
2348                      try {
2349                        setAdminedTournaments(
2350                          await window.electron.getTournaments(),
2351                        );
2352                      } catch (e: unknown) {
2353                        showErrorDialog([
2354                          `Unable to fetch admined tournaments: ${
2355                            e instanceof Error ? e.message : e
2356                          }`,
2357                        ]);
2358                      }
2359                      setGettingAdminedTournaments(false);
2360                    }}
2361                    getTournament={getParryggTournament}
2362                    close={() => {
2363                      setParryggSlugDialogOpen(false);
2364                    }}
2365                  />
2366                </Dialog>
2367              </Stack>
2368            )}
2369            {mode === Mode.OFFLINE_MODE && (
2370              <OfflineModeConnection
2371                offlineModeStatus={offlineModeStatus}
2372                offlineModeTournament={offlineModeTournament}
2373              />
2374            )}
2375            {mode === Mode.MANUAL && (
2376              <ManualBar
2377                manualDialogOpen={manualDialogOpen}
2378                setManualDialogOpen={setManualDialogOpen}
2379                manualNames={manualNames}
2380                setManualNames={setManualNamesOuter}
2381              />
2382            )}
2383          </AppBarSection>
2384        </Toolbar>
2385      </AppBar>
2386      <TopColumns
2387        direction="row"
2388        divider={<Divider flexItem orientation="vertical" />}
2389        spacing="8px"
2390      >
2391        <TopColumn flexGrow={1} minWidth="600px">
2392          {dir &&
2393            !gettingReplays &&
2394            (dirExists ? (
2395              <>
2396                <ReplayList
2397                  dirInit={dirInit}
2398                  numAvailablePlayers={availablePlayers.length}
2399                  replays={replays}
2400                  replayRefs={replayRefs}
2401                  selectedChipData={selectedChipData}
2402                  findOtherPlayer={findOtherPlayer}
2403                  onClick={onReplayClick}
2404                  onOverride={onPlayerOverride}
2405                  resetSelectedChipData={resetSelectedChipData}
2406                  elevate={
2407                    guideActive &&
2408                    guideBackdropOpen &&
2409                    guideState === GuideState.REPLAYS
2410                  }
2411                  elevateChips={
2412                    guideActive &&
2413                    guideBackdropOpen &&
2414                    guideState === GuideState.PLAYERS &&
2415                    numBatchActive !== 2 &&
2416                    numBatchActive !== 4
2417                  }
2418                  elevateNames={
2419                    guideActive &&
2420                    guideBackdropOpen &&
2421                    guideState === GuideState.PLAYERS
2422                  }
2423                />
2424                <Dialog
2425                  open={skewDialogOpen}
2426                  onClose={() => {
2427                    setSkewDialogOpen(false);
2428                  }}
2429                >
2430                  <DialogTitle>
2431                    {skewDetected
2432                      ? 'Large time gap detected!'
2433                      : 'Re-order replays'}
2434                  </DialogTitle>
2435                  <DialogContent>
2436                    {replays.map((replay, i) => (
2437                      <ListItem key={replay.fileName} disableGutters>
2438                        <Stack alignItems="center" direction="row" gap="8px">
2439                          <SkewReplay replay={replay} />
2440                          {i === 0 ? (
2441                            <Tooltip arrow placement="left" title="First">
2442                              <div style={{ height: '40px', width: '40px' }} />
2443                            </Tooltip>
2444                          ) : (
2445                            <Tooltip arrow placement="left" title="Move up">
2446                              <IconButton
2447                                onClick={() => {
2448                                  const arr = [...replays];
2449                                  [arr[i - 1], arr[i]] = [arr[i], arr[i - 1]];
2450                                  setReplays(arr);
2451                                }}
2452                              >
2453                                <ArrowUpward />
2454                              </IconButton>
2455                            </Tooltip>
2456                          )}
2457                          {i === replays.length - 1 ? (
2458                            <Tooltip arrow placement="right" title="Last">
2459                              <div style={{ height: '40px', width: '40px' }} />
2460                            </Tooltip>
2461                          ) : (
2462                            <Tooltip arrow placement="right" title="Move down">
2463                              <IconButton
2464                                onClick={() => {
2465                                  const arr = [...replays];
2466                                  [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
2467                                  setReplays(arr);
2468                                }}
2469                              >
2470                                <ArrowDownward />
2471                              </IconButton>
2472                            </Tooltip>
2473                          )}
2474                        </Stack>
2475                      </ListItem>
2476                    ))}
2477                  </DialogContent>
2478                  <DialogActions>
2479                    <Button
2480                      variant="contained"
2481                      onClick={() => {
2482                        for (let i = replays.length - 1; i > 0; i -= 1) {
2483                          const firstMs = replays[i - 1].startAt.getTime();
2484                          const secondMs = replays[i].startAt.getTime();
2485                          if (
2486                            firstMs > secondMs ||
2487                            secondMs - firstMs > 3600000
2488                          ) {
2489                            const durationMs = Math.ceil(
2490                              (replays[i - 1].lastFrame + 124) / frameMsDivisor,
2491                            );
2492                            replays[i - 1].startAt = new Date(
2493                              secondMs - durationMs,
2494                            );
2495                          }
2496                        }
2497                        setReplays([...replays]);
2498                        setSkewDialogOpen(false);
2499                      }}
2500                    >
2501                      Fix!
2502                    </Button>
2503                  </DialogActions>
2504                </Dialog>
2505              </>
2506            ) : (
2507              <Alert
2508                severity={wasDeleted ? 'warning' : 'error'}
2509                sx={{ mb: '8px', mt: '8px', pl: '10px' }}
2510              >
2511                {wasDeleted
2512                  ? 'Replays folder deleted.'
2513                  : 'Replays folder not found.'}
2514              </Alert>
2515            ))}
2516          {dir && gettingReplays && (
2517            <CircularProgress
2518              size="24px"
2519              style={{
2520                marginTop: '8px',
2521                marginBottom: '8px',
2522                marginLeft: '10px',
2523              }}
2524            />
2525          )}
2526          <div ref={copyControlsRef} />
2527          <CopyControls
2528            dir={copyDir}
2529            setDir={setCopyDir}
2530            useLAN={useLAN}
2531            host={host}
2532            hostFormat={hostFormat}
2533            error={copyError}
2534            setError={setCopyError}
2535            errorDialogOpen={copyErrorDialogOpen}
2536            setErrorDialogOpen={setCopyErrorDialogOpen}
2537            hasSelectedReplays={selectedReplays.length > 0}
2538            isCopying={isCopying}
2539            onCopy={onCopy}
2540            success={copySuccess}
2541            copySettings={copySettings}
2542            setCopySettings={setCopySettings}
2543            elevateSettings={
2544              guidedMode &&
2545              tournamentSet &&
2546              copyDirSet &&
2547              !confirmedCopySettings
2548            }
2549            vlerkMode={vlerkMode}
2550            undoSubdir={undoSubdir}
2551            hideCopyButton={hideCopyButton}
2552            setConfirmedCopySettings={setConfirmedCopySettings}
2553            guideState={guideState}
2554            setGuideBackdropOpen={setGuideBackdropOpen}
2555          />
2556        </TopColumn>
2557        <TopColumn
2558          width="300px"
2559          sx={{
2560            zIndex: (theme) =>
2561              guideActive &&
2562              guideBackdropOpen &&
2563              (guideState === GuideState.SET ||
2564                (mode === Mode.MANUAL && guideState === GuideState.PLAYERS))
2565                ? theme.zIndex.drawer + 2
2566                : undefined,
2567          }}
2568        >
2569          <RightColumn
2570            mode={mode}
2571            guideState={guideState}
2572            selectSet={selectSet}
2573            setGuideState={setGuideState}
2574            vlerkMode={vlerkMode}
2575            selectedSetChain={selectedSetChain}
2576            setSelectedSetChain={setSelectedSetChain}
2577            startggTournament={startggTournament}
2578            challongeTournaments={challongeTournaments}
2579            getChallongeTournament={getChallongeTournament}
2580            setSelectedChallongeTournament={setSelectedChallongeTournament}
2581            parryggTournament={parryggTournament}
2582            offlineModeTournament={offlineModeTournament}
2583            manualNames={manualNames}
2584            selectedChipData={selectedChipData}
2585            setSelectedChipData={setSelectedChipData}
2586          />
2587        </TopColumn>
2588      </TopColumns>
2589      <Bottom elevation={3}>
2590        <BottomColumns
2591          direction="row"
2592          divider={<Divider flexItem orientation="vertical" />}
2593          spacing="8px"
2594        >
2595          <Stack
2596            boxSizing="border-box"
2597            flexGrow={1}
2598            minWidth="600px"
2599            padding="20px 0 0 42px"
2600          >
2601            <Stack direction="row">
2602              {batchChip(0)}
2603              {batchChip(1)}
2604              {batchChip(2)}
2605              {batchChip(3)}
2606            </Stack>
2607            {guidedMode ? (
2608              <Stack
2609                alignItems="start"
2610                direction="row"
2611                flexGrow={1}
2612                justifyContent="right"
2613                marginTop="8px"
2614                spacing="8px"
2615              >
2616                <GuidedDialog
2617                  open={guidedDialogOpen}
2618                  mode={mode}
2619                  gettingAdminedTournaments={gettingAdminedTournaments}
2620                  adminedTournaments={adminedTournaments}
2621                  getAdminedTournaments={async () => {
2622                    setGettingAdminedTournaments(true);
2623                    try {
2624                      setAdminedTournaments(
2625                        await window.electron.getTournaments(),
2626                      );
2627                    } catch (e: unknown) {
2628                      showErrorDialog([
2629                        `Unable to fetch admined tournaments: ${
2630                          e instanceof Error ? e.message : e
2631                        }`,
2632                      ]);
2633                    }
2634                    setGettingAdminedTournaments(false);
2635                  }}
2636                  gettingTournament={gettingTournament}
2637                  tournamentSet={tournamentSet}
2638                  copyDirSet={copyDirSet}
2639                  getStartggTournament={getStartggTournament}
2640                  getChallongeTournament={getChallongeTournament}
2641                  getParryggTournament={getParryggTournament}
2642                  offlineModeStatus={offlineModeStatus}
2643                  manualNames={manualNames}
2644                  setManualNames={setManualNamesOuter}
2645                  setCopyDir={setCopyDir}
2646                  confirmedCopySettings={confirmedCopySettings}
2647                  state={guideState}
2648                  setState={setGuideState}
2649                  backdropOpen={guideBackdropOpen}
2650                  setBackdropOpen={setGuideBackdropOpen}
2651                />
2652                <Stack>
2653                  <Typography
2654                    variant="caption"
2655                    style={{ cursor: 'pointer' }}
2656                    onClick={() => {
2657                      setGuidedMode((old) => {
2658                        window.electron.setGuidedMode(!old);
2659                        return !old;
2660                      });
2661                    }}
2662                  >
2663                    F1: Walkthrough Mode Off
2664                  </Typography>
2665                  {(mode === Mode.STARTGG || mode === Mode.OFFLINE_MODE) && (
2666                    <Typography
2667                      variant="caption"
2668                      style={{ cursor: 'pointer' }}
2669                      onClick={() => {
2670                        window.electron.openEntrantsWindow();
2671                      }}
2672                    >
2673                      {superKey} + E: Pool Entrants
2674                    </Typography>
2675                  )}
2676                  <Typography
2677                    variant="caption"
2678                    style={{ cursor: 'pointer' }}
2679                    onClick={() => {
2680                      window.dispatchEvent(new Event(WindowEvent.CTRLF));
2681                    }}
2682                  >
2683                    {superKey} + F: Search players
2684                  </Typography>
2685                  <Typography
2686                    variant="caption"
2687                    style={{ cursor: 'pointer' }}
2688                    onClick={async () => {
2689                      setUndoDialogOpen(true);
2690                      try {
2691                        setGettingReportedSubdirs(true);
2692                        setReportedSubdirs(
2693                          await window.electron.getReportedSubdirs(),
2694                        );
2695                      } catch (e: any) {
2696                        showErrorDialog([e instanceof Error ? e.message : e]);
2697                      } finally {
2698                        setGettingReportedSubdirs(false);
2699                      }
2700                    }}
2701                  >
2702                    {superKey} + Z: Fix reported set
2703                  </Typography>
2704                </Stack>
2705              </Stack>
2706            ) : (
2707              <Stack
2708                alignItems="start"
2709                direction="row"
2710                flexGrow={1}
2711                justifyContent="right"
2712                marginTop="8px"
2713                spacing="8px"
2714              >
2715                {vlerkMode && (
2716                  <Stack alignItems="end">
2717                    <Stack direction="row" alignItems="center" gap="8px">
2718                      <FormControl>
2719                        <InputLabel
2720                          size="small"
2721                          id="vlerk-mode-character-select-label"
2722                        >
2723                          Character
2724                        </InputLabel>
2725                        <Select
2726                          label="Character"
2727                          labelId="vlerk-mode-character-select-label"
2728                          size="small"
2729                          style={{ width: '106px' }}
2730                          value={vlerkModeExternalId}
2731                          onChange={(event) => {
2732                            if (Number.isInteger(event.target.value)) {
2733                              setVlerkModeExternalId(
2734                                event.target.value as number,
2735                              );
2736                              setVlerkModeColorIndex(-1);
2737                            }
2738                          }}
2739                        >
2740                          <MenuItem value={-1}>Any</MenuItem>
2741                          {Array.from(characterNames.entries())
2742                            .sort((a, b) => a[1].localeCompare(b[1]))
2743                            .map(([externalId, characterName]) => (
2744                              <MenuItem key={externalId} value={externalId}>
2745                                {characterName}
2746                              </MenuItem>
2747                            ))}
2748                        </Select>
2749                      </FormControl>
2750                      <FormControl>
2751                        <InputLabel
2752                          size="small"
2753                          id="vlerk-mode-color-select-label"
2754                        >
2755                          Color
2756                        </InputLabel>
2757                        <Select
2758                          label="Color"
2759                          labelId="vlerk-mode-color-select-label"
2760                          size="small"
2761                          value={vlerkModeColorIndex}
2762                          onChange={(event) => {
2763                            if (Number.isInteger(event.target.value)) {
2764                              setVlerkModeColorIndex(
2765                                event.target.value as number,
2766                              );
2767                            }
2768                          }}
2769                        >
2770                          <MenuItem value={-1}>Any</MenuItem>
2771                          {vlerkModeExternalId !== -1 &&
2772                            Array(
2773                              characterColorIndexLength.get(
2774                                vlerkModeExternalId,
2775                              )!,
2776                            )
2777                              .fill(0)
2778                              .map((_, i) => i)
2779                              .map((i) => (
2780                                <MenuItem key={i} value={i}>
2781                                  <Avatar
2782                                    src={getCharacterIcon(
2783                                      vlerkModeExternalId,
2784                                      i,
2785                                    )}
2786                                    style={{ height: '24px', width: '24px' }}
2787                                    variant="square"
2788                                  />
2789                                </MenuItem>
2790                              ))}
2791                        </Select>
2792                      </FormControl>
2793                      <IconButton
2794                        disabled={
2795                          replays.length === 0 ||
2796                          (vlerkModeExternalId === -1 &&
2797                            vlerkModeColorIndex === -1)
2798                        }
2799                        onClick={() => {
2800                          for (
2801                            let i = vlerkModeFilterLastIndex + 1;
2802                            i < replays.length;
2803                            i += 1
2804                          ) {
2805                            const replay = replays[i];
2806                            if (
2807                              replay.players.some(
2808                                (player) =>
2809                                  player.playerType === 0 &&
2810                                  (vlerkModeExternalId === -1 ||
2811                                    vlerkModeExternalId ===
2812                                      player.externalCharacterId) &&
2813                                  (vlerkModeColorIndex === -1 ||
2814                                    vlerkModeColorIndex ===
2815                                      player.costumeIndex),
2816                              )
2817                            ) {
2818                              replayRefs[i].current!.scrollIntoView({
2819                                behavior: 'smooth',
2820                              });
2821                              setVlerkModeFilterLastIndex(i);
2822                              setVlerkModeFilterNotFound(false);
2823                              return;
2824                            }
2825                          }
2826                          if (vlerkModeFilterLastIndex === 0) {
2827                            setVlerkModeFilterNotFound(true);
2828                            return;
2829                          }
2830                          // return to top and continue
2831                          for (
2832                            let i = 0;
2833                            i < vlerkModeFilterLastIndex;
2834                            i += 1
2835                          ) {
2836                            const replay = replays[i];
2837                            if (
2838                              replay.players.some(
2839                                (player) =>
2840                                  player.playerType === 0 &&
2841                                  (vlerkModeExternalId === -1 ||
2842                                    vlerkModeExternalId ===
2843                                      player.externalCharacterId) &&
2844                                  (vlerkModeColorIndex === -1 ||
2845                                    vlerkModeColorIndex ===
2846                                      player.costumeIndex),
2847                              )
2848                            ) {
2849                              replayRefs[i].current!.scrollIntoView({
2850                                behavior: 'smooth',
2851                              });
2852                              setVlerkModeFilterLastIndex(i);
2853                              setVlerkModeFilterNotFound(false);
2854                              return;
2855                            }
2856                          }
2857                          setVlerkModeFilterLastIndex(0);
2858                          setVlerkModeFilterNotFound(true);
2859                        }}
2860                      >
2861                        <Search />
2862                      </IconButton>
2863                    </Stack>
2864                    {vlerkModeFilterNotFound && (
2865                      <Typography variant="body2" color="error">
2866                        Not found
2867                      </Typography>
2868                    )}
2869                  </Stack>
2870                )}
2871                <Stack>
2872                  {(mode === Mode.STARTGG || mode === Mode.OFFLINE_MODE) && (
2873                    <Typography
2874                      variant="caption"
2875                      style={{ cursor: 'pointer' }}
2876                      onClick={() => {
2877                        window.electron.openEntrantsWindow();
2878                      }}
2879                    >
2880                      {superKey} + E: Pool Entrants
2881                    </Typography>
2882                  )}
2883                  <Typography
2884                    variant="caption"
2885                    style={{ cursor: 'pointer' }}
2886                    onClick={() => {
2887                      window.dispatchEvent(new Event(WindowEvent.CTRLF));
2888                    }}
2889                  >
2890                    {superKey} + F: Search players
2891                  </Typography>
2892                  {vlerkMode && (
2893                    <Typography
2894                      variant="caption"
2895                      style={{ cursor: 'pointer' }}
2896                      onClick={() => {
2897                        window.dispatchEvent(new Event(WindowEvent.CTRLS));
2898                      }}
2899                    >
2900                      {superKey} + S: Copy replays
2901                    </Typography>
2902                  )}
2903                </Stack>
2904                <Stack>
2905                  <Typography
2906                    variant="caption"
2907                    style={{ cursor: 'pointer' }}
2908                    onClick={() => {
2909                      setSkewDialogOpen(true);
2910                    }}
2911                  >
2912                    {superKey} + T: Re-order replays
2913                  </Typography>
2914                  <Typography
2915                    variant="caption"
2916                    style={{ cursor: 'pointer' }}
2917                    onClick={async () => {
2918                      setUndoDialogOpen(true);
2919                      try {
2920                        setGettingReportedSubdirs(true);
2921                        setReportedSubdirs(
2922                          await window.electron.getReportedSubdirs(),
2923                        );
2924                      } catch (e: any) {
2925                        showErrorDialog([e instanceof Error ? e.message : e]);
2926                      } finally {
2927                        setGettingReportedSubdirs(false);
2928                      }
2929                    }}
2930                  >
2931                    {superKey} + Z: Fix reported set
2932                  </Typography>
2933                  <Typography
2934                    variant="caption"
2935                    style={{ cursor: 'pointer' }}
2936                    onClick={() => {
2937                      setGuidedMode((old) => {
2938                        window.electron.setGuidedMode(!old);
2939                        return !old;
2940                      });
2941                    }}
2942                  >
2943                    F1: Walkthrough Mode
2944                  </Typography>
2945                </Stack>
2946              </Stack>
2947            )}
2948          </Stack>
2949          <Stack justifyContent="space-between" width="300px">
2950            <Stack>
2951              {selectedSet.id !== 0 && (
2952                <>
2953                  <Stack
2954                    alignItems="center"
2955                    justifyContent="center"
2956                    direction="row"
2957                    gap="8px"
2958                  >
2959                    <Box width="16px" />
2960                    <Typography noWrap lineHeight="20px" variant="caption">
2961                      {selectedSet.fullRoundText}
2962                      {(typeof selectedSet.id === 'string' ||
2963                        (Number.isInteger(selectedSet.id) &&
2964                          selectedSet.id > 0)) &&
2965                        ` (${selectedSet.id})`}
2966                    </Typography>
2967                    {selectedSet.state === State.CALLED && (
2968                      <Tooltip arrow placement="top" title="Called">
2969                        <NotificationsActive
2970                          fontSize="inherit"
2971                          style={{ color: calledColor }}
2972                        />
2973                      </Tooltip>
2974                    )}
2975                    {selectedSet.state === State.STARTED && (
2976                      <Tooltip arrow placement="top" title="Started">
2977                        <HourglassTop
2978                          fontSize="inherit"
2979                          style={{ color: startedColor }}
2980                        />
2981                      </Tooltip>
2982                    )}
2983                    {selectedSet.state === State.COMPLETED && (
2984                      <Tooltip arrow placement="top" title="Completed">
2985                        <Backup fontSize="inherit" />
2986                      </Tooltip>
2987                    )}
2988                  </Stack>
2989                  <Tooltip arrow placement="top" title="Click or drag!">
2990                    <Stack direction="row" gap="8px">
2991                      <Stack gap="8px" width="50%">
2992                        <DraggableChip
2993                          entrantId={selectedSet.entrant1Id}
2994                          nameWithHighlight={{
2995                            name: selectedSet.entrant1Participants[0]
2996                              .displayName,
2997                          }}
2998                          participantId={selectedSet.entrant1Participants[0].id}
2999                          prefix={selectedSet.entrant1Participants[0].prefix}
3000                          pronouns={
3001                            selectedSet.entrant1Participants[0].pronouns
3002                          }
3003                          selectedChipData={selectedChipData}
3004                          setSelectedChipData={setSelectedChipData}
3005                          elevate={
3006                            guideActive &&
3007                            guideBackdropOpen &&
3008                            guideState === GuideState.PLAYERS
3009                          }
3010                        />
3011                        {selectedSet.entrant1Participants.length > 1 && (
3012                          <DraggableChip
3013                            entrantId={selectedSet.entrant1Id}
3014                            nameWithHighlight={{
3015                              name: selectedSet.entrant1Participants[1]
3016                                .displayName,
3017                            }}
3018                            participantId={
3019                              selectedSet.entrant1Participants[1].id
3020                            }
3021                            prefix={selectedSet.entrant1Participants[1].prefix}
3022                            pronouns={
3023                              selectedSet.entrant1Participants[1].pronouns
3024                            }
3025                            selectedChipData={selectedChipData}
3026                            setSelectedChipData={setSelectedChipData}
3027                            elevate={
3028                              guideActive &&
3029                              guideBackdropOpen &&
3030                              guideState === GuideState.PLAYERS
3031                            }
3032                          />
3033                        )}
3034                      </Stack>
3035                      <Stack gap="8px" width="50%">
3036                        <DraggableChip
3037                          entrantId={selectedSet.entrant2Id}
3038                          nameWithHighlight={{
3039                            name: selectedSet.entrant2Participants[0]
3040                              .displayName,
3041                          }}
3042                          participantId={selectedSet.entrant2Participants[0].id}
3043                          prefix={selectedSet.entrant2Participants[0].prefix}
3044                          pronouns={
3045                            selectedSet.entrant2Participants[0].pronouns
3046                          }
3047                          selectedChipData={selectedChipData}
3048                          setSelectedChipData={setSelectedChipData}
3049                          elevate={
3050                            guideActive &&
3051                            guideBackdropOpen &&
3052                            guideState === GuideState.PLAYERS
3053                          }
3054                        />
3055                        {selectedSet.entrant2Participants.length > 1 && (
3056                          <DraggableChip
3057                            entrantId={selectedSet.entrant2Id}
3058                            nameWithHighlight={{
3059                              name: selectedSet.entrant2Participants[1]
3060                                .displayName,
3061                            }}
3062                            participantId={
3063                              selectedSet.entrant2Participants[1].id
3064                            }
3065                            prefix={selectedSet.entrant2Participants[1].prefix}
3066                            pronouns={
3067                              selectedSet.entrant2Participants[1].pronouns
3068                            }
3069                            selectedChipData={selectedChipData}
3070                            setSelectedChipData={setSelectedChipData}
3071                            elevate={
3072                              guideActive &&
3073                              guideBackdropOpen &&
3074                              guideState === GuideState.PLAYERS
3075                            }
3076                          />
3077                        )}
3078                      </Stack>
3079                    </Stack>
3080                  </Tooltip>
3081                </>
3082              )}
3083            </Stack>
3084            <Stack direction="row" justifyContent="flex-end" paddingTop="8px">
3085              <AssignStream
3086                mode={mode}
3087                selectedSet={selectedSet}
3088                stations={stations}
3089                streams={streams}
3090                refreshStartggTournament={() =>
3091                  getStartggTournament(startggTournament.slug)
3092                }
3093              />
3094              <ResetSet mode={mode} selectedSet={selectedSet} />
3095              {(mode === Mode.STARTGG || mode === Mode.OFFLINE_MODE) && (
3096                <Tooltip arrow title="Mark set called">
3097                  <div>
3098                    <IconButton
3099                      color="primary"
3100                      disabled={
3101                        !(
3102                          (typeof selectedSet.id === 'string' ||
3103                            (Number.isInteger(selectedSet.id) &&
3104                              selectedSet.id > 0)) &&
3105                          (selectedSet.state === State.PENDING ||
3106                            selectedSet.state === State.STARTED)
3107                        ) || callingSet
3108                      }
3109                      size="small"
3110                      onClick={() => callSet(selectedSet)}
3111                    >
3112                      {callingSet ? (
3113                        <CircularProgress size="24px" />
3114                      ) : (
3115                        <NotificationsActive />
3116                      )}
3117                    </IconButton>
3118                  </div>
3119                </Tooltip>
3120              )}
3121              <Tooltip arrow title="Mark set started">
3122                <div>
3123                  <IconButton
3124                    color="primary"
3125                    disabled={
3126                      !(
3127                        (typeof selectedSet.id === 'string' ||
3128                          (Number.isInteger(selectedSet.id) &&
3129                            selectedSet.id > 0)) &&
3130                        (selectedSet.state === State.PENDING ||
3131                          selectedSet.state === State.CALLED)
3132                      ) || startingSet
3133                    }
3134                    size="small"
3135                    onClick={() => startSet(selectedSet)}
3136                  >
3137                    {startingSet ? (
3138                      <CircularProgress size="24px" />
3139                    ) : (
3140                      <HourglassTop />
3141                    )}
3142                  </IconButton>
3143                </div>
3144              </Tooltip>
3145              <ManualReport
3146                mode={mode}
3147                reportChallongeSet={reportChallongeSet}
3148                reportStartggSet={reportStartggSet}
3149                reportParryggSet={reportParryggSet}
3150                reportOfflineModeSet={reportOfflineModeSet}
3151                selectedSet={selectedSet}
3152              />
3153              <SetControls
3154                mode={mode}
3155                copyReplays={onCopy}
3156                deleteReplays={
3157                  // eslint-disable-next-line no-nested-ternary
3158                  undoSubdir ? deleteUndo : isUsb ? deleteDir : deleteSelected
3159                }
3160                reportChallongeSet={reportChallongeSet}
3161                reportStartggSet={reportStartggSet}
3162                reportParryggSet={reportParryggSet}
3163                reportOfflineModeSet={reportOfflineModeSet}
3164                setReportSettings={async (
3165                  newReportSettings: ReportSettings,
3166                ) => {
3167                  await window.electron.setReportSettings(newReportSettings);
3168                  setReportSettings(newReportSettings);
3169                }}
3170                resetGuide={() => {
3171                  setGuideState(GuideState.NONE);
3172                  setGuideBackdropOpen(false);
3173                }}
3174                isCopying={isCopying}
3175                copyDisabled={
3176                  (!copyDir && !host.address) || selectedReplays.length === 0
3177                }
3178                isDeleting={dirDeleting}
3179                dqId={dq.entrantId}
3180                hasRemainingReplays={hasRemainingReplays}
3181                reportSettings={reportSettings}
3182                selectedReplays={selectedReplays}
3183                set={selectedSet}
3184                elevate={
3185                  guideActive &&
3186                  guideBackdropOpen &&
3187                  guideState === GuideState.PLAYERS
3188                }
3189                enforcerVersion={ENFORCER_VERSION}
3190                enforcerSetting={enforcerSetting}
3191                smuggleCostumeIndex={smuggleCostumeIndex}
3192                wouldDeleteCopyDir={wouldDeleteCopyDir}
3193                replayLoadCount={replayLoadCount}
3194                undoSubdir={undoSubdir}
3195              />
3196            </Stack>
3197          </Stack>
3198        </BottomColumns>
3199      </Bottom>
3200      <Dialog
3201        open={undoDialogOpen}
3202        onClose={() => {
3203          setUndoDialogOpen(false);
3204        }}
3205      >
3206        <DialogTitle>Fix Reported Set</DialogTitle>
3207        <DialogContent>
3208          {gettingReportedSubdirs ? (
3209            <CircularProgress />
3210          ) : (
3211            <List disablePadding>
3212              {reportedSubdirs.map((reportedSubdir) => (
3213                <ListItem disablePadding key={reportedSubdir}>
3214                  <ListItemButton
3215                    disableGutters
3216                    onClick={async () => {
3217                      try {
3218                        setDir(
3219                          await window.electron.setUndoSubdir(reportedSubdir),
3220                        );
3221                        setUndoSubdir(reportedSubdir);
3222                        setUndoDialogOpen(false);
3223                        setIsUsb(false);
3224                        setWasDeleted(false);
3225                        refreshReplays(true);
3226                        setEjected(false);
3227                      } catch (e: any) {
3228                        showErrorDialog([e instanceof Error ? e.message : e]);
3229                      }
3230                    }}
3231                  >
3232                    <ListItemText>{reportedSubdir}</ListItemText>
3233                  </ListItemButton>
3234                </ListItem>
3235              ))}
3236            </List>
3237          )}
3238        </DialogContent>
3239      </Dialog>
3240      <Backdrop
3241        onClick={resetSelectedChipData}
3242        open={Boolean(
3243          selectedChipData.entrantId && selectedChipData.participantId,
3244        )}
3245        sx={{ zIndex: (theme) => theme.zIndex.drawer + 3 }}
3246      />
3247      <Backdrop
3248        onClick={() => setGuideBackdropOpen(false)}
3249        open={guidedMode && guideBackdropOpen}
3250        sx={{ zIndex: (theme) => theme.zIndex.drawer + 1 }}
3251      />
3252      <ErrorDialog
3253        messages={errors}
3254        onClose={() => {
3255          setErrors([]);
3256          setErrorDialogOpen(false);
3257        }}
3258        open={errorDialogOpen}
3259      />
3260      <Settings
3261        appVersion={appVersion}
3262        latestAppVersion={latestAppVersion}
3263        mode={mode}
3264        setMode={async (newMode: Mode) => {
3265          setMode(newMode);
3266          setSelectedSet(EMPTY_SET);
3267          setSelectedSetChain(EMPTY_SELECTED_SET_CHAIN);
3268          setSelectedChallongeTournament({
3269            name: '',
3270            slug: '',
3271            tournamentType: '',
3272          });
3273          await window.electron.setSelectedSetChain(0, 0, 0);
3274          await window.electron.setSelectedChallongeTournament('');
3275        }}
3276        useLAN={useLAN}
3277        setUseLAN={setUseLAN}
3278        enforcerSetting={enforcerSetting}
3279        setEnforcerSetting={setEnforcerSetting}
3280        vlerkMode={vlerkMode}
3281        setVlerkMode={setVlerkMode}
3282        guidedMode={guidedMode}
3283        setGuidedMode={setGuidedMode}
3284        smuggleCostumeIndex={smuggleCostumeIndex}
3285        setSmuggleCostumeIndex={setSmuggleCostumeIndex}
3286        fileNameFormat={fileNameFormat}
3287        setFileNameFormat={setFileNameFormat}
3288        folderNameFormat={folderNameFormat}
3289        setFolderNameFormat={setFolderNameFormat}
3290        hideCopyButton={hideCopyButton}
3291        setHideCopyButton={setHideCopyButton}
3292        setAdminedTournaments={setAdminedTournaments}
3293        showErrorDialog={showErrorDialog}
3294        enforcerVersion={ENFORCER_VERSION}
3295        hostFormat={hostFormat}
3296      />
3297      <GlobalHotKeys
3298        keyMap={{
3299          COPY: window.electron.isMac
3300            ? ['command+s', 'command+S']
3301            : ['ctrl+s', 'ctrl+S'],
3302          ENTRANTS: window.electron.isMac
3303            ? ['command+e', 'command+E']
3304            : ['ctrl+e', 'ctrl+E'],
3305          ESC: 'escape',
3306          FIND: window.electron.isMac
3307            ? ['command+f', 'command+F']
3308            : ['ctrl+f', 'ctrl+F'],
3309          SKEW: window.electron.isMac
3310            ? ['command+t', 'command+T']
3311            : ['ctrl+t', 'ctrl+T'],
3312          UNDO: window.electron.isMac
3313            ? ['command+z', 'command+Z']
3314            : ['ctrl+z', 'ctrl+Z'],
3315          WALKTHROUGH: 'F1',
3316        }}
3317        handlers={{
3318          COPY: () => {
3319            window.dispatchEvent(new Event(WindowEvent.CTRLS));
3320          },
3321          ENTRANTS: () => {
3322            window.electron.openEntrantsWindow();
3323          },
3324          ESC: () => {
3325            window.dispatchEvent(new Event(WindowEvent.ESCAPE));
3326          },
3327          FIND: () => {
3328            window.dispatchEvent(new Event(WindowEvent.CTRLF));
3329          },
3330          SKEW: () => {
3331            setSkewDialogOpen(true);
3332          },
3333          UNDO: async () => {
3334            setUndoDialogOpen(true);
3335            try {
3336              setGettingReportedSubdirs(true);
3337              setReportedSubdirs(await window.electron.getReportedSubdirs());
3338            } catch (e: any) {
3339              showErrorDialog([e instanceof Error ? e.message : e]);
3340            } finally {
3341              setGettingReportedSubdirs(false);
3342            }
3343          },
3344          WALKTHROUGH: () => {
3345            setGuidedMode((old) => {
3346              window.electron.setGuidedMode(!old);
3347              return !old;
3348            });
3349          },
3350        }}
3351      />
3352    </>
3353  );
3354}
3355
3356export default function App() {
3357  return (
3358    <Router>
3359      <Routes>
3360        <Route path="/" element={<Hello />} />
3361      </Routes>
3362    </Router>
3363  );
3364}