import { BrowserWindow } from 'electron'; import WebSocket from 'ws'; import { createHash } from 'crypto'; import { DnsSd, DnsSdBrowse } from '@fugood/dns-sd'; import { parse } from 'ipaddr.js'; import { lookup } from 'dns'; import { OfflineModeParticipant, OfflineModeSeed, OfflineModeSet, OfflineModeStatus, OfflineModeTournament, Participant, RendererOfflineModePhase, RendererOfflineModePool, RendererOfflineModeTournament, RendererPool, RendererWave, SelectedSetChain, Set, StartggGame, State, } from '../common/types'; import { getComputerName, lookupInner } from './util'; const INITIAL_TOURNAMENT: RendererOfflineModeTournament = { id: 0, name: '', slug: '', location: '', events: [], participants: [], stations: [], streams: [], }; let addressOrHost = ''; let error = ''; const idToSet = new Map(); let selectedSetId = 0; let tournament = INITIAL_TOURNAMENT; let mainWindow: BrowserWindow | undefined; export function initOfflineMode(initMainWindow: BrowserWindow) { mainWindow = initMainWindow; addressOrHost = ''; error = ''; idToSet.clear(); selectedSetId = 0; tournament = INITIAL_TOURNAMENT; } export function setSelectedOfflineModeSetId(id: number) { selectedSetId = id; } export function getSelectedOfflineModeSet() { return idToSet.get(selectedSetId); } function setStatus(newAddressOrHost: string, newError?: string) { addressOrHost = newAddressOrHost; if (newError !== undefined) { error = newError; } const offlineModeStatus: OfflineModeStatus = { addressOrHost, error, }; mainWindow?.webContents.send('offlineModeStatus', offlineModeStatus); } function setTournament(newTournament: RendererOfflineModeTournament) { tournament = newTournament; mainWindow?.webContents.send('tournament', { selectedSet: getSelectedOfflineModeSet(), offlineModeTournament: tournament, }); } export function getOfflineModeStatus(): OfflineModeStatus { return { addressOrHost, error }; } export function getCurrentOfflineModeTournament() { return tournament; } export function getSelectedOfflineModeSetChain( selectedEventId: number, selectedPhaseId: number, selectedPhaseGroupId: number, ): SelectedSetChain { let selectedPool: RendererOfflineModePool | undefined; let selectedPhase: RendererOfflineModePhase | undefined; const selectedEvent = tournament.events.find( (event) => event.id === selectedEventId, ); if (selectedEvent) { selectedPhase = selectedEvent.phases.find( (phase) => phase.id === selectedPhaseId, ); if (selectedPhase) { selectedPool = selectedPhase.pools.find( (pool) => pool.id === selectedPhaseGroupId, ); } } return { event: selectedEvent ? { id: selectedEvent.id, name: selectedEvent.name, slug: selectedEvent.slug, hasSiblings: tournament.events.length > 1, } : undefined, phase: selectedPhase ? { id: selectedPhase.id, name: selectedPhase.name, hasSiblings: selectedEvent!.phases.length > 1, } : undefined, phaseGroup: selectedPool ? { id: selectedPool.id, name: selectedPool.name, bracketType: selectedPool.bracketType, hasSiblings: selectedPhase!.pools.length > 1, waveId: selectedPool.waveId, winnersTargetPhaseId: selectedPool.winnersTargetPhaseId, } : undefined, }; } function toParticipant(participant: OfflineModeParticipant): Participant { return { id: participant.id, displayName: participant.gamerTag, prefix: participant.prefix, pronouns: participant.pronouns, }; } export function getOfflineModePoolsByWave(): RendererWave[] { const poolIdToSeeds = new Map(); const waveIdToPools = new Map(); const noWavePools: (RendererPool & { eventId: number; phaseId: number; winnersTargetPhaseId: number | null; })[] = []; tournament.events.forEach((event) => { event.phases.forEach((phase) => { const parentName = event.phases.length > 1 ? phase.name : event.name; phase.seeds.forEach((seed) => { let seeds = poolIdToSeeds.get(seed.poolId); if (!seeds) { seeds = []; poolIdToSeeds.set(seed.poolId, seeds); } seeds.push(seed); }); phase.pools.forEach((pool) => { const rendererPool: RendererPool = { id: pool.id, name: pool.name, seeds: (poolIdToSeeds.get(pool.id) ?? []).map((seed) => ({ id: seed.id, seedNum: seed.seedNum, groupSeedNum: seed.groupSeedNum, placeholder: seed.placeholder, entrant: seed.entrant ? { id: seed.entrant.id, participants: seed.entrant.participants.map(toParticipant), } : null, })), }; if (pool.waveId) { let pools = waveIdToPools.get(pool.waveId); if (!pools) { pools = []; waveIdToPools.set(pool.waveId, pools); } pools.push(rendererPool); } else { noWavePools.push({ ...rendererPool, name: phase.pools.length > 1 ? `${parentName}, ${pool.name}` : parentName, eventId: event.id, phaseId: phase.id, winnersTargetPhaseId: pool.winnersTargetPhaseId, }); } }); }); }); noWavePools.sort((a, b) => { if (a.eventId !== b.eventId) { return a.eventId - b.eventId; } if (a.winnersTargetPhaseId !== null && b.winnersTargetPhaseId === null) { return -1; } if (a.winnersTargetPhaseId === null && b.winnersTargetPhaseId !== null) { return 1; } if ( a.winnersTargetPhaseId !== null && b.winnersTargetPhaseId !== null && a.winnersTargetPhaseId !== b.winnersTargetPhaseId ) { if (a.winnersTargetPhaseId === b.phaseId) { return -1; } if (a.phaseId === b.winnersTargetPhaseId) { return 1; } return a.winnersTargetPhaseId - b.winnersTargetPhaseId; } if (a.phaseId !== b.phaseId) { return a.phaseId - b.phaseId; } return a.name.length === b.name.length ? a.name.localeCompare(b.name) : a.name.length - b.name.length; }); Array.from(waveIdToPools.values()).forEach((phaseGroups) => phaseGroups.sort((a, b) => a.name.length === b.name.length ? a.name.localeCompare(b.name) : a.name.length - b.name.length, ), ); return [ ...Array.from(waveIdToPools.keys()) .sort((a, b) => a - b) .map( (waveId): RendererWave => ({ id: waveId, pools: waveIdToPools.get(waveId)!, }), ), { id: 0, pools: noWavePools, }, ]; } const reportedSetIds = new Map(); function toSet(set: OfflineModeSet): Omit & { id: number } { if (set.entrant1Id === null) { throw new Error(`entrant1Id null in set: ${set.id}`); } if (set.entrant2Id === null) { throw new Error(`entrant2Id null in set: ${set.id}`); } return { id: set.id, sggId: typeof set.setId === 'number' && Number.isInteger(set.setId) && set.setId > 0 ? set.setId : null, state: set.state, round: set.round, fullRoundText: set.fullRoundText, winnerId: set.winnerId, entrant1Id: set.entrant1Id, entrant1Participants: set.entrant1Participants.map(toParticipant), entrant1Score: set.entrant1Score, entrant2Id: set.entrant2Id, entrant2Participants: set.entrant2Participants.map(toParticipant), entrant2Score: set.entrant2Score, gameScores: set.games.map((game) => ({ entrant1Score: game.entrant1Score, entrant2Score: game.entrant2Score, })), stream: set.stream ? { id: set.stream.id, domain: set.stream.streamSource.toLowerCase(), path: set.stream.streamName, } : null, station: set.station ? { id: set.station.id, number: set.station.number, } : null, ordinal: set.ordinal, wasReported: reportedSetIds.has(set.id), updatedAtMs: set.updatedAt * 1000, completedAtMs: set.completedAt ? set.completedAt * 1000 : 0, }; } let offlineModePassword = ''; export function setOfflineModePassword(newOfflineModePassword: string) { offlineModePassword = newOfflineModePassword; } const hostnameToAddresses = new Map(); export function getOfflineModeHosts() { return Array.from(hostnameToAddresses.keys()); } function sendOfflineModeHosts() { mainWindow?.webContents.send('offlineModeHosts', getOfflineModeHosts()); } let browser: DnsSdBrowse | null = null; export function deafenForOfflineMode() { if (browser) { browser.removeAllListeners(); browser.stop(); browser = null; } hostnameToAddresses.clear(); } export function deafenForOfflineModeAndSend() { deafenForOfflineMode(); sendOfflineModeHosts(); } export function listenForOfflineMode() { if (!browser) { browser = DnsSd.search('_http._tcp') .on('serviceFound', (service) => { if (service.txt?.offlinemode) { hostnameToAddresses.set( service.hostName.slice(0, -1).toLowerCase(), service.addresses, ); sendOfflineModeHosts(); } }) .on('serviceLost', (service) => { if (service.txt?.offlinemode) { hostnameToAddresses.delete( service.hostName.slice(0, -1).toLowerCase(), ); sendOfflineModeHosts(); } }); } } type AuthIdentify = { op: 'auth-identify'; authentication: string; }; type Request = { num: number; } & ( | { op: 'reset-set-request' | 'call-set-request' | 'start-set-request'; id: number; } | { op: 'assign-set-station-request'; id: number; stationId: number; } | { op: 'assign-set-stream-request'; id: number; streamId: number; } | { op: 'report-set-request'; id: number; winnerId: number; isDQ: boolean; gameData: StartggGame[]; } | { op: 'client-id-request'; computerName: string; clientName: string; } ); let websocket: WebSocket | null = null; export function disconnectFromOfflineMode() { if (websocket) { websocket.close(); } } let nextNum = 1; function cleanup() { websocket?.removeAllListeners(); websocket = null; nextNum = 1; idToSet.clear(); selectedSetId = 0; setTournament(INITIAL_TOURNAMENT); addressOrHost = ''; } const UNAUTH_CODE = 4009; export function connectToOfflineMode(newAddressOrHost: string) { if (websocket) { return; } let host = ''; try { const ipaddr = parse(newAddressOrHost); host = ipaddr.kind() === 'ipv4' ? ipaddr.toString() : `[${ipaddr.toString()}]`; } catch { host = newAddressOrHost; } try { websocket = new WebSocket(`ws://${host}`, 'admin-protocol', { handshakeTimeout: 1000, lookup: (hostname, options, callback) => { const addresses = hostnameToAddresses.get(hostname); if (!addresses) { lookup(hostname, options, callback); return; } const retAddrs = lookupInner(addresses, options); if (retAddrs.length === 0) { lookup(hostname, options, callback); return; } let all = false; if (options.all) { all = options.all; } if (all) { process.nextTick(callback, null, retAddrs); } else { process.nextTick( callback, null, retAddrs[0].address, retAddrs[0].family, ); } }, }) .on('error', (err) => { cleanup(); setStatus('', err.message); }) .on('close', (code) => { cleanup(); if (code === UNAUTH_CODE) { setStatus('', 'Incorrect Password'); } else { setStatus(''); } }) .on('message', (data) => { try { const message = JSON.parse(data.toString()); if (message.op === 'auth-hello') { if ( typeof message.challenge === 'string' && typeof message.salt === 'string' ) { const secret = createHash('sha256') .update(offlineModePassword) .update(message.salt) .digest() .toString('base64url'); const authentication = createHash('sha256') .update(secret) .update(message.challenge) .digest() .toString('base64url'); const authIdentify: AuthIdentify = { op: 'auth-identify', authentication, }; websocket?.send(JSON.stringify(authIdentify)); } } else if (message.op === 'auth-success-event') { setStatus(host, ''); deafenForOfflineMode(); const num = nextNum; nextNum += 1; const clientIdRequest: Request = { op: 'client-id-request', num, computerName: getComputerName(), clientName: 'Replay Reporter', }; websocket?.send(JSON.stringify(clientIdRequest)); } else if (message.op === 'tournament-update-event') { idToSet.clear(); if (message.tournament) { const newTournament = message.tournament as OfflineModeTournament; setTournament({ ...newTournament, events: newTournament.events .filter((event) => event.videogameId === 1 && !event.isOnline) .map((event) => ({ ...event, phases: event.phases.map((phase) => ({ ...phase, pools: phase.pools.map((pool) => { const completedSets: Set[] = []; const pendingSets: Set[] = []; pool.sets.forEach((offlineModeSet) => { if ( offlineModeSet.entrant1Id && offlineModeSet.entrant2Id ) { const set = toSet(offlineModeSet); idToSet.set(set.id, set); if (set.state === State.COMPLETED) { completedSets.push(set); } else { pendingSets.push(set); } } }); completedSets.reverse(); return { ...pool, sets: { completedSets, pendingSets }, }; }), })), })), streams: newTournament.streams.map((stream) => ({ id: stream.id, domain: stream.streamSource.toLowerCase(), path: stream.streamName, })), }); } else { setTournament(INITIAL_TOURNAMENT); } } } catch { // just catch } }); } catch (e: any) { setStatus('', e.message); } } type ResponseOp = | 'reset-set-response' | 'call-set-response' | 'start-set-response' | 'assign-set-station-response' | 'assign-set-stream-response' | 'report-set-response'; type Response = { num: number; op: ResponseOp; err?: string; data?: { set: OfflineModeSet; }; }; function getExpectedResponseOp(request: Request): ResponseOp { switch (request.op) { case 'reset-set-request': return 'reset-set-response'; case 'call-set-request': return 'call-set-response'; case 'start-set-request': return 'start-set-response'; case 'assign-set-station-request': return 'assign-set-station-response'; case 'assign-set-stream-request': return 'assign-set-stream-response'; case 'report-set-request': return 'report-set-response'; default: throw new Error('unreachable'); } } async function sendRequest(request: Request) { const expectedOp = getExpectedResponseOp(request); return new Promise((resolve, reject) => { if (websocket === null) { reject(new Error('offline mode not connected')); return; } const listener = (data: WebSocket.RawData) => { try { const message = JSON.parse(data.toString()) as Response; if (message.num === request.num && message.op === expectedOp) { websocket?.removeListener('message', listener); if (message.err) { reject(new Error(message.err)); } else if (!message.data) { reject(new Error('no data')); } else { resolve(message.data.set); } } } catch { // just catch } }; websocket.addListener('message', listener); websocket.send(JSON.stringify(request)); }); } export async function resetOfflineModeSet(id: number): Promise { const num = nextNum; nextNum += 1; const resetSetRequest: Request = { num, op: 'reset-set-request', id, }; const updatedSet = await sendRequest(resetSetRequest); return toSet(updatedSet); } export async function callOfflineModeSet(id: number): Promise { const num = nextNum; nextNum += 1; const callSetRequest: Request = { num, op: 'call-set-request', id, }; const updatedSet = await sendRequest(callSetRequest); return toSet(updatedSet); } export async function startOfflineModeSet(id: number): Promise { const num = nextNum; nextNum += 1; const startSetRequest: Request = { num, op: 'start-set-request', id, }; const updatedSet = await sendRequest(startSetRequest); return toSet(updatedSet); } export async function assignOfflineModeSetStation( id: number, stationId: number, ): Promise { const num = nextNum; nextNum += 1; const assignSetStationRequest: Request = { num, op: 'assign-set-station-request', id, stationId, }; const updatedSet = await sendRequest(assignSetStationRequest); return toSet(updatedSet); } export async function assignOfflineModeSetStream( id: number, streamId: number, ): Promise { const num = nextNum; nextNum += 1; const assignSetStreamRequest: Request = { num, op: 'assign-set-stream-request', id, streamId, }; const updatedSet = await sendRequest(assignSetStreamRequest); return toSet(updatedSet); } export async function reportOfflineModeSet( id: number, winnerId: number, isDQ: boolean, gameData: StartggGame[], ): Promise { const num = nextNum; nextNum += 1; const reportSetRequest: Request = { num, op: 'report-set-request', id, winnerId, isDQ, gameData, }; const updatedSet = await sendRequest(reportSetRequest); reportedSetIds.set(updatedSet.id, true); return toSet(updatedSet); }