Wand-Enhancer-k1tbyte/web-panel/bridge/scripts/default/installed-apps-sync/game-status.js

import {
  GAME_ENDED_EVENT,
  GAME_LAUNCHED_EVENT,
  GAME_STATUS_CHANNEL,
  SYNTHETIC_SESSION_IDLE_EVENT,
  SYNTHETIC_SESSION_RUNNING_EVENT,
  TRAINER_ENDED_EVENT,
  TRAINER_SNAPSHOT_CHANNEL,
} from "./constants.js"
import { invokeIpc, isRecord, safeString, toStringId } from "./runtime.js"

export function createIdleGameSession() {
  return {
    state: "idle",
    event: "snapshot",
    processId: null,
    gameId: null,
    titleId: null,
    titleName: null,
    sessionDurationSeconds: null,
    startedAt: null,
    endedAt: null,
  }
}

export function createIdleTrainerStatus() {
  return {
    state: "idle",
    event: "snapshot",
    trainerId: null,
    displayName: null,
    gameId: null,
    titleId: null,
  }
}

export function installGameStatusSubscriptions(state) {
  let installed = false

  if (
    state.gameLifecycleService &&
    !state.gameLifecycleSubscriptionsInstalled
  ) {
    installed = installLifecycleSubscriptions(state) || installed
  }

  if (
    state.trainerVisibilityService &&
    !state.trainerVisibilitySubscriptionInstalled
  ) {
    state.currentRunningTrainer = normalizeRunningTrainerStatus(
      state.trainerVisibilityService.runningTrainer,
      "snapshot"
    )
    syncGameSessionFromTrainerStatus(state, state.currentRunningTrainer)
    installed = installTrainerVisibilitySubscription(state) || installed
    state.trainerVisibilitySubscriptionInstalled = true
  }

  if (
    state.trainerService &&
    !state.trainerEndedSubscriptionInstalled &&
    typeof state.trainerService.onTrainerEnded === "function"
  ) {
    state.trainerService.onTrainerEnded(() => {
      clearTrainerSnapshot(state, TRAINER_ENDED_EVENT, true)
    })
    state.trainerEndedSubscriptionInstalled = true
    installed = true
  }

  if (!installed) {
    return
  }

  state.log(
    "info",
    "Game status hooks installed.",
    `lifecycle=${state.gameLifecycleSubscriptionsInstalled ? "yes" : "no"}, trainer=${state.trainerVisibilitySubscriptionInstalled ? "yes" : "no"}, trainerEnded=${state.trainerEndedSubscriptionInstalled ? "yes" : "no"}`
  )
  void syncGameStatus(state, true)
}

export function clearTrainerSnapshot(state, reason, clearSession = false) {
  state.currentRunningTrainer = {
    ...createIdleTrainerStatus(),
    event: reason,
  }

  if (clearSession) {
    clearGameSession(state, reason)
  } else if (
    state.currentGameSession.state === "running" &&
    isSyntheticGameSessionEvent(state.currentGameSession.event)
  ) {
    syncGameSessionFromTrainerStatus(state, state.currentRunningTrainer)
  }

  void syncGameStatus(state, true)
  void invokeIpc(state, TRAINER_SNAPSHOT_CHANNEL, null, "Trainer snapshot clear")
}

export async function syncGameStatus(state, force = false) {
  if (!state.ipcRenderer) {
    return false
  }

  const snapshot = buildGameStatusSnapshot(state)
  const signature = makeGameStatusSignature(snapshot)
  if (!force && signature === state.lastGameStatusSignature) {
    return false
  }

  state.lastGameStatusSignature = signature

  const sent = await invokeIpc(
    state,
    GAME_STATUS_CHANNEL,
    snapshot,
    "Game status snapshot",
    "error"
  )
  if (sent) {
    state.log(
      "info",
      "Game status snapshot sent.",
      `session=${snapshot.session.state}/${snapshot.session.event}, trainer=${snapshot.trainer.state}/${snapshot.trainer.event}`
    )
  }
  return sent
}

function installLifecycleSubscriptions(state) {
  let installed = false

  if (typeof state.gameLifecycleService.onGameLaunched === "function") {
    state.gameLifecycleService.onGameLaunched((event) => {
      state.currentGameSession = {
        state: "running",
        event: GAME_LAUNCHED_EVENT,
        processId:
          typeof event?.processId === "number" ? event.processId : null,
        gameId: toStringId(event?.gameId),
        titleId: toStringId(event?.titleId),
        titleName: safeString(event?.titleName),
        sessionDurationSeconds: null,
        startedAt: new Date().toISOString(),
        endedAt: null,
      }
      void syncGameStatus(state, true)
    })
    installed = true
  }

  if (typeof state.gameLifecycleService.onGameEnded === "function") {
    state.gameLifecycleService.onGameEnded((event) => {
      clearGameSession(
        state,
        GAME_ENDED_EVENT,
        typeof event?.sessionDurationSeconds === "number"
          ? event.sessionDurationSeconds
          : state.currentGameSession.sessionDurationSeconds
      )
      void syncGameStatus(state, true)
    })
    installed = true
  }

  if (installed) {
    state.gameLifecycleSubscriptionsInstalled = true
  }

  return installed
}

