fork/replay-manager-for-slippi

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

Nicoletbetter admined tournamentscbf5f06

main
116.4 KiB3371 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 (usedFilenames: string[]) => {
809    if (!dir || wouldDeleteCopyDir) {
810      return;
811    }
812
813    setDirDeleting(true);
814    setEjecting(true);
815    try {
816      setEjected(await window.electron.deleteReplaysDir(usedFilenames));
817      setWasDeleted(true);
818      await refreshReplays();
819    } finally {
820      setDirDeleting(false);
821      setEjecting(false);
822    }
823  };
824  const deleteSelected = async (used: boolean) => {
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        used,
834      );
835      await refreshReplays();
836    } finally {
837      setDirDeleting(false);
838    }
839  };
840  const deleteUndo = async () => {
841    if (!dir || !undoSubdir || wouldDeleteCopyDir) {
842      return;
843    }
844
845    setDirDeleting(true);
846    try {
847      setDir(await window.electron.deleteUndoSrcDst());
848      setUndoSubdir('');
849      refreshReplays(true);
850    } finally {
851      setDirDeleting(false);
852    }
853  };
854  const onPlayerOverride = () => {
855    setReplays(Array.from(replays));
856  };
857  const onReplayClick = (index: number) => {
858    const newReplays = Array.from(replays);
859    newReplays[index].selected = !newReplays[index].selected;
860    const newBatchActives = getNewBatchActives(
861      newReplays.filter((replay) => replay.selected),
862    );
863
864    const newOverrides = Array.from(overrides) as [
865      PlayerOverrides,
866      PlayerOverrides,
867      PlayerOverrides,
868      PlayerOverrides,
869    ];
870    for (let i = 0; i < 4; i += 1) {
871      if (batchActives[i].active && !newBatchActives[i].active) {
872        newOverrides[i] = {
873          displayName: '',
874          entrantId: 0,
875          participantId: 0,
876          prefix: '',
877          pronouns: '',
878        };
879      }
880    }
881
882    if (newReplays[index].selected) {
883      newReplays[index].players.forEach((player, i) => {
884        player.playerOverrides = { ...newOverrides[i] };
885      });
886    } else {
887      newReplays[index].players.forEach((player) => {
888        player.playerOverrides = {
889          displayName: '',
890          entrantId: 0,
891          participantId: 0,
892          prefix: '',
893          pronouns: '',
894        };
895      });
896    }
897
898    setBatchActives(newBatchActives);
899    setOverrides(newOverrides);
900    setReplays(newReplays);
901    resetDq();
902  };
903  useEffect(() => {
904    window.electron.onTournament(
905      (
906        e,
907        {
908          selectedSet: newSelectedSet,
909          startggTournament: newTournament,
910          challongeTournaments: newChallongeTournaments,
911          parryggTournament: newParryggTournament,
912          offlineModeTournament: newOfflineModeTournament,
913        },
914      ) => {
915        if (newSelectedSet) {
916          setSelectedSet(newSelectedSet);
917        }
918        if (newTournament) {
919          if (tournamentSet && copyDirSet && confirmedCopySettings) {
920            setGuideBackdropOpen(false);
921          }
922          setStartggTournament(newTournament);
923        }
924        if (newChallongeTournaments) {
925          if (tournamentSet && copyDirSet && confirmedCopySettings) {
926            setGuideBackdropOpen(false);
927          }
928          setChallongeTournaments(newChallongeTournaments);
929        }
930        if (newParryggTournament) {
931          if (tournamentSet && copyDirSet && confirmedCopySettings) {
932            setGuideBackdropOpen(false);
933          }
934          setParryggTournament(newParryggTournament);
935        }
936        if (newOfflineModeTournament) {
937          if (tournamentSet && copyDirSet && confirmedCopySettings) {
938            setGuideBackdropOpen(false);
939          }
940          setOfflineModeTournament(newOfflineModeTournament);
941        }
942      },
943      selectedSet.id,
944    );
945  }, [confirmedCopySettings, copyDirSet, selectedSet, tournamentSet]);
946
947  useEffect(() => {
948    window.electron.onUsb((e, newDir, newIsUsb) => {
949      if (!undoSubdir) {
950        setDir(newDir);
951        setIsUsb(newIsUsb);
952        setWasDeleted(false);
953        refreshReplays(true);
954        setEjected(false);
955      }
956    });
957  }, [refreshReplays, undoSubdir]);
958
959  const availablePlayers: PlayerOverrides[] = [];
960  selectedSet.entrant1Participants.forEach((participant) => {
961    availablePlayers.push({
962      displayName: participant.displayName,
963      entrantId: selectedSet.entrant1Id,
964      participantId: participant.id,
965      prefix: participant.prefix,
966      pronouns: participant.pronouns,
967    });
968  });
969  selectedSet.entrant2Participants.forEach((participant) => {
970    availablePlayers.push({
971      displayName: participant.displayName,
972      entrantId: selectedSet.entrant1Id,
973      participantId: participant.id,
974      prefix: participant.prefix,
975      pronouns: participant.pronouns,
976    });
977  });
978
979  const [slugDialogOpen, setSlugDialogOpen] = useState(false);
980  const [parryggSlugDialogOpen, setParryggSlugDialogOpen] = useState(false);
981  const [gettingTournament, setGettingTournament] = useState(false);
982
983  // Challonge tournament view
984  const getChallongeTournament = async (maybeSlug: string) => {
985    if (!maybeSlug) {
986      return;
987    }
988
989    setGettingTournament(true);
990    try {
991      await window.electron.getChallongeTournament(maybeSlug);
992    } catch (e: any) {
993      showErrorDialog([e.toString()]);
994    } finally {
995      setGettingTournament(false);
996    }
997  };
998
999  const getParryggTournament = async (
1000    maybeSlug: string,
1001    initial: boolean = false,
1002  ) => {
1003    if (!maybeSlug) {
1004      return;
1005    }
1006
1007    setGettingTournament(true);
1008    try {
1009      await window.electron.getParryggTournament(
1010        maybeSlug,
1011        initial && vlerkMode,
1012      );
1013      if (parryggSlug !== maybeSlug) {
1014        setSelectedSet(EMPTY_SET);
1015        setSelectedSetChain(EMPTY_SELECTED_SET_CHAIN);
1016        await window.electron.setSelectedSetChain('', '', '');
1017      }
1018    } catch (e: any) {
1019      showErrorDialog([e.toString()]);
1020    } finally {
1021      setGettingTournament(false);
1022    }
1023  };
1024
1025  const findOtherPlayer = (
1026    entrantId: Id,
1027    participantId: Id,
1028  ): PlayerOverrides => {
1029    const isEntrant1 = entrantId === selectedSet.entrant1Id;
1030    const isTeams = selectedSet.entrant1Participants.length > 1;
1031    if (isEntrant1 && isTeams) {
1032      const participantToCheck = selectedSet.entrant1Participants.find(
1033        (participant) => participant.id !== participantId,
1034      );
1035      if (participantToCheck) {
1036        return {
1037          displayName: participantToCheck.displayName,
1038          entrantId: selectedSet.entrant1Id,
1039          participantId: participantToCheck.id,
1040          prefix: participantToCheck.prefix,
1041          pronouns: participantToCheck.pronouns,
1042        };
1043      }
1044    } else if (!isEntrant1 && isTeams) {
1045      const participantToCheck = selectedSet.entrant2Participants.find(
1046        (participant) => participant.id !== participantId,
1047      );
1048      if (participantToCheck) {
1049        return {
1050          displayName: participantToCheck.displayName,
1051          entrantId: selectedSet.entrant2Id,
1052          participantId: participantToCheck.id,
1053          prefix: participantToCheck.prefix,
1054          pronouns: participantToCheck.pronouns,
1055        };
1056      }
1057    } else if (isEntrant1 && !isTeams) {
1058      return {
1059        displayName: selectedSet.entrant2Participants[0].displayName,
1060        entrantId: selectedSet.entrant2Id,
1061        participantId: selectedSet.entrant2Participants[0].id,
1062        prefix: selectedSet.entrant2Participants[0].prefix,
1063        pronouns: selectedSet.entrant2Participants[0].pronouns,
1064      };
1065    } else if (!isEntrant1 && !isTeams) {
1066      return {
1067        displayName: selectedSet.entrant1Participants[0].displayName,
1068        entrantId: selectedSet.entrant1Id,
1069        participantId: selectedSet.entrant1Participants[0].id,
1070        prefix: selectedSet.entrant1Participants[0].prefix,
1071        pronouns: selectedSet.entrant1Participants[0].pronouns,
1072      };
1073    }
1074    return {
1075      displayName: '',
1076      entrantId: 0,
1077      participantId: 0,
1078      prefix: '',
1079      pronouns: '',
1080    };
1081  };
1082
1083  // for click-assigning set participants
1084  const [selectedChipData, setSelectedChipData] = useState<PlayerOverrides>({
1085    displayName: '',
1086    entrantId: 0,
1087    participantId: 0,
1088    prefix: '',
1089    pronouns: '',
1090  });
1091  const resetSelectedChipData = () => {
1092    setSelectedChipData({
1093      displayName: '',
1094      entrantId: 0,
1095      participantId: 0,
1096      prefix: '',
1097      pronouns: '',
1098    });
1099  };
1100
1101  // batch chips
1102  const onClickOrDrop = (
1103    displayName: string,
1104    entrantId: Id,
1105    participantId: Id,
1106    prefix: string,
1107    pronouns: string,
1108    index: number,
1109  ) => {
1110    const newOverrides = Array.from(overrides) as [
1111      PlayerOverrides,
1112      PlayerOverrides,
1113      PlayerOverrides,
1114      PlayerOverrides,
1115    ];
1116    newOverrides[index] = {
1117      displayName,
1118      entrantId,
1119      participantId,
1120      prefix,
1121      pronouns,
1122    };
1123    newOverrides.forEach((override, i) => {
1124      if (
1125        i !== index &&
1126        override.entrantId === entrantId &&
1127        override.participantId === participantId
1128      ) {
1129        override.displayName = '';
1130        override.entrantId = 0;
1131        override.participantId = 0;
1132        override.prefix = '';
1133        override.pronouns = '';
1134      }
1135    });
1136
1137    // pigeonhole remaining player if possible
1138    if (numBatchActive === availablePlayers.length) {
1139      const { teamI } = batchActives[index];
1140      const isTeams = availablePlayers.length === 4 && teamI !== -1;
1141
1142      // find if there's exactly one hole to pigeon
1143      const elligibleIndicies: number[] = [];
1144      for (let i = 0; i < 4; i += 1) {
1145        if (
1146          batchActives[i].active &&
1147          (!isTeams || batchActives[i].teamI === teamI) &&
1148          newOverrides[i].participantId !== participantId
1149        ) {
1150          elligibleIndicies.push(i);
1151        }
1152      }
1153      if (elligibleIndicies.length === 1) {
1154        const otherPlayer = findOtherPlayer(entrantId, participantId);
1155        if (otherPlayer.entrantId && otherPlayer.participantId) {
1156          newOverrides[elligibleIndicies[0]] = otherPlayer;
1157          newOverrides.forEach((override, i) => {
1158            if (
1159              i !== elligibleIndicies[0] &&
1160              override.entrantId === otherPlayer.entrantId &&
1161              override.participantId === otherPlayer.participantId
1162            ) {
1163              override.displayName = '';
1164              override.entrantId = 0;
1165              override.participantId = 0;
1166              override.prefix = '';
1167              override.pronouns = '';
1168            }
1169          });
1170        }
1171      }
1172    }
1173
1174    selectedReplays.forEach((replay) => {
1175      replay.players[index].playerOverrides = { ...newOverrides[index] };
1176      replay.players.forEach((otherPlayer) => {
1177        if (
1178          otherPlayer.port === replay.players[index].port ||
1179          (otherPlayer.playerType !== 0 && otherPlayer.playerType !== 1)
1180        ) {
1181          return;
1182        }
1183        if (
1184          otherPlayer.playerOverrides.displayName === displayName &&
1185          otherPlayer.playerOverrides.entrantId
1186        ) {
1187          otherPlayer.playerOverrides.displayName = '';
1188          otherPlayer.playerOverrides.entrantId = 0;
1189          otherPlayer.playerOverrides.participantId = 0;
1190          otherPlayer.playerOverrides.prefix = '';
1191          otherPlayer.playerOverrides.pronouns = '';
1192        }
1193      });
1194      for (let i = 0; i < 4; i += 1) {
1195        replay.players[i].playerOverrides = { ...newOverrides[i] };
1196      }
1197    });
1198    setOverrides(newOverrides);
1199    resetDq();
1200    resetSelectedChipData();
1201  };
1202  const batchChip = (index: number) => {
1203    const { active } = batchActives[index];
1204    return (
1205      <DroppableChip
1206        active={active}
1207        label={overrides[index].displayName || `P${index + 1} (all games)`}
1208        outlined={active}
1209        selectedChipData={selectedChipData}
1210        style={{ width: '25%' }}
1211        onClickOrDrop={(
1212          displayName: string,
1213          entrantId: Id,
1214          participantId: Id,
1215          prefix: string,
1216          pronouns: string,
1217        ) =>
1218          onClickOrDrop(
1219            displayName,
1220            entrantId,
1221            participantId,
1222            prefix,
1223            pronouns,
1224            index,
1225          )
1226        }
1227      />
1228    );
1229  };
1230
1231  const getStartggTournament = async (
1232    maybeSlug: string,
1233    initial: boolean = false,
1234  ) => {
1235    if (!maybeSlug) {
1236      return;
1237    }
1238
1239    setGettingTournament(true);
1240    try {
1241      await window.electron.getStartggTournament(
1242        maybeSlug,
1243        initial && vlerkMode,
1244      );
1245      if (startggTournament.slug !== maybeSlug) {
1246        setSelectedSet(EMPTY_SET);
1247        setSelectedSetChain(EMPTY_SELECTED_SET_CHAIN);
1248        await window.electron.setSelectedSetChain(0, 0, 0);
1249      }
1250    } catch (e: any) {
1251      showErrorDialog([e.toString()]);
1252    } finally {
1253      setGettingTournament(false);
1254    }
1255  };
1256
1257  // set controls
1258  const selectSet = (set: Set) => {
1259    const newOverrides: [
1260      PlayerOverrides,
1261      PlayerOverrides,
1262      PlayerOverrides,
1263      PlayerOverrides,
1264    ] = [
1265      {
1266        displayName: '',
1267        entrantId: 0,
1268        participantId: 0,
1269        prefix: '',
1270        pronouns: '',
1271      },
1272      {
1273        displayName: '',
1274        entrantId: 0,
1275        participantId: 0,
1276        prefix: '',
1277        pronouns: '',
1278      },
1279      {
1280        displayName: '',
1281        entrantId: 0,
1282        participantId: 0,
1283        prefix: '',
1284        pronouns: '',
1285      },
1286      {
1287        displayName: '',
1288        entrantId: 0,
1289        participantId: 0,
1290        prefix: '',
1291        pronouns: '',
1292      },
1293    ];
1294    selectedReplays.forEach((replay) => {
1295      replay.players.forEach((player, i) => {
1296        player.playerOverrides = { ...newOverrides[i] };
1297      });
1298    });
1299    const newReplays = Array.from(replays);
1300    setSelectedSet(set);
1301    setOverrides(newOverrides);
1302    setReplays(newReplays);
1303  };
1304
1305  const [callingSet, setCallingSet] = useState(false);
1306  const callSet = async (originalSet: Set) => {
1307    setCallingSet(true);
1308    try {
1309      if (mode === Mode.STARTGG) {
1310        await window.electron.callSet(originalSet);
1311      } else if (mode === Mode.OFFLINE_MODE) {
1312        await window.electron.callOfflineModeSet(assertInteger(originalSet.id));
1313      }
1314    } catch (e: any) {
1315      showErrorDialog([e.toString()]);
1316    } finally {
1317      setCallingSet(false);
1318    }
1319  };
1320
1321  const [startingSet, setStartingSet] = useState(false);
1322  const startSet = async (originalSet: Set) => {
1323    setStartingSet(true);
1324    try {
1325      if (mode === Mode.STARTGG) {
1326        await window.electron.startSet(originalSet);
1327      } else if (mode === Mode.CHALLONGE) {
1328        await window.electron.startChallongeSet(
1329          selectedChallongeTournament.slug,
1330          assertString(originalSet.id),
1331        );
1332      } else if (mode === Mode.PARRYGG) {
1333        await window.electron.startParryggSet(assertString(originalSet.id));
1334      } else if (mode === Mode.OFFLINE_MODE) {
1335        await window.electron.startOfflineModeSet(
1336          assertInteger(originalSet.id),
1337        );
1338      }
1339    } catch (e: any) {
1340      showErrorDialog([e.toString()]);
1341    } finally {
1342      setStartingSet(false);
1343    }
1344  };
1345
1346  const reportStartggSet = useCallback(
1347    async (set: StartggSet, originalSet: Set) => {
1348      const updatedSet =
1349        originalSet.state === State.COMPLETED
1350          ? await window.electron.updateSet(set)
1351          : await window.electron.reportSet(set, originalSet);
1352      resetDq();
1353      return updatedSet;
1354    },
1355    [resetDq],
1356  );
1357  const reportChallongeSet = useCallback(
1358    async (matchId: string, items: ChallongeMatchItem[]) => {
1359      const updatedSet = await window.electron.reportChallongeSet(
1360        matchId,
1361        items,
1362      );
1363      resetDq();
1364      return updatedSet;
1365    },
1366    [resetDq],
1367  );
1368  const reportParryggSet = useCallback(
1369    async (
1370      result: MatchResult.AsObject,
1371      originalSet: Set,
1372      games?: ParryggGame[],
1373    ) => {
1374      const updatedSet = await window.electron.reportParryggSet(
1375        assertString(originalSet.id),
1376        result,
1377        games,
1378      );
1379      resetDq();
1380      return updatedSet;
1381    },
1382    [resetDq],
1383  );
1384  const reportOfflineModeSet = useCallback(
1385    async (set: StartggSet) => {
1386      const updatedSet = await window.electron.reportOfflineModeSet(
1387        assertInteger(set.setId),
1388        assertInteger(set.winnerId),
1389        set.isDQ,
1390        set.gameData,
1391      );
1392      resetDq();
1393      return updatedSet;
1394    },
1395    [resetDq],
1396  );
1397
1398  // copy
1399  type NameObj = {
1400    characterName: string;
1401    displayName: string;
1402    entrantId: Id;
1403    participantId: Id;
1404    nametag: string;
1405  };
1406  type NamesObj = {
1407    characterNames: Map<string, number>;
1408    displayName: string;
1409    entrantId: Id;
1410    participantId: Id;
1411    nametags: Map<string, number>;
1412  };
1413  type CombinedNameObj = {
1414    characterNames: string[];
1415    displayName: string;
1416    entrantId: Id;
1417    participantId: Id;
1418    nametags: string[];
1419  };
1420
1421  const [isCopying, setIsCopying] = useState(false);
1422  const [copyError, setCopyError] = useState('');
1423  const [copyErrorDialogOpen, setCopyErrorDialogOpen] = useState(false);
1424  const [copySuccess, setCopySuccess] = useState('');
1425
1426  const onCopy = async (
1427    updatedSetFields?: {
1428      id: Id;
1429      sggId: number | null;
1430      completedAtMs: number;
1431      stream: Stream | null;
1432    },
1433    violators?: {
1434      checkNames: Map<string, boolean>;
1435      displayName: string;
1436      entrantId: Id;
1437    }[],
1438  ) => {
1439    setIsCopying(true);
1440
1441    let offsetMs = 0;
1442    let startDate = selectedReplays[0].startAt;
1443    if (copySettings.writeStartTimes && undoSubdir.length === 0) {
1444      const lastReplay = selectedReplays[selectedReplays.length - 1];
1445      const lastStartMs = lastReplay.startAt.getTime();
1446      const completedMs =
1447        (updatedSetFields
1448          ? updatedSetFields.completedAtMs
1449          : selectedSet.completedAtMs) || Date.now();
1450      offsetMs =
1451        completedMs -
1452        lastStartMs -
1453        Math.round((lastReplay.lastFrame + 124) / frameMsDivisor);
1454      startDate = new Date(selectedReplays[0].startAt.getTime() + offsetMs);
1455    }
1456
1457    let fileNames = selectedReplays.map((replay) => replay.fileName);
1458    let subdir = '';
1459    let context: Context | undefined;
1460    if (
1461      copySettings.writeFileNames ||
1462      copySettings.output === Output.FOLDER ||
1463      copySettings.output === Output.ZIP
1464    ) {
1465      let allEntrantIdsSet = true;
1466      const nameObjs = selectedReplays.map((replay) =>
1467        replay.players.map((player): NameObj => {
1468          if (player.playerType === 0 || player.playerType === 1) {
1469            if (!player.playerOverrides.entrantId) {
1470              allEntrantIdsSet = false;
1471            }
1472            return {
1473              characterName: characterNames.get(player.externalCharacterId)!,
1474              displayName:
1475                player.playerOverrides.displayName || player.displayName,
1476              entrantId: player.playerOverrides.entrantId,
1477              participantId: player.playerOverrides.participantId,
1478              nametag: player.nametag,
1479            };
1480          }
1481          return {
1482            characterName: '',
1483            displayName: '',
1484            entrantId: 0,
1485            participantId: 0,
1486            nametag: '',
1487          };
1488        }),
1489      );
1490
1491      const nameObjToPlayerOnly = (nameObj: NameObj) => {
1492        if (nameObj.displayName) {
1493          return nameObj.displayName;
1494        }
1495        if (nameObj.nametag) {
1496          return nameObj.nametag;
1497        }
1498        return nameObj.characterName;
1499      };
1500      const combinedNameObjToPlayerOnly = (
1501        combinedNameObj: CombinedNameObj,
1502      ) => {
1503        if (combinedNameObj.displayName) {
1504          return combinedNameObj.displayName;
1505        }
1506        if (combinedNameObj.nametags.length > 0) {
1507          return combinedNameObj.nametags.join(', ');
1508        }
1509        return combinedNameObj.characterNames.join(', ');
1510      };
1511      const nameObjToPlayerChar = (nameObj: NameObj) => {
1512        if (nameObj.displayName) {
1513          return `${nameObj.displayName} (${nameObj.characterName})`;
1514        }
1515        if (nameObj.nametag) {
1516          return `${nameObj.characterName} (${nameObj.nametag})`;
1517        }
1518        return nameObj.characterName;
1519      };
1520      const combinedNameObjToPlayerChar = (
1521        combinedNameObj: CombinedNameObj,
1522      ) => {
1523        if (combinedNameObj.displayName) {
1524          return `${
1525            combinedNameObj.displayName
1526          } (${combinedNameObj.characterNames.join(', ')})`;
1527        }
1528        if (combinedNameObj.nametags.length > 0) {
1529          return `${combinedNameObj.characterNames.join(
1530            ', ',
1531          )} (${combinedNameObj.nametags.join(', ')})`;
1532        }
1533        return combinedNameObj.characterNames.join(', ');
1534      };
1535      const entrant1CombinedNameObjs: CombinedNameObj[] = [];
1536      const entrant2CombinedNameObjs: CombinedNameObj[] = [];
1537
1538      let roundShort = '';
1539      const regex = /([A-Z]|[0-9])/g;
1540      let regexRes = regex.exec(selectedSet.fullRoundText);
1541      while (regexRes) {
1542        roundShort += regexRes[0];
1543        regexRes = regex.exec(selectedSet.fullRoundText);
1544      }
1545      const roundLong = String(selectedSet.fullRoundText);
1546      if (
1547        copySettings.output === Output.FOLDER ||
1548        copySettings.output === Output.ZIP
1549      ) {
1550        const namesObjs: NamesObj[] = nameObjs[0].map((nameObj) => ({
1551          characterNames: new Map([[nameObj.characterName, 0]]),
1552          displayName: nameObj.displayName,
1553          entrantId: nameObj.entrantId,
1554          participantId: nameObj.participantId,
1555          nametags: new Map([[nameObj.nametag, 0]]),
1556        }));
1557        if (allEntrantIdsSet) {
1558          for (let i = 1; i < nameObjs.length; i += 1) {
1559            for (let j = 0; j < nameObjs[i].length; j += 1) {
1560              const nameObj = nameObjs[i][j];
1561              const existingNamesObj = namesObjs.find(
1562                (namesObj) =>
1563                  namesObj.entrantId === nameObj.entrantId &&
1564                  namesObj.participantId === nameObj.participantId,
1565              )!;
1566              if (
1567                nameObj.characterName &&
1568                !existingNamesObj.characterNames.has(nameObj.characterName)
1569              ) {
1570                existingNamesObj.characterNames.set(nameObj.characterName, i);
1571              }
1572              if (
1573                nameObj.nametag &&
1574                !existingNamesObj.nametags.has(nameObj.nametag)
1575              ) {
1576                existingNamesObj.nametags.set(nameObj.nametag, i);
1577              }
1578            }
1579          }
1580        } else {
1581          for (let i = 1; i < nameObjs.length; i += 1) {
1582            for (let j = 0; j < nameObjs[i].length; j += 1) {
1583              const nameObj = nameObjs[i][j];
1584              if (nameObj.characterName) {
1585                namesObjs[j].displayName = nameObj.displayName;
1586                namesObjs[j].entrantId = nameObj.entrantId;
1587                if (!namesObjs[j].characterNames.has(nameObj.characterName)) {
1588                  namesObjs[j].characterNames.set(nameObj.characterName, i);
1589                }
1590              }
1591              if (
1592                nameObj.nametag &&
1593                !namesObjs[i].nametags.has(nameObj.nametag)
1594              ) {
1595                namesObjs[i].nametags.set(nameObj.nametag, j);
1596              }
1597            }
1598          }
1599        }
1600        const combinedNameObjs: CombinedNameObj[] = namesObjs
1601          .map((namesObj) => ({
1602            displayName: namesObj.displayName,
1603            entrantId: namesObj.entrantId,
1604            participantId: namesObj.participantId,
1605            characterNames: [...namesObj.characterNames.entries()]
1606              .sort(([, a], [, b]) => a - b)
1607              .map((entry) => entry[0]),
1608            nametags: [...namesObj.nametags.entries()]
1609              .sort(([, a], [, b]) => a - b)
1610              .map((entry) => entry[0]),
1611          }))
1612          .filter((nameObj) =>
1613            nameObj.characterNames.some((characterName) => characterName),
1614          );
1615
1616        selectedSet.entrant1Participants.forEach((participant) => {
1617          const combinedNameObj = combinedNameObjs.find(
1618            (cbn) => cbn.participantId === participant.id,
1619          );
1620          if (combinedNameObj) {
1621            entrant1CombinedNameObjs.push(combinedNameObj);
1622          }
1623        });
1624        selectedSet.entrant2Participants.forEach((participant) => {
1625          const combinedNameObj = combinedNameObjs.find(
1626            (cbn) => cbn.participantId === participant.id,
1627          );
1628          if (combinedNameObj) {
1629            entrant2CombinedNameObjs.push(combinedNameObj);
1630          }
1631        });
1632
1633        const playersOnly = `${entrant1CombinedNameObjs
1634          .map(combinedNameObjToPlayerOnly)
1635          .join(' + ')} vs ${entrant2CombinedNameObjs
1636          .map(combinedNameObjToPlayerOnly)
1637          .join(' + ')}`;
1638        const playersChars = `${entrant1CombinedNameObjs
1639          .map(combinedNameObjToPlayerChar)
1640          .join(' + ')} vs ${entrant2CombinedNameObjs
1641          .map(combinedNameObjToPlayerChar)
1642          .join(' + ')}`;
1643        const singlesChars =
1644          combinedNameObjs.length === 4 ? playersOnly : playersChars;
1645        subdir = String(folderNameFormat);
1646        subdir = subdir.replace('{date}', format(startDate, 'yyyyMMdd'));
1647        subdir = subdir.replace('{time}', format(startDate, 'HHmm'));
1648        subdir = subdir.replace('{roundShort}', roundShort);
1649        subdir = subdir.replace('{roundLong}', roundLong);
1650        subdir = subdir.replace('{games}', selectedReplays.length.toString(10));
1651
1652        // do last in case tournament/event/phase/phase group names contain template strings LOL
1653        let tournamentName = '';
1654        let tournamentSlug = '';
1655        if (mode === Mode.STARTGG) {
1656          tournamentName = startggTournament.name;
1657          tournamentSlug = startggTournament.slug;
1658        } else if (mode === Mode.CHALLONGE) {
1659          tournamentName = selectedChallongeTournament.name;
1660          tournamentSlug = selectedChallongeTournament.slug;
1661        } else if (mode === Mode.PARRYGG) {
1662          tournamentName = parryggTournament?.name ?? '';
1663          tournamentSlug = parryggSlug;
1664        } else if (mode === Mode.OFFLINE_MODE) {
1665          tournamentName = offlineModeTournament.name;
1666          tournamentSlug = offlineModeTournament.slug;
1667        }
1668        subdir = subdir.replace('{tournamentName}', tournamentName);
1669        subdir = subdir.replace('{tournamentSlug}', tournamentSlug);
1670
1671        let eventName = '';
1672        let phaseName = '';
1673        let phaseGroupName = '';
1674        let phaseOrEvent = '';
1675        if (
1676          mode === Mode.STARTGG ||
1677          mode === Mode.PARRYGG ||
1678          mode === Mode.OFFLINE_MODE
1679        ) {
1680          eventName = selectedSetChain.event?.name ?? '';
1681          phaseName = selectedSetChain.phase?.name ?? '';
1682          phaseGroupName = selectedSetChain.phaseGroup?.name ?? '';
1683          if (selectedSetChain.phase?.hasSiblings) {
1684            phaseOrEvent = selectedSetChain.phase.name;
1685          } else if (selectedSetChain.event) {
1686            phaseOrEvent = selectedSetChain.event.name;
1687          }
1688        }
1689        subdir = subdir.replace('{event}', eventName);
1690        subdir = subdir.replace('{phase}', phaseName);
1691        subdir = subdir.replace('{phaseGroup}', phaseGroupName);
1692        subdir = subdir.replace('{phaseOrEvent}', phaseOrEvent);
1693
1694        // do last in case player names contain template strings LOL
1695        subdir = subdir.replace('{playersOnly}', playersOnly);
1696        subdir = subdir.replace('{playersChars}', playersChars);
1697        subdir = subdir.replace('{singlesChars}', singlesChars);
1698      }
1699
1700      if (copySettings.writeFileNames) {
1701        fileNames = nameObjs.map((game, i) => {
1702          const { stageId, startAt } = selectedReplays[i];
1703          const writeStartDate =
1704            copySettings.writeStartTimes && undoSubdir.length === 0
1705              ? new Date(startAt.getTime() + offsetMs)
1706              : startAt;
1707          const time = format(writeStartDate, 'HHmmss');
1708          const names = game.filter((nameObj) => nameObj.characterName);
1709          const playersOnly = names.map(nameObjToPlayerOnly).join(', ');
1710          const playersChars = names.map(nameObjToPlayerChar).join(', ');
1711          const singlesChars =
1712            nameObjs.length === 4 ? playersOnly : playersChars;
1713
1714          let fileName = `{ordinal}${fileNameFormat}`;
1715          fileName = fileName.replace(
1716            '{date}',
1717            format(writeStartDate, 'yyyyMMdd'),
1718          );
1719          fileName = fileName.replace('{time}', time);
1720          fileName = fileName.replace('{roundShort}', roundShort);
1721          fileName = fileName.replace('{roundLong}', roundLong);
1722          fileName = fileName.replace('{stage}', stageNames.get(stageId) || '');
1723          fileName = fileName.replace(
1724            '{ordinal}',
1725            copySettings.output === Output.FILES ? time : (i + 1).toString(10),
1726          );
1727          // do last in case player names contain template strings LOL
1728          fileName = fileName.replace('{playersOnly}', playersOnly);
1729          fileName = fileName.replace('{playersChars}', playersChars);
1730          fileName = fileName.replace('{singlesChars}', singlesChars);
1731          return `${fileName}.slp`;
1732        });
1733      }
1734
1735      if (
1736        copySettings.writeContext &&
1737        (copySettings.output === Output.FOLDER ||
1738          copySettings.output === Output.ZIP)
1739      ) {
1740        let canWriteContext = true;
1741        const scores: ContextScore[] = [];
1742        const gameScores = [0, 0];
1743        selectedReplays.forEach((replay) => {
1744          const slots: ContextSlot[] = [];
1745          const usedK = new Map<number, boolean>();
1746          for (let j = 0; j < 2; j += 1) {
1747            slots[j] = {
1748              displayNames: [],
1749              ports: [],
1750              prefixes: [],
1751              pronouns: [],
1752              score: gameScores[j],
1753            };
1754            let teamId: number | undefined;
1755            for (let k = 0; k < replay.players.length; k += 1) {
1756              const player = replay.players[k];
1757              if (
1758                (player.playerType === 0 || player.playerType === 1) &&
1759                !usedK.has(k) &&
1760                (teamId === undefined || teamId === player.teamId)
1761              ) {
1762                const displayName =
1763                  player.playerOverrides.displayName || player.displayName;
1764                if (!displayName) {
1765                  canWriteContext = false;
1766                }
1767                slots[j].displayNames.push(displayName);
1768                slots[j].ports.push(player.port);
1769                slots[j].prefixes.push(player.playerOverrides.prefix);
1770                slots[j].pronouns.push(player.playerOverrides.pronouns);
1771                if (player.isWinner) {
1772                  gameScores[j] += 1;
1773                }
1774                usedK.set(k, true);
1775                if (replay.isTeams) {
1776                  if (teamId === undefined) {
1777                    teamId = player.teamId;
1778                  }
1779                } else {
1780                  break;
1781                }
1782              }
1783            }
1784          }
1785          scores.push({ slots: [slots[0], slots[1]] });
1786        });
1787        const lastScore = scores[scores.length - 1];
1788        const finalScore: ContextScore = {
1789          slots: [
1790            {
1791              displayNames: lastScore.slots[0].displayNames,
1792              ports: lastScore.slots[0].ports,
1793              prefixes: lastScore.slots[0].prefixes,
1794              pronouns: lastScore.slots[0].pronouns,
1795              score: gameScores[0],
1796            },
1797            {
1798              displayNames: lastScore.slots[1].displayNames,
1799              ports: lastScore.slots[1].ports,
1800              prefixes: lastScore.slots[1].prefixes,
1801              pronouns: lastScore.slots[1].pronouns,
1802              score: gameScores[1],
1803            },
1804          ],
1805        };
1806        if (canWriteContext) {
1807          const contextPlayers: ContextPlayers = {
1808            entrant1: entrant1CombinedNameObjs.map((cbn) => ({
1809              name: cbn.displayName,
1810              characters: cbn.characterNames,
1811            })),
1812            entrant2: entrant2CombinedNameObjs.map((cbn) => ({
1813              name: cbn.displayName,
1814              characters: cbn.characterNames,
1815            })),
1816          };
1817          context = {
1818            bestOf: Math.max(gameScores[0], gameScores[1]) * 2 - 1,
1819            durationMs: selectedReplays
1820              .map((replay) =>
1821                Math.ceil((replay.lastFrame + 124) / frameMsDivisor),
1822              )
1823              .reduce((prev, curr) => prev + curr, 0),
1824            scores,
1825            finalScore,
1826            players: contextPlayers,
1827            startMs: startDate.getTime(),
1828          };
1829
1830          const setId = updatedSetFields ? updatedSetFields.id : selectedSet.id;
1831          const sggId = updatedSetFields
1832            ? updatedSetFields.sggId
1833            : selectedSet.sggId;
1834          if (setId) {
1835            if (mode === Mode.STARTGG) {
1836              context.startgg = {
1837                tournament: {
1838                  name: startggTournament.name,
1839                  location: startggTournament.location,
1840                },
1841                event: selectedSetChain.event!,
1842                phase: selectedSetChain.phase!,
1843                phaseGroup: selectedSetChain.phaseGroup!,
1844                set: {
1845                  id: sggId,
1846                  internalId: setId,
1847                  fullRoundText: selectedSet.fullRoundText,
1848                  ordinal: selectedSet.ordinal,
1849                  round: selectedSet.round,
1850                  stream: updatedSetFields
1851                    ? updatedSetFields.stream
1852                    : selectedSet.stream,
1853                },
1854              };
1855            } else if (mode === Mode.CHALLONGE) {
1856              context.challonge = {
1857                tournament: {
1858                  name: selectedChallongeTournament.name,
1859                  slug: selectedChallongeTournament.slug,
1860                  tournamentType: selectedChallongeTournament.tournamentType,
1861                },
1862                set: {
1863                  id: typeof setId === 'string' ? setId : undefined,
1864                  fullRoundText: selectedSet.fullRoundText,
1865                  ordinal: selectedSet.ordinal,
1866                  round: selectedSet.round,
1867                  stream: updatedSetFields
1868                    ? updatedSetFields.stream
1869                    : selectedSet.stream,
1870                },
1871              };
1872            } else if (mode === Mode.PARRYGG) {
1873              context.startgg = {
1874                tournament: {
1875                  name: parryggTournament?.name || '',
1876                  location: parryggTournament?.venueAddress || '',
1877                },
1878                event: selectedSetChain.event!,
1879                phase: selectedSetChain.phase!,
1880                phaseGroup: selectedSetChain.phaseGroup!,
1881                set: {
1882                  id: sggId,
1883                  internalId: setId,
1884                  fullRoundText: selectedSet.fullRoundText,
1885                  ordinal: selectedSet.ordinal,
1886                  round: selectedSet.round,
1887                  stream: updatedSetFields
1888                    ? updatedSetFields.stream
1889                    : selectedSet.stream,
1890                },
1891              };
1892            } else if (mode === Mode.OFFLINE_MODE) {
1893              context.startgg = {
1894                tournament: {
1895                  name: offlineModeTournament.name,
1896                  location: offlineModeTournament.location,
1897                },
1898                event: selectedSetChain.event!,
1899                phase: selectedSetChain.phase!,
1900                phaseGroup: selectedSetChain.phaseGroup!,
1901                set: {
1902                  id: sggId,
1903                  internalId: setId,
1904                  fullRoundText: selectedSet.fullRoundText,
1905                  ordinal: selectedSet.ordinal,
1906                  round: selectedSet.round,
1907                  stream: updatedSetFields
1908                    ? updatedSetFields.stream
1909                    : selectedSet.stream,
1910                },
1911              };
1912            }
1913          }
1914        }
1915      }
1916    }
1917
1918    let startTimes: string[] = [];
1919    if (copySettings.writeStartTimes && undoSubdir.length === 0) {
1920      startTimes = selectedReplays.map((replay) =>
1921        new Date(replay.startAt.getTime() + offsetMs).toISOString(),
1922      );
1923    }
1924    try {
1925      await window.electron.writeReplays(
1926        fileNames,
1927        copySettings.output,
1928        selectedReplays,
1929        startTimes,
1930        subdir,
1931        copySettings.writeDisplayNames,
1932        context,
1933      );
1934      if (violators && violators.length > 0) {
1935        const vsStr = `${selectedSet.entrant1Participants
1936          .map((participant) => participant.displayName)
1937          .join('/')} vs ${selectedSet.entrant2Participants
1938          .map((participant) => participant.displayName)
1939          .join('/')}`;
1940        let poolName = '';
1941        if (
1942          mode === Mode.STARTGG ||
1943          mode === Mode.PARRYGG ||
1944          mode === Mode.OFFLINE_MODE
1945        ) {
1946          poolName = selectedSetChain.phaseGroup?.name ?? '';
1947        } else if (mode === Mode.CHALLONGE) {
1948          poolName = selectedChallongeTournament.name;
1949        }
1950        await window.electron.appendEnforcerResult(
1951          violators
1952            .map(
1953              ({ checkNames, displayName, entrantId }) =>
1954                `${entrantId},${displayName},${Array.from(checkNames.keys())
1955                  .sort()
1956                  .join('|')},${poolName},${
1957                  selectedSet.fullRoundText
1958                },${vsStr}`,
1959            )
1960            .join('\n')
1961            .concat('\n'),
1962        );
1963      }
1964      setCopySuccess('Success!');
1965      setTimeout(() => setCopySuccess(''), 5000);
1966    } finally {
1967      setIsCopying(false);
1968    }
1969  };
1970
1971  const [undoDialogOpen, setUndoDialogOpen] = useState(false);
1972  const [gettingReportedSubdirs, setGettingReportedSubdirs] = useState(false);
1973  const [reportedSubdirs, setReportedSubdirs] = useState<string[]>([]);
1974
1975  const superKey = window.electron.isMac ? 'CMD' : 'CTRL';
1976
1977  return (
1978    <>
1979      <SlpDownloadModal
1980        status={slpDownloadStatus}
1981        onClose={async () => {
1982          setSlpDownloadStatus({ status: 'idle' });
1983        }}
1984      />
1985      <AppBar position="fixed" color="inherit">
1986        <Toolbar disableGutters variant="dense">
1987          <AppBarSection flexGrow={1} minWidth={600}>
1988            <Stack alignItems="center" direction="row">
1989              <Tooltip
1990                arrow
1991                title={
1992                  allReplaysSelected
1993                    ? 'Deselect all replays'
1994                    : 'Select all replays'
1995                }
1996              >
1997                <Checkbox
1998                  checked={allReplaysSelected}
1999                  onClick={() => {
2000                    const newAllReplaysSelected = !allReplaysSelected;
2001                    setAllReplaysSelected(newAllReplaysSelected);
2002                    applyAllReplaysSelected(replays, newAllReplaysSelected);
2003                    replays.forEach((replay) => {
2004                      replay.players.forEach((player) => {
2005                        player.playerOverrides = {
2006                          displayName: '',
2007                          entrantId: 0,
2008                          participantId: 0,
2009                          prefix: '',
2010                          pronouns: '',
2011                        };
2012                      });
2013                    });
2014                    resetOverrides();
2015                    setBatchActives(
2016                      getNewBatchActives(
2017                        replays.filter((replay) => replay.selected),
2018                      ),
2019                    );
2020                    setReplays(Array.from(replays));
2021                  }}
2022                />
2023              </Tooltip>
2024              <InputBase
2025                disabled
2026                size="small"
2027                value={
2028                  undoSubdir
2029                    ? `Fixing ${undoSubdir}`
2030                    : dir || 'Set replays folder...'
2031                }
2032                style={{ flexGrow: 1 }}
2033              />
2034              {ejected && <Typography variant="body2">Ejected!</Typography>}
2035              {undoSubdir &&
2036                (gettingReplays ? (
2037                  <CircularProgress size="24px" style={{ margin: '9px' }} />
2038                ) : (
2039                  <Tooltip arrow title="Cancel">
2040                    <IconButton
2041                      onClick={async () => {
2042                        setDir(await window.electron.setUndoSubdir(''));
2043                        setUndoSubdir('');
2044                        refreshReplays(true);
2045                      }}
2046                    >
2047                      <Close />
2048                    </IconButton>
2049                  </Tooltip>
2050                ))}
2051              {!undoSubdir && (
2052                <>
2053                  {dir && (
2054                    <Tooltip arrow title="Eject (if USB)">
2055                      <IconButton
2056                        disabled={ejecting}
2057                        onClick={async () => {
2058                          setEjecting(true);
2059                          try {
2060                            setEjected(await window.electron.maybeEject());
2061                          } finally {
2062                            setEjecting(false);
2063                          }
2064                        }}
2065                      >
2066                        <Eject />
2067                      </IconButton>
2068                    </Tooltip>
2069                  )}
2070                  {dir &&
2071                    dirExists &&
2072                    !gettingReplays &&
2073                    (replays.length > 0 || invalidReplays.length > 0) &&
2074                    (isUsb ? (
2075                      <>
2076                        <Tooltip
2077                          arrow
2078                          title={
2079                            wouldDeleteCopyDir
2080                              ? 'Would delete copy folder'
2081                              : 'Delete replays folder and eject'
2082                          }
2083                        >
2084                          <div>
2085                            <IconButton
2086                              disabled={wouldDeleteCopyDir}
2087                              onClick={() => setDirDeleteDialogOpen(true)}
2088                            >
2089                              <DeleteForeverOutlined />
2090                            </IconButton>
2091                          </div>
2092                        </Tooltip>
2093                        <Dialog
2094                          open={dirDeleteDialogOpen}
2095                          onClose={() => {
2096                            setDirDeleteDialogOpen(false);
2097                          }}
2098                        >
2099                          <DialogTitle>Delete Replays Folder?</DialogTitle>
2100                          <DialogContent>
2101                            <Alert severity="warning">
2102                              {replays.length} replays{' '}
2103                              {invalidReplays.length > 0
2104                                ? `(and ${invalidReplays.length} invalid replays) `
2105                                : ''}
2106                              will be deleted! (And the drive will be ejected if
2107                              applicable)
2108                            </Alert>
2109                          </DialogContent>
2110                          <DialogActions>
2111                            <Button
2112                              disabled={dirDeleting}
2113                              endIcon={
2114                                dirDeleting ? (
2115                                  <CircularProgress size="24px" />
2116                                ) : (
2117                                  <DeleteForever />
2118                                )
2119                              }
2120                              onClick={async () => {
2121                                try {
2122                                  await deleteDir([]);
2123                                  setGuideState(GuideState.NONE);
2124                                } catch (e: any) {
2125                                  showErrorDialog([
2126                                    e instanceof Error ? e.message : e,
2127                                  ]);
2128                                } finally {
2129                                  setDirDeleteDialogOpen(false);
2130                                }
2131                              }}
2132                              variant="contained"
2133                            >
2134                              Delete
2135                            </Button>
2136                          </DialogActions>
2137                        </Dialog>
2138                      </>
2139                    ) : (
2140                      <Tooltip
2141                        arrow
2142                        title={
2143                          wouldDeleteCopyDir
2144                            ? 'Would delete copy folder'
2145                            : 'Delete selected replays'
2146                        }
2147                      >
2148                        <div>
2149                          <IconButton
2150                            disabled={
2151                              selectedReplays.length === 0 ||
2152                              wouldDeleteCopyDir ||
2153                              dirDeleting
2154                            }
2155                            onClick={() => deleteSelected(false)}
2156                          >
2157                            <DeleteForeverOutlined />
2158                          </IconButton>
2159                        </div>
2160                      </Tooltip>
2161                    ))}
2162                  {dir && !gettingReplays && (
2163                    <Tooltip arrow title="Refresh replays">
2164                      <IconButton onClick={() => refreshReplays()}>
2165                        <Refresh />
2166                      </IconButton>
2167                    </Tooltip>
2168                  )}
2169                  {gettingReplays ? (
2170                    <CircularProgress size="24px" style={{ margin: '9px' }} />
2171                  ) : (
2172                    <Tooltip arrow title="Set replays folder">
2173                      <IconButton onClick={chooseDir}>
2174                        <FolderOpen />
2175                      </IconButton>
2176                    </Tooltip>
2177                  )}
2178                </>
2179              )}
2180            </Stack>
2181          </AppBarSection>
2182          <Divider
2183            flexItem
2184            orientation="vertical"
2185            style={{ marginTop: 8, marginBottom: 8 }}
2186          />
2187          <AppBarSection width={300}>
2188            {mode === Mode.STARTGG && (
2189              <Stack direction="row">
2190                <InputBase
2191                  disabled
2192                  size="small"
2193                  value={startggTournament.slug || 'Set start.gg tournament...'}
2194                  style={{ flexGrow: 1 }}
2195                />
2196                <Tooltip arrow title="Refresh tournament and all descendants">
2197                  <div>
2198                    <IconButton
2199                      disabled={gettingTournament}
2200                      onClick={() =>
2201                        getStartggTournament(startggTournament.slug)
2202                      }
2203                    >
2204                      {gettingTournament ? (
2205                        <CircularProgress size="24px" />
2206                      ) : (
2207                        <Refresh />
2208                      )}
2209                    </IconButton>
2210                  </div>
2211                </Tooltip>
2212                <Tooltip arrow title="Set start.gg tournament">
2213                  <IconButton
2214                    aria-label="Set start.gg tournament"
2215                    onClick={() => setSlugDialogOpen(true)}
2216                  >
2217                    <Edit />
2218                  </IconButton>
2219                </Tooltip>
2220                <Dialog
2221                  open={slugDialogOpen}
2222                  onClose={() => {
2223                    setSlugDialogOpen(false);
2224                  }}
2225                >
2226                  <StartggTournamentForm
2227                    gettingAdminedTournaments={gettingAdminedTournaments}
2228                    adminedTournaments={adminedTournaments}
2229                    gettingTournament={gettingTournament}
2230                    getAdminedTournaments={async () => {
2231                      setGettingAdminedTournaments(true);
2232                      try {
2233                        setAdminedTournaments(
2234                          await window.electron.getTournaments(),
2235                        );
2236                      } catch (e: unknown) {
2237                        showErrorDialog([
2238                          `Unable to fetch admined tournaments: ${
2239                            e instanceof Error ? e.message : e
2240                          }`,
2241                        ]);
2242                      }
2243                      setGettingAdminedTournaments(false);
2244                    }}
2245                    getTournament={getStartggTournament}
2246                    close={() => {
2247                      setSlugDialogOpen(false);
2248                    }}
2249                  />
2250                </Dialog>
2251              </Stack>
2252            )}
2253            {mode === Mode.CHALLONGE && (
2254              <Stack direction="row">
2255                <InputBase
2256                  disabled
2257                  size="small"
2258                  value="Add Challonge tournament..."
2259                  style={{ flexGrow: 1 }}
2260                />
2261                <Tooltip arrow title="Add Challonge tournament">
2262                  <IconButton
2263                    aria-label="Add Challonge tournament"
2264                    onClick={() => setSlugDialogOpen(true)}
2265                  >
2266                    <Edit />
2267                  </IconButton>
2268                </Tooltip>
2269                <Dialog
2270                  open={slugDialogOpen}
2271                  onClose={() => {
2272                    setSlugDialogOpen(false);
2273                  }}
2274                >
2275                  <ChallongeTournamentForm
2276                    gettingAdminedTournaments={gettingAdminedTournaments}
2277                    adminedTournaments={adminedTournaments}
2278                    gettingTournament={gettingTournament}
2279                    getAdminedTournaments={async () => {
2280                      setGettingAdminedTournaments(true);
2281                      try {
2282                        setAdminedTournaments(
2283                          await window.electron.getTournaments(),
2284                        );
2285                      } catch (e: unknown) {
2286                        showErrorDialog([
2287                          `Unable to fetch admined tournaments: ${
2288                            e instanceof Error ? e.message : e
2289                          }`,
2290                        ]);
2291                      }
2292                      setGettingAdminedTournaments(false);
2293                    }}
2294                    getTournament={getChallongeTournament}
2295                    close={() => {
2296                      setSlugDialogOpen(false);
2297                    }}
2298                  />
2299                </Dialog>
2300              </Stack>
2301            )}
2302            {mode === Mode.PARRYGG && (
2303              <Stack direction="row">
2304                <InputBase
2305                  disabled
2306                  size="small"
2307                  value={parryggSlug || 'Set parry.gg tournament...'}
2308                  style={{ flexGrow: 1 }}
2309                />
2310                <Tooltip arrow title="Refresh tournament and all descendants">
2311                  <div>
2312                    <IconButton
2313                      disabled={gettingTournament}
2314                      onClick={() => getParryggTournament(parryggSlug)}
2315                    >
2316                      {gettingTournament ? (
2317                        <CircularProgress size="24px" />
2318                      ) : (
2319                        <Refresh />
2320                      )}
2321                    </IconButton>
2322                  </div>
2323                </Tooltip>
2324                <Tooltip arrow title="Set parry.gg tournament">
2325                  <IconButton
2326                    aria-label="Set parry.gg tournament"
2327                    onClick={() => setParryggSlugDialogOpen(true)}
2328                  >
2329                    <Edit />
2330                  </IconButton>
2331                </Tooltip>
2332                <Dialog
2333                  open={parryggSlugDialogOpen}
2334                  onClose={() => {
2335                    setParryggSlugDialogOpen(false);
2336                  }}
2337                >
2338                  <ParryggTournamentForm
2339                    gettingAdminedTournaments={gettingAdminedTournaments}
2340                    adminedTournaments={adminedTournaments}
2341                    gettingTournament={gettingTournament}
2342                    getAdminedTournaments={async () => {
2343                      setGettingAdminedTournaments(true);
2344                      try {
2345                        setAdminedTournaments(
2346                          await window.electron.getTournaments(),
2347                        );
2348                      } catch (e: unknown) {
2349                        showErrorDialog([
2350                          `Unable to fetch admined tournaments: ${
2351                            e instanceof Error ? e.message : e
2352                          }`,
2353                        ]);
2354                      }
2355                      setGettingAdminedTournaments(false);
2356                    }}
2357                    getTournament={getParryggTournament}
2358                    close={() => {
2359                      setParryggSlugDialogOpen(false);
2360                    }}
2361                  />
2362                </Dialog>
2363              </Stack>
2364            )}
2365            {mode === Mode.OFFLINE_MODE && (
2366              <OfflineModeConnection
2367                offlineModeStatus={offlineModeStatus}
2368                offlineModeTournament={offlineModeTournament}
2369              />
2370            )}
2371            {mode === Mode.MANUAL && (
2372              <ManualBar
2373                manualDialogOpen={manualDialogOpen}
2374                setManualDialogOpen={setManualDialogOpen}
2375                manualNames={manualNames}
2376                setManualNames={setManualNamesOuter}
2377              />
2378            )}
2379          </AppBarSection>
2380        </Toolbar>
2381      </AppBar>
2382      <TopColumns
2383        direction="row"
2384        divider={<Divider flexItem orientation="vertical" />}
2385        spacing="8px"
2386      >
2387        <TopColumn flexGrow={1} minWidth="600px">
2388          {dir &&
2389            !gettingReplays &&
2390            (dirExists ? (
2391              <>
2392                <ReplayList
2393                  dirInit={dirInit}
2394                  numAvailablePlayers={availablePlayers.length}
2395                  replays={replays}
2396                  replayRefs={replayRefs}
2397                  selectedChipData={selectedChipData}
2398                  findOtherPlayer={findOtherPlayer}
2399                  onClick={onReplayClick}
2400                  onOverride={onPlayerOverride}
2401                  resetSelectedChipData={resetSelectedChipData}
2402                  elevate={
2403                    guideActive &&
2404                    guideBackdropOpen &&
2405                    guideState === GuideState.REPLAYS
2406                  }
2407                  elevateChips={
2408                    guideActive &&
2409                    guideBackdropOpen &&
2410                    guideState === GuideState.PLAYERS &&
2411                    numBatchActive !== 2 &&
2412                    numBatchActive !== 4
2413                  }
2414                  elevateNames={
2415                    guideActive &&
2416                    guideBackdropOpen &&
2417                    guideState === GuideState.PLAYERS
2418                  }
2419                />
2420                <Dialog
2421                  open={skewDialogOpen}
2422                  onClose={() => {
2423                    setSkewDialogOpen(false);
2424                  }}
2425                >
2426                  <DialogTitle>
2427                    {skewDetected
2428                      ? 'Large time gap detected!'
2429                      : 'Re-order replays'}
2430                  </DialogTitle>
2431                  <DialogContent>
2432                    {replays.map((replay, i) => (
2433                      <ListItem key={replay.fileName} disableGutters>
2434                        <Stack alignItems="center" direction="row" gap="8px">
2435                          <SkewReplay replay={replay} />
2436                          {i === 0 ? (
2437                            <Tooltip arrow placement="left" title="First">
2438                              <div style={{ height: '40px', width: '40px' }} />
2439                            </Tooltip>
2440                          ) : (
2441                            <Tooltip arrow placement="left" title="Move up">
2442                              <IconButton
2443                                onClick={() => {
2444                                  const arr = [...replays];
2445                                  [arr[i - 1], arr[i]] = [arr[i], arr[i - 1]];
2446                                  setReplays(arr);
2447                                }}
2448                              >
2449                                <ArrowUpward />
2450                              </IconButton>
2451                            </Tooltip>
2452                          )}
2453                          {i === replays.length - 1 ? (
2454                            <Tooltip arrow placement="right" title="Last">
2455                              <div style={{ height: '40px', width: '40px' }} />
2456                            </Tooltip>
2457                          ) : (
2458                            <Tooltip arrow placement="right" title="Move down">
2459                              <IconButton
2460                                onClick={() => {
2461                                  const arr = [...replays];
2462                                  [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
2463                                  setReplays(arr);
2464                                }}
2465                              >
2466                                <ArrowDownward />
2467                              </IconButton>
2468                            </Tooltip>
2469                          )}
2470                        </Stack>
2471                      </ListItem>
2472                    ))}
2473                  </DialogContent>
2474                  <DialogActions>
2475                    <Button
2476                      variant="contained"
2477                      onClick={() => {
2478                        for (let i = replays.length - 1; i > 0; i -= 1) {
2479                          const firstMs = replays[i - 1].startAt.getTime();
2480                          const secondMs = replays[i].startAt.getTime();
2481                          if (
2482                            firstMs > secondMs ||
2483                            secondMs - firstMs > 3600000
2484                          ) {
2485                            const durationMs = Math.ceil(
2486                              (replays[i - 1].lastFrame + 124) / frameMsDivisor,
2487                            );
2488                            replays[i - 1].startAt = new Date(
2489                              secondMs - durationMs,
2490                            );
2491                          }
2492                        }
2493                        setReplays([...replays]);
2494                        setSkewDialogOpen(false);
2495                      }}
2496                    >
2497                      Fix!
2498                    </Button>
2499                  </DialogActions>
2500                </Dialog>
2501              </>
2502            ) : (
2503              <Alert
2504                severity={wasDeleted ? 'warning' : 'error'}
2505                sx={{ mb: '8px', mt: '8px', pl: '10px' }}
2506              >
2507                {wasDeleted
2508                  ? 'Replays folder deleted.'
2509                  : 'Replays folder not found.'}
2510              </Alert>
2511            ))}
2512          {dir && gettingReplays && (
2513            <CircularProgress
2514              size="24px"
2515              style={{
2516                marginTop: '8px',
2517                marginBottom: '8px',
2518                marginLeft: '10px',
2519              }}
2520            />
2521          )}
2522          <div ref={copyControlsRef} />
2523          <CopyControls
2524            dir={copyDir}
2525            setDir={setCopyDir}
2526            useLAN={useLAN}
2527            host={host}
2528            hostFormat={hostFormat}
2529            error={copyError}
2530            setError={setCopyError}
2531            errorDialogOpen={copyErrorDialogOpen}
2532            setErrorDialogOpen={setCopyErrorDialogOpen}
2533            hasSelectedReplays={selectedReplays.length > 0}
2534            isCopying={isCopying}
2535            onCopy={onCopy}
2536            success={copySuccess}
2537            copySettings={copySettings}
2538            setCopySettings={setCopySettings}
2539            elevateSettings={
2540              guidedMode &&
2541              tournamentSet &&
2542              copyDirSet &&
2543              !confirmedCopySettings
2544            }
2545            vlerkMode={vlerkMode}
2546            undoSubdir={undoSubdir}
2547            hideCopyButton={hideCopyButton}
2548            setConfirmedCopySettings={setConfirmedCopySettings}
2549            guideState={guideState}
2550            setGuideBackdropOpen={setGuideBackdropOpen}
2551          />
2552        </TopColumn>
2553        <TopColumn
2554          width="300px"
2555          sx={{
2556            zIndex: (theme) =>
2557              guideActive &&
2558              guideBackdropOpen &&
2559              (guideState === GuideState.SET ||
2560                (mode === Mode.MANUAL && guideState === GuideState.PLAYERS))
2561                ? theme.zIndex.drawer + 2
2562                : undefined,
2563          }}
2564        >
2565          <RightColumn
2566            mode={mode}
2567            guideState={guideState}
2568            selectSet={selectSet}
2569            setGuideState={setGuideState}
2570            vlerkMode={vlerkMode}
2571            selectedSetChain={selectedSetChain}
2572            setSelectedSetChain={setSelectedSetChain}
2573            startggTournament={startggTournament}
2574            challongeTournaments={challongeTournaments}
2575            getChallongeTournament={getChallongeTournament}
2576            setSelectedChallongeTournament={setSelectedChallongeTournament}
2577            parryggTournament={parryggTournament}
2578            offlineModeTournament={offlineModeTournament}
2579            manualNames={manualNames}
2580            selectedChipData={selectedChipData}
2581            setSelectedChipData={setSelectedChipData}
2582          />
2583        </TopColumn>
2584      </TopColumns>
2585      <Bottom elevation={3}>
2586        <BottomColumns
2587          direction="row"
2588          divider={<Divider flexItem orientation="vertical" />}
2589          spacing="8px"
2590        >
2591          <Stack
2592            boxSizing="border-box"
2593            flexGrow={1}
2594            minWidth="600px"
2595            padding="20px 0 0 42px"
2596          >
2597            <Stack direction="row">
2598              {batchChip(0)}
2599              {batchChip(1)}
2600              {batchChip(2)}
2601              {batchChip(3)}
2602            </Stack>
2603            {guidedMode ? (
2604              <Stack
2605                alignItems="start"
2606                direction="row"
2607                flexGrow={1}
2608                justifyContent="right"
2609                marginTop="8px"
2610                spacing="8px"
2611              >
2612                <GuidedDialog
2613                  open={guidedDialogOpen}
2614                  mode={mode}
2615                  gettingAdminedTournaments={gettingAdminedTournaments}
2616                  adminedTournaments={adminedTournaments}
2617                  getAdminedTournaments={async () => {
2618                    setGettingAdminedTournaments(true);
2619                    try {
2620                      setAdminedTournaments(
2621                        await window.electron.getTournaments(),
2622                      );
2623                    } catch (e: unknown) {
2624                      showErrorDialog([
2625                        `Unable to fetch admined tournaments: ${
2626                          e instanceof Error ? e.message : e
2627                        }`,
2628                      ]);
2629                    }
2630                    setGettingAdminedTournaments(false);
2631                  }}
2632                  gettingTournament={gettingTournament}
2633                  tournamentSet={tournamentSet}
2634                  copyDirSet={copyDirSet}
2635                  getStartggTournament={getStartggTournament}
2636                  getChallongeTournament={getChallongeTournament}
2637                  getParryggTournament={getParryggTournament}
2638                  offlineModeStatus={offlineModeStatus}
2639                  manualNames={manualNames}
2640                  setManualNames={setManualNamesOuter}
2641                  setCopyDir={setCopyDir}
2642                  confirmedCopySettings={confirmedCopySettings}
2643                  state={guideState}
2644                  setState={setGuideState}
2645                  backdropOpen={guideBackdropOpen}
2646                  setBackdropOpen={setGuideBackdropOpen}
2647                />
2648                <Stack>
2649                  <Typography
2650                    variant="caption"
2651                    style={{ cursor: 'pointer' }}
2652                    onClick={() => {
2653                      setGuidedMode((old) => {
2654                        window.electron.setGuidedMode(!old);
2655                        return !old;
2656                      });
2657                    }}
2658                  >
2659                    F1: Walkthrough Mode Off
2660                  </Typography>
2661                  {(mode === Mode.STARTGG || mode === Mode.OFFLINE_MODE) && (
2662                    <Typography
2663                      variant="caption"
2664                      style={{ cursor: 'pointer' }}
2665                      onClick={() => {
2666                        window.electron.openEntrantsWindow();
2667                      }}
2668                    >
2669                      {superKey} + E: Pool Entrants
2670                    </Typography>
2671                  )}
2672                  <Typography
2673                    variant="caption"
2674                    style={{ cursor: 'pointer' }}
2675                    onClick={() => {
2676                      window.dispatchEvent(new Event(WindowEvent.CTRLF));
2677                    }}
2678                  >
2679                    {superKey} + F: Search players
2680                  </Typography>
2681                  <Typography
2682                    variant="caption"
2683                    style={{ cursor: 'pointer' }}
2684                    onClick={async () => {
2685                      setUndoDialogOpen(true);
2686                      try {
2687                        setGettingReportedSubdirs(true);
2688                        setReportedSubdirs(
2689                          await window.electron.getReportedSubdirs(),
2690                        );
2691                      } catch (e: any) {
2692                        showErrorDialog([e instanceof Error ? e.message : e]);
2693                      } finally {
2694                        setGettingReportedSubdirs(false);
2695                      }
2696                    }}
2697                  >
2698                    {superKey} + Z: Fix reported set
2699                  </Typography>
2700                </Stack>
2701              </Stack>
2702            ) : (
2703              <Stack
2704                alignItems="start"
2705                direction="row"
2706                flexGrow={1}
2707                justifyContent="right"
2708                marginTop="8px"
2709                spacing="8px"
2710              >
2711                {vlerkMode && (
2712                  <Stack alignItems="end">
2713                    <Stack direction="row" alignItems="center" gap="8px">
2714                      <FormControl>
2715                        <InputLabel
2716                          size="small"
2717                          id="vlerk-mode-character-select-label"
2718                        >
2719                          Character
2720                        </InputLabel>
2721                        <Select
2722                          label="Character"
2723                          labelId="vlerk-mode-character-select-label"
2724                          size="small"
2725                          style={{ width: '106px' }}
2726                          value={vlerkModeExternalId}
2727                          onChange={(event) => {
2728                            if (Number.isInteger(event.target.value)) {
2729                              setVlerkModeExternalId(
2730                                event.target.value as number,
2731                              );
2732                              setVlerkModeColorIndex(-1);
2733                            }
2734                          }}
2735                        >
2736                          <MenuItem value={-1}>Any</MenuItem>
2737                          {Array.from(characterNames.entries())
2738                            .sort((a, b) => a[1].localeCompare(b[1]))
2739                            .map(([externalId, characterName]) => (
2740                              <MenuItem key={externalId} value={externalId}>
2741                                {characterName}
2742                              </MenuItem>
2743                            ))}
2744                        </Select>
2745                      </FormControl>
2746                      <FormControl>
2747                        <InputLabel
2748                          size="small"
2749                          id="vlerk-mode-color-select-label"
2750                        >
2751                          Color
2752                        </InputLabel>
2753                        <Select
2754                          label="Color"
2755                          labelId="vlerk-mode-color-select-label"
2756                          size="small"
2757                          value={vlerkModeColorIndex}
2758                          onChange={(event) => {
2759                            if (Number.isInteger(event.target.value)) {
2760                              setVlerkModeColorIndex(
2761                                event.target.value as number,
2762                              );
2763                            }
2764                          }}
2765                        >
2766                          <MenuItem value={-1}>Any</MenuItem>
2767                          {vlerkModeExternalId !== -1 &&
2768                            Array(
2769                              characterColorIndexLength.get(
2770                                vlerkModeExternalId,
2771                              )!,
2772                            )
2773                              .fill(0)
2774                              .map((_, i) => i)
2775                              .map((i) => (
2776                                <MenuItem key={i} value={i}>
2777                                  <Avatar
2778                                    src={getCharacterIcon(
2779                                      vlerkModeExternalId,
2780                                      i,
2781                                    )}
2782                                    style={{ height: '24px', width: '24px' }}
2783                                    variant="square"
2784                                  />
2785                                </MenuItem>
2786                              ))}
2787                        </Select>
2788                      </FormControl>
2789                      <IconButton
2790                        disabled={
2791                          replays.length === 0 ||
2792                          (vlerkModeExternalId === -1 &&
2793                            vlerkModeColorIndex === -1)
2794                        }
2795                        onClick={() => {
2796                          for (
2797                            let i = vlerkModeFilterLastIndex + 1;
2798                            i < replays.length;
2799                            i += 1
2800                          ) {
2801                            const replay = replays[i];
2802                            if (
2803                              replay.players.some(
2804                                (player) =>
2805                                  player.playerType === 0 &&
2806                                  (vlerkModeExternalId === -1 ||
2807                                    vlerkModeExternalId ===
2808                                      player.externalCharacterId) &&
2809                                  (vlerkModeColorIndex === -1 ||
2810                                    vlerkModeColorIndex ===
2811                                      player.costumeIndex),
2812                              )
2813                            ) {
2814                              replayRefs[i].current!.scrollIntoView({
2815                                behavior: 'smooth',
2816                              });
2817                              setVlerkModeFilterLastIndex(i);
2818                              setVlerkModeFilterNotFound(false);
2819                              return;
2820                            }
2821                          }
2822                          if (vlerkModeFilterLastIndex === 0) {
2823                            setVlerkModeFilterNotFound(true);
2824                            return;
2825                          }
2826                          // return to top and continue
2827                          for (
2828                            let i = 0;
2829                            i < vlerkModeFilterLastIndex;
2830                            i += 1
2831                          ) {
2832                            const replay = replays[i];
2833                            if (
2834                              replay.players.some(
2835                                (player) =>
2836                                  player.playerType === 0 &&
2837                                  (vlerkModeExternalId === -1 ||
2838                                    vlerkModeExternalId ===
2839                                      player.externalCharacterId) &&
2840                                  (vlerkModeColorIndex === -1 ||
2841                                    vlerkModeColorIndex ===
2842                                      player.costumeIndex),
2843                              )
2844                            ) {
2845                              replayRefs[i].current!.scrollIntoView({
2846                                behavior: 'smooth',
2847                              });
2848                              setVlerkModeFilterLastIndex(i);
2849                              setVlerkModeFilterNotFound(false);
2850                              return;
2851                            }
2852                          }
2853                          setVlerkModeFilterLastIndex(0);
2854                          setVlerkModeFilterNotFound(true);
2855                        }}
2856                      >
2857                        <Search />
2858                      </IconButton>
2859                    </Stack>
2860                    {vlerkModeFilterNotFound && (
2861                      <Typography variant="body2" color="error">
2862                        Not found
2863                      </Typography>
2864                    )}
2865                  </Stack>
2866                )}
2867                <Stack>
2868                  {(mode === Mode.STARTGG || mode === Mode.OFFLINE_MODE) && (
2869                    <Typography
2870                      variant="caption"
2871                      style={{ cursor: 'pointer' }}
2872                      onClick={() => {
2873                        window.electron.openEntrantsWindow();
2874                      }}
2875                    >
2876                      {superKey} + E: Pool Entrants
2877                    </Typography>
2878                  )}
2879                  <Typography
2880                    variant="caption"
2881                    style={{ cursor: 'pointer' }}
2882                    onClick={() => {
2883                      window.dispatchEvent(new Event(WindowEvent.CTRLF));
2884                    }}
2885                  >
2886                    {superKey} + F: Search players
2887                  </Typography>
2888                  {vlerkMode && (
2889                    <Typography
2890                      variant="caption"
2891                      style={{ cursor: 'pointer' }}
2892                      onClick={() => {
2893                        window.dispatchEvent(new Event(WindowEvent.CTRLS));
2894                      }}
2895                    >
2896                      {superKey} + S: Copy replays
2897                    </Typography>
2898                  )}
2899                </Stack>
2900                <Stack>
2901                  <Typography
2902                    variant="caption"
2903                    style={{ cursor: 'pointer' }}
2904                    onClick={() => {
2905                      setSkewDialogOpen(true);
2906                    }}
2907                  >
2908                    {superKey} + T: Re-order replays
2909                  </Typography>
2910                  <Typography
2911                    variant="caption"
2912                    style={{ cursor: 'pointer' }}
2913                    onClick={async () => {
2914                      setUndoDialogOpen(true);
2915                      try {
2916                        setGettingReportedSubdirs(true);
2917                        setReportedSubdirs(
2918                          await window.electron.getReportedSubdirs(),
2919                        );
2920                      } catch (e: any) {
2921                        showErrorDialog([e instanceof Error ? e.message : e]);
2922                      } finally {
2923                        setGettingReportedSubdirs(false);
2924                      }
2925                    }}
2926                  >
2927                    {superKey} + Z: Fix reported set
2928                  </Typography>
2929                  <Typography
2930                    variant="caption"
2931                    style={{ cursor: 'pointer' }}
2932                    onClick={() => {
2933                      setGuidedMode((old) => {
2934                        window.electron.setGuidedMode(!old);
2935                        return !old;
2936                      });
2937                    }}
2938                  >
2939                    F1: Walkthrough Mode
2940                  </Typography>
2941                </Stack>
2942              </Stack>
2943            )}
2944          </Stack>
2945          <Stack justifyContent="space-between" width="300px">
2946            <Stack>
2947              {selectedSet.id !== 0 && (
2948                <>
2949                  <Stack
2950                    alignItems="center"
2951                    justifyContent="center"
2952                    direction="row"
2953                    gap="8px"
2954                  >
2955                    <Box width="16px" />
2956                    <Typography noWrap lineHeight="20px" variant="caption">
2957                      {selectedSet.fullRoundText}
2958                      {(typeof selectedSet.id === 'string' ||
2959                        (Number.isInteger(selectedSet.id) &&
2960                          selectedSet.id > 0)) &&
2961                        ` (${selectedSet.id})`}
2962                    </Typography>
2963                    {selectedSet.state === State.CALLED && (
2964                      <Tooltip arrow placement="top" title="Called">
2965                        <NotificationsActive
2966                          fontSize="inherit"
2967                          style={{ color: calledColor }}
2968                        />
2969                      </Tooltip>
2970                    )}
2971                    {selectedSet.state === State.STARTED && (
2972                      <Tooltip arrow placement="top" title="Started">
2973                        <HourglassTop
2974                          fontSize="inherit"
2975                          style={{ color: startedColor }}
2976                        />
2977                      </Tooltip>
2978                    )}
2979                    {selectedSet.state === State.COMPLETED && (
2980                      <Tooltip arrow placement="top" title="Completed">
2981                        <Backup fontSize="inherit" />
2982                      </Tooltip>
2983                    )}
2984                  </Stack>
2985                  <Tooltip arrow placement="top" title="Click or drag!">
2986                    <Stack direction="row" gap="8px">
2987                      <Stack gap="8px" width="50%">
2988                        <DraggableChip
2989                          entrantId={selectedSet.entrant1Id}
2990                          nameWithHighlight={{
2991                            name: selectedSet.entrant1Participants[0]
2992                              .displayName,
2993                          }}
2994                          participantId={selectedSet.entrant1Participants[0].id}
2995                          prefix={selectedSet.entrant1Participants[0].prefix}
2996                          pronouns={
2997                            selectedSet.entrant1Participants[0].pronouns
2998                          }
2999                          selectedChipData={selectedChipData}
3000                          setSelectedChipData={setSelectedChipData}
3001                          elevate={
3002                            guideActive &&
3003                            guideBackdropOpen &&
3004                            guideState === GuideState.PLAYERS
3005                          }
3006                        />
3007                        {selectedSet.entrant1Participants.length > 1 && (
3008                          <DraggableChip
3009                            entrantId={selectedSet.entrant1Id}
3010                            nameWithHighlight={{
3011                              name: selectedSet.entrant1Participants[1]
3012                                .displayName,
3013                            }}
3014                            participantId={
3015                              selectedSet.entrant1Participants[1].id
3016                            }
3017                            prefix={selectedSet.entrant1Participants[1].prefix}
3018                            pronouns={
3019                              selectedSet.entrant1Participants[1].pronouns
3020                            }
3021                            selectedChipData={selectedChipData}
3022                            setSelectedChipData={setSelectedChipData}
3023                            elevate={
3024                              guideActive &&
3025                              guideBackdropOpen &&
3026                              guideState === GuideState.PLAYERS
3027                            }
3028                          />
3029                        )}
3030                      </Stack>
3031                      <Stack gap="8px" width="50%">
3032                        <DraggableChip
3033                          entrantId={selectedSet.entrant2Id}
3034                          nameWithHighlight={{
3035                            name: selectedSet.entrant2Participants[0]
3036                              .displayName,
3037                          }}
3038                          participantId={selectedSet.entrant2Participants[0].id}
3039                          prefix={selectedSet.entrant2Participants[0].prefix}
3040                          pronouns={
3041                            selectedSet.entrant2Participants[0].pronouns
3042                          }
3043                          selectedChipData={selectedChipData}
3044                          setSelectedChipData={setSelectedChipData}
3045                          elevate={
3046                            guideActive &&
3047                            guideBackdropOpen &&
3048                            guideState === GuideState.PLAYERS
3049                          }
3050                        />
3051                        {selectedSet.entrant2Participants.length > 1 && (
3052                          <DraggableChip
3053                            entrantId={selectedSet.entrant2Id}
3054                            nameWithHighlight={{
3055                              name: selectedSet.entrant2Participants[1]
3056                                .displayName,
3057                            }}
3058                            participantId={
3059                              selectedSet.entrant2Participants[1].id
3060                            }
3061                            prefix={selectedSet.entrant2Participants[1].prefix}
3062                            pronouns={
3063                              selectedSet.entrant2Participants[1].pronouns
3064                            }
3065                            selectedChipData={selectedChipData}
3066                            setSelectedChipData={setSelectedChipData}
3067                            elevate={
3068                              guideActive &&
3069                              guideBackdropOpen &&
3070                              guideState === GuideState.PLAYERS
3071                            }
3072                          />
3073                        )}
3074                      </Stack>
3075                    </Stack>
3076                  </Tooltip>
3077                </>
3078              )}
3079            </Stack>
3080            <Stack direction="row" justifyContent="flex-end" paddingTop="8px">
3081              <AssignStream
3082                mode={mode}
3083                selectedSet={selectedSet}
3084                stations={stations}
3085                streams={streams}
3086                refreshStartggTournament={() =>
3087                  getStartggTournament(startggTournament.slug)
3088                }
3089              />
3090              <ResetSet mode={mode} selectedSet={selectedSet} />
3091              {(mode === Mode.STARTGG || mode === Mode.OFFLINE_MODE) && (
3092                <Tooltip arrow title="Mark set called">
3093                  <div>
3094                    <IconButton
3095                      color="primary"
3096                      disabled={
3097                        !(
3098                          (typeof selectedSet.id === 'string' ||
3099                            (Number.isInteger(selectedSet.id) &&
3100                              selectedSet.id > 0)) &&
3101                          (selectedSet.state === State.PENDING ||
3102                            selectedSet.state === State.STARTED)
3103                        ) || callingSet
3104                      }
3105                      size="small"
3106                      onClick={() => callSet(selectedSet)}
3107                    >
3108                      {callingSet ? (
3109                        <CircularProgress size="24px" />
3110                      ) : (
3111                        <NotificationsActive />
3112                      )}
3113                    </IconButton>
3114                  </div>
3115                </Tooltip>
3116              )}
3117              <Tooltip arrow title="Mark set started">
3118                <div>
3119                  <IconButton
3120                    color="primary"
3121                    disabled={
3122                      !(
3123                        (typeof selectedSet.id === 'string' ||
3124                          (Number.isInteger(selectedSet.id) &&
3125                            selectedSet.id > 0)) &&
3126                        (selectedSet.state === State.PENDING ||
3127                          selectedSet.state === State.CALLED)
3128                      ) || startingSet
3129                    }
3130                    size="small"
3131                    onClick={() => startSet(selectedSet)}
3132                  >
3133                    {startingSet ? (
3134                      <CircularProgress size="24px" />
3135                    ) : (
3136                      <HourglassTop />
3137                    )}
3138                  </IconButton>
3139                </div>
3140              </Tooltip>
3141              <ManualReport
3142                mode={mode}
3143                reportChallongeSet={reportChallongeSet}
3144                reportStartggSet={reportStartggSet}
3145                reportParryggSet={reportParryggSet}
3146                reportOfflineModeSet={reportOfflineModeSet}
3147                selectedSet={selectedSet}
3148              />
3149              <SetControls
3150                mode={mode}
3151                copyReplays={onCopy}
3152                deleteReplays={
3153                  // eslint-disable-next-line no-nested-ternary
3154                  undoSubdir
3155                    ? deleteUndo
3156                    : isUsb
3157                    ? () => {
3158                        return deleteDir(
3159                          selectedReplays.map((replay) => replay.fileName),
3160                        );
3161                      }
3162                    : () => {
3163                        return deleteSelected(true);
3164                      }
3165                }
3166                reportChallongeSet={reportChallongeSet}
3167                reportStartggSet={reportStartggSet}
3168                reportParryggSet={reportParryggSet}
3169                reportOfflineModeSet={reportOfflineModeSet}
3170                setReportSettings={async (
3171                  newReportSettings: ReportSettings,
3172                ) => {
3173                  await window.electron.setReportSettings(newReportSettings);
3174                  setReportSettings(newReportSettings);
3175                }}
3176                resetGuide={() => {
3177                  setGuideState(GuideState.NONE);
3178                  setGuideBackdropOpen(false);
3179                }}
3180                isCopying={isCopying}
3181                copyDisabled={
3182                  (!copyDir && !host.address) || selectedReplays.length === 0
3183                }
3184                isDeleting={dirDeleting}
3185                dqId={dq.entrantId}
3186                hasRemainingReplays={hasRemainingReplays}
3187                reportSettings={reportSettings}
3188                selectedReplays={selectedReplays}
3189                set={selectedSet}
3190                elevate={
3191                  guideActive &&
3192                  guideBackdropOpen &&
3193                  guideState === GuideState.PLAYERS
3194                }
3195                enforcerVersion={ENFORCER_VERSION}
3196                enforcerSetting={enforcerSetting}
3197                smuggleCostumeIndex={smuggleCostumeIndex}
3198                wouldDeleteCopyDir={wouldDeleteCopyDir}
3199                replayLoadCount={replayLoadCount}
3200                undoSubdir={undoSubdir}
3201              />
3202            </Stack>
3203          </Stack>
3204        </BottomColumns>
3205      </Bottom>
3206      <Dialog
3207        open={undoDialogOpen}
3208        onClose={() => {
3209          setUndoDialogOpen(false);
3210        }}
3211      >
3212        <DialogTitle>Fix Reported Set</DialogTitle>
3213        <DialogContent>
3214          {gettingReportedSubdirs ? (
3215            <CircularProgress />
3216          ) : (
3217            <List disablePadding>
3218              {reportedSubdirs.map((reportedSubdir) => (
3219                <ListItem disablePadding key={reportedSubdir}>
3220                  <ListItemButton
3221                    disableGutters
3222                    onClick={async () => {
3223                      try {
3224                        setDir(
3225                          await window.electron.setUndoSubdir(reportedSubdir),
3226                        );
3227                        setUndoSubdir(reportedSubdir);
3228                        setUndoDialogOpen(false);
3229                        setIsUsb(false);
3230                        setWasDeleted(false);
3231                        refreshReplays(true);
3232                        setEjected(false);
3233                      } catch (e: any) {
3234                        showErrorDialog([e instanceof Error ? e.message : e]);
3235                      }
3236                    }}
3237                  >
3238                    <ListItemText>{reportedSubdir}</ListItemText>
3239                  </ListItemButton>
3240                </ListItem>
3241              ))}
3242            </List>
3243          )}
3244        </DialogContent>
3245      </Dialog>
3246      <Backdrop
3247        onClick={resetSelectedChipData}
3248        open={Boolean(
3249          selectedChipData.entrantId && selectedChipData.participantId,
3250        )}
3251        sx={{ zIndex: (theme) => theme.zIndex.drawer + 3 }}
3252      />
3253      <Backdrop
3254        onClick={() => setGuideBackdropOpen(false)}
3255        open={guidedMode && guideBackdropOpen}
3256        sx={{ zIndex: (theme) => theme.zIndex.drawer + 1 }}
3257      />
3258      <ErrorDialog
3259        messages={errors}
3260        onClose={() => {
3261          setErrors([]);
3262          setErrorDialogOpen(false);
3263        }}
3264        open={errorDialogOpen}
3265      />
3266      <Settings
3267        appVersion={appVersion}
3268        latestAppVersion={latestAppVersion}
3269        mode={mode}
3270        setMode={async (newMode: Mode) => {
3271          setMode(newMode);
3272          setSelectedSet(EMPTY_SET);
3273          setSelectedSetChain(EMPTY_SELECTED_SET_CHAIN);
3274          setSelectedChallongeTournament({
3275            name: '',
3276            slug: '',
3277            tournamentType: '',
3278          });
3279          await window.electron.setSelectedSetChain(0, 0, 0);
3280          await window.electron.setSelectedChallongeTournament('');
3281        }}
3282        useLAN={useLAN}
3283        setUseLAN={setUseLAN}
3284        enforcerSetting={enforcerSetting}
3285        setEnforcerSetting={setEnforcerSetting}
3286        vlerkMode={vlerkMode}
3287        setVlerkMode={setVlerkMode}
3288        guidedMode={guidedMode}
3289        setGuidedMode={setGuidedMode}
3290        smuggleCostumeIndex={smuggleCostumeIndex}
3291        setSmuggleCostumeIndex={setSmuggleCostumeIndex}
3292        fileNameFormat={fileNameFormat}
3293        setFileNameFormat={setFileNameFormat}
3294        folderNameFormat={folderNameFormat}
3295        setFolderNameFormat={setFolderNameFormat}
3296        hideCopyButton={hideCopyButton}
3297        setHideCopyButton={setHideCopyButton}
3298        setAdminedTournaments={setAdminedTournaments}
3299        setGettingAdminedTournaments={setGettingAdminedTournaments}
3300        showErrorDialog={showErrorDialog}
3301        enforcerVersion={ENFORCER_VERSION}
3302        hostFormat={hostFormat}
3303      />
3304      <GlobalHotKeys
3305        keyMap={{
3306          COPY: window.electron.isMac
3307            ? ['command+s', 'command+S']
3308            : ['ctrl+s', 'ctrl+S'],
3309          ENTRANTS: window.electron.isMac
3310            ? ['command+e', 'command+E']
3311            : ['ctrl+e', 'ctrl+E'],
3312          ESC: 'escape',
3313          FIND: window.electron.isMac
3314            ? ['command+f', 'command+F']
3315            : ['ctrl+f', 'ctrl+F'],
3316          SKEW: window.electron.isMac
3317            ? ['command+t', 'command+T']
3318            : ['ctrl+t', 'ctrl+T'],
3319          UNDO: window.electron.isMac
3320            ? ['command+z', 'command+Z']
3321            : ['ctrl+z', 'ctrl+Z'],
3322          WALKTHROUGH: 'F1',
3323        }}
3324        handlers={{
3325          COPY: () => {
3326            window.dispatchEvent(new Event(WindowEvent.CTRLS));
3327          },
3328          ENTRANTS: () => {
3329            window.electron.openEntrantsWindow();
3330          },
3331          ESC: () => {
3332            window.dispatchEvent(new Event(WindowEvent.ESCAPE));
3333          },
3334          FIND: () => {
3335            window.dispatchEvent(new Event(WindowEvent.CTRLF));
3336          },
3337          SKEW: () => {
3338            setSkewDialogOpen(true);
3339          },
3340          UNDO: async () => {
3341            setUndoDialogOpen(true);
3342            try {
3343              setGettingReportedSubdirs(true);
3344              setReportedSubdirs(await window.electron.getReportedSubdirs());
3345            } catch (e: any) {
3346              showErrorDialog([e instanceof Error ? e.message : e]);
3347            } finally {
3348              setGettingReportedSubdirs(false);
3349            }
3350          },
3351          WALKTHROUGH: () => {
3352            setGuidedMode((old) => {
3353              window.electron.setGuidedMode(!old);
3354              return !old;
3355            });
3356          },
3357        }}
3358      />
3359    </>
3360  );
3361}
3362
3363export default function App() {
3364  return (
3365    <Router>
3366      <Routes>
3367        <Route path="/" element={<Hello />} />
3368      </Routes>
3369    </Router>
3370  );
3371}