fork/replay-manager-for-slippi

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

Grant Warmanadd character & stage reporting for parrygg (#197)82b5e4d

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