function installTrainerVisibilitySubscription(state) {
  if (
    typeof state.trainerVisibilityService.onRunningTrainerChanged !== "function"
  ) {
    return false
  }

  state.trainerVisibilityService.onRunningTrainerChanged((runningTrainer) => {
    state.currentRunningTrainer = normalizeRunningTrainerStatus(
      runningTrainer,
      runningTrainer ? "trainer-running" : "trainer-idle"
    )
    syncGameSessionFromTrainerStatus(state, state.currentRunningTrainer)
    void syncGameStatus(state, true)
  })

  return true
}

function normalizeRunningTrainerStatus(runningTrainer, event = "snapshot") {
  const info = isRecord(runningTrainer?.info)
    ? runningTrainer.info
    : isRecord(runningTrainer)
      ? runningTrainer
      : null
  if (!info) {
    return {
      ...createIdleTrainerStatus(),
      event,
    }
  }

  return {
    state: "running",
    event,
    trainerId: toStringId(info.trainerId) || toStringId(info.id),
    displayName: safeString(
      info.displayName,
      info.gameName,
      info.titleName,
      info.title,
      info.name
    ),
    gameId: toStringId(info.gameId),
    titleId: toStringId(info.titleId),
  }
}

function syncGameSessionFromTrainerStatus(state, trainerStatus) {
  if (trainerStatus?.state === "running") {
    if (
      state.currentGameSession.state === "running" &&
      !isSyntheticGameSessionEvent(state.currentGameSession.event)
    ) {
      return false
    }

    state.currentGameSession = {
      state: "running",
      event: SYNTHETIC_SESSION_RUNNING_EVENT,
      processId: state.currentGameSession.processId,
      gameId: trainerStatus.gameId ?? state.currentGameSession.gameId,
      titleId: trainerStatus.titleId ?? state.currentGameSession.titleId,
      titleName:
        trainerStatus.displayName ?? state.currentGameSession.titleName,
      sessionDurationSeconds: null,
      startedAt:
        state.currentGameSession.state === "running" &&
        isSyntheticGameSessionEvent(state.currentGameSession.event)
          ? state.currentGameSession.startedAt
          : new Date().toISOString(),
      endedAt: null,
    }

    return true
  }

  if (
    state.currentGameSession.state !== "running" ||
    !isSyntheticGameSessionEvent(state.currentGameSession.event)
  ) {
    return false
  }

  const startedAt = state.currentGameSession.startedAt
  const sessionDurationSeconds = startedAt
    ? Math.max(
        0,
        Math.round((Date.now() - new Date(startedAt).getTime()) / 1000)
      )
    : null

  clearGameSession(state, SYNTHETIC_SESSION_IDLE_EVENT, sessionDurationSeconds)

  return true
}

function clearGameSession(
  state,
  event,
  sessionDurationSeconds = state.currentGameSession.sessionDurationSeconds
) {
  state.currentGameSession = {
    state: "idle",
    event,
    processId: null,
    gameId: null,
    titleId: null,
    titleName: null,
    sessionDurationSeconds,
    startedAt: state.currentGameSession.startedAt,
    endedAt: new Date().toISOString(),
  }
}

function isSyntheticGameSessionEvent(event) {
  return (
    event === SYNTHETIC_SESSION_RUNNING_EVENT ||
    event === SYNTHETIC_SESSION_IDLE_EVENT
  )
}

function buildGameStatusSnapshot(state) {
  return {
    instanceId: "wand-game-status",
    updatedAt: new Date().toISOString(),
    session: { ...state.currentGameSession },
    trainer: { ...state.currentRunningTrainer },
  }
}

function makeGameStatusSignature(snapshot) {
  return [
    snapshot.session.state,
    snapshot.session.event,
    snapshot.session.processId ?? "",
    snapshot.session.gameId ?? "",
    snapshot.session.titleId ?? "",
    snapshot.session.titleName ?? "",
    snapshot.session.sessionDurationSeconds ?? "",
    snapshot.session.startedAt ?? "",
    snapshot.session.endedAt ?? "",
    snapshot.trainer.state,
    snapshot.trainer.event,
    snapshot.trainer.trainerId ?? "",
    snapshot.trainer.displayName ?? "",
    snapshot.trainer.gameId ?? "",
    snapshot.trainer.titleId ?? "",
  ].join("|")
}