abstractplay.ts

/* eslint-disable @typescript-eslint/ban-ts-comment */
'use strict';

import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, PutCommand, GetCommand, UpdateCommand, DeleteCommand, QueryCommand, ScanCommand, BatchWriteCommand, QueryCommandInput, GetCommandOutput, PutCommandOutput, UpdateCommandOutput, DeleteCommandOutput, QueryCommandOutput } from '@aws-sdk/lib-dynamodb';
import { SQSClient, SendMessageCommand, SendMessageCommandOutput, SendMessageRequest } from "@aws-sdk/client-sqs";
import { CognitoIdentityProviderClient, CreateUserPoolClientCommand, DeleteUserPoolClientCommand } from "@aws-sdk/client-cognito-identity-provider";
import { v4 as uuid } from 'uuid';
import { gameinfo, GameFactory, GameBase, GameBaseSimultaneous, type APGamesInformation } from '@abstractplay/gameslib';
import { SESClient, SendEmailCommand } from '@aws-sdk/client-ses';
import webpush from "web-push";
import { validateToken } from '@sunknudsen/totp';
import i18n from 'i18next';
import en from '../locales/en/apback.json';
import fr from '../locales/fr/apback.json';
import de from '../locales/de/apback.json';
import it from '../locales/it/apback.json';
import pt from '../locales/pt/apback.json';
import ta from '../locales/ta/apback.json';

const LOCALE_RESOURCES = { en, fr, de, it, pt, ta } as const;
const REGISTERED_LANGUAGES = Object.keys(LOCALE_RESOURCES);
import { wsBroadcast } from '../lib/wsBroadcast';
import { checkInGameCommentAuth } from '../lib/commentAuth';
import {
  isBotId,
  getParticipants,
  getBotRecord,
  filterHumanIds,
  botToFullUserStub,
  toClientBot,
  ClientBot,
  BotRecord,
} from '../lib/participants';
import { enqueueBotOutbound, getToMovePlayerIds, loadGameRecord } from '../lib/botOutbound';
import {
  beginBotSecretRotation as cognitoBeginBotSecretRotation,
  finalizeBotSecretRotation as cognitoFinalizeBotSecretRotation,
} from '../lib/botSecrets';
import { buildCreateBotClientInput } from '../lib/botCognito';
import {
  BotNameTakenError,
  BotNameValidationError,
  reserveBotDisplayName,
  releaseBotDisplayName,
  renameBotDisplayName,
  validateBotDisplayName,
} from '../lib/botNames';
import { testBotStatus, updateTestBot } from './testBot';
import { hydrateGameState, prepareGameStateForStorage } from '../lib/gameState';
import {
  type PushOptions,
  deleteAllPushSubscriptions,
  deletePushSubscriptionByEndpoint,
  queryPushSubscriptions,
  savePushSubscription,
  sendPushToSubscriptions,
} from '../lib/pushSubscriptions';

const REGION = "us-east-1";
const sesClient = new SESClient({ region: REGION });
const sqsClient = new SQSClient({ region: REGION });
const cognitoClient = new CognitoIdentityProviderClient({ region: REGION });
const clnt = new DynamoDBClient({ region: REGION });
const marshallOptions = {
  // Whether to automatically convert empty strings, blobs, and sets to `null`.
  convertEmptyValues: false, // false, by default.
  // Whether to remove undefined values while marshalling.
  removeUndefinedValues: true, // false, by default.
  // Whether to convert typeof object to map attribute.
  convertClassInstanceToMap: false, // false, by default.
};
const unmarshallOptions = {
  // Whether to return numbers as a string instead of converting them to native JavaScript numbers.
  wrapNumbers: false, // false, by default.
};
const translateConfig = { marshallOptions, unmarshallOptions };
const ddbDocClient = DynamoDBDocumentClient.from(clnt, translateConfig);
const headers = {
  'content-type': 'application/json',
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Credentials': true,
  "Access-Control-Allow-Headers": "*",
  "Access-Control-Allow-Methods": "*",
};

// Types
type MetaGameCounts = {
  [metaGame: string]: {
    currentgames: number;
    completedgames: number;
    standingchallenges: number;
    ratings?: string[];
    stars?: number;
    tags?: string[];
  }
}

type Challenge = {
  metaGame: string;
  standing?: boolean;
  challenger: User;
  players: User[];
  challengees?: User[];
}

type FullChallenge = {
  pk?: string,
  sk?: string,
  metaGame: string;
  numPlayers: number;
  standing?: boolean;
  duration?: number;
  seating: string;
  variants: string[];
  challenger: User;
  challengees?: User[]; // players who were challenged
  players?: User[]; // players that have accepted
  clockStart: number;
  clockInc: number;
  clockMax: number;
  clockHard: boolean;
  rated: boolean;
  noExplore?: boolean;
  comment?: string;
  dateIssued?: number;
}

export type UserSettings = {
  [k: string]: any;
  all?: {
    [k: string]: any;
    color?: string;
    annotate?: boolean;
    notifications?: {
      gameStart: boolean;
      gameEnd: boolean;
      challenges: boolean;
      yourturn: boolean;
      tournamentStart: boolean;
      tournamentEnd: boolean;
    }
  }
};

export type UserLastSeen = {
  id: string;
  name: string;
  lastSeen?: number;
};

export type User = {
  id: string;
  name: string;
  time?: number;
  settings?: UserSettings;
  draw?: string;
}

type FullUser = {
  pk?: string,
  sk?: string,
  id: string;
  name: string;
  email: string;
  gamesUpdate?: number;
  games: Game[];
  challenges_issued?: Set<string>;
  bots?: Set<string>;
  challenges_received?: Set<string>;
  challenges_accepted?: Set<string>;
  challenges_standing?: Set<string>;
  admin: boolean | undefined;
  organizer: boolean | undefined;
  language: string;
  country: string;
  lastSeen?: number;
  settings: UserSettings;
  ratings?: {
    [metaGame: string]: Rating
  };
  stars?: string[];
  tags?: TagList[];
  palettes?: Palette[];
  mayPush?: boolean;
  bggid?: string;
  about?: string;
}

export type UsersData = {
  id: string;
  name: string;
  country: string;
  lastSeen: number;
  stars: string[];
  bggid?: string;
  about?: string;
  bot: boolean;
};

type Bot = ClientBot;

type MeData = {
  id: string;
  name: string;
  admin: boolean;
  organizer: boolean;
  language: string;
  country: string;
  games: Game[];
  settings: UserSettings;
  stars: string[];
  bggid?: string;
  about?: string;
  tags?: TagList[];
  palettes?: Palette[];
  mayPush: boolean;
  bots?: Bot[];
  challengesIssued?: FullChallenge[];
  challengesReceived?: FullChallenge[];
  challengesAccepted?: FullChallenge[];
  standingChallenges?: FullChallenge[];
  realStanding?: StandingChallenge[];
  customizations?: { [key: string]: any };
  blocked?: string[];
}

type Rating = {
  rating: number;
  N: number;
  wins: number;
  draws: number;
}

type Note = {
  pk: string;
  sk: string;
  note: string;
}

type Game = {
  pk?: string,
  sk?: string,
  id: string;
  metaGame: string;
  players: User[];
  lastMoveTime: number;
  clockHard: boolean;
  noExplore?: boolean;
  toMove?: string | boolean[];
  note?: string;
  seen?: number;
  winner?: number[];
  numMoves?: number;
  gameStarted?: number;
  gameEnded?: number;
  lastChat?: number;
  variants?: string[];
  commented?: number; // 0 or missing: no comments or post game variations, 1: has in-game comments, 2: has post game variations, 3: has post game comments. Only used in COMPLETEDGAMES#<metaGame> rows.
}

type FullGame = {
  pk: string;
  sk: string;
  id: string;
  clockHard: boolean;
  clockInc: number;
  clockMax: number;
  clockStart: number;
  gameStarted: number;
  gameEnded?: number;
  lastMoveTime: number;
  metaGame: string;
  numPlayers: number;
  players: User[];
  state: string;
  note?: string;
  toMove: string | boolean[];
  partialMove?: string;
  winner?: number[];
  numMoves?: number;
  rated?: boolean;
  pieInvoked?: boolean;
  variants?: string[];
  published?: string[];
  smevent?: string;
  smeventRound?: number;
  tournament?: string;
  event?: string;
  division?: number;
  noExplore?: boolean;
  commented?: number; // 0 or missing: no comments or post game variations, 1: has in-game comments (note this does NOT get updated for post-game comments/variations)
}

type Playground = {
  pk: "PLAYGROUND";
  sk: string;
  metaGame: string;
  state: string;
}

type Comment = {
  comment: string;
  userId: string;
  moveNumber: number;
  timeStamp: number;
}

type Exploration = {
  version?: number;
  id: string;
  move: number;
  comment: string;
  children: Exploration[];
  outcome?: number; // Optional. 0 for player1 win, 1 for player2 win, -1 for undecided.
  premove?: boolean; // Optional. If true, this move will be automatically submitted when the opponent plays the parent move.
};

type Division = {
  numGames: number;
  numCompleted: number;
  processed: boolean;
  winnerid?: string;
  winner?: string;
};

type Tournament = {
  pk: string;
  sk: string;
  id: string;
  metaGame: string;
  variants: string[];
  number: number;
  started: boolean;
  dateCreated: number;
  datePreviousEnded: number; // 0 means either the first tournament or a restart of the series (after it stopped because not enough participants), 3000000000000 means previous tournament still running.
  nextid?: string;
  dateStarted?: number;
  dateEnded?: number;
  divisions?: {
    [division: number]: Division;
  };
  players?: TournamentPlayer[]; // only on archived tournaments
  waiting?: boolean; // tournament does not yet have 4 players
};

type TournamentPlayer = {
  pk: string;
  sk: string;
  playerid: string;
  playername: string;
  once?: boolean;
  division?: number;
  score?: number;
  tiebreak?: number;
  rating?: number;
  timeout?: boolean;
};

type TournamentGame = {
  pk: string;
  sk: string;
  id: string;
  player1: string;
  player2: string;
  winner?: string[];
};

type OrgEvent = {
  pk: "ORGEVENT";
  sk: string;             // <eventid>
  name: string;
  description: string;
  organizer: string;
  dateStart: number;
  dateEnd?: number;
  winner?: string[];
  visible: boolean;
  maxPlayers: number;
  invited?: string[];
  blocked?: string[];
}

type OrgEventGame = {
  pk: "ORGEVENTGAME";
  sk: string;             // <eventid>#<gameid>
  metaGame: string;
  variants?: string[];
  round: number;
  gameid: string;
  player1: string;
  player2: string;
  winner?: string[];
  arbitrated?: boolean;
};

type OrgEventPlayer = {
  pk: "ORGEVENTPLAYER";
  sk: string;             // <eventid>#<playerid>
  playerid: string;
  division?: number;
  seed?: number;
};

type TagList = {
  meta: string;
  tags: string[];
}

type TagRec = {
  pk: "TAG";
  sk: string;
  tags: TagList[];
}

type Palette = {
  name: string;
  colours: string[];
}

type PaletteRec = {
  pk: "PALETTES";
  sk: string;
  palettes: Palette[];
}

type Customization = {
  colourContext: {
    [k: string]: string;
  },
  palette: string[];
}

type CustomizationRec = {
  pk: string;
  sk: string;
  settings: Customization;
}

// SDG-style standing challenges
type StandingChallenge = {
  id: string;
  metaGame: string;
  numPlayers: number;
  variants?: string[];
  clockStart: number;
  clockInc: number;
  clockMax: number;
  clockHard: boolean;
  rated: boolean;
  noExplore?: boolean
  limit: number;
  sensitivity: "meta" | "variants";
  suspended: boolean;
};

type StandingChallengeRec = {
  pk: "REALSTANDING";
  sk: string; // user's ID
  standing: StandingChallenge[];
};

const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));

async function sendCommandWithRetry<T = any>(command: any, maxRetries = 8, initialDelay = 100, maxDelay = 5000): Promise<T> {
  let retries = 0;
  while (retries < maxRetries) {
    try {
      // @ts-ignore
      return await ddbDocClient.send(command) as T;
    } catch (err: any) {
      if (['ThrottlingException', 'ProvisionedThroughputExceededException', 'InternalServerError', 'ServiceUnavailable'].includes(err.name)) {
        retries++;
        if (retries >= maxRetries) {
          console.error(`Command failed after ${maxRetries} retries.`);
          throw err;
        }
        const delay = Math.min(initialDelay * Math.pow(2, retries - 1), maxDelay);
        const jitter = delay * 0.1 * Math.random();
        console.log(`Retryable error (${err.name}) caught. Retrying in ${Math.round(delay + jitter)}ms...`);
        await sleep(delay + jitter);
      } else {
        throw err;
      }
    }
  }
  // This should never be reached due to the throw in the catch block
  throw new Error(`Command failed after ${maxRetries} retries without a retryable error`);
}

const DEFAULT_META_GAME_COUNTS = {
  currentgames: 0,
  completedgames: 0,
  standingchallenges: 0,
  stars: 0,
};

function isMetaGameCountsKey(key: string): boolean {
  return key === "pk" || key === "sk" || key.endsWith("_ratings");
}

async function ensureMetaGameCountEntry(metaGame: string): Promise<void> {
  await ddbDocClient.send(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { pk: "METAGAMES", sk: "COUNTS" },
    ExpressionAttributeNames: { "#g": metaGame },
    ExpressionAttributeValues: { ":defaults": DEFAULT_META_GAME_COUNTS },
    UpdateExpression: "SET #g = if_not_exists(#g, :defaults)",
  }));
}

async function ensureMissingMetaGameCounts(): Promise<void> {
  const data = await ddbDocClient.send(new GetCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { pk: "METAGAMES", sk: "COUNTS" },
  }));
  const item = data.Item ?? {};
  const existing = new Set(Object.keys(item).filter(k => !isMetaGameCountsKey(k)));
  const missing: string[] = [];
  gameinfo.forEach(g => {
    if (!existing.has(g.uid)) {
      missing.push(g.uid);
    }
  });
  if (missing.length === 0) {
    return;
  }
  console.log(`Initializing METAGAMES/COUNTS for new games: ${missing.join(", ")}`);
  await Promise.all(missing.map(uid => ensureMetaGameCountEntry(uid)));
}

module.exports.query = async (event: { queryStringParameters: any; body?: string; httpMethod: string; }) => {
  console.log(event);

  let pars;
  let query;

  // Handle both GET (query parameters) and POST (JSON body) requests
  if (event.httpMethod === 'POST' && event.body) {
    try {
      const bodyData = JSON.parse(event.body);
      query = bodyData.query;
      pars = bodyData.pars || {};
    } catch (error) {
      return {
        statusCode: 400,
        body: JSON.stringify({
          message: "Invalid JSON in request body"
        }),
        headers
      };
    }
  } else {
    // Existing GET request handling
    pars = event.queryStringParameters;
    query = pars.query;
  }

  console.log(pars);
  switch (query) {
    case "user_names":
      return await userNames();
    case "challenge_details":
      return await challengeDetails(pars);
    case "standing_challenges":
      return await standingChallenges(pars);
    case "games":
      return await games(pars);
    case "ratings":
      return await ratings(pars);
    case "meta_games":
      return await metaGamesDetails();
    case "get_game":
      return await game("", pars);
    case "get_public_exploration":
      return await getPublicExploration(pars);
    case "bot_move":
      return await botMove(pars);
    case "get_tournaments":
      return await getTournaments();
    case "get_old_tournaments":
      return await getOldTournaments(pars);
    case "get_tournament":
      return await getTournament(pars);
    case "start_tournaments":
      return await startTournaments();
    case "archive_tournaments":
      return await archiveTournaments();
    case "get_event":
      return await eventGetEvent(pars);
    case "get_events":
      return await eventGetEvents();
    case "report_problem":
      return await reportProblem(pars);
    default:
      return {
        statusCode: 500,
        body: JSON.stringify({
          message: `Unable to execute unknown open query '${pars.query}'`
        }),
        headers
      };
  }
}

function parseLambdaIntegrationBody(body: string | Record<string, unknown> | undefined): Record<string, unknown> {
  if (body === undefined || body === null) {
    throw new Error("Missing request body");
  }
  if (typeof body === "string") {
    return JSON.parse(body) as Record<string, unknown>;
  }
  return body;
}

module.exports.botQuery = async (event: { body: string | Record<string, unknown>; cognitoPoolClaims: PartialClaims; }) => {
  console.log("botQuery: ", event.body);
  console.log("botQuery claims:", {
    sub: event.cognitoPoolClaims?.sub,
    email: event.cognitoPoolClaims?.email,
    email_verified: event.cognitoPoolClaims?.email_verified,
  });
  let body: Record<string, unknown>;
  try {
    body = parseLambdaIntegrationBody(event.body);
  } catch (error) {
    return {
      statusCode: 400,
      body: JSON.stringify({
        message: "Invalid JSON in request body"
      }),
      headers
    };
  }

  const verb = body.verb;
  switch (verb) {
    case "move":
      return await handleMove(event.cognitoPoolClaims, body as { gameid: string; move: string; metaGame: string; });
    default:
      return {
        statusCode: 400,
        body: JSON.stringify({
          message: `Unknown bot verb '${verb}'`
        }),
        headers
      };
  }
}

type PartialClaims = { sub: string; email: string; email_verified: boolean };

// It looks like there is no way to "run and forget", you need to finish all work before returning a response to the front end. :(
// Make sure the @typescript-eslint/no-floating-promises linter rule passes, otherwise promise might (at best?) only be fullfilled on the next call to the API...
module.exports.authQuery = async (event: { body: { query: any; pars: any; }; cognitoPoolClaims: PartialClaims; }) => {
  console.log("authQuery: ", event.body.query);
  const query = event.body.query;
  const pars = event.body.pars;
  switch (query) {
    case "me":
      return await me(event.cognitoPoolClaims, pars);
    case "create_bot":
    case "createBot":
      return await createBot(event.cognitoPoolClaims, pars);
    case "update_bot":
    case "updateBot":
      return await updateBot(event.cognitoPoolClaims, pars);
    case "delete_bot":
    case "deleteBot":
      return await deleteBot(event.cognitoPoolClaims, pars);
    case "begin_bot_secret_rotation":
    case "beginBotSecretRotation":
      return await beginBotSecretRotation(event.cognitoPoolClaims, pars);
    case "finalize_bot_secret_rotation":
    case "finalizeBotSecretRotation":
      return await finalizeBotSecretRotation(event.cognitoPoolClaims, pars);
    case "test_bot_status":
      return await testBotStatus(event.cognitoPoolClaims);
    case "update_test_bot":
      return await updateTestBot(event.cognitoPoolClaims, pars);
    case "next_game":
      return await nextGame(event.cognitoPoolClaims.sub);
    case "my_settings":
      return await mySettings(event.cognitoPoolClaims);
    case "new_setting":
      return await newSetting(event.cognitoPoolClaims.sub, pars);
    case "new_profile":
      return await newProfile(event.cognitoPoolClaims, pars);
    case "set_push":
      return await setPush(event.cognitoPoolClaims.sub, pars);
    case "save_push":
      return await savePush(event.cognitoPoolClaims.sub, pars);
    case "delete_push":
      return await deletePush(event.cognitoPoolClaims.sub, pars);
    case "save_tags":
      return await saveTags(event.cognitoPoolClaims.sub, pars);
    case "save_palettes":
      return await savePalettes(event.cognitoPoolClaims.sub, pars);
    case "save_customization":
      return await saveCustomization(event.cognitoPoolClaims.sub, pars);
    case "delete_customization":
      return await deleteCustomization(event.cognitoPoolClaims.sub, pars);
    case "update_standing":
      return await updateStanding(event.cognitoPoolClaims.sub, pars);
    case "block_player":
      return await block_player(event.cognitoPoolClaims.sub, pars);
    case "unblock_player":
      return await unblock_player(event.cognitoPoolClaims.sub, pars);
    case "standing_challenges":
      return await standingChallenges({ ...pars, userId: event.cognitoPoolClaims.sub });
    case "new_challenge":
      return await newChallenge(event.cognitoPoolClaims.sub, pars);
    case "challenge_revoke":
      return await revokeChallenge(event.cognitoPoolClaims.sub, pars);
    case "challenge_response":
      return await respondedChallenge(event.cognitoPoolClaims.sub, pars);
    case "submit_move":
      return await submitMove(event.cognitoPoolClaims.sub, pars);
    case "timeloss":
      return await checkForTimeloss(event.cognitoPoolClaims.sub, pars);
    case "abandoned":
      return await checkForAbandonedGame(event.cognitoPoolClaims.sub, pars);
    case "invoke_pie":
      return await invokePie(event.cognitoPoolClaims.sub, pars);
    case "update_note":
      return await updateNote(event.cognitoPoolClaims.sub, pars);
    case "update_commented":
      return await updateCommented(event.cognitoPoolClaims.sub, pars);
    case "set_lastSeen":
      return await setLastSeen(event.cognitoPoolClaims.sub, pars);
    case "submit_comment":
      return await submitComment(event.cognitoPoolClaims.sub, pars);
    case "save_exploration":
      return await saveExploration(event.cognitoPoolClaims.sub, pars);
    case "get_exploration":
      return await getExploration(event.cognitoPoolClaims.sub, pars);
    case "get_private_exploration":
      return await getPrivateExploration(event.cognitoPoolClaims.sub, pars);
    case "get_game":
      return await game(event.cognitoPoolClaims.sub, pars);
    case "get_playground":
      return await getPlayground(event.cognitoPoolClaims.sub, pars);
    case "new_playground":
      return await newPlayground(event.cognitoPoolClaims.sub, pars);
    case "reset_playground":
      return await resetPlayground(event.cognitoPoolClaims.sub);
    case "toggle_star":
      return await toggleStar(event.cognitoPoolClaims.sub, pars);
    case "set_game_state":
      return await injectState(event.cognitoPoolClaims.sub, pars);
    case "update_game_settings":
      return await updateGameSettings(event.cognitoPoolClaims.sub, pars);
    case "update_user_settings":
      return await updateUserSettings(event.cognitoPoolClaims.sub, pars);
    case "update_meta_game_counts":
      return await updateMetaGameCounts(event.cognitoPoolClaims.sub);
    case "purge_retired_completed_games":
      return await purgeRetiredCompletedGames(event.cognitoPoolClaims.sub);
    case "mark_published":
      return await markAsPublished(event.cognitoPoolClaims.sub, pars);
    case "new_tournament":
      return await newTournament(event.cognitoPoolClaims.sub, pars);
    case "join_tournament":
      return await joinTournament(event.cognitoPoolClaims.sub, pars);
    case "withdraw_tournament":
      return await withdrawTournament(event.cognitoPoolClaims.sub, pars);
    case "event_create":
      return await eventCreate(event.cognitoPoolClaims.sub, pars);
    case "event_delete":
      return await eventDelete(event.cognitoPoolClaims.sub, pars);
    case "event_publish":
      return await eventPublish(event.cognitoPoolClaims.sub, pars);
    case "event_register":
      return await eventRegister(event.cognitoPoolClaims.sub, pars);
    case "event_withdraw":
      return await eventWithdraw(event.cognitoPoolClaims.sub, pars);
    case "event_update_start":
      return await eventUpdateStart(event.cognitoPoolClaims.sub, pars);
    case "event_update_name":
      return await eventUpdateName(event.cognitoPoolClaims.sub, pars);
    case "event_update_desc":
      return await eventUpdateDesc(event.cognitoPoolClaims.sub, pars);
    case "event_update_invites":
      return await eventUpdateInvites(event.cognitoPoolClaims.sub, pars);
    case "event_update_result":
      return await eventUpdateResult(event.cognitoPoolClaims.sub, pars);
    case "event_update_divisions":
      return await eventUpdateDivisions(event.cognitoPoolClaims.sub, pars);
    case "event_create_games":
      return await eventCreateGames(event.cognitoPoolClaims.sub, pars);
    case "event_close":
      return await eventClose(event.cognitoPoolClaims.sub, pars);
    case "ping_bot":
      return await pingBot(event.cognitoPoolClaims.sub, pars);
    case "onetime_fix":
      return await onetimeFix(event.cognitoPoolClaims.sub);
    case "fix_games":
      return await fixGames(event.cognitoPoolClaims.sub, pars);
    case "test_push":
      return await testPush(event.cognitoPoolClaims.sub);
    case "test_async":
      return await testAsync(event.cognitoPoolClaims.sub, pars);
    case "delete_games":
      return await deleteGames(event.cognitoPoolClaims.sub, pars);
    case "end_tournament":
      return await endATournament(event.cognitoPoolClaims.sub, pars);
    case "start_tournament":
      return await startATournament(event.cognitoPoolClaims.sub, pars);
    default:
      return {
        statusCode: 500,
        body: JSON.stringify({
          message: `Unable to execute unknown query '${query}'`
        }),
        headers
      };
  }
}

async function userNames() {
  // Bots are listed from the stage's DynamoDB table (abstract-play-dev vs abstract-play-prod).
  // Bot Cognito credentials are also per-stage; dev tokens cannot call prod botQuery.
  console.log("userNames: Scanning users.");
  try {
    const [data, botData] = await Promise.all([
      ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          KeyConditionExpression: "#pk = :pk",
          ExpressionAttributeValues: { ":pk": "USERS" },
          ExpressionAttributeNames: { "#pk": "pk", "#name": "name" },
          ProjectionExpression: "sk, #name, lastSeen, country, stars, bggid, about",
          ReturnConsumedCapacity: "INDEXES"
        })),
      ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          KeyConditionExpression: "#pk = :pk",
          ExpressionAttributeValues: { ":pk": "BOT" },
          ExpressionAttributeNames: { "#pk": "pk", "#name": "name" },
          ProjectionExpression: "sk, #name, lastseen, description, supported",
        })),
    ]);

    const users = data.Items;
    if (users == undefined) {
      throw new Error("Found no users?");
    }

    // tweak bot info
    const idx = users.findIndex(u => u.sk === process.env.AIAI_USERID);
    if (idx !== -1) {
      users[idx].lastSeen = Date.now();
    }

    const userResults = users.map(u => ({ id: u.sk, name: u.name, country: u.country, stars: u.stars, lastSeen: u.lastSeen, bggid: u.bggid, about: u.about, bot: false } as UsersData));
    const botResults = (botData.Items ?? []).map(b => ({
      id: b.sk,
      name: b.name,
      country: "",
      stars: [...new Set(((b.supported ?? []) as { meta: string }[]).map(s => s.meta))],
      lastSeen: b.lastseen ?? 0,
      about: b.description,
      bot: true,
    } as UsersData));

    return {
      statusCode: 200,
      body: JSON.stringify([...userResults, ...botResults]),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to query table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

async function challengeDetails(pars: { id: string; }) {
  try {
    const data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "CHALLENGE", "sk": pars.id
        },
      }));
    console.log("Got:");
    console.log(data);
    return {
      statusCode: 200,
      body: JSON.stringify(data.Item),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get challenge ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

async function games(pars: { metaGame: string, type: string; }) {
  const game = pars.metaGame;
  console.log(game);

  if (pars.type === "current") {
    try {
      const gamesData = await ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
          ExpressionAttributeValues: { ":pk": "GAME", ":sk": game + '#0#' },
          ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        }));

      const gamelist = (gamesData.Items as FullGame[]).map(hydrateGameState);

      const returnlist = gamelist.map(g => {
        const state = GameFactory(g.metaGame, g.state); // JSON.parse(g.state);
        if (state === undefined) {
          throw new Error(`Could not parse game state for ${g.metaGame}:\n${g.state}`);
        }
        return {
          "id": g.id, "metaGame": g.metaGame, "players": g.players, "toMove": g.toMove, "gameStarted": g.gameStarted,
          "numMoves": state.stack.length - 1, "variants": state.variants, "commented": g.commented || 0
        }
      });
      return {
        statusCode: 200,
        body: JSON.stringify(returnlist),
        headers
      };
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to get games for ${pars.metaGame}`);
    }
  } else if (pars.type === "completed") {
    try {
      const gamesData = await ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          KeyConditionExpression: "#pk = :pk",
          ExpressionAttributeValues: { ":pk": "COMPLETEDGAMES#" + game },
          ExpressionAttributeNames: { "#pk": "pk" }
        }));

      return {
        statusCode: 200,
        body: JSON.stringify(gamesData.Items),
        headers
      };
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to get games for ${pars.metaGame}`);
    }
  } else {
    return formatReturnError(`Unknown type ${pars.type}`);
  }
}

async function ratings(pars: { metaGame: string }) {
  const game = pars.metaGame;

  try {
    const ratingsData = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "RATINGS#" + game },
        ExpressionAttributeNames: { "#pk": "pk" }
      }));

    return {
      statusCode: 200,
      body: JSON.stringify(ratingsData.Items),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get ratings for ${pars.metaGame}`);
  }
}

async function getPlayerRelationIds(userId: string, skPrefix: string): Promise<string[]> {
  const ids: string[] = [];
  let result = await ddbDocClient.send(
    new QueryCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      KeyConditionExpression: "#pk = :pk AND begins_with(#sk, :skPrefix)",
      ExpressionAttributeValues: {
        ":pk": "PLAYER#" + userId,
        ":skPrefix": skPrefix,
      },
      ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      ProjectionExpression: "#sk",
    })
  );
  if (result.Items !== undefined) {
    for (const item of result.Items) {
      ids.push((item.sk as string).slice(skPrefix.length));
    }
  }
  let last = result.LastEvaluatedKey;
  while (last !== undefined) {
    result = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk AND begins_with(#sk, :skPrefix)",
        ExpressionAttributeValues: {
          ":pk": "PLAYER#" + userId,
          ":skPrefix": skPrefix,
        },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        ProjectionExpression: "#sk",
        ExclusiveStartKey: last,
      })
    );
    if (result.Items !== undefined) {
      for (const item of result.Items) {
        ids.push((item.sk as string).slice(skPrefix.length));
      }
    }
    last = result.LastEvaluatedKey;
  }
  return ids;
}

async function block_player(blockingPlayerId: string, pars: { playerId: string }) {
  const blockedPlayerId = pars.playerId;
  if (blockingPlayerId === blockedPlayerId) {
    return formatReturnError("Cannot block yourself");
  }
  try {
    await Promise.all([
      ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          pk: `PLAYER#${blockingPlayerId}`,
          sk: `BLOCKED#${blockedPlayerId}`,
        },
      })),
      ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          pk: `PLAYER#${blockedPlayerId}`,
          sk: `BLOCKEDBY#${blockingPlayerId}`,
        },
      })),
    ]);
    return {
      statusCode: 200,
      body: JSON.stringify({ message: "Successfully blocked player" }),
      headers,
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to block player ${blockedPlayerId}`);
  }
}

async function unblock_player(blockingPlayerId: string, pars: { playerId: string }) {
  const blockedPlayerId = pars.playerId;
  try {
    await Promise.all([
      ddbDocClient.send(new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          pk: `PLAYER#${blockingPlayerId}`,
          sk: `BLOCKED#${blockedPlayerId}`,
        },
      })),
      ddbDocClient.send(new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          pk: `PLAYER#${blockedPlayerId}`,
          sk: `BLOCKEDBY#${blockingPlayerId}`,
        },
      })),
    ]);
    return {
      statusCode: 200,
      body: JSON.stringify({ message: "Successfully unblocked player" }),
      headers,
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to unblock player ${blockedPlayerId}`);
  }
}

async function standingChallenges(pars: { metaGame: string; userId?: string }) {
  const game = pars.metaGame;
  console.log(game);

  const blockedByPromise = pars.userId
    ? getPlayerRelationIds(pars.userId, "BLOCKEDBY#")
    : Promise.resolve([] as string[]);

  try {
    const [challengesData, blockedBy] = await Promise.all([
      ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          KeyConditionExpression: "#pk = :pk",
          ExpressionAttributeValues: { ":pk": "STANDINGCHALLENGE#" + game },
          ExpressionAttributeNames: { "#pk": "pk" }
        })),
      blockedByPromise,
    ]);

    let items = challengesData.Items || [];
    if (blockedBy.length > 0) {
      const blockedBySet = new Set(blockedBy);
      items = items.filter(c => !blockedBySet.has((c as FullChallenge).challenger?.id));
    }

    return {
      statusCode: 200,
      body: JSON.stringify(items),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get standing challenges for ${pars.metaGame}`);
  }
}

async function assembleTags(): Promise<TagList[] | undefined> {
  try {
    const data = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "TAG" },
        ExpressionAttributeNames: { "#pk": "pk" },
      }));
    const allTags = data.Items as TagRec[];
    const collated = new Map<string, string[]>();
    if (allTags !== undefined) {
      for (const rec of allTags) {
        for (const { meta, tags } of rec.tags) {
          const uniques = new Set<string>(tags);
          if (collated.has(meta)) {
            for (const tag of collated.get(meta)!) {
              uniques.add(tag);
            }
          }
          collated.set(meta, [...uniques.values()].sort((a, b) => a.localeCompare(b)));
        }
      }
    }
    return [...collated.entries()].map(([meta, tags]) => { return { meta, tags } });
  } catch (error) {
    return undefined;
  }
}

async function metaGamesDetails() {
  try {
    await ensureMissingMetaGameCounts();
    const data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "METAGAMES", "sk": "COUNTS"
        },
      }));
    const details = { ...(data.Item ?? {}) } as MetaGameCounts;
    gameinfo.forEach(g => {
      if (!details[g.uid]) {
        details[g.uid] = { ...DEFAULT_META_GAME_COUNTS };
      }
    });
    // get list of tags
    const taglist = await assembleTags();
    if (taglist === undefined) {
      throw new Error("An error occured while fetching game tags");
    }
    for (const key of Object.keys(details)) {
      if (isMetaGameCountsKey(key)) {
        continue;
      }
      const tags = taglist.find(l => l.meta === key);
      if (tags !== undefined) {
        details[key].tags = [...tags.tags]
      } else {
        details[key].tags = [];
      }
    }
    // console.log(`Details:\n${JSON.stringify(details, undefined, 2)}`);
    // Change every "ratings" to the number of elements in the Set.
    const details2 = Object.keys(details)
      .filter(key => !isMetaGameCountsKey(key))
      .reduce((a, k) => ({
        ...a,
        [k]: {
          ...details[k],
          "ratings": (details as any)[k + "_ratings"]?.size ?? 0
        }
      }), {})
    // console.log(`Details2:\n${JSON.stringify(details2, undefined, 2)}`);
    return {
      statusCode: 200,
      body: JSON.stringify(details2),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError("Unable to get meta game details.");
  }
}

async function game(userid: string, pars: { id: string, cbit: string | number, metaGame: string, retryAttempt?: number }) {
  try {
    if (pars.retryAttempt && pars.retryAttempt > 0) {
      console.log(`get_game called with retry attempt ${pars.retryAttempt} for game ${pars.id}, metaGame ${pars.metaGame}`);
    }
    if (pars.cbit !== 0 && pars.cbit !== 1 && pars.cbit !== "0" && pars.cbit !== "1") {
      return formatReturnError("cbit must be 0 or 1");
    }
    const getGame = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metaGame + "#" + pars.cbit + '#' + pars.id
        },
      }));
    const getComments = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAMECOMMENTS",
          "sk": pars.id
        },
        ReturnConsumedCapacity: "INDEXES"
      }));
    const getNote = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "NOTE",
          "sk": `${pars.id}#${userid}`,
        },
        ReturnConsumedCapacity: "INDEXES"
      }));

    const gameData = await getGame;
    // console.log(`Game data fetched:\n${JSON.stringify(gameData)}`);
    let game = gameData.Item !== undefined ? hydrateGameState(gameData.Item as FullGame) : undefined;
    if (game === undefined && (pars.cbit === 0 || pars.cbit === "0")) {
      const completedGameData = await ddbDocClient.send(
        new GetCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "GAME",
            "sk": pars.metaGame + "#1#" + pars.id
          },
        }));
      game = completedGameData.Item !== undefined
        ? hydrateGameState(completedGameData.Item as FullGame)
        : undefined;
    }
    if (game === undefined) {
      throw new Error(`Game ${pars.id}, metaGame ${pars.metaGame}, completed bit ${pars.cbit} not found`);
    }
    // Always set seen time, not just when the game is over
    if (userid !== undefined && userid !== null && userid !== "") {
      await setSeenTime(userid, pars.id);
    }
    // hide other player's simultaneous moves
    const flags = gameinfo.get(game.metaGame).flags;
    if (flags !== undefined && flags.includes('simultaneous') && game.partialMove !== undefined) {
      const players = game.players;
      game.partialMove = game.partialMove.split(',').map((m: string, i: number) => (players[i].id === userid ? m : '')).join(',');
    }
    const noteData = await getNote;
    console.log(`Fetched notes:\n${JSON.stringify(noteData)}`);
    if (noteData.Item !== undefined && noteData.Item.note) {
      game.note = noteData.Item.note;
    }
    let comments = [];
    const commentData = await getComments;
    // console.log(`Fetched comments:\n${JSON.stringify(commentData)}`);
    if (commentData.Item !== undefined && commentData.Item.comments)
      comments = commentData.Item.comments;

    // TODO: Rehydrate state, run it through the stripper if game is not over, and then replace with the new, stripped state
    if (game.gameEnded === undefined) {
      const engine = GameFactory(game.metaGame, game.state);
      if (engine === undefined) {
        throw new Error(`Could not rehydrate the state for id "${pars.id}", cbit "${pars.cbit}", meta "${pars.metaGame}".`);
      }
      if (!engine.gameover) {
        let player: number | undefined;
        const pidx = game.players.findIndex(p => p.id === userid);
        if (pidx >= 0) {
          player = pidx + 1;
        }
        game.state = engine.serialize({ strip: true, player });
      }
    }

    console.log(`Returning 200.`);
    return {
      statusCode: 200,
      body: JSON.stringify({ "game": game, "comments": comments }),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get ${pars.metaGame} game ${pars.id}, completed bit ${pars.cbit} from DB`);
  }
}

async function newPlayground(userid: string, pars: { metaGame: string; state: string; }) {
  console.log(`New playground request received:\nGame: ${pars.metaGame}\nState: ${pars.state}`);
  // first make sure it's a 2-player non-simultaneous game
  const info: APGamesInformation | undefined = gameinfo.get(pars.metaGame);
  let valid = true;
  if (info !== undefined) {
    if ((!info.playercounts.includes(2)) || (info.flags.includes("simultaneous"))) {
      valid = false;
    }
  } else {
    valid = false;
  }

  if (!valid) {
    console.log(`Invalid game (400)`);
    return {
      statusCode: 400,
      headers
    };
  }

  // initialize the playground
  try {
    // delete existing exploration
    console.log(`Deleting existing exploration`);
    const explorationQuery = ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "GAMEEXPLORATION#" + userid },
        ExpressionAttributeNames: { "#pk": "pk" },
      }));
    const explorationData = await explorationQuery;
    const explorationRecs = explorationData.Items;
    if (explorationRecs !== undefined) {
      const batches = Math.ceil(explorationRecs.length / 10);
      for (let batch = 0; batch < batches; batch++) {
        const subset = explorationRecs.slice(batch * 10, 10);
        await ddbDocClient.send(
          new BatchWriteCommand({
            "RequestItems": {
              [process.env.ABSTRACT_PLAY_TABLE!]: subset.map(item => ({
                DeleteRequest: {
                  Key: {
                    pk: item.pk,
                    sk: item.sk,
                  }
                }
              }))
            }
          })
        );
      }
    }

    // create new playground record
    console.log(`Creating playground record`);
    const Item: Playground = {
      pk: "PLAYGROUND",
      sk: userid,
      metaGame: pars.metaGame,
      state: pars.state,
    };
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item,
      })
    );
    console.log(`Returning ${JSON.stringify(Item)}`);
    return {
      statusCode: 200,
      body: JSON.stringify(Item),
      headers
    };
  }
  catch (error) {
    handleCommonErrors(error as { code: any; message: any });
    return formatReturnError(`Unable to create playground for ${userid}: ${error}`);
  }
}

async function resetPlayground(userid: string) {
  console.log(`Playground reset requested`);
  try {
    // delete existing exploration
    console.log(`Deleting existing exploration`);
    const explorationQuery = ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "GAMEEXPLORATION#" + userid },
        ExpressionAttributeNames: { "#pk": "pk" },
      }));
    const explorationData = await explorationQuery;
    const explorationRecs = explorationData.Items;
    if (explorationRecs !== undefined) {
      const batches = Math.ceil(explorationRecs.length / 10);
      for (let batch = 0; batch < batches; batch++) {
        const subset = explorationRecs.slice(batch * 10, 10);
        await ddbDocClient.send(
          new BatchWriteCommand({
            "RequestItems": {
              [process.env.ABSTRACT_PLAY_TABLE!]: subset.map(item => ({
                DeleteRequest: {
                  Key: {
                    pk: item.pk,
                    sk: item.sk,
                  }
                }
              }))
            }
          })
        );
      }
    }

    // delete existing playground record
    await ddbDocClient.send(
      new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "PLAYGROUND", "sk": userid
        },
      })
    )
    console.log(`Playground reset`);
    return {
      statusCode: 200,
      headers
    };
  }
  catch (error) {
    handleCommonErrors(error as { code: any; message: any });
    return formatReturnError(`Unable to reset playground for ${userid}: ${error}`);
  }
}

async function getPlayground(userid: string, pars: any) {
  try {
    const getGame = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "PLAYGROUND",
          "sk": userid
        },
      }));

    const gameData = await getGame;
    const game = gameData.Item as Playground;
    if (game === undefined) {
      return {
        statusCode: 200,
        body: JSON.stringify(null),
        headers
      };
    } else {
      return {
        headers,
        statusCode: 200,
        body: JSON.stringify(game),
      };
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get playground for user ${userid} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

async function toggleStar(userid: string, pars: { metaGame: string }) {
  try {
    // get player
    const player = (await getPlayers([userid]))[0];
    // add or remove metaGame
    let delta = 0;
    if (player.stars === undefined) {
      player.stars = [];
    }
    if (!player.stars.includes(pars.metaGame)) {
      delta = 1;
      player.stars.push(pars.metaGame);
    } else {
      delta = -1;
      const idx = player.stars.findIndex(m => m === pars.metaGame);
      player.stars.splice(idx, 1);
    }
    // queue player update
    const list: Promise<any>[] = [];
    list.push(
      ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "USER", "sk": player.id },
        ExpressionAttributeValues: { ":ss": player.stars },
        UpdateExpression: "set stars = :ss",
      }))
    );
    list.push(
      ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "USERS", "sk": player.id },
        ExpressionAttributeValues: { ":ss": player.stars },
        UpdateExpression: "set stars = :ss",
      }))
    );
    console.log(`Queued update to player ${player.id}, ${player.name}, toggling star for ${pars.metaGame}: ${delta}`);

    await ensureMetaGameCountEntry(pars.metaGame);

    // queue game update
    list.push(
      ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "METAGAMES", "sk": "COUNTS" },
        ExpressionAttributeNames: { "#g": pars.metaGame },
        ExpressionAttributeValues: { ":n": delta, ":zero": 0 },
        UpdateExpression: "set #g.stars = if_not_exists(#g.stars, :zero) + :n",
      }))
    );

    // run all updates
    console.log("Running queued updates");
    await Promise.all(list);
    console.log("Done");
    return {
      statusCode: 200,
      body: JSON.stringify(player.stars),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to toggle star for ${userid}, ${pars.metaGame} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

// NOTE: This function will blow up hidden-information games
async function injectState(userid: string, pars: { id: string; newState: string; metaGame: string; }) {
  // Make sure people aren't getting clever
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to inject state ${userid}`);
  }

  // get the game. For now we will assume this isn't a finished game.
  let game: FullGame;
  try {
    const getGame = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metaGame + "#0#" + pars.id
        },
      }));
    const gameData = await getGame;
    console.log("Got:");
    console.log(gameData);
    game = hydrateGameState(gameData.Item as FullGame);
    if (game === undefined) {
      throw new Error(`Game ${pars.id} not found`);
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get game ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  // update the state
  game.state = pars.newState;

  // store the updated game
  try {
    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: prepareGameStateForStorage(game)
    }));
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to update game ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  return {
    statusCode: 200,
    body: JSON.stringify(game),
    headers
  };
}

async function updateGameSettings(userid: string, pars: { game: string, settings: any, metaGame: string, cbit: number }) {
  if (pars.cbit !== 0 && pars.cbit !== 1) {
    return formatReturnError("cbit must be 0 or 1");
  }
  try {
    const data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metaGame + "#" + pars.cbit + '#' + pars.game
        },
      }));
    console.log("Got:");
    console.log(data);
    const game = hydrateGameState(data.Item as FullGame);
    if (game === undefined)
      throw new Error(`updateGameSettings: game ${pars.game} not found`);
    const player = game.players.find((p: { id: any; }) => p.id === userid);
    if (player === undefined)
      throw new Error(`updateGameSettings: player ${userid} isn't playing in game ${pars.game}`);
    player.settings = pars.settings;
    try {
      await ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: prepareGameStateForStorage(game)
      }));
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to update game ${pars.game} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
    }
    return {
      statusCode: 200,
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get or update game ${pars.game} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

async function setSeenTime(userid: string, gameid: any) {
  let user: FullUser;
  try {
    const userData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (userData.Item === undefined)
      throw new Error(`setSeenTime, no user?? ${userid}`);
    user = userData.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    throw new Error(`setSeenTime, no user?? ${userid}`);
  }

  const games = user.games;
  if (games !== undefined) {
    const thegame = games.find((g: { id: any; }) => g.id == gameid);
    if (thegame !== undefined) {
      thegame.seen = Date.now();
    }
  }
  return updateUserGames(userid, user.gamesUpdate, [gameid], games);
}

async function updateUserSettings(userid: string, pars: { settings: any; }) {
  try {
    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": userid },
      ExpressionAttributeValues: { ":ss": pars.settings },
      UpdateExpression: "set settings = :ss",
    }))
    console.log("Success - user settings updated");
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: `Sucessfully stored user settings for user ${userid}`,
      }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to store user settings for user ${userid}`);
  }
}

function mapBotNameError(error: unknown) {
  if (error instanceof BotNameTakenError) {
    return {
      statusCode: 409,
      body: JSON.stringify({ message: error.message }),
      headers
    };
  }
  if (error instanceof BotNameValidationError) {
    return {
      statusCode: 400,
      body: JSON.stringify({ message: error.message }),
      headers
    };
  }
  return undefined;
}

async function createBot(claim: PartialClaims, pars: { name: string, endpoint: string }) {
  if (!claim || !claim.sub) {
    return {
      statusCode: 401,
      body: JSON.stringify({ message: "Unauthorized" }),
      headers
    };
  }

  let displayName: string;
  try {
    displayName = validateBotDisplayName(pars?.name ?? '');
  } catch (error) {
    const mapped = mapBotNameError(error);
    if (mapped) {
      return mapped;
    }
    throw error;
  }

  const endpoint = pars?.endpoint?.trim();
  if (!endpoint) {
    return {
      statusCode: 400,
      body: JSON.stringify({ message: "An HTTPS endpoint is required for the bot" }),
      headers
    };
  }

  const userPoolId = process.env.BOTPOOL_ID;
  if (!userPoolId) {
    return formatReturnError("BOTPOOL_ID environment variable is not set");
  }

  let clientId: string | undefined;
  let nameReserved = false;

  try {
    const response = await cognitoClient.send(new CreateUserPoolClientCommand(
      buildCreateBotClientInput(userPoolId, `bot-${uuid()}`)
    ));
    clientId = response.UserPoolClient?.ClientId;
    const clientSecret = response.UserPoolClient?.ClientSecret;

    if (!clientId || !clientSecret) {
      throw new Error("Cognito did not return ClientId or ClientSecret");
    }

    displayName = await reserveBotDisplayName(displayName, clientId, claim.sub);
    nameReserved = true;

    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: {
        pk: "BOT",
        sk: clientId,
        name: displayName,
        endpoint,
        lastseen: Date.now(),
        owner: claim.sub
      }
    }));

    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": claim.sub },
      ExpressionAttributeNames: { "#b": "bots" },
      ExpressionAttributeValues: { ":b": new Set([clientId]) },
      UpdateExpression: "ADD #b :b",
    }));

    return {
      statusCode: 200,
      body: JSON.stringify({ clientId, clientSecret }),
      headers
    };
  } catch (error: any) {
    console.error("Error creating bot: ", error);

    if (nameReserved) {
      try {
        await releaseBotDisplayName(displayName);
      } catch (releaseError) {
        console.error("Error releasing bot name reservation after failed create: ", releaseError);
      }
    }

    if (clientId) {
      try {
        await cognitoClient.send(new DeleteUserPoolClientCommand({
          UserPoolId: userPoolId,
          ClientId: clientId,
        }));
      } catch (deleteError) {
        console.error("Error deleting Cognito client after failed create: ", deleteError);
      }
    }

    const mapped = mapBotNameError(error);
    if (mapped) {
      return mapped;
    }

    return formatReturnError(`Unable to create bot: ${error.message || error}`);
  }
}

async function updateBot(
  claim: PartialClaims,
  pars: {
    clientId: string;
    name: string;
    endpoint: string;
    description?: string;
    supported?: { meta: string; variants: string[] }[];
  }
) {
  if (!claim || !claim.sub) {
    return {
      statusCode: 401,
      body: JSON.stringify({ message: "Unauthorized" }),
      headers
    };
  }

  const clientId = pars?.clientId;
  if (!clientId || clientId.trim().length === 0) {
    return {
      statusCode: 400,
      body: JSON.stringify({ message: "A clientId is required to identify the bot" }),
      headers
    };
  }

  try {
    const data = await ddbDocClient.send(new GetCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        pk: "BOT",
        sk: clientId
      }
    }));

    if (!data.Item) {
      return {
        statusCode: 404,
        body: JSON.stringify({ message: `Bot with client ID ${clientId} not found` }),
        headers
      };
    }

    const bot = data.Item;
    if (bot.owner !== claim.sub) {
      return {
        statusCode: 403,
        body: JSON.stringify({ message: "You are not the owner of this bot" }),
        headers
      };
    }

    // Update the values (but never update clientId/sk)
    if (pars.name !== undefined) {
      bot.name = await renameBotDisplayName(
        bot.name as string,
        pars.name,
        clientId,
        claim.sub
      );
    }
    if (pars.endpoint !== undefined) {
      const trimmedEndpoint = pars.endpoint.trim();
      if (!trimmedEndpoint) {
        return {
          statusCode: 400,
          body: JSON.stringify({ message: "An HTTPS endpoint is required for the bot" }),
          headers
        };
      }
      bot.endpoint = trimmedEndpoint;
    }
    if (pars.description !== undefined) {
      bot.description = pars.description;
    }
    if (pars.supported !== undefined) {
      if (!Array.isArray(pars.supported)) {
        return {
          statusCode: 400,
          body: JSON.stringify({ message: "supported must be an array of objects matching {meta: string, variants: string[]}" }),
          headers
        };
      }
      bot.supported = pars.supported;
    }

    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: bot
    }));

    return {
      statusCode: 200,
      body: JSON.stringify({ message: "Bot updated successfully" }),
      headers
    };
  } catch (error: any) {
    console.error("Error updating bot: ", error);
    const mapped = mapBotNameError(error);
    if (mapped) {
      return mapped;
    }
    return formatReturnError(`Unable to update bot: ${error.message || error}`);
  }
}

type OwnedBotRecord = {
  pk: string;
  sk: string;
  owner: string;
  name: string;
  endpoint: string;
  pendingSecretId?: string;
  pendingSecretCreatedAt?: number;
};

function mapCognitoBotSecretError(error: any, action: string) {
  const name = error?.name ?? error?.__type;
  if (name === 'InvalidParameterException') {
    return {
      statusCode: 400,
      body: JSON.stringify({ message: error.message || 'Invalid parameter' }),
      headers
    };
  }
  if (name === 'LimitExceededException') {
    return {
      statusCode: 409,
      body: JSON.stringify({ message: error.message || 'Secret limit exceeded' }),
      headers
    };
  }
  return formatReturnError(`Unable to ${action}: ${error.message || error}`);
}

async function loadOwnedBot(claim: PartialClaims, clientId: string | undefined) {
  if (!claim || !claim.sub) {
    return {
      response: {
        statusCode: 401,
        body: JSON.stringify({ message: "Unauthorized" }),
        headers
      }
    };
  }

  if (!clientId || clientId.trim().length === 0) {
    return {
      response: {
        statusCode: 400,
        body: JSON.stringify({ message: "A clientId is required to identify the bot" }),
        headers
      }
    };
  }

  try {
    const data = await ddbDocClient.send(new GetCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        pk: "BOT",
        sk: clientId
      }
    }));

    if (!data.Item) {
      return {
        response: {
          statusCode: 404,
          body: JSON.stringify({ message: `Bot with client ID ${clientId} not found` }),
          headers
        }
      };
    }

    const bot = data.Item as OwnedBotRecord;
    if (bot.owner !== claim.sub) {
      return {
        response: {
          statusCode: 403,
          body: JSON.stringify({ message: "You are not the owner of this bot" }),
          headers
        }
      };
    }

    return { bot };
  } catch (error: any) {
    console.error("Error loading bot: ", error);
    return { response: formatReturnError(`Unable to load bot: ${error.message || error}`) };
  }
}

async function beginBotSecretRotation(claim: PartialClaims, pars: { clientId: string }) {
  const loaded = await loadOwnedBot(claim, pars?.clientId);
  if ("response" in loaded) {
    return loaded.response;
  }

  const clientId = loaded.bot.sk;

  try {
    const { clientSecretId, clientSecret } = await cognitoBeginBotSecretRotation(clientId);
    const pendingSecretCreatedAt = Date.now();

    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { pk: "BOT", sk: clientId },
      UpdateExpression: "SET pendingSecretId = :pendingSecretId, pendingSecretCreatedAt = :pendingSecretCreatedAt",
      ExpressionAttributeValues: {
        ":pendingSecretId": clientSecretId,
        ":pendingSecretCreatedAt": pendingSecretCreatedAt,
      },
    }));

    return {
      statusCode: 200,
      body: JSON.stringify({
        clientSecretId,
        clientSecret,
        secretRotationPending: true,
        pendingSecretId: clientSecretId,
        pendingSecretCreatedAt,
      }),
      headers
    };
  } catch (error: any) {
    console.error("Error beginning bot secret rotation: ", error);
    if (error.message === "No client secrets found") {
      return {
        statusCode: 400,
        body: JSON.stringify({ message: error.message }),
        headers
      };
    }
    return mapCognitoBotSecretError(error, "begin bot secret rotation");
  }
}

async function finalizeBotSecretRotation(claim: PartialClaims, pars: { clientId: string }) {
  const loaded = await loadOwnedBot(claim, pars?.clientId);
  if ("response" in loaded) {
    return loaded.response;
  }

  const clientId = loaded.bot.sk;

  try {
    await cognitoFinalizeBotSecretRotation(clientId);

    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { pk: "BOT", sk: clientId },
      UpdateExpression: "REMOVE pendingSecretId, pendingSecretCreatedAt",
    }));

    return {
      statusCode: 200,
      body: JSON.stringify({
        message: "Bot secret rotation finalized successfully",
        secretRotationPending: false,
      }),
      headers
    };
  } catch (error: any) {
    console.error("Error finalizing bot secret rotation: ", error);
    if (error.message === "No secret rotation in progress") {
      return {
        statusCode: 400,
        body: JSON.stringify({ message: error.message }),
        headers
      };
    }
    return mapCognitoBotSecretError(error, "finalize bot secret rotation");
  }
}

async function deleteBot(claim: PartialClaims, pars: { clientId: string }) {
  if (!claim || !claim.sub) {
    return {
      statusCode: 401,
      body: JSON.stringify({ message: "Unauthorized" }),
      headers
    };
  }

  const clientId = pars?.clientId;
  if (!clientId || clientId.trim().length === 0) {
    return {
      statusCode: 400,
      body: JSON.stringify({ message: "A clientId is required to identify the bot to delete" }),
      headers
    };
  }

  try {
    // 1. Fetch BOT record to verify owner
    const data = await ddbDocClient.send(new GetCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        pk: "BOT",
        sk: clientId
      }
    }));

    if (!data.Item) {
      return {
        statusCode: 404,
        body: JSON.stringify({ message: `Bot with client ID ${clientId} not found` }),
        headers
      };
    }

    const bot = data.Item;
    if (bot.owner !== claim.sub) {
      return {
        statusCode: 403,
        body: JSON.stringify({ message: "You are not the owner of this bot" }),
        headers
      };
    }

    // 2. Delete User Pool Client from botpool
    const userPoolId = process.env.BOTPOOL_ID;
    if (!userPoolId) {
      throw new Error("BOTPOOL_ID environment variable is not set");
    }

    const command = new DeleteUserPoolClientCommand({
      UserPoolId: userPoolId,
      ClientId: clientId
    });
    await cognitoClient.send(command);

    try {
      await releaseBotDisplayName(bot.name as string);
    } catch (releaseError) {
      console.error(`Error releasing bot name for ${clientId}:`, releaseError);
    }

    // 3. Delete BOT record from DynamoDB
    await ddbDocClient.send(new DeleteCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        pk: "BOT",
        sk: clientId
      }
    }));

    // Update owner's USER record
    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": claim.sub },
      ExpressionAttributeNames: { "#b": "bots" },
      UpdateExpression: "DELETE #b :b",
      ExpressionAttributeValues: { ":b": new Set([clientId]) }
    }));

    return {
      statusCode: 200,
      body: JSON.stringify({ message: "Bot deleted successfully" }),
      headers
    };
  } catch (error: any) {
    console.error("Error deleting bot: ", error);
    const mapped = mapBotNameError(error);
    if (mapped) {
      return mapped;
    }
    return formatReturnError(`Unable to delete bot: ${error.message || error}`);
  }
}

async function me(claim: PartialClaims, pars: { size: string, vars: string, update: string }) {
  const userId = claim.sub;
  const email = claim.email;
  if (!claim.email || claim.email.trim().length === 0) {
    console.log(`How!?: claim.email is ${claim.email}`);
  }
  if (!pars || !pars.size || pars.size !== "small")
    console.log(`ME: Attempting to find data for user id ${userId}, vars ${pars?.vars}, update ${pars?.update}`);
  else
    console.log(`ME (small): Attempting to find data for user id ${userId}, vars ${pars.vars}, update ${pars.update}`);

  const fixGames = false;
  try {
    console.log(`Getting USER record`);
    const userData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (userData.Item === undefined) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
    const user = userData.Item as FullUser;
    if (user.email !== email)
      await updateUserEMail(claim);
    let games = user.games;
    if (games == undefined)
      games = [];
    if (fixGames) {
      console.log("games before", games);
      games = await getGamesForUser(userId);
      console.log("games after", games);
    }

    // fetch tags
    const tagWork = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TAG",
          "sk": userId
        },
      })
    );

    // fetch palettes
    const paletteWork = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "PALETTES",
          "sk": userId
        },
      })
    );

    // fetch "real" standing challenges
    const standingWork = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "REALSTANDING",
          "sk": userId
        },
      })
    );

    // fetch customizations
    const customizationWork = ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "CUSTOMIZATION#" + userId },
        ExpressionAttributeNames: { "#pk": "pk" },
      })
    );

    const botIds: string[] = Array.from(user?.bots ?? new Set());
    const botsWork = getBots(botIds);
    const blockedWork = getPlayerRelationIds(userId, "BLOCKED#");

    const removedGameIDs: string[] = [];
    if (!pars || !pars.size || pars.size !== "small") {
      // LogInOutButton calls "me" with "small". If we do the below from the dashboard (and then at the same time from LogInOutButton) we run into
      // all kinds of race conditions. So we only do the below if we are not in "small" mode.

      // Check for "recently completed games"
      console.log(`Checking for recently completed games`);
      // As soon as a game is over move it to archive status (game.type = 0).
      // Remove the game from user's games list one week after they have seen it. "Seen it" means they clicked on the game (or they were the one that caused the end of the game).
      for (let i = games.length - 1; i >= 0; i--) {
        const game = games[i];
        if (game.toMove === "" || game.toMove === null) {
          if ((game.seen !== undefined) && (Date.now() - (game.seen || 0) > 7 * 24 * 3600000) && ((game.lastChat || 0) <= (game.seen || 0))) {
            games.splice(i, 1);
            removedGameIDs.push(game.id);
          }
        }
      }
      // Check for out-of-time games

      console.log(`Checking for out-of-time games`);
      for (const game of games) {
        if (game.clockHard && game.toMove && game.toMove !== '') {
          if (Array.isArray(game.toMove)) {
            let minTime = 0;
            let minIndex = -1;
            const elapsed = Date.now() - game.lastMoveTime;
            game.toMove.forEach((p: any, i: number) => {
              if (p && game.players[i].time! - elapsed < minTime) {
                minTime = game.players[i].time! - elapsed;
                minIndex = i;
              }
            });
            if (minIndex !== -1) {
              await updateUserGames(userId, user.gamesUpdate, removedGameIDs, games);
              const newLastMoveTime = game.lastMoveTime + game.players[minIndex].time!;

              try {
                // Build expected array for condition
                const expectedToMove = [...game.toMove];

                await ddbDocClient.send(new UpdateCommand({
                  TableName: process.env.ABSTRACT_PLAY_TABLE,
                  Key: {
                    "pk": "GAME",
                    "sk": game.metaGame + "#0#" + game.id
                  },
                  ConditionExpression: "toMove = :expectedToMove",
                  ExpressionAttributeValues: {
                    ":expectedToMove": expectedToMove,
                    ":newToMove": '',
                    ":newLastMoveTime": newLastMoveTime
                  },
                  UpdateExpression: "set toMove = :newToMove, lastMoveTime = :newLastMoveTime"
                }));

                console.log(`Successfully marked simultaneous game ${game.id} as timed out, processing...`);
                game.toMove = '';
                game.lastMoveTime = newLastMoveTime;
                await timeloss(false, minIndex, game.id, game.metaGame, game.lastMoveTime);

              } catch (err: any) {
                if (err.name === 'ConditionalCheckFailedException') {
                  console.log(`Simultaneous game ${game.id} already processed, skipping`);
                  game.toMove = '';
                  game.lastMoveTime = newLastMoveTime;
                } else {
                  throw err;
                }
              }
            }
          } else {
            const toMove = parseInt(game.toMove);
            if (game.players[toMove].time! - (Date.now() - game.lastMoveTime) < 0) {
              // To make sure games are up to date before we update further. Note this is a noop if removedGameIDs === [].
              await updateUserGames(userId, user.gamesUpdate, removedGameIDs, games);
              const newLastMoveTime = game.lastMoveTime + game.players[toMove].time!;
              try {
                // Conditional update: only succeed if toMove hasn't been cleared yet
                await ddbDocClient.send(new UpdateCommand({
                  TableName: process.env.ABSTRACT_PLAY_TABLE,
                  Key: {
                    "pk": "GAME",
                    "sk": game.metaGame + "#0#" + game.id
                  },
                  ConditionExpression: "toMove = :expectedToMove",
                  ExpressionAttributeValues: {
                    ":expectedToMove": toMove.toString(),
                    ":newToMove": '',
                    ":newLastMoveTime": newLastMoveTime
                  },
                  UpdateExpression: "set toMove = :newToMove, lastMoveTime = :newLastMoveTime"
                }));

                // Only if the conditional update succeeded, process the timeout
                console.log(`Successfully marked game ${game.id} as timed out, processing...`);
                game.lastMoveTime = newLastMoveTime;
                game.toMove = '';

                // Now safe to process timeout - we "own" this timeout
                await timeloss(false, toMove, game.id, game.metaGame, game.lastMoveTime);

              } catch (err: any) {
                if (err.name === 'ConditionalCheckFailedException') {
                  // Another request already processed this timeout, skip
                  console.log(`Game ${game.id} already processed by another request, skipping`);
                  // Update local game object to reflect the change
                  game.toMove = '';
                  game.lastMoveTime = newLastMoveTime;
                } else {
                  throw err;
                }
              }
            }
          }
        }
      }
    }
    // Update last seen date for user
    console.log(`Updating last seen date for USER and USERS`);
    const lastSeenUserWork = ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": userId },
      ExpressionAttributeValues: { ":dt": Date.now() },
      UpdateExpression: "set lastSeen = :dt"
    }));
    const lastSeenUsersWork = ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USERS", "sk": userId },
      ExpressionAttributeValues: { ":dt": Date.now() },
      UpdateExpression: "set lastSeen = :dt"
    }));

    let data = null;
    console.log(`Fetching challenges`);
    let tagData, paletteData, standingData, customizationData, botData;
    if (!pars || !pars.size || pars.size !== "small") {
      const challengesIssuedIDs: string[] = Array.from(user?.challenges_issued ?? new Set());
      const challengesReceivedIDs: string[] = Array.from(user?.challenges_received ?? new Set());
      const challengesAcceptedIDs: string[] = Array.from(user?.challenges_accepted ?? new Set());
      const standingChallengeIDs: string[] = Array.from(user?.challenges_standing ?? new Set());
      const challengesIssued = getChallenges(challengesIssuedIDs);
      const challengesReceived = getChallenges(challengesReceivedIDs);
      const challengesAccepted = getChallenges(challengesAcceptedIDs);
      const standingChallenges = getChallenges(standingChallengeIDs);
      data = await Promise.all([challengesIssued, challengesReceived, challengesAccepted, standingChallenges, tagWork, paletteWork, lastSeenUserWork, lastSeenUsersWork,
        updateUserGames(userId, user.gamesUpdate, removedGameIDs, games), standingWork, customizationWork, botsWork, blockedWork]);
      tagData = data[4];
      paletteData = data[5];
      standingData = data[9];
      customizationData = data[10];
      botData = data[11];
    } else {
      data = await Promise.all([tagWork, paletteWork, lastSeenUserWork, lastSeenUsersWork,
        standingWork, customizationWork, botsWork, blockedWork]);
      tagData = data[0];
      paletteData = data[1];
      standingData = data[4];
      customizationData = data[5];
      botData = data[6];
    }
    const blocked: string[] = data[data.length - 1] as string[];
    const bots = (botData as { Item?: BotRecord }[])
      .map(d => toClientBot(d.Item))
      .filter((bot): bot is ClientBot => bot !== undefined);
    let tags: TagList[] = [];
    if (tagData.Item !== undefined) {
      const tagRec = tagData.Item as TagRec;
      tags = tagRec.tags;
    }
    let palettes: Palette[] = [];
    if (paletteData.Item !== undefined) {
      const paletteRec = paletteData.Item as PaletteRec;
      palettes = paletteRec.palettes;
    }
    let realStanding: StandingChallenge[] = [];
    if (standingData.Item !== undefined) {
      const standingRec = standingData.Item as StandingChallengeRec;
      realStanding = standingRec.standing;
    }
    const customizations: { [key: string]: Customization } = {};
    if (customizationData.Items !== undefined) {
      for (const item of (customizationData.Items as CustomizationRec[])) {
        const settings: any = item.settings;
        if (typeof settings === "string") {
          customizations[item.sk] = JSON.parse(settings);
        } else {
          customizations[item.sk] = settings;
        }
      }
    }

    if (data && (!pars || !pars.size || pars.size !== "small")) {
      // Still trying to get to the bottom of games shown as "to move" when already moved.
      console.log(`me returning for ${user.name}, id ${user.id} with games`, games);
      return {
        statusCode: 200,
        body: JSON.stringify({
          "id": user.id,
          "name": user.name,
          "admin": (user.admin === true),
          "organizer": (user.organizer === true),
          "language": user.language,
          "country": user.country,
          "games": games,
          "settings": user.settings,
          "stars": user.stars,
          "bggid": user.bggid,
          "about": user.about,
          tags,
          palettes,
          "mayPush": user.mayPush,
          bots,
          "challengesIssued": (data[0] as any[]).map(d => d.Item),
          "challengesReceived": (data[1] as any[]).map(d => d.Item),
          "challengesAccepted": (data[2] as any[]).map(d => d.Item),
          "standingChallenges": (data[3] as any[]).map(d => d.Item),
          "realStanding": realStanding,
          customizations,
          blocked,
        } as MeData, Set_toJSON),
        headers
      };
    } else {
      return {
        statusCode: 200,
        body: JSON.stringify({
          "id": user.id,
          "name": user.name,
          "admin": (user.admin === true),
          "organizer": (user.organizer === true),
          "language": user.language,
          "country": user.country,
          "games": games,
          "settings": user.settings,
          "stars": user.stars,
          "bggid": user.bggid,
          "about": user.about,
          "mayPush": user.mayPush,
          bots,
          tags,
          palettes,
          "realStanding": realStanding,
          customizations,
          blocked,
        } as MeData, Set_toJSON),
        headers
      }
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to get user data for ${userId}`);
  }
}

async function nextGame(userid: string) {
  try {
    console.log(`Getting USER record`);
    const userData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (userData.Item === undefined) {
      return {
        statusCode: 400,
        headers
      };
    }
    const userRec = userData.Item as FullUser;

    // get list of all games where it is your turn
    type GameWithTime = {
      game: Game;
      remaining: number;
    };
    const yourturn: GameWithTime[] = [];
    for (const game of userRec.games) {
      const thisPlayerIdx = game.players.findIndex(p => p.id === userid);
      // explicitly this player's turn
      if ((Array.isArray(game.toMove) && game.toMove.length > thisPlayerIdx + 1 && game.toMove[thisPlayerIdx]) || (game.toMove === thisPlayerIdx.toString())) {
        const remaining = (game.players[thisPlayerIdx].time || 0) - (Date.now() - game.lastMoveTime);
        yourturn.push({ game, remaining });
      }
    }
    // sort by time remaining
    yourturn.sort((a, b) => a.remaining - b.remaining);
    console.log(`It is your turn in ${yourturn.length} games.`)
    console.log(`Yourturn results: ${JSON.stringify(yourturn, null, 2)}`)
    return {
      statusCode: 200,
      headers,
      body: JSON.stringify(yourturn.map(x => x.game)),
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to get next game for ${userid}`);
  }
}

async function updateUserEMail(claim: PartialClaims) {
  if (claim.email && claim.email.trim().length > 0) {
    console.log(`updateUserEMail: updating email to ${claim.email}`);
    return ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": claim.sub },
      ExpressionAttributeValues: { ":e": claim.email },
      UpdateExpression: "set email = :e",
    }));
  } else {
    console.log(`updateUserEMail: claim.email is ${claim.email}`);
  }
}

// Make sure we "lock" games while updating. We are often updating multiple games at once.
async function updateUserGames(userId: string, gamesUpdate: undefined | number, gameIDsChanged: string[], games: Game[] = []) {
  if (gameIDsChanged.length === 0) {
    return;
  }
  if (await isBotId(userId)) {
    return;
  }
  const gameIDsCloned = gameIDsChanged.slice();
  gameIDsChanged.length = 0;
  if (gamesUpdate === undefined) {
    // Update "old" users. This is a one-time update.
    return sendCommandWithRetry(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": userId },
      ExpressionAttributeValues: { ":val": 1, ":gs": games },
      UpdateExpression: "set gamesUpdate = :val, games = :gs"
    }));
  } else {
    console.log(`updateUserGames: optimistically updating games for ${userId}`);
    try {
      await sendCommandWithRetry(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "USER", "sk": userId },
        ExpressionAttributeValues: { ":val": gamesUpdate, ":inc": 1, ":gs": games },
        ConditionExpression: "gamesUpdate = :val",
        UpdateExpression: "set gamesUpdate = gamesUpdate + :inc, games = :gs"
      }));
    } catch (err: any) {
      if (err.name === 'ConditionalCheckFailedException') {
        // games has been modified by another process
        // (I should have put these in their own list in the DB!)
        console.log(`updateUserGames: games has been modified by another process for ${userId}`);
        let count = 0;
        while (count < 3) {
          const userData = await ddbDocClient.send(
            new GetCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              Key: {
                "pk": "USER",
                "sk": userId
              },
            }));
          const user = userData.Item as FullUser;
          const dbGames = user.games;
          const gamesUpdate = user.gamesUpdate;
          const newgames: Game[] = [];
          for (const game of dbGames) {
            if (gameIDsCloned.includes(game.id)) {
              const newgame = games.find(g => g.id === game.id);
              if (newgame) {
                newgames.push(newgame);
              }
            } else {
              newgames.push(game);
            }
          }
          try {
            console.log(`updateUserGames: Update ${count} of games for user`, userId, newgames);
            await sendCommandWithRetry(new UpdateCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              Key: { "pk": "USER", "sk": userId },
              ExpressionAttributeValues: { ":val": gamesUpdate, ":inc": 1, ":gs": newgames },
              ConditionExpression: "gamesUpdate = :val",
              UpdateExpression: "set gamesUpdate = gamesUpdate + :inc, games = :gs"
            }));
            return;
          } catch (innerErr: any) {
            if (innerErr.name === 'ConditionalCheckFailedException') {
              count++;
            } else {
              throw innerErr;
            }
          }
        }
        throw new Error(`updateUserGames: Unable to update games for user ${userId} after 3 retries`);
      } else {
        throw err;
      }
    }
  }
}

async function mySettings(claim: PartialClaims) {
  const userId = claim.sub;
  const email = claim.email;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
        ExpressionAttributeNames: { "#name": "name", "#language": "language" },
        ProjectionExpression: "id,#name,email,#language",
      }));
    if (user.Item === undefined)
      throw new Error("mySettings no user ${userId}");
    if (user.Item.email !== email)
      await updateUserEMail(claim);

    console.log("mySettings Item: ", user.Item);
    return {
      statusCode: 200,
      body: JSON.stringify({
        "id": user.Item.id,
        "name": user.Item.name,
        "email": email,
        "language": user.Item.language
      }, Set_toJSON),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to get user data for ${userId}`);
  }
}

async function newSetting(userId: string, pars: { attribute: string; value: string; }) {
  let attr = '';
  let val = '';
  switch (pars.attribute) {
    case "name":
      attr = "name";
      val = pars.value;
      break;
    case "language":
      attr = "language";
      val = pars.value;
      break;
    case "country":
      attr = "country";
      val = pars.value;
      break;
    case "bggid":
      attr = "bggid";
      val = pars.value;
      break;
    case "about":
      attr = "about";
      val = pars.value.substring(0, 255);
      break;
    default:
      return;
  }
  console.log("attr, val: ", attr, val);
  const work = [];
  work.push(ddbDocClient.send(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "USER", "sk": userId },
    ExpressionAttributeValues: { ":v": val },
    ExpressionAttributeNames: { "#a": attr },
    UpdateExpression: "set #a = :v"
  })));
  if (pars.attribute === "name") {
    work.push(ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USERS", "sk": userId },
      ExpressionAttributeValues: { ":newname": val },
      ExpressionAttributeNames: { "#name": "name" },
      UpdateExpression: "set #name = :newname"
    })));
  }
  if (pars.attribute === "country") {
    work.push(ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USERS", "sk": userId },
      ExpressionAttributeValues: { ":newcountry": val },
      ExpressionAttributeNames: { "#country": "country" },
      UpdateExpression: "set #country = :newcountry"
    })));
  }
  if (attr === "bggid" || attr === "about") {
    console.log(`Pushing USERS update: ${userId} -> ${attr} = ${val}`)
    work.push(ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USERS", "sk": userId },
      ExpressionAttributeValues: { ":v": val },
      ExpressionAttributeNames: { "#a": attr },
      UpdateExpression: "set #a = :v"
    })));
  }
  try {
    await Promise.all(work);
    console.log("attr, val: ", attr, val, " updated");
    return {
      statusCode: 200,
      body: JSON.stringify({
        "result": "success"
      }, Set_toJSON),
      headers
    };
  } catch (err) {
    logGetItemError(err);
  }
}

// This is expensive, so only use when things go belly up. E.g. if a game had to be deleted.
async function getGamesForUser(userId: any) {
  const games: Game[] = [];
  for (const game of gameinfo.values()) {
    // let count = 0;
    let result = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk AND begins_with(#sk, :skPrefix)",
        ExpressionAttributeValues: {
          ":pk": "GAME",
          ":skPrefix": game.uid + "#0"
        },
        ExpressionAttributeNames: {
          "#pk": "pk",
          "#sk": "sk"
        },
        ProjectionExpression: "id, players, metaGame, clockHard, toMove, lastMoveTime, noExplore",
        // Limit: 2 // For testing!
      })
    );
    if (result !== undefined) {
      // count += result.Count || 0;
      processGames(userId, result, games);
      let last = result.LastEvaluatedKey;
      while (last !== undefined && result !== undefined) {
        result = await ddbDocClient.send(
          new QueryCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            KeyConditionExpression: "#pk = :pk AND begins_with(#sk, :skPrefix)",
            ExpressionAttributeValues: {
              ":pk": "GAME",
              ":skPrefix": game.uid + "#0"
            },
            ExpressionAttributeNames: {
              "#pk": "pk",
              "#sk": "sk"
            },
            ProjectionExpression: "id, players, metaGame, clockHard, toMove, lastMoveTime, noExplore",
            // Limit: 2, // For testing!
            ExclusiveStartKey: last
          }));
        // count += result.Count || 0;
        processGames(userId, result, games);
        last = result.LastEvaluatedKey;
      }
    }
    // if (count > 0) {
    //     console.log(`Found ${count} ${game.uid} game${count !== 1 ? "s" : ""}`);
    // }
  }
  return games;
}

function processGames(userid: any, result: QueryCommandOutput, games: Game[]) {
  if (result.Items === undefined)
    throw new Error("processGames: no games found!?");
  const fullGames = result.Items as FullGame[];
  if (fullGames !== undefined) {
    for (const game of fullGames) {
      if ("players" in game && game.players !== undefined && game.players.length > 0 && game.players.some(p => p.id === userid)) {
        games.push({ "id": game.id, "metaGame": game.metaGame, "players": game.players, "clockHard": game.clockHard, "toMove": game.toMove, "lastMoveTime": game.lastMoveTime, "noExplore": game.noExplore || false });
      }
    }
  }
}

async function getChallenges(challengeIds: string[]) {
  const challenges: any[] = [];
  challengeIds.forEach((id: string) => {
    const ind = id.indexOf('#'); // neither metaGame ids, not guids can contain '#'s.
    if (ind > -1) {
      const metaGame = id.substring(0, ind);
      const challengeId = id.substring(ind + 1);
      challenges.push(
        ddbDocClient.send(
          new GetCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: {
              "pk": "STANDINGCHALLENGE#" + metaGame,
              "sk": challengeId
            }
          })
        )
      );
    } else {
      challenges.push(
        ddbDocClient.send(
          new GetCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: {
              "pk": "CHALLENGE",
              "sk": id
            }
          })
        )
      );
    }
  });
  return Promise.all(challenges);
}

async function getBots(botIds: string[]) {
  return Promise.all(botIds.map((clientId: string) =>
    ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          pk: "BOT",
          sk: clientId
        }
      })
    )
  ));
}

async function newProfile(claim: PartialClaims, pars: { name: any; consent: any; anonymous: any; country: any; tagline: any; }) {
  const userid = claim.sub;
  const email = claim.email;
  if (!email || email.trim() === "") {
    logGetItemError(`No email for user ${pars.name}, id ${userid} in newProfile`);
    return formatReturnError(`No email for user ${pars.name}, id ${userid} in newProfile`);
  }
  const data = {
    "pk": "USER",
    "sk": userid,
    "id": userid,
    "name": pars.name,
    "email": email,
    "consent": pars.consent,
    "anonymous": pars.anonymous,
    "country": pars.country,
    "tagline": pars.tagline,
    "settings": {
      "all": {
        "annotate": true,
        "color": "standard"
      }
    }
  };
  // So that we can list all users
  const data2 = {
    "pk": "USERS",
    "sk": userid,
    "name": pars.name
  };
  try {
    const insertUser = ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: data
    }));
    const insertIntoUserList = ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: data2
    }));
    await Promise.all([insertUser, insertIntoUserList]);
    console.log("Success - user added", data);
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: `Sucessfully stored user profile for user ${pars.name}`,
      }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to store user profile for user ${pars.name}`);
  }
}

async function setPush(userid: string, pars: { state: boolean }) {
  try {
    console.log(`Setting 'mayPush' to ${pars.state} for user ${userid}`);
    await ddbDocClient.send(
      new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "USER", "sk": userid },
        ExpressionAttributeNames: { "#mp": "mayPush" },
        ExpressionAttributeValues: { ":mp": pars.state },
        UpdateExpression: "set #mp = :mp"
      })
    );
    if (pars.state === false) {
      await deleteAllPushSubscriptions(userid);
    }
  } catch (error) {
    logGetItemError(error);
    throw new Error("setPush: Failed to save push preference");
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Successfully saved push preference for ${userid}`,
    }),
    headers
  };
}

async function savePush(userid: string, pars: { payload: any }) {
  if (pars.payload?.endpoint === undefined) {
    return {
      statusCode: 400,
      body: JSON.stringify({
        message: 'savePush: missing payload.endpoint',
      }),
      headers
    };
  }
  try {
    console.log(`Attempting to save push notification credentials for user ${userid}:\n${JSON.stringify(pars.payload)}`);
    await savePushSubscription(userid, pars.payload);
    await ddbDocClient.send(
      new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { pk: "USER", sk: userid },
        ExpressionAttributeNames: { "#mp": "mayPush" },
        ExpressionAttributeValues: { ":mp": true },
        UpdateExpression: "set #mp = :mp",
      })
    );
  } catch (error) {
    logGetItemError(error);
    throw new Error("savePush: Failed to save push notification credentials");
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Successfully saved push notifications credentials for ${userid}`,
    }),
    headers
  };
}

async function deletePush(userid: string, pars: { endpoint?: string }) {
  const endpoint = pars.endpoint;
  if (endpoint === undefined || endpoint.length === 0) {
    return {
      statusCode: 400,
      body: JSON.stringify({
        message: "deletePush: missing endpoint",
      }),
      headers,
    };
  }
  try {
    await deletePushSubscriptionByEndpoint(userid, endpoint);
    const remaining = await queryPushSubscriptions(userid);
    if (remaining.length === 0) {
      await ddbDocClient.send(
        new UpdateCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: { pk: "USER", sk: userid },
          ExpressionAttributeNames: { "#mp": "mayPush" },
          ExpressionAttributeValues: { ":mp": false },
          UpdateExpression: "set #mp = :mp",
        })
      );
    }
  } catch (error) {
    logGetItemError(error);
    throw new Error("deletePush: Failed to delete push subscription");
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Successfully deleted push subscription for ${userid}`,
    }),
    headers
  };
}

async function saveTags(userid: string, pars: { payload: TagList[] }) {
  try {
    console.log(`Attempting to save tags for user ${userid}:\n${JSON.stringify(pars.payload)}`);
    if (pars.payload.length === 0) {
      await ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "TAG", "sk": userid
          },
        })
      )
    } else {
      await ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          "pk": "TAG",
          "sk": userid,
          "tags": pars.payload,
        }
      }));
    }
  } catch (error) {
    logGetItemError(error);
    throw new Error("saveTags: Failed to save tags");
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Successfully saved tags for ${userid}`,
    }),
    headers
  };
}

async function savePalettes(userid: string, pars: { palettes: Palette[] }) {
  try {
    console.log(`Attempting to save palettes for user ${userid}:\n${JSON.stringify(pars.palettes)}`);
    if (pars.palettes.length === 0) {
      await ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "PALETTES", "sk": userid
          },
        })
      )
    } else {
      await ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          "pk": "PALETTES",
          "sk": userid,
          "palettes": pars.palettes,
        } as PaletteRec
      }));
    }
  } catch (error) {
    logGetItemError(error);
    throw new Error("saveTags: Failed to save palettes");
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Successfully saved palettes for ${userid}`,
    }),
    headers
  };
}

async function saveCustomization(userid: string, pars: { metaGame: string; settings: Customization }) {
  try {
    // console.log(`Saving customization for user ${userid}, game ${pars.metaGame}:\n${JSON.stringify(pars.settings)}`);
    let settings = pars.settings as Customization | string;
    if (typeof settings === "string") {
      settings = JSON.parse(settings);
    }
    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: {
        "pk": "CUSTOMIZATION#" + userid,
        "sk": pars.metaGame,
        "settings": settings,
      }
    }));
  } catch (error) {
    logGetItemError(error);
    throw new Error("saveCustomization: Failed to save customization");
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Successfully saved customization for ${userid}, ${pars.metaGame}`,
    }),
    headers
  };
}

async function deleteCustomization(userid: string, pars: { metaGame: string }) {
  try {
    console.log(`Deleting customization for user ${userid}, game ${pars.metaGame}`);
    await ddbDocClient.send(new DeleteCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        "pk": "CUSTOMIZATION#" + userid,
        "sk": pars.metaGame,
      }
    }));
  } catch (error) {
    logGetItemError(error);
    throw new Error("deleteCustomization: Failed to delete customization");
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Successfully deleted customization for ${userid}, ${pars.metaGame}`,
    }),
    headers
  };
}

async function updateStanding(userid: string, pars: { entries: StandingChallenge[] }) {
  try {
    // simply replace the existing record
    const Item: StandingChallengeRec = {
      pk: "REALSTANDING",
      sk: userid,
      standing: pars.entries,
    };
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item,
      })
    );
    console.log(`Returning ${JSON.stringify(Item)}`);
    return {
      statusCode: 200,
      body: JSON.stringify(Item),
      headers
    };
  }
  catch (error) {
    handleCommonErrors(error as { code: any; message: any });
    return formatReturnError(`Unable to update standing challenges for ${userid}: ${error}`);
  }
}

async function notifyRegisteredBotsTurn(metaGame: string, gameid: string, game?: FullGame) {
  let loaded = game;
  if (!loaded) {
    const item = await loadGameRecord(metaGame, gameid);
    if (!item) {
      return;
    }
    loaded = item as FullGame;
  }
  const info = gameinfo.get(metaGame);
  const simultaneous = info.flags !== undefined && info.flags.includes('simultaneous');
  const toMoveIds = getToMovePlayerIds(loaded, simultaneous);
  for (const id of toMoveIds) {
    if (await isBotId(id)) {
      await enqueueBotOutbound({ type: 'move', metaGame, gameid, botId: id });
    }
  }
}

export async function botRespondToChallenge(
  botId: string,
  challengeId: string,
  metaGame: string,
  standing: boolean,
  accepted: boolean
) {
  return respondedChallenge(botId, {
    response: accepted,
    id: challengeId,
    standing,
    metaGame,
    comment: accepted ? "Let's play!" : "",
  });
}

async function newChallenge(userid: string, challenge: FullChallenge) {
  console.log("newChallenge challenge:", challenge);
  if (challenge.standing) {
    return await newStandingChallenge(userid, challenge);
  }
  const challengeId = uuid();
  const botChallengees: { id: string }[] = [];
  const addChallenge = ddbDocClient.send(new PutCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Item: {
      "pk": "CHALLENGE",
      "sk": challengeId,
      "id": challengeId,
      "metaGame": challenge.metaGame,
      "numPlayers": challenge.numPlayers,
      "standing": challenge.standing,
      "duration": challenge.duration,
      "seating": challenge.seating,
      "variants": challenge.variants,
      "challenger": challenge.challenger,
      "challengees": challenge.challengees, // users that were challenged
      "players": [challenge.challenger], // users that have accepted
      "clockStart": challenge.clockStart,
      "clockInc": challenge.clockInc,
      "clockMax": challenge.clockMax,
      "clockHard": challenge.clockHard,
      "rated": challenge.rated,
      "noExplore": challenge.noExplore || false,
      "comment": challenge.comment || "",
      "dateIssued": Date.now(),
    }
  }));

  const updateChallenger = ddbDocClient.send(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "USER", "sk": userid },
    ExpressionAttributeValues: { ":c": new Set([challengeId]) },
    ExpressionAttributeNames: { "#ci": "challenges_issued" },
    UpdateExpression: "add #ci :c",
  }));

  const list: Promise<any>[] = [addChallenge, updateChallenger];
  if (challenge.challengees !== undefined) {
    const humanChallengees: { id: string; name?: string }[] = [];
    for (const challengee of challenge.challengees) {
      if (await isBotId(challengee.id)) {
        botChallengees.push(challengee);
      } else {
        humanChallengees.push(challengee);
        list.push(
          ddbDocClient.send(new UpdateCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: { "pk": "USER", "sk": challengee.id },
            ExpressionAttributeValues: { ":c": new Set([challengeId]) },
            ExpressionAttributeNames: { "#cr": "challenges_received" },
            UpdateExpression: "add #cr :c",
          }))
        );
      }
    }
    try {
      if (humanChallengees.length > 0) {
        list.push(sendChallengedEmail(challenge.challenger.name, humanChallengees as User[], challenge.metaGame, challenge.comment));
      }
    } catch (error) {
      logGetItemError(error);
      throw new Error("newChallenge: Failed to send emails");
    }
  }
  try {
    await Promise.all(list);
    console.log("Successfully added challenge" + challengeId);

    for (const challengee of botChallengees) {
      await enqueueBotOutbound({
        type: 'challenge',
        challengeId,
        metaGame: challenge.metaGame,
        botId: challengee.id,
        standing: false,
      });
    }

    // If the bot is challenged, trigger its challenge mgmt code here
    if (challenge.challengees !== undefined) {
      const idx = challenge.challengees.findIndex(u => u.id === process.env.AIAI_USERID);
      if (idx !== -1) {
        console.log("Triggering bot management code");
        await botManageChallenges();
      }
    }

    return {
      statusCode: 200,
      body: JSON.stringify({
        message: "Successfully added challenge",
      }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError("Failed to add challenge");
  }
}

async function newStandingChallenge(userid: string, challenge: FullChallenge) {
  const challengeId = uuid();
  const addChallenge = ddbDocClient.send(new PutCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Item: {
      "pk": "STANDINGCHALLENGE#" + challenge.metaGame,
      "sk": challengeId,
      "id": challengeId,
      "metaGame": challenge.metaGame,
      "numPlayers": challenge.numPlayers,
      "standing": challenge.standing,
      "duration": challenge.duration,
      "seating": challenge.seating,
      "variants": challenge.variants,
      "challenger": challenge.challenger,
      "players": [challenge.challenger], // users that have accepted
      "clockStart": challenge.clockStart,
      "clockInc": challenge.clockInc,
      "clockMax": challenge.clockMax,
      "clockHard": challenge.clockHard,
      "rated": challenge.rated,
      "noExplore": challenge.noExplore || false,
      "comment": challenge.comment || "",
      "dateIssued": Date.now(),
    }
  }));

  const updateChallenger = ddbDocClient.send(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "USER", "sk": userid },
    ExpressionAttributeValues: { ":c": new Set([challenge.metaGame + '#' + challengeId]) },
    ExpressionAttributeNames: { "#cs": "challenges_standing" },
    UpdateExpression: "add #cs :c",
  }));

  const updateStandingChallengeCnt = updateStandingChallengeCount(challenge.metaGame, 1);

  try {
    await Promise.all([addChallenge, updateChallenger, updateStandingChallengeCnt]);
    console.log("Successfully added challenge" + challengeId);
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: "Successfully added challenge",
      }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError("Failed to add challenge");
  }
}

async function sendChallengedEmail(challengerName: string, opponents: User[], metaGame: string, comment: string | undefined) {
  const humanIds = await filterHumanIds(opponents.map((o: { id: any; }) => o.id));
  const players: FullUser[] = await getPlayers(humanIds);
  metaGame = gameinfo.get(metaGame).name;
  await initi18n('en');
  const work: Promise<any>[] = [];
  comment = comment ? comment.trim() : "";
  if (!comment.endsWith(".") && !comment.endsWith("!") && !comment.endsWith("?"))
    comment += ".";
  for (const player of players) {
    await changeLanguageForPlayer(player);
    let body;
    if (comment === ".") {
      body = i18n.t("ChallengeBody", { "challenger": challengerName, metaGame });
    } else {
      body = i18n.t("ChallengeBodyComment", { "challenger": challengerName, metaGame, comment });
    }
    if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
      if ((player.settings?.all?.notifications === undefined) || (player.settings.all.notifications.challenges)) {
        const comm = createSendEmailCommand(player.email, player.name, i18n.t("ChallengeSubject"), body);
        work.push(sesClient.send(comm));
      } else {
        console.log(`Player ${player.name} (${player.id}) has elected to not receive challenge notifications.`);
      }
    } else {
      console.log(`No verified email address found for ${player.name} (${player.id})`);
    }
    // push notifications are sent no matter what
    work.push(sendPush({
      userId: player.id,
      topic: "challenges",
      title: i18n.t("PUSH.titles.challenged"),
      body: body,
      url: "/",
    }));
  }
  return Promise.all(work);
}

async function revokeChallenge(userid: any, pars: { id: string; metaGame: string; standing: boolean; comment: string; }) {
  let challenge: Challenge | undefined;
  const work: Promise<any>[] = [];
  let work1: Promise<any> | undefined;
  try {
    ({ challenge, work: work1 } = await removeChallenge(pars.id, pars.metaGame, pars.standing === true, true, userid));
  } catch (err) {
    logGetItemError(err);
    return formatReturnError("Failed to remove challenge");
  }
  if (work1 !== undefined)
    work.push(work1);
  // send e-mails
  if (challenge) {
    let comment = pars.comment ? pars.comment.trim() : "";
    if (!comment.endsWith(".") && !comment.endsWith("!") && !comment.endsWith("?"))
      comment += ".";
    const metaGame = gameinfo.get(challenge.metaGame).name;
    await initi18n('en');
    // Inform challenged
    if (challenge.challengees) {
      const players: FullUser[] = await getPlayers(await filterHumanIds(challenge.challengees.map((c: { id: any; }) => c.id)));
      for (const player of players) {
        await changeLanguageForPlayer(player);
        let body;
        if (comment === ".") {
          body = i18n.t("ChallengeRevokedBody", { name: challenge.challenger.name, metaGame });
        } else {
          body = i18n.t("ChallengeRevokedBodyComment", { name: challenge.challenger.name, metaGame, comment });
        }
        if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
          if ((player.settings?.all?.notifications === undefined) || (player.settings.all.notifications.challenges)) {
            const comm = createSendEmailCommand(player.email, player.name, i18n.t("ChallengeRevokedSubject"), body);
            work.push(sesClient.send(comm));
          } else {
            console.log(`Player ${player.name} (${player.id}) has elected to not receive challenge notifications.`);
          }
        } else {
          console.log(`No verified email address found for ${player.name} (${player.id})`);
        }
        // push notifications are sent no matter what
        work.push(sendPush({
          userId: player.id,
          topic: "challenges",
          title: i18n.t("PUSH.titles.revoked"),
          body: body,
          url: "/",
        }));
      }
    }
    // Inform players that have already accepted
    if (challenge.players) {
      const players = await getPlayers(await filterHumanIds(challenge.players.map((c: { id: any; }) => c.id).filter((id: any) => id !== challenge!.challenger.id)));
      for (const player of players) {
        await changeLanguageForPlayer(player);
        let body;
        if (comment === ".") {
          body = i18n.t("ChallengeRevokedBody", { name: challenge.challenger.name, metaGame });
        } else {
          body = i18n.t("ChallengeRevokedBodyComment", { name: challenge.challenger.name, metaGame, comment });
        }
        if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
          if ((player.settings?.all?.notifications === undefined) || (player.settings.all.notifications.challenges)) {
            const comm = createSendEmailCommand(player.email, player.name, i18n.t("ChallengeRevokedSubject"), body);
            work.push(sesClient.send(comm));
          } else {
            console.log(`Player ${player.name} (${player.id}) has elected to not receive challenge notifications.`);
          }
        } else {
          console.log(`No verified email address found for ${player.name} (${player.id})`);
        }
        // push notifications are sent no matter what
        work.push(sendPush({
          userId: player.id,
          topic: "challenges",
          title: i18n.t("PUSH.titles.revoked"),
          body: body,
          url: "/",
        }));
      }
    }
  }

  await Promise.all(work);
  console.log("Successfully removed challenge" + pars.id);
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: "Successfully removed challenge" + pars.id
    }),
    headers
  };
}

async function respondedChallenge(userid: string, pars: { response: boolean; id: string; standing?: boolean; metaGame: string; comment: string; }) {
  const response = pars.response;
  const challengeId = pars.id;
  const standing = pars.standing === true;
  const metaGame = pars.metaGame;
  console.log(`Responding to challenge standing = ${standing} ${metaGame}.${challengeId} for user ${userid}: ${response ? "accepted" : "rejected"}`);
  let comment = pars.comment ? pars.comment.trim() : "";
  if (!comment.endsWith(".") && !comment.endsWith("!") && !comment.endsWith("?"))
    comment += ".";
  let ret: any;
  const work: Promise<any>[] = [];
  if (response) {
    // challenge was accepted
    let email;
    try {
      email = await acceptChallenge(userid, metaGame, challengeId, standing);
      console.log("Challenge" + challengeId + "successfully accepted.");
      ret = {
        statusCode: 200,
        body: JSON.stringify({
          message: "Challenge " + challengeId + " successfully accepted."
        }),
        headers
      };
    } catch (err) {
      logGetItemError(err);
      return formatReturnError("Failed to accept challenge");
    }
    if (email !== undefined) {
      console.log(email);
      await initi18n('en');
      try {
        for (const [ind, player] of email.players.entries()) {
          await changeLanguageForPlayer(player);
          let body = i18n.t("GameStartedBody", { metaGame: email.metaGame });
          if (ind === 0 || email.simultaneous) {
            body += " " + i18n.t("YourMove");
          }
          if (comment !== "." && player.id !== userid) {
            body += " " + i18n.t("ChallengeResponseComment", { comment });
          }
          if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
            if ((player.settings?.all?.notifications === undefined) || (player.settings.all.notifications.gameStart)) {
              const ebody = body + " " + i18n.t("GameLink", { metaGame: metaGame, gameId: email.gameId });
              const comm = createSendEmailCommand(player.email, player.name, i18n.t("GameStartedSubject"), ebody);
              work.push(sesClient.send(comm));
            } else {
              console.log(`Player ${player.name} (${player.id}) has elected to not receive game start notifications.`);
            }
          } else {
            console.log(`No verified email address found for ${player.name} (${player.id})`);
          }
          // push notifications are sent no matter what
          work.push(sendPush({
            userId: player.id,
            topic: "started",
            title: i18n.t("PUSH.titles.started"),
            body,
            url: "/",
          }));
        }
      } catch (err) {
        logGetItemError(err);
      }
    }
  } else {
    // challenge was rejected
    let challenge: Challenge | undefined;
    let work2: Promise<any> | undefined;
    try {
      ({ challenge, work: work2 } = await removeChallenge(pars.id, pars.metaGame, standing, false, userid));
      await work2;
      console.log("Successfully removed challenge " + pars.id);
      ret = {
        statusCode: 200,
        body: JSON.stringify({
          message: "Successfully removed challenge " + pars.id
        }),
        headers
      };
    } catch (err) {
      logGetItemError(err);
      return formatReturnError("Failed to remove challenge");
    }
    // send e-mails
    if (challenge !== undefined) {
      await initi18n('en');
      // Inform everyone (except the decliner, he knows).
      const players: FullUser[] = await getPlayers(await filterHumanIds(challenge.challengees!.map(c => c.id).filter(id => id !== userid).concat(challenge.players.map(c => c.id))));
      const quitter = challenge.challengees!.find(c => c.id === userid)!.name;
      const metaGame = gameinfo.get(challenge.metaGame).name;
      for (const player of players) {
        await changeLanguageForPlayer(player);
        let body = i18n.t("ChallengeRejectedBody", { quitter, metaGame });
        if (comment !== ".") {
          body += " " + i18n.t("ChallengeResponseComment", { comment });
        }
        if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
          if ((player.settings?.all?.notifications === undefined) || (player.settings.all.notifications.challenges)) {
            const comm = createSendEmailCommand(player.email, player.name, i18n.t("ChallengeRejectedSubject"), body);
            work.push(sesClient.send(comm));
          } else {
            console.log(`Player ${player.name} (${player.id}) has elected to not receive challenge notifications.`);
          }
        } else {
          console.log(`No verified email address found for ${player.name} (${player.id})`);
        }
        // push notifications are sent no matter what
        work.push(sendPush({
          userId: player.id,
          topic: "challenges",
          title: i18n.t("PUSH.titles.declined"),
          body: body,
          url: "/",
        }));
      }
    }
  }
  await Promise.all(work);
  return ret;
}

async function removeChallenge(challengeId: string, metaGame: string, standing: boolean, revoked: boolean, quitter: string) {
  const chall = await ddbDocClient.send(
    new GetCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        "pk": standing ? "STANDINGCHALLENGE#" + metaGame : "CHALLENGE",
        "sk": challengeId
      },
    }));
  if (chall.Item === undefined) {
    // The challenge might have been revoked or rejected by another user (while you were deciding)
    console.log("Challenge not found");
    return { "challenge": undefined, "work": undefined };
  }
  const challenge = chall.Item as Challenge;
  if (revoked && challenge.challenger.id !== quitter)
    throw new Error(`${quitter} tried to revoke a challenge that they did not create.`);
  if (!revoked && !(challenge.players.find((p: { id: any; }) => p.id === quitter) || (!standing && challenge.challengees!.find((p: { id: any; }) => p.id === quitter))))
    throw new Error(`${quitter} tried to leave a challenge that they are not part of.`);
  return { challenge, "work": removeAChallenge(challenge, standing, revoked, false, quitter) };
}

// Remove the challenge either because the game has started, or someone withrew: either challenger revoked the challenge or someone withdrew an acceptance, or didn't accept the challenge.
async function removeAChallenge(challenge: { [x: string]: any; challenger?: any; id?: any; challengees?: any; numPlayers?: any; metaGame?: any; players?: any; }, standing: any, revoked: boolean, started: boolean, quitter: string) {
  const list: Promise<any>[] = [];

  // determine if a standing challenge has expired
  let expired = false;
  if (standing && !revoked) {
    if (("duration" in challenge) && (typeof challenge.duration === "number") && (challenge.duration > 0)) {
      if (challenge.duration === 1) {
        expired = true;
      } else {
        console.log(`decrementing standing challenge ${challenge.metaGame + '#' + challenge.id} duration from ${challenge.duration} to ${challenge.duration - 1}`);
        list.push(
          ddbDocClient.send(
            new UpdateCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              Key: { "pk": "STANDINGCHALLENGE#" + challenge.metaGame, "sk": challenge.id },
              ExpressionAttributeValues: { ":d": challenge.duration - 1 },
              ExpressionAttributeNames: { "#d": "duration" },
              UpdateExpression: "set #d = :d"
            })
          )
        );
      }
    }
  }

  if (!standing) {
    // Remove from challenger
    list.push(sendCommandWithRetry(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": challenge.challenger.id },
      UpdateExpression: "DELETE challenges_issued :c",
      ExpressionAttributeValues: { ":c": new Set([challenge.id]) }
    })));
    // Remove from challenged
    for (const challengee of challenge.challengees) {
      if (!(await isBotId(challengee.id))) {
        list.push(sendCommandWithRetry(new UpdateCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: { "pk": "USER", "sk": challengee.id },
          UpdateExpression: "DELETE challenges_received :c",
          ExpressionAttributeValues: { ":c": new Set([challenge.id]) }
        })));
      }
    }
  } else if (
    revoked
    || challenge.numPlayers > 2 // Had to duplicate the standing challenge when someone accepted but there were still spots left. Remove the duplicated standing challenge
    || expired
  ) {
    // Remove from challenger
    console.log(`removing duplicated challenge ${standing ? challenge.metaGame + '#' + challenge.id : challenge.id} from challenger ${challenge.challenger.id}`);
    list.push(sendCommandWithRetry(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": challenge.challenger.id },
      UpdateExpression: "DELETE challenges_standing :c",
      ExpressionAttributeValues: { ":c": new Set([challenge.metaGame + '#' + challenge.id]) }
    })));
  }

  // Remove from players that have already accepted
  let playersToUpdate = [];
  if (standing || revoked || started) {
    playersToUpdate = challenge.players.filter((p: { id: any; }) => p.id != challenge.challenger.id);
  } else {
    playersToUpdate = [{ "id": quitter }];
  }
  for (const player of playersToUpdate) {
    if (await isBotId(player.id)) {
      continue;
    }
    console.log(`removing challenge ${standing ? challenge.metaGame + '#' + challenge.id : challenge.id} from ${player.id}`);
    list.push(sendCommandWithRetry(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": player.id },
      UpdateExpression: "DELETE challenges_accepted :c",
      ExpressionAttributeValues: { ":c": new Set([standing ? challenge.metaGame + '#' + challenge.id : challenge.id]) }
    })));
  }

  // Remove challenge
  if (!standing) {
    list.push(
      ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "CHALLENGE", "sk": challenge.id
          },
        }))
    );
  } else if (
    revoked
    || challenge.numPlayers > 2 // Had to duplicate the standing challenge when someone accepted but there were still spots left. Remove the duplicated standing challenge
    || expired
  ) {
    console.log(`removing challenge ${challenge.metaGame + '#' + challenge.id}`);
    list.push(
      ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "STANDINGCHALLENGE#" + challenge.metaGame, "sk": challenge.id
          },
        }))
    );

    list.push(updateStandingChallengeCount(challenge.metaGame, -1));
  }
  return Promise.all(list);
}

async function updateStandingChallengeCount(metaGame: any, diff: number) {
  await ensureMetaGameCountEntry(metaGame);
  return ddbDocClient.send(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "METAGAMES", "sk": "COUNTS" },
    ExpressionAttributeNames: { "#g": metaGame },
    ExpressionAttributeValues: { ":n": diff, ":zero": 0 },
    UpdateExpression: "set #g.standingchallenges = if_not_exists(#g.standingchallenges, :zero) + :n",
  }));
}

async function acceptChallenge(userid: string, metaGame: string, challengeId: string, standing: boolean) {
  const challengeData = await ddbDocClient.send(
    new GetCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        "pk": standing ? "STANDINGCHALLENGE#" + metaGame : "CHALLENGE", "sk": challengeId
      },
    }));

  if (challengeData.Item === undefined) {
    // The challenge might have been revoked or rejected by another user (while you were deciding)
    console.log("Challenge not found");
    return;
  }

  const challenge = challengeData.Item as FullChallenge;
  const challengees = standing || !challenge.challengees ? [] : challenge.challengees.filter((c: { id: any; }) => c.id != userid);
  if (!standing && challengees.length !== (challenge.challengees ? challenge.challengees.length : 0) - 1) {
    logGetItemError(`userid ${userid} wasn't a challengee, challenge ${challengeId}`);
    throw new Error("Can't accept a challenge if you weren't challenged");
  }
  const players = challenge.players;
  if ((players ? players.length : 0) === challenge.numPlayers - 1) {
    // Enough players accepted. Start game.
    const gameId = uuid();
    let playerIDs: string[] = [];
    if (challenge.seating === 'random') {
      playerIDs = players!.map(player => player.id) as string[];
      playerIDs.push(userid);
      shuffle(playerIDs);
    } else if (challenge.seating === 's1') {
      playerIDs.push(challenge.challenger.id);
      playerIDs.push(userid);
    } else if (challenge.seating === 's2') {
      playerIDs.push(userid);
      playerIDs.push(challenge.challenger.id);
    }
    const playersFull = await getParticipants(playerIDs);
    let whoseTurn: string | boolean[] = "0";
    const info = gameinfo.get(challenge.metaGame);
    if (info.flags !== undefined && info.flags.includes('simultaneous')) {
      whoseTurn = playerIDs.map(() => true);
    }
    const variants = challenge.variants;
    console.log(`Variants in the challenge object: ${JSON.stringify(variants)}`);
    let engine;
    if (info.playercounts.length > 1)
      engine = GameFactory(challenge.metaGame, challenge.numPlayers, variants);
    else
      engine = GameFactory(challenge.metaGame, undefined, variants);
    if (!engine)
      throw new Error(`Unknown metaGame ${challenge.metaGame}`);
    console.log(`Variants in the game engine: ${JSON.stringify(engine.variants)}`);
    const state = engine.serialize();
    const now = Date.now();
    const gamePlayers = playersFull.map(p => { return { "id": p.id, "name": p.name, "time": challenge.clockStart * 3600000 } }) as User[];
    if (info.flags !== undefined && info.flags.includes('perspective')) {
      let rot = 180;
      if (playerIDs.length > 2 && info.flags !== undefined && info.flags.includes('rotate90')) {
        rot = -90;
      }
      for (let i = 1; i < playerIDs.length; i++) {
        gamePlayers[i].settings = { "rotate": i * rot };
      }
    }
    const addGame = ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: prepareGameStateForStorage({
        "pk": "GAME",
        "sk": challenge.metaGame + "#0#" + gameId,
        "id": gameId,
        "metaGame": challenge.metaGame,
        "numPlayers": challenge.numPlayers,
        "rated": challenge.rated === true,
        "players": gamePlayers,
        "clockStart": challenge.clockStart,
        "clockInc": challenge.clockInc,
        "clockMax": challenge.clockMax,
        "clockHard": challenge.clockHard,
        "noExplore": challenge.noExplore || false,
        "state": state,
        "toMove": whoseTurn,
        "lastMoveTime": now,
        "gameStarted": now,
        "variants": engine.variants,
      })
    }));
    // this should be all the info we want to show on the "my games" summary page.
    const game = {
      "id": gameId,
      "metaGame": challenge.metaGame,
      "players": playersFull.map(p => { return { "id": p.id, "name": p.name, "time": challenge.clockStart * 3600000 } }),
      "clockHard": challenge.clockHard,
      "noExplore": challenge.noExplore || false,
      "toMove": whoseTurn,
      "lastMoveTime": now,
      "variants": engine.variants,
    } as Game;
    const list: Promise<any>[] = [];
    list.push(addToGameLists("CURRENTGAMES", game, now, false));

    // Now remove the challenge and add the game to all players
    list.push(addGame);
    list.push(removeAChallenge(challenge, standing, false, true, ''));

    // Update players
    playersFull.forEach(player => {
      if (player.isBot) {
        return;
      }
      const games = [...(player.games ?? []) as Game[], game];
      const updatedGameIDs = [game.id];
      list.push(updateUserGames(player.id, player.gamesUpdate, updatedGameIDs, games));
    });
    try {
      await Promise.all(list);
      await notifyRegisteredBotsTurn(challenge.metaGame, gameId);
      return {
        metaGame: info.name,
        players: playersFull.filter(p => !p.isBot) as unknown as FullUser[],
        simultaneous: info.flags !== undefined && info.flags.includes('simultaneous'),
        gameId
      };
    }
    catch (error) {
      logGetItemError(error);
      throw new Error('Unable to update players and create game');
    }
  } else {
    // Still waiting on more players to accept.
    // Update challenge
    let newplayer: User | undefined;
    if (standing) {
      const playerFull = await getParticipants([userid]);
      newplayer = { "id": playerFull[0].id, "name": playerFull[0].name };
    } else {
      newplayer = challenge.challengees!.find(c => c.id == userid);
      if (!newplayer)
        throw new Error("Can't accept a challenge if you weren't challenged");
    }
    let updateChallenge: Promise<any>;
    if (!standing || challenge.numPlayers == 2 || (players && players.length !== 1)) {
      challenge.challengees = challengees;
      players!.push(newplayer);
      updateChallenge = ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: challenge
      }));
    } else {
      // need to duplicate the challenge, because numPlayers > 2 and we have our first accepter
      ({ challengeId, work: updateChallenge } = await duplicateStandingChallenge(challenge, newplayer));
    }
    // Update accepter
    const challengeValue = new Set([standing ? challenge.metaGame + '#' + challengeId : challengeId]);

    const userUpdates: Promise<any>[] = [updateChallenge];
    if (!(await isBotId(userid))) {
      userUpdates.push(sendCommandWithRetry(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "USER", "sk": userid },
        UpdateExpression: "DELETE challenges_received :c",
        ExpressionAttributeValues: { ":c": challengeValue }
      })));
      userUpdates.push(sendCommandWithRetry(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "USER", "sk": userid },
        UpdateExpression: "ADD challenges_accepted :c",
        ExpressionAttributeValues: { ":c": challengeValue }
      })));
    }

    await Promise.all(userUpdates);
    return;
  }
}

async function duplicateStandingChallenge(challenge: { [x: string]: any; metaGame?: any; numPlayers?: any; standing?: any; seating?: any; variants?: any; challenger?: any; clockStart?: any; clockInc?: any; clockMax?: any; clockHard?: any; rated?: any; }, newplayer: any) {
  const challengeId = uuid();
  console.log("Duplicate challenge with newplayer", newplayer);
  const addChallenge = ddbDocClient.send(new PutCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Item: {
      "pk": "STANDINGCHALLENGE#" + challenge.metaGame,
      "sk": challengeId,
      "id": challengeId,
      "metaGame": challenge.metaGame,
      "numPlayers": challenge.numPlayers,
      "standing": challenge.standing,
      "seating": challenge.seating,
      "variants": challenge.variants,
      "challenger": challenge.challenger,
      "players": [challenge.challenger, newplayer], // users that have accepted
      "challengees": [challenge.challenger, newplayer], // users that have accepted
      "clockStart": challenge.clockStart,
      "clockInc": challenge.clockInc,
      "clockMax": challenge.clockMax,
      "clockHard": challenge.clockHard,
      "noExplore": challenge.noExplore || false,
      "rated": challenge.rated,
      "dateIssued": challenge.dateIssued,
    }
  }));

  const updateStandingChallengeCnt = updateStandingChallengeCount(challenge.metaGame, 1);

  const updateChallenger = ddbDocClient.send(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "USER", "sk": challenge.challenger.id },
    ExpressionAttributeValues: { ":c": new Set([challenge.metaGame + '#' + challengeId]) },
    ExpressionAttributeNames: { "#cs": "challenges_standing" },
    UpdateExpression: "add #cs :c",
  }));

  return { challengeId, "work": Promise.all([addChallenge, updateStandingChallengeCnt, updateChallenger]) };
}

async function getPlayers(playerIDs: string[]) {
  const players: FullUser[] = [];
  for (const id of playerIDs) {
    if (await isBotId(id)) {
      const bot = await getBotRecord(id);
      if (bot) {
        players.push(botToFullUserStub(bot) as FullUser);
      }
      continue;
    }
    const playerData = await sendCommandWithRetry<GetCommandOutput>(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER", "sk": id
        },
      })
    );
    if (playerData.Item) {
      players.push(playerData.Item as FullUser);
    }
  }
  return players;
}

async function getPlayersSlowly(playerIDs: string[]) {
  const players: FullUser[] = [];
  for (const id of playerIDs) {
    try {
      if (await isBotId(id)) {
        const bot = await getBotRecord(id);
        if (bot) {
          players.push(botToFullUserStub(bot) as FullUser);
        }
        continue;
      }
      const playerData = await ddbDocClient.send(
        new GetCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "USER", "sk": id
          },
        })
      );
      if (playerData.Item) {
        players.push(playerData.Item as FullUser);
      }
    } catch (error) {
      logGetItemError(error);
      console.log(`Unable to get player ${id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
      throw error;
    }
  }
  return players;
}

async function scheduleRatingUpdates(
  game: FullGame,
  player: { id: string; name: string },
  ind: number,
  newRatings: { [metaGame: string]: Rating }[] | null,
  list: Promise<any>[]
) {
  if (newRatings === null || await isBotId(player.id)) {
    return;
  }
  list.push(
    sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": player.id },
      ExpressionAttributeValues: { ":rs": newRatings[ind] },
      UpdateExpression: "set ratings = :rs"
    }))
  );

  list.push(sendCommandWithRetry<PutCommandOutput>(new PutCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Item: {
      "pk": "RATINGS#" + game.metaGame,
      "sk": player.id,
      "id": player.id,
      "name": player.name,
      "rating": newRatings[ind][game.metaGame]
    }
  })));

  list.push(ensureMetaGameCountEntry(game.metaGame));
  list.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "METAGAMES", "sk": "COUNTS" },
    ExpressionAttributeNames: { "#gr": game.metaGame + "_ratings" },
    ExpressionAttributeValues: { ":p": new Set([player.id]) },
    UpdateExpression: "add #gr :p",
  })));
}

async function addToGameLists(type: string, game: Game, now: number, keepgame: boolean) {
  const work: Promise<any>[] = [];
  const sk = now + "#" + game.id;
  if (type === "COMPLETEDGAMES" && keepgame) {
    work.push(sendCommandWithRetry(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: {
        "pk": type + "#" + game.metaGame,
        "sk": sk,
        ...game
      }
    })));
    game.players.forEach((player: { id: string; }) => {
      work.push(sendCommandWithRetry(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          "pk": type + "#" + player.id,
          "sk": sk,
          ...game
        }
      })));
    });
  }
  if (type === "CURRENTGAMES" || type === "COMPLETEDGAMES") {
    await ensureMetaGameCountEntry(game.metaGame);
  }
  if (type === "CURRENTGAMES") {
    work.push(sendCommandWithRetry(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "METAGAMES", "sk": "COUNTS" },
      ExpressionAttributeNames: { "#g": game.metaGame },
      ExpressionAttributeValues: { ":n": 1, ":zero": 0 },
      UpdateExpression: "set #g.currentgames = if_not_exists(#g.currentgames, :zero) + :n"
    })));
  } else if (type === "COMPLETEDGAMES") {
    let update = "set #g.currentgames = if_not_exists(#g.currentgames, :zero) + :nm";
    const eavObj: { [k: string]: number } = { ":nm": -1, ":zero": 0 };
    if (keepgame) {
      update += ", #g.completedgames = if_not_exists(#g.completedgames, :zero) + :n";
      eavObj[":n"] = 1
    }
    work.push(sendCommandWithRetry(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "METAGAMES", "sk": "COUNTS" },
      ExpressionAttributeNames: { "#g": game.metaGame },
      ExpressionAttributeValues: eavObj,
      UpdateExpression: update
    })));
  }
  return Promise.all(work);
}

async function deleteFromGameLists(type: string, game: FullGame) {
  const work: Promise<any>[] = [];
  if (type === "COMPLETEDGAMES") {
    const sk = game.lastMoveTime + "#" + game.id;
    work.push(ddbDocClient.send(new DeleteCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        "pk": "COMPLETEDGAMES#" + game.metaGame, "sk": sk
      },
    })));
    game.players.forEach((player: { id: string; }) => {
      work.push(ddbDocClient.send(new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "COMPLETEDGAMES#" + player.id, "sk": sk
        },
      })));
    });
  }
  if (type === "CURRENTGAMES") {
    await ensureMetaGameCountEntry(game.metaGame);
    work.push(ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "METAGAMES", "sk": "COUNTS" },
      ExpressionAttributeNames: { "#g": game.metaGame },
      ExpressionAttributeValues: { ":n": -1, ":zero": 0 },
      UpdateExpression: "set #g.currentgames = if_not_exists(#g.currentgames, :zero) + :n"
    })));
  }
  return Promise.all(work);
}

async function submitMove(userid: string, pars: {
  id: string, move: string, draw: string, metaGame: string, cbit: number, moveNumber?: number, opponentId?: string,
  exploration?: Exploration[]
}) {
  if (pars.cbit !== 0) {
    return formatReturnError("cbit must be 0");
  }

  // Build parallel fetch promises
  const gamePromise = sendCommandWithRetry<GetCommandOutput>(
    new GetCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        "pk": "GAME",
        "sk": pars.metaGame + "#0#" + pars.id
      },
    }));

  // If opponentId and moveNumber are provided, also fetch opponent exploration data
  let opponentExplorationPromise: Promise<GetCommandOutput> | null = null;
  if (pars.opponentId && pars.moveNumber !== undefined) {
    opponentExplorationPromise = sendCommandWithRetry<GetCommandOutput>(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAMEEXPLORATION#" + pars.id,
          "sk": pars.opponentId + "#" + pars.moveNumber
        },
      }));
  }

  let data: any;
  let opponentExplorationData: any = null;
  try {
    if (opponentExplorationPromise) {
      [data, opponentExplorationData] = await Promise.all([gamePromise, opponentExplorationPromise]);
    } else {
      data = await gamePromise;
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get game ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  if (!data.Item)
    throw new Error(`No game ${pars.id} in table ${process.env.ABSTRACT_PLAY_TABLE}`);
  try {
    const game = hydrateGameState(data.Item as FullGame);
    console.log("got game in submitMove:");
    console.log(game);
    const engine = GameFactory(game.metaGame, game.state);
    if (!engine)
      throw new Error(`Unknown metaGame ${game.metaGame}`);

    // Validate moveNumber if provided (to catch stale browser submissions)
    const currentMoveNumber = engine.stack.length;
    if (pars.moveNumber !== undefined && pars.moveNumber !== currentMoveNumber) {
      return formatReturnError(`Move number mismatch: browser has ${pars.moveNumber} moves but game has ${currentMoveNumber} moves. Please refresh your browser.`);
    }

    // Parse explorations if fetched (for premove processing)
    let opponentExploration: Exploration[] | null = null;
    if (opponentExplorationData?.Item?.tree) {
      try {
        opponentExploration = JSON.parse(opponentExplorationData.Item.tree as string);
      } catch (error) {
        console.log(`Error parsing opponent exploration tree: ${error}`);
        // Non-fatal, continue without premove processing
      }
    }

    const flags = gameinfo.get(game.metaGame).flags;
    const simultaneous = flags !== undefined && flags.includes('simultaneous');
    const lastMoveTime = (new Date(engine.stack[engine.stack.length - 1]._timestamp)).getTime();
    let autoMoves = 0;
    let autoMovesPerPlayer: number[] = [];
    const list: Promise<any>[] = [];

    try {
      if (pars.move === "resign") {
        resign(userid, engine, game);
      } else if (pars.move === "timeout") {
        timeout(userid, engine, game);
      } else if (pars.move === "" && pars.draw === "drawaccepted") {
        drawaccepted(userid, engine, game, simultaneous);
      } else if (simultaneous) {
        applySimultaneousMove(userid, pars.move, engine as GameBaseSimultaneous, game);
      } else {
        const result = applyMove(userid, pars.move, currentMoveNumber, engine, game, flags, opponentExploration, pars.exploration);
        autoMoves = result.autoMoves;
        autoMovesPerPlayer = result.autoMovesPerPlayer;
        for (const workItem of result.work) {
          list.push(workItem);
        }
      }
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to apply move ${pars.move}`);
    }

    const player = game.players.find(p => p.id === userid);
    if (!player)
      throw new Error(`Player ${userid} isn't playing in game ${pars.id}`)
    // deal with draw offers
    if (pars.draw === "drawoffer" && autoMoves === 0) {
      player.draw = "offered";
    } else {
      // if a player just moved, other draw offers are declined
      game.players.forEach(p => delete p.draw);
    }
    const timestamp = (new Date(engine.stack[engine.stack.length - 1]._timestamp)).getTime();
    const timeUsed = timestamp - lastMoveTime;
    // console.log("timeUsed", timeUsed);
    // console.log("player", player);
    if (player.time! - timeUsed < 0)
      player.time = game.clockInc * 3600000; // If the opponent didn't claim a timeout win, and player moved, pretend his remaining time was zero.
    else
      player.time = player.time! - timeUsed + game.clockInc * 3600000;
    if (player.time > game.clockMax * 3600000) player.time = game.clockMax * 3600000;
    // Apply time increments for players whose moves were auto-applied (forced moves or premoves)
    for (let i = 0; i < autoMovesPerPlayer.length; i++) {
      if (autoMovesPerPlayer[i] > 0) {
        game.players[i].time = (game.players[i].time || 0) + autoMovesPerPlayer[i] * game.clockInc * 3600000;
        if (game.players[i].time! > game.clockMax * 3600000) game.players[i].time = game.clockMax * 3600000;
      }
    }
    // console.log("players", game.players);
    const playerIDs = game.players.map((p: { id: any; }) => p.id);
    // TODO: We are updating players and their games. This should be put in some kind of critical section!
    const players = await getParticipants(playerIDs);

    // this should be all the info we want to show on the "my games" summary page.
    const playerGame = {
      "id": game.id,
      "metaGame": game.metaGame,
      "players": game.players,
      "clockHard": game.clockHard,
      "noExplore": game.noExplore || false,
      "lastMoveTime": timestamp,
      "numMoves": engine.stack.length - 1,
      "gameStarted": new Date(engine.stack[0]._timestamp).getTime(),
      "variants": engine.variants
    } as Game;
    if (engine.gameover) {
      playerGame.gameEnded = new Date(engine.stack[engine.stack.length - 1]._timestamp).getTime();
      playerGame.winner = engine.winner;
    }
    let newRatings: { [metaGame: string]: Rating }[] | null = null;
    if ((game.toMove === "" || game.toMove === null)) {
      newRatings = updateRatings(game, players as unknown as FullUser[]);
      list.push(addToGameLists("COMPLETEDGAMES", { ...playerGame, commented: game.commented }, timestamp, game.numMoves !== undefined && game.numMoves > game.numPlayers));
      // delete at old sk
      list.push(sendCommandWithRetry<DeleteCommandOutput>(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "GAME",
            "sk": game.sk
          }
        })
      ));
      console.log("Scheduled delete and updates to game lists");
      game.sk = game.metaGame + "#1#" + game.id;

      /*
            As originally conceived, notes were part of the PLAYER record and were thus retained
            until the game was cleared from the record. But when moving them to a separate record,
            now they're being deleted immediately. So for now, let's not delete the notes until
            I can find a way to schedule deletions.
       */
      // TODO: Find a way to schedule deletions
      // delete associated notes
      //   try {
      //     const notesData = await ddbDocClient.send(
      //         new QueryCommand({
      //           TableName: process.env.ABSTRACT_PLAY_TABLE,
      //           KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
      //           ExpressionAttributeValues: { ":pk": "NOTE", ":sk": game.id },
      //           ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      //           ProjectionExpression: "#pk, #sk"
      //     }));
      //     if ( (notesData.Items) && (notesData.Items.length > 0) ) {
      //         const notesList = notesData.Items as Note[];
      //         for (const note of notesList) {
      //             list.push(ddbDocClient.send(
      //                 new DeleteCommand({
      //                   TableName: process.env.ABSTRACT_PLAY_TABLE,
      //                   Key: {
      //                     "pk": note.pk,
      //                     "sk": note.sk
      //                   }
      //                 })
      //             ));
      //         }
      //     }
      //   } catch (err) {
      //     logGetItemError(err);
      //     return formatReturnError('Unable to process submit move');
      //   }
      if (game.tournament !== undefined) {
        list.push(tournamentUpdates(game, players as unknown as FullUser[], pars.move === "timeout" ? parseInt(game.toMove) : undefined));
      }
      if (game.event !== undefined) {
        const winners = engine.winner.map(n => players[n - 1]).map(p => p.id);
        list.push(eventUpdates({ eventid: game.event, gameid: pars.id, winner: winners }))
      }
    }
    game.lastMoveTime = timestamp;
    const updateGame = sendCommandWithRetry<PutCommandOutput>(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: prepareGameStateForStorage(game)
    }));
    list.push(updateGame);
    console.log("Scheduled update to game");
    // Update players
    for (let ind = 0; ind < players.length; ind++) {
      const player = players[ind];
      if (player.isBot) {
        continue;
      }
      const games: Game[] = [];
      const updatedGames: string[] = [];
      playerGame.toMove = game.toMove;
      (player.games as Game[] ?? []).forEach(g => {
        if (g.id === playerGame.id) {
          if (player.id === userid) {
            if (game.toMove === "" || game.toMove === null)
              games.push({ ...playerGame, seen: Date.now() });
            else
              games.push(playerGame);
          }
          else {
            games.push(playerGame);
          }
          updatedGames.push(g.id);
        }
        else
          games.push(g)
      });
      list.push(updateUserGames(player.id, player.gamesUpdate, updatedGames, games));
      console.log(`Scheduled update to player ${player.id}, ${player.name}, with games`, games);
      await scheduleRatingUpdates(game, player, ind, newRatings, list);
    }

    if (simultaneous)
      game.partialMove = game.players.map((p: User, i: number) => (p.id === userid ? game.partialMove!.split(',')[i] : '')).join(',');

    list.push(sendSubmittedMoveEmails(game, players.filter(p => !p.isBot) as unknown as FullUser[], simultaneous, newRatings));
    console.log("Scheduled emails");

    await realPingBot(game.metaGame, game.id, game);
    await Promise.all(list);

    // broadcasting that state has updated
    await wsBroadcast("game", { "meta": pars.metaGame, "id": pars.id }, [userid]);

    // TODO: Rehydrate state, run it through the stripper, and then replace with the new, stripped state
    if (game.gameEnded === undefined) {
      const engine = GameFactory(game.metaGame, game.state);
      if (engine === undefined) {
        throw new Error(`Could not rehydrate the state for id "${pars.id}", meta "${pars.metaGame}".`);
      }
      if (!engine.gameover) {
        let player: number | undefined;
        const pidx = game.players.findIndex(p => p.id === userid);
        if (pidx >= 0) {
          player = pidx + 1;
        }
        game.state = engine.serialize({ strip: true, player });
      }
    }

    console.log("All updates complete");
    return {
      statusCode: 200,
      body: JSON.stringify(game),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError('Unable to process submit move');
  }
}

async function tournamentUpdates(game: FullGame, players: FullUser[], timeout: number | undefined) {
  let work: Promise<any>[] = [];
  for (let i = 0; i < 2; i++) {
    const player = players[i];
    let score = 0;
    if (game.winner?.length === 1 && game.players[game.winner[0] - 1].id === player.id) {
      score = 1;
    } else if (game.winner?.length === 2) {
      score = 0.5;
    }
    console.log(`player ${player.name} now has score ${score} in game ${game.id} from tournament ${game.tournament}`);
    work.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "TOURNAMENTPLAYER", "sk": game.tournament + '#' + game.division!.toString() + '#' + player.id },
      ExpressionAttributeNames: { "#s": "score", "#t": "timeout" },
      ExpressionAttributeValues: { ":inc": score, ":t": i === timeout },
      UpdateExpression: "add #s :inc set #t = :t"
    })));
  }
  const winner = game.winner?.map((w: number) => game.players[w - 1].id);
  work.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "TOURNAMENTGAME", "sk": game.tournament + '#' + game.division!.toString() + '#' + game.id },
    ExpressionAttributeNames: { "#w": "winner" },
    ExpressionAttributeValues: { ":w": winner },
    UpdateExpression: "set #w = :w"
  })));
  const tournamentData = await sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Key: { "pk": "TOURNAMENT", "sk": game.tournament },
    ExpressionAttributeNames: { "#d": "divisions", "#n": game.division!.toString() },
    ExpressionAttributeValues: { ":inc": 1, ":zero": 0 },
    UpdateExpression: "set #d.#n.numCompleted = if_not_exists(#d.#n.numCompleted, :zero) + :inc",
    ReturnValues: "ALL_NEW"
  }));
  const tournament = tournamentData.Attributes as Tournament;
  let divisionCompleted = false;
  for (const division of Object.values(tournament.divisions!)) {
    if (division.numCompleted === division.numGames && !division.processed) {
      divisionCompleted = true;
      break;
    }
  }
  if (divisionCompleted) {
    console.log("division completed, processing tournament");
    await Promise.all(work);
    work = [];
    work.push(endTournament(tournament))
  }
  return Promise.all(work);
}

function updateRatings(game: FullGame, players: FullUser[]) {
  console.log("game.numMoves", game.numMoves);
  if (!game.rated || (game.numMoves && game.numMoves <= game.numPlayers))
    return null;
  if (game.numPlayers !== 2)
    throw new Error(`Only 2 player games can be rated, game ${game.id}`);
  let rating1: Rating = { rating: 1200, N: 0, wins: 0, draws: 0 }
  let rating2: Rating = { rating: 1200, N: 0, wins: 0, draws: 0 }
  if (players[0].ratings !== undefined && players[0].ratings[game.metaGame] !== undefined)
    rating1 = players[0].ratings[game.metaGame];
  if (players[1].ratings !== undefined && players[1].ratings[game.metaGame] !== undefined)
    rating2 = players[1].ratings[game.metaGame];
  let score;
  if (Array.isArray(game.winner)) {
    if (game.winner.length == 1) {
      if (game.winner[0] === 1) {
        score = 1;
        rating1.wins += 1;
      } else if (game.winner[0] === 2) {
        score = 0;
        rating2.wins += 1;
      } else {
        throw new Error(`Winner ([${game.winner[0]}]) not in expected format, game ${game.id}`);
      }
    } else if (game.winner.length == 2) {
      if (game.winner.includes(1) && game.winner.includes(2)) {
        score = 0.5;
        rating1.draws += 1;
        rating2.draws += 1;
      } else {
        throw new Error(`Winner ([${game.winner[0]}, ${game.winner[1]}]) not in expected format, game ${game.id}`);
      }
    } else {
      throw new Error(`Winner has length ${game.winner.length}, this is not expected, game ${game.id}`);
    }
  } else {
    throw new Error(`Winner is not an array!? Game ${game.id}`);
  }
  const expectedScore = 1 / (1 + Math.pow(10, (rating2.rating - rating1.rating) / 400)); // player 1's expected score;
  const E2 = 1 / (1 + Math.pow(10, (rating1.rating - rating2.rating) / 400));
  console.log(`E = ${expectedScore}, E2 = ${E2}`);
  rating1.rating += getK(rating1.N) * (score - expectedScore);
  rating2.rating += getK(rating2.N) * (expectedScore - score);
  rating1.N += 1;
  rating2.N += 1;
  const ratings1 = players[0].ratings === undefined ? {} : players[0].ratings;
  const ratings2 = players[1].ratings === undefined ? {} : players[1].ratings;
  ratings1[game.metaGame] = rating1;
  ratings2[game.metaGame] = rating2;
  return [ratings1, ratings2];
}

function getK(N: number) {
  return (
    N < 10 ? 40
      : N < 20 ? 30
        : N < 40 ? 25
          : 20
  );
}

async function sendSubmittedMoveEmails(game: FullGame, players0: FullUser[], simultaneous: any, newRatings: any[] | null) {
  await initi18n('en');
  const work: Promise<any>[] = [];
  if (game.toMove !== '') {
    let playerIds: any[] = [];
    if (!simultaneous) {
      playerIds.push(game.players[parseInt(game.toMove as string)].id);
    }
    else if ((game.toMove as boolean[]).every(b => b === true)) {
      playerIds = game.players.map(p => p.id);
    }
    const players = players0.filter(p => playerIds.includes(p.id));
    const metaGame = gameinfo.get(game.metaGame).name;
    // Realtime YourTurn notifications are only sent by push
    for (const player of players) {
      await changeLanguageForPlayer(player);
      work.push(sendPush({
        userId: player.id,
        topic: "yourturn",
        title: i18n.t("PUSH.titles.yourturn"),
        body: i18n.t("YourMoveBody", { metaGame }),
        url: `/move/${game.metaGame}/0/${game.id}`,
      }));
    }
  } else {
    // Game over
    const playerIds = game.players.map((p: { id: any; }) => p.id);
    const players = players0.filter((p: { id: any; }) => playerIds.includes(p.id));
    const metaGame = gameinfo.get(game.metaGame).name;
    const engine = GameFactory(game.metaGame, game.state);
    if (!engine)
      throw new Error(`Unknown metaGame ${game.metaGame}`);
    const scores = [];
    if (gameinfo.get(game.metaGame).flags.includes("scores")) {
      for (let p = 1; p <= engine.numplayers; p++) {
        scores.push(engine.getPlayerScore(p));
      }
    }

    for (const [ind, player] of players.entries()) {
      await changeLanguageForPlayer(player);
      // The Game Over email has a few components:
      const body = [];
      //   - Initial line
      body.push(i18n.t("GameOverBody", { metaGame }));
      //   - Winner statement
      let result = "lose";
      if (engine.winner.length > 1) {
        result = "draw";
      } else if (engine.winner.length === 1) {
        const winner = playerIds[engine.winner[0] - 1];
        if (winner === player.id) {
          result = "win";
        }
      }
      body.push(i18n.t("GameOverResult", { context: result }));
      //   - Rating, if applicable
      if (newRatings != null) {
        body.push(i18n.t("GameOverRating", { "rating": `${Math.round(newRatings[ind][game.metaGame].rating)}` }));
      }
      //   - Final scores, if applicable
      if (scores.length > 0) {
        body.push(i18n.t("GameOverScores", { scores: scores.join(", ") }))
      }
      //   - Direct link to game
      body.push(i18n.t("GameOverLink", { metaGame: game.metaGame, gameID: game.id }));

      if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
        if ((player.settings?.all?.notifications === undefined) || (player.settings.all.notifications.gameEnd)) {
          const comm = createSendEmailCommand(player.email, player.name, i18n.t("GameOverSubject"), body.join(" "));
          work.push(sesClient.send(comm));
        } else {
          console.log(`Player ${player.name} (${player.id}) has elected to not receive game end notifications.`);
        }
      } else {
        console.log(`No verified email address found for ${player.name} (${player.id})`);
      }
      // push notifications are sent no matter what
      work.push(sendPush({
        userId: player.id,
        topic: "ended",
        title: i18n.t("PUSH.titles.ended"),
        body: body.join(" "),
        url: `/move/${game.metaGame}/1/${game.id}`,
      }));
    }
  }
  return Promise.all(work);
}

function resign(userid: any, engine: GameBase, game: FullGame) {
  const player = game.players.findIndex((p: { id: any; }) => p.id === userid);
  if (player === undefined)
    throw new Error(`${userid} isn't playing in this game!`);
  engine.resign(player + 1);
  game.state = engine.serialize();
  game.state = engine.serialize();
  if (engine.gameover) {
    game.toMove = "";
    game.winner = engine.winner;
    game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
  } else {
    const flags = gameinfo.get(game.metaGame).flags;
    const simultaneous = flags !== undefined && flags.includes('simultaneous');
    if (simultaneous) {
      applySimultaneousMove(userid, "resign", engine as GameBaseSimultaneous, game);
    } else {
      applyMove(userid, "resign", -1, engine, game, flags);
    }
  }
}

function timeout(userid: string, engine: GameBase | GameBaseSimultaneous, game: FullGame) {
  if (game.toMove === '')
    throw new Error("Can't timeout a game that has already ended");
  // Find player that timed out
  let loser: number;
  if (Array.isArray(game.toMove)) {
    let minTime = 0;
    let minIndex = -1;
    const elapsed = Date.now() - game.lastMoveTime;
    game.toMove.forEach((p: any, i: number) => {
      if (p && game.players[i].time! - elapsed < minTime) {
        minTime = game.players[i].time! - elapsed;
        minIndex = i;
      }
    });
    if (minIndex !== -1) {
      loser = minIndex;
    } else {
      throw new Error("Nobody's time is up!");
    }
  } else {
    if (game.players[parseInt(game.toMove)].time! - (Date.now() - game.lastMoveTime) < 0) {
      loser = parseInt(game.toMove);
    } else {
      throw new Error("Opponent's time isn't up!");
    }
  }
  engine.timeout(loser + 1);
  game.state = engine.serialize();
  if (engine.gameover) {
    game.toMove = "";
    game.winner = engine.winner;
    game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
  } else {
    const loserid = game.players[loser].id;
    const flags = gameinfo.get(game.metaGame).flags;
    const simultaneous = flags !== undefined && flags.includes('simultaneous');
    if (simultaneous) {
      applySimultaneousMove(loserid, "timeout", engine as GameBaseSimultaneous, game);
    } else {
      applyMove(loserid, "timeout", -1, engine, game, flags);
    }
  }
}

function drawaccepted(userid: string, engine: GameBase, game: FullGame, simultaneous: boolean) {
  if ((!simultaneous && game.players[parseInt(game.toMove as string)].id !== userid) || (simultaneous && !game.players.some((p: User, i: number) => game.toMove[i] && p.id === userid))) {
    throw new Error('It is not your turn!');
  }
  const player = game.players.find((p: { id: any; }) => p.id === userid);
  if (!player)
    throw new Error("You can't accept a draw in a game you aren't playig in!");
  player.draw = "accepted";
  if (game.players.every(p => p.draw === "offered" || p.draw === "accepted")) {
    engine.draw();
    game.state = engine.serialize();
    game.toMove = "";
    game.winner = engine.winner;
    game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
  }
}

async function timeloss(check: boolean, player: number, gameid: string, metaGame: string, timestamp: number) {
  let data: any;
  try {
    data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": metaGame + "#0#" + gameid
        },
      }));
  }
  catch (error) {
    logGetItemError(error);
    throw new Error(`Unable to get game ${metaGame}, ${gameid} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  if (!data.Item)
    throw new Error(`No game ${metaGame}, ${gameid} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);

  const game = hydrateGameState(data.Item as FullGame);
  if (check) {
    console.log("game.toMove", game.toMove);
    if (Array.isArray(game.toMove)) {
      let minTime = 0;
      let minIndex = -1;
      const elapsed = Date.now() - game.lastMoveTime;
      game.toMove.forEach((p: any, i: number) => {
        if (p && game.players[i].time! - elapsed < minTime) {
          minTime = game.players[i].time! - elapsed;
          minIndex = i;
        }
      });
      if (minIndex !== -1) {
        player = minIndex;
      } else {
        throw "Nobody's time is up!";
      }
    } else {
      if (game.toMove === "")
        throw "Game is already over!";
      const toMove = parseInt(game.toMove);
      if (game.players[toMove].time! - (Date.now() - game.lastMoveTime) < 0) {
        player = toMove;
      } else {
        throw "Opponent's time isn't up!";
      }
    }
  }
  const engine = GameFactory(game.metaGame, game.state);
  if (!engine)
    throw new Error(`Unknown metaGame ${game.metaGame}`);
  engine.timeout(player + 1);
  game.state = engine.serialize();
  game.toMove = "";
  game.winner = engine.winner;
  game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
  game.lastMoveTime = timestamp;
  const playerIDs = game.players.map((p: { id: any; }) => p.id);
  const players = await getPlayers(playerIDs);

  // this should be all the info we want to show on the "my games" summary page.
  const playerGame = {
    "id": game.id,
    "metaGame": game.metaGame,
    "players": game.players,
    "clockHard": game.clockHard,
    "noExplore": game.noExplore || false,
    "winner": game.winner,
    "toMove": game.toMove,
    "lastMoveTime": game.lastMoveTime,
    "gameStarted": new Date(engine.stack[0]._timestamp).getTime(),
    "gameEnded": new Date(engine.stack[engine.stack.length - 1]._timestamp).getTime(),
    "numMoves": engine.stack.length - 1,
    "variants": engine.variants,
  } as Game;
  const work: Promise<any>[] = [];
  work.push(addToGameLists("COMPLETEDGAMES", playerGame, game.lastMoveTime, game.numMoves !== undefined && game.numMoves > game.numPlayers));

  // delete at old sk
  work.push(ddbDocClient.send(
    new DeleteCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: {
        "pk": "GAME",
        "sk": game.sk
      }
    })
  ));
  console.log("Scheduled delete and updates to game lists");
  game.sk = game.metaGame + "#1#" + game.id;

  work.push(ddbDocClient.send(new PutCommand({
    TableName: process.env.ABSTRACT_PLAY_TABLE,
    Item: prepareGameStateForStorage(game)
  })));

  const newRatings = updateRatings(game, players as unknown as FullUser[]);

  // Update players
  for (let ind = 0; ind < players.length; ind++) {
    const player = players[ind];
    const games: Game[] = [];
    (player.games ?? []).forEach(g => {
      if (g.id === playerGame.id)
        games.push(playerGame);
      else
        games.push(g)
    });
    const updatedGameIds = [playerGame.id];
    work.push(updateUserGames(player.id, player.gamesUpdate, updatedGameIds, games));
    await scheduleRatingUpdates(game, player, ind, newRatings, work);
  }
  if (game.tournament !== undefined) {
    work.push(tournamentUpdates(game, players as unknown as FullUser[], player));
  }
  await Promise.all(work);
  return game;
}

async function checkForAbandonedGame(userid: string, pars: { id: string, metaGame: string }) {
  let data: any;
  try {
    data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metaGame + "#0#" + pars.id
        },
      }));
  }
  catch (error) {
    logGetItemError(error);
    throw new Error(`Unable to get game ${pars.metaGame}, ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  if (!data.Item)
    throw new Error(`No game ${pars.metaGame}, ${pars.id} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);

  try {
    const game = hydrateGameState(data.Item as FullGame);
    const playerIDs = game.players.map((p: { id: any; }) => p.id);
    const players = await getPlayers(playerIDs);
    const now = Date.now();
    if (
      game.toMove == ""
      || game.clockHard
      || players.some(p => p.lastSeen !== undefined && p.lastSeen > now - 30 * 24 * 60 * 60 * 1000)
      || game.lastMoveTime > now - 30 * 24 * 60 * 60 * 1000
    ) {
      return {
        statusCode: 200,
        body: "not_abandoned",
        headers
      };
    }
    const engine = GameFactory(game.metaGame, game.state);
    if (!engine)
      throw new Error(`Unknown metaGame ${game.metaGame}`);
    engine.abandoned();
    game.state = engine.serialize();
    game.toMove = "";
    game.winner = engine.winner;
    game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
    game.lastMoveTime = now;

    // this should be all the info we want to show on the "my games" summary page.
    const playerGame = {
      "id": game.id,
      "metaGame": game.metaGame,
      "players": game.players,
      "clockHard": game.clockHard,
      "noExplore": game.noExplore || false,
      "winner": game.winner,
      "toMove": game.toMove,
      "lastMoveTime": game.lastMoveTime,
      "gameStarted": new Date(engine.stack[0]._timestamp).getTime(),
      "gameEnded": new Date(engine.stack[engine.stack.length - 1]._timestamp).getTime(),
      "numMoves": engine.stack.length - 1,
      "variants": engine.variants,
    } as Game;
    const work: Promise<any>[] = [];
    work.push(addToGameLists("COMPLETEDGAMES", playerGame, game.lastMoveTime, game.numMoves !== undefined && game.numMoves > game.numPlayers));

    // delete at old sk
    work.push(ddbDocClient.send(
      new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": game.sk
        }
      })
    ));
    console.log("Scheduled delete and updates to game lists");
    game.sk = game.metaGame + "#1#" + game.id;

    work.push(ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: prepareGameStateForStorage(game)
    })));

    // Update players
    for (const player of players) {
      const games: Game[] = [];
      (player.games ?? []).forEach(g => {
        if (g.id === playerGame.id)
          games.push(playerGame);
        else
          games.push(g)
      });
      const updatedGameIds = [playerGame.id];
      work.push(updateUserGames(player.id, player.gamesUpdate, updatedGameIds, games));
    }
    await Promise.all(work);
    return {
      statusCode: 200,
      body: JSON.stringify(game),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError('Error in checking for abandoned game');
  }
}

async function checkForTimeloss(userid: string, pars: { id: string, metaGame: string }) {
  try {
    const game = await timeloss(true, -1, pars.id, pars.metaGame, Date.now());
    return {
      statusCode: 200,
      body: JSON.stringify(game),
      headers
    };
  }
  catch (error) {
    // eslint-disable-next-line no-constant-condition
    if (error === "Nobody's time is up!" || error === "Opponent's time isn't up!" || "Game is already over!") {
      return {
        statusCode: 200,
        body: "not_a_timeloss",
        headers
      };
    }
    logGetItemError(error);
    return formatReturnError('Unable to process check for timeloss');
  }
}

function applySimultaneousMove(userid: string, move: string, engine: GameBaseSimultaneous, game: FullGame) {
  const partialMove = game.partialMove;
  const moves = partialMove === undefined ? game.players.map(() => '') : partialMove.split(',');
  let cnt = 0;
  let found = false;
  for (let i = 0; i < game.numPlayers; i++) {
    if (game.players[i].id === userid) {
      found = true;
      if (moves[i] !== '' || !game.toMove[i]) {
        throw new Error('You have already submitted your move for this turn!');
      }
      moves[i] = move;
      (game.toMove as boolean[])[i] = false;
    }
    // check if current player is eliminated and insert a blank move
    // all simultaneous games should accept the character U+0091 as a blank move for eliminated players
    if (engine.isEliminated(i + 1)) {
      moves[i] = '\u0091';
    }
    if (moves[i] !== '')
      cnt++;
  }
  if (!found) {
    throw new Error('You are not participating in this game!');
  }
  if (cnt < game.numPlayers) {
    // not a complete "turn" yet, just validate and save the new partial move
    game.partialMove = moves.join(',');
    console.log(game.partialMove);
    engine.move(game.partialMove, { partial: true });
  }
  else {
    // full move.
    engine.move(moves.join(','));
    game.state = engine.serialize();
    game.partialMove = game.players.map(() => '').join(',');
    if (engine.gameover) {
      game.toMove = "";
      game.winner = engine.winner;
      game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
    }
    else {
      game.toMove = game.players.map((p, i) => !engine.isEliminated(i + 1));
    }
  }
}

// Helper to find a child in exploration that matches a move using engine.sameMove
function findExplorationChild(exploration: Exploration[] | null | undefined, move: string, engine: GameBase): Exploration | null {
  if (!exploration) return null;
  for (const child of exploration) {
    // @ts-ignore - sameMove exists on game engines
    if (engine.sameMove(move, child.move as unknown as string)) {
      return child;
    }
  }
  return null;
}

// Helper to find a premove child in exploration
function findPremoveChild(exploration: Exploration[] | null | undefined): Exploration | null {
  if (!exploration) return null;
  return exploration.find(child => child.premove === true) || null;
}

// Helper to apply forced moves (automove/autopass) and return true if any were applied
function findForcedMove(engine: GameBase, flags: string[]): string {
  let forcedMove = null;
  if (flags !== undefined && flags.includes("automove") && !engine.gameover) {
    // @ts-ignore
    if (engine.moves().length === 1 && !(flags.includes("pie-even") && engine.state().stack.length === 2)) {
      // @ts-ignore
      forcedMove = engine.moves()[0];
      console.log(`Found forced move: ${forcedMove}`);
    }
  } else if (flags !== undefined && flags.includes("autopass") && !engine.gameover) {
    // @ts-ignore
    if (engine.moves().length === 1 && engine.moves()[0] === "pass" && !(flags.includes("pie-even") && engine.state().stack.length === 2)) {
      console.log(`Applying forced pass`);
      // @ts-ignore
      forcedMove = engine.moves()[0];
      console.log(`Found forced move: ${forcedMove}`);
    }
  }
  return forcedMove;
}

function applyMove(
  userid: string,
  move: string,
  moveNumber: number,
  engine: GameBase,
  game: FullGame,
  flags: string[],
  opponentExploration: Exploration[] | null = null,
  myExploration: Exploration[] | null = null
): { autoMoves: number, autoMovesPerPlayer: number[], work: Promise<any>[] } {
  // non simultaneous move game.
  if (game.players[parseInt(game.toMove as string)].id !== userid) {
    throw new Error('It is not your turn!');
  }

  const myPlayerIndex = parseInt(game.toMove as string);
  const opponentPlayerIndex = 1 - myPlayerIndex;

  // Track exploration positions for both players
  // explorations[0] is player 0's current exploration node children, explorations[1] is player 1's
  const explorations: (Exploration[] | null)[] = [null, null];
  explorations[myPlayerIndex] = myExploration;
  explorations[opponentPlayerIndex] = opponentExploration;
  console.log(`My explorations: ${JSON.stringify(explorations[myPlayerIndex])}, Opponent explorations: ${JSON.stringify(explorations[opponentPlayerIndex])}`);
  let autoMoves = 0;
  const autoMovesPerPlayer: number[] = new Array(game.players.length).fill(0);

  // Apply the initial submitted move
  console.log(`Applying submitted move: ${move}`);
  engine.move(move);

  // Main loop: handle forced moves and premoves until no more can be applied
  while (!engine.gameover && move) {
    // Update both explorations based on the applied move
    explorations[0] = findExplorationChild(explorations[0], move, engine)?.children || null;
    explorations[1] = findExplorationChild(explorations[1], move, engine)?.children || null;

    // First, apply any forced moves (automove/autopass)
    move = findForcedMove(engine, flags);
    if (!move) {
      // Check if there's a premove for the current player
      // @ts-ignore
      const currentPlayerIndex = engine.currplayer - 1;
      const currentExploration = explorations[currentPlayerIndex];
      const premoveNode = findPremoveChild(currentExploration);
      if (premoveNode) {
        move = premoveNode.move as unknown as string;
        console.log(`Applying premove for player ${currentPlayerIndex}: ${move}`);
      }
    }
    if (move) {
      // @ts-ignore
      const movedPlayerIndex = engine.currplayer - 1;
      try {
        engine.move(move);
        autoMoves += 1;
        autoMovesPerPlayer[movedPlayerIndex] += 1;
      } catch (e) {
        console.log(`Premove ${move} is invalid!: ${e}`);
        break;
      }
    }
  }

  const work: Promise<any>[] = [];
  if (!engine.gameover) {
    if (explorations[0] && explorations[0].length > 0) {
      // save back the updated exploration for player 0
      work.push(sendCommandWithRetry<PutCommandOutput>(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          "pk": "GAMEEXPLORATION#" + game.id,
          "sk": game.players[0].id + "#" + (moveNumber + 1 + autoMoves),
          "user": game.players[0].id,
          "game": game.id,
          "move": (moveNumber + 1 + autoMoves),
          "tree": JSON.stringify(explorations[0])
        }
      })));
    }
    if (explorations[1] && explorations[1].length > 0) {
      // save back the updated exploration for player 1
      work.push(sendCommandWithRetry<PutCommandOutput>(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          "pk": "GAMEEXPLORATION#" + game.id,
          "sk": game.players[1].id + "#" + (moveNumber + 1 + autoMoves),
          "user": game.players[1].id,
          "game": game.id,
          "move": (moveNumber + 1 + autoMoves),
          "tree": JSON.stringify(explorations[1])
        }
      })));
    }
  }

  game.state = engine.serialize();
  if (engine.gameover) {
    game.toMove = "";
    game.winner = engine.winner;
    game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
  } else {
    if ((!("currplayer" in engine)) || (engine.currplayer === undefined) || (engine.currplayer === null) || (typeof engine.currplayer !== "number")) {
      throw new Error("The engine must provide a current player for `applyMove()` to be able to function.");
    }
    game.toMove = `${engine.currplayer - 1}`;
  }
  return { autoMoves, autoMovesPerPlayer, work };
}

function isInterestingComment(comment: string): boolean {
  if (!comment || comment.trim().length === 0) {
    return false;
  }
  // Normalize the comment
  const normalized = comment.toLowerCase().trim();

  // Remove punctuation for comparison
  const withoutPunctuation = normalized.replace(/[^\w\s]/g, '');

  // Common boring phrases (exact matches)
  const boringPhrases = new Set([
    'gg', 'glhf', 'gl', 'hf', 'tagg', 'hi', 'hello', 'hey',
    'thanks', 'thx', 'ty', 'yw', 'np', 'wp', 'well played',
    'good game', 'good luck', 'have fun', 'thanks for the game',
    'pie invoked', 'move', 'gg sir', 'gg!', 'tagg!', 'glhf!',
    'to a good game', 'have a good game', 'good luck!', 'have fun!',
    'thanks for playing', 'thanks for the game!', 'gg thanks',
    'yoyo', 'yoyo gl', 'yoyo gl hf'
  ]);

  // Check for exact matches (with or without punctuation)
  if (boringPhrases.has(normalized) || boringPhrases.has(withoutPunctuation)) {
    return false;
  }

  // Split into words for further analysis
  const words = withoutPunctuation.split(/\s+/).filter(w => w.length > 0);

  // Very short comments with only common game words are boring
  const commonWords = new Set([
    'gg', 'gl', 'hf', 'tagg', 'hi', 'hello', 'yoyo',
    'thanks', 'thx', 'ty', 'wp', 'move', 'pie', 'invoked',
    'good', 'game', 'luck', 'fun', 'for', 'the', 'a', 'to',
    'have', 'sir', 'well', 'played', 'you', 'too'
  ]);

  if (words.length <= 3 && words.every(w => commonWords.has(w))) {
    return false;
  }

  // If we got here, the comment is interesting
  return true;
}

// Helper function to update lastChat and seen for all players of a game
// Used by both submitComment (for in-game chats) and saveExploration (for completed game comments)
async function updateLastChatForPlayers(
  gameId: string,
  metaGame: string,
  players: { [k: string]: any; id: string }[],
  currentUserId: string,
  allowReAdd = false  // Only true for completed games via saveExploration
) {
  console.log(`Updating lastChat for all players of game ${gameId}`);

  // Lazy-loaded only if needed (when a player doesn't have the game in their list)
  let fullGame: FullGame | undefined;
  let gameEngine: any | undefined;

  const now = Date.now();

  for (const pid of players.map(p => p.id)) {
    if (await isBotId(pid)) {
      continue;
    }
    let data: any;
    let user: FullUser | undefined;
    try {
      data = await ddbDocClient.send(
        new GetCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "USER",
            "sk": pid
          },
        })
      );
      if (data.Item !== undefined) {
        user = data.Item as FullUser;
      }
    } catch (err) {
      logGetItemError(err);
      console.log(`Unable to get user data for user ${pid} when updating lastChat`);
      continue; // Don't fail the whole operation
    }

    if (user === undefined) {
      console.log(`Unable to get user data for user ${pid} when updating lastChat`);
      continue; // Don't fail the whole operation
    }

    const game = user.games?.find(g => g.id === gameId);

    if (game !== undefined) {
      game.lastChat = now;
      // if this is the user who added the comment/exploration, also update their `seen`
      // so it doesn't get flagged as new
      if (pid === currentUserId) {
        game.seen = now + 10;
      }
      await updateUserGames(pid, user.gamesUpdate, [gameId], user.games);
      console.log(`Updated lastChat for user ${user.name} on game ${gameId}`);
    } else if (allowReAdd) {
      // Only try to re-add for completed games (when allowReAdd is true)
      console.log(`User ${user.name} does not have a game entry for ${gameId}, re-adding it`);

      // Fetch the full game only once (lazy loading)
      if (fullGame === undefined) {
        try {
          const gameData = await ddbDocClient.send(
            new GetCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              Key: {
                "pk": "GAME",
                "sk": `${metaGame}#1#${gameId}`
              },
            })
          );
          if (gameData.Item !== undefined) {
            fullGame = hydrateGameState(gameData.Item as FullGame);
            gameEngine = GameFactory(metaGame, fullGame.state);
            if (gameEngine === undefined) {
              console.log(`Unable to hydrate state for ${metaGame}`);
              fullGame = undefined; // Mark as invalid
            }
          }
        } catch (err) {
          console.log(`Failed to get completed game ${gameId} for re-adding to user's list:`, err);
        }
      }

      if (fullGame !== undefined && gameEngine !== undefined) {
        const newGame: Game = {
          id: gameId,
          metaGame: metaGame,
          players: [...fullGame.players], // This has the full User objects with time, etc.
          lastMoveTime: fullGame.lastMoveTime,
          clockHard: fullGame.clockHard,
          toMove: fullGame.toMove || "",
          numMoves: gameEngine.stack.length - 1,
          gameStarted: fullGame.gameStarted || new Date(gameEngine.stack[0]._timestamp).getTime(),
          gameEnded: fullGame.gameEnded || new Date(gameEngine.stack[gameEngine.stack.length - 1]._timestamp).getTime(),
          lastChat: now,
          seen: pid === currentUserId ? now + 10 : undefined,
        };

        if (!user.games) {
          user.games = [];
        }
        user.games.push(newGame);
        await updateUserGames(pid, user.gamesUpdate, [gameId], user.games);
        console.log(`Re-added completed game ${gameId} to user ${user.name}'s games list`);
      } else {
        console.log(`Could not re-add game ${gameId} to user ${user.name}'s list - failed to fetch game data`);
      }
    } else {
      // In-game comment but user doesn't have the game - this shouldn't happen
      console.log(`Warning: User ${user.name} doesn't have in-progress game ${gameId} in their list`);
    }
  }
}

async function submitComment(userid: string, pars: { id: string; metaGame: string; players?: { [k: string]: any; id: string }[]; comment: string; moveNumber: number; }) {
  // reject empty comments
  if ((pars.comment.length === 0) || (/^\s*$/.test(pars.comment))) {
    return formatReturnError(`Refusing to accept blank comment.`);
  }
  if (!pars.metaGame) {
    return formatReturnError(`metaGame is required.`);
  }

  try {
    const auth = await checkInGameCommentAuth(
      ddbDocClient,
      process.env.ABSTRACT_PLAY_TABLE!,
      userid,
      pars.metaGame,
      pars.id,
    );
    if (!auth.ok) {
      return {
        statusCode: 401,
        body: JSON.stringify({ message: auth.message }),
        headers,
      };
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to verify permissions for user ${userid} on game ${pars.id}`);
  }

  let data: any;
  try {
    data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAMECOMMENTS",
          "sk": pars.id
        },
      }));
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get comments for game ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  const commentsData = data.Item;
  console.log("got comments in submitComment:");
  console.log(commentsData);
  let comments: Comment[];
  if (commentsData === undefined)
    comments = []
  else
    comments = commentsData.comments;

  // Check if there were any interesting comments before adding the new one
  const hadInterestingCommentBefore = comments.some(c => isInterestingComment(c.comment));

  if (comments.reduce((s: number, a: Comment) => s + 110 + Buffer.byteLength(a.comment, 'utf8'), 0) < 360000) {
    const comment: Comment = { "comment": pars.comment.substring(0, 4000), "userId": userid, "moveNumber": pars.moveNumber, "timeStamp": Date.now() };
    comments.push(comment);
    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: {
        "pk": "GAMECOMMENTS",
        "sk": pars.id,
        "comments": comments
      }
    }));

    // Check if the new comment is interesting
    const newCommentIsInteresting = isInterestingComment(comment.comment);

    // If we didn't have interesting comments before but the new one is interesting,
    // update the GAME record to set commented = 1
    if (pars.metaGame && !hadInterestingCommentBefore && newCommentIsInteresting) {
      try {
        await ddbDocClient.send(new UpdateCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "GAME",
            "sk": pars.metaGame + "#0#" + pars.id
          },
          ExpressionAttributeValues: { ":c": 1 },
          UpdateExpression: "set commented = :c",
          ConditionExpression: "attribute_exists(pk) AND attribute_exists(sk)"
        }));
        console.log(`Updated commented flag to 1 for game ${pars.id} (first interesting comment added)`);
      } catch (error) {
        console.log(`Failed to update commented flag for game ${pars.id}:`, error);
        // Don't fail the whole operation just because of the flag update
      }
    }
  }

  // Update lastChat for all players when a comment is added to an in-game chat
  // Note: For completed games, comments go through the exploration system (saveExploration)
  if (pars.players && pars.metaGame) {
    await updateLastChatForPlayers(
      pars.id,
      pars.metaGame,
      pars.players,
      userid,
      false  // Don't re-add game to list for in-game comments
    );
  }

  if (pars.metaGame) {
    // broadcasting that state has updated
    await wsBroadcast("game", { "meta": pars.metaGame, "id": pars.id }, [userid]);
  }

  return {
    statusCode: 200,
    body: JSON.stringify({ success: true }),
    headers,
  };
}

async function saveExploration(userid: string, pars: { public: boolean, game: string; metaGame: string; move: number; version: number; tree: Exploration; updateCommentedFlag?: number; gameEnded?: number; updateLastChat?: boolean; players?: { [k: string]: any; id: string }[]; }) {
  // If we need to update the commented flag for a completed game
  if (pars.updateCommentedFlag !== undefined && pars.public && pars.gameEnded !== undefined) {
    // Update the commented flag in COMPLETEDGAMES
    try {
      await ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "COMPLETEDGAMES#" + pars.metaGame,
          "sk": pars.gameEnded + "#" + pars.game
        },
        ExpressionAttributeValues: { ":c": pars.updateCommentedFlag },
        UpdateExpression: "set commented = :c",
        ConditionExpression: "attribute_exists(pk) AND attribute_exists(sk)"
      }));
      console.log(`Updated commented flag for completed game ${pars.game} to ${pars.updateCommentedFlag}`);
    } catch (error) {
      console.log(`Failed to update commented flag for completed game ${pars.game}:`, error);
      // Don't fail the whole operation just because of the flag update
    }
  }

  // If we need to update lastChat and seen for all players (completed games only)
  if (pars.updateLastChat && pars.public && pars.players) {
    await updateLastChatForPlayers(
      pars.game,
      pars.metaGame,
      pars.players,
      userid,
      true  // Allow re-adding game to list for completed games
    );
  }

  if (!pars.public) {
    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: {
        "pk": "GAMEEXPLORATION#" + pars.game,
        "sk": userid + "#" + pars.move,
        "user": userid,
        "game": pars.game,
        "move": pars.move,
        "tree": JSON.stringify(pars.tree)
      }
    }));
  } else {
    try {
      console.log("Trying to update public exploration at key " + JSON.stringify({ "pk": "PUBLICEXPLORATION#" + pars.game, "sk": `${pars.move}` }));
      await ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "PUBLICEXPLORATION#" + pars.game, "sk": `${pars.move}` },
        ExpressionAttributeValues: { ":v": pars.version, ":inc": 1, ":t": JSON.stringify(pars.tree) },
        ExpressionAttributeNames: { "#v": "version", "#t": "tree" },
        ConditionExpression: "#v = :v",
        UpdateExpression: "set #v = :v + :inc, #t = :t"
      }));
    } catch (err: any) {
      if (err.name === 'ConditionalCheckFailedException') {
        // Either nothing here yet, or somebody else has updated the tree. Send back to the front end to merge and try to save again.
        console.log("Failed to update public exploration, trying to get it.")
        const explorationData = await ddbDocClient.send(
          new GetCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: {
              "pk": "PUBLICEXPLORATION#" + pars.game,
              "sk": `${pars.move}`
            },
          }));
        let exploration: Exploration | undefined = undefined;
        if (explorationData.Item === undefined) {
          console.log("Nothing here yet, try inserting.");
          // try to insert
          try {
            await ddbDocClient.send(new PutCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              Item: {
                "pk": "PUBLICEXPLORATION#" + pars.game,
                "sk": `${pars.move}`,
                "version": pars.version + 1,
                "game": pars.game,
                "tree": JSON.stringify(pars.tree)
              },
              ConditionExpression: "attribute_not_exists(sk)"
            }));
          }
          catch (error: any) {
            if (err.name === 'ConditionalCheckFailedException') {
              console.log("Wow, that was unlikely. Failed to insert public exploration, trying to get it.")
              // Somebody else has updated the tree. Send back to the front end to merge and try to save again.
              const explorationData = await ddbDocClient.send(
                new GetCommand({
                  TableName: process.env.ABSTRACT_PLAY_TABLE,
                  Key: {
                    "pk": "PUBLICEXPLORATION#" + pars.game,
                    "sk": `${pars.move}`
                  },
                }));
              exploration = explorationData.Item as Exploration;
            } else {
              logGetItemError(err);
              return formatReturnError(`Unable to save exploration data for game ${pars.game} move ${pars.move}`);
            }
          }
          if (exploration === undefined) {
            console.log("Successfully inserted public exploration, returning to client.");
            return;
          }
        } else {
          exploration = explorationData.Item as Exploration;
        }
        return {
          statusCode: 200,
          body: JSON.stringify(exploration),
          headers
        };
      }
      else {
        logGetItemError(err);
        return formatReturnError(`Unable to save exploration data for game ${pars.game} move ${pars.move}`);
      }
    }
  }
}

async function getExploration(userid: string, pars: { game: string; move: number }) {
  const work: Promise<any>[] = [];
  let exploration;
  try {
    // get exploration. At pars.move. submitMove now takes care of moving exploration to the current game state.
    exploration = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAMEEXPLORATION#" + pars.game,
          "sk": userid + "#" + pars.move
        },
      })
    );
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get exploration data for game ${pars.game} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  const trees = [exploration.Item, ,]; // return as an array as was done in the past. Not really needed, but makes transition safer.
  return {
    statusCode: 200,
    body: JSON.stringify(trees),
    headers
  };
}

// This is for publishing your "during game" exploration for all to see after the game ends.
async function getPrivateExploration(userid: string, pars: { id: string }) {
  let data;
  try {
    data = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "GAMEEXPLORATION#" + pars.id, ":sk": userid + "#" },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" }
      }));
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get exploration data for game ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  const trees = data.Items;
  return {
    statusCode: 200,
    body: JSON.stringify(trees),
    headers
  };
}

// Mark a game as having had its exploration (for one of the players) published.
async function markAsPublished(userid: string, pars: { id: string; metagame: string }) {
  try {
    const data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metagame + "#1#" + pars.id
        },
      }));
    if (!data.Item)
      throw new Error(`No game ${pars.metagame + "#1#" + pars.id} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);
    const game = data.Item as FullGame;
    if (!game.players.find((p: { id: any; }) => p.id === userid))
      throw new Error(`Only players can publish exploration!`);
    let published: string[] = [];
    if (game.published)
      published = game.published;
    if (published.includes(userid))
      throw new Error(`${userid} has already published for game ${pars.id}`);
    published.push(userid);
    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "GAME", "sk": pars.metagame + "#1#" + pars.id },
      ExpressionAttributeValues: { ":p": published },
      UpdateExpression: "set published = :p"
    }));
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to mark game ${pars.id} as published`);
  }
}

async function getPublicExploration(pars: { game: string }) {
  let data;
  try {
    data = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "PUBLICEXPLORATION#" + pars.game },
        ExpressionAttributeNames: { "#pk": "pk" }
      }));
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get public exploration data for game ${pars.game}`);
  }
  if (data.Items === undefined) {
    return;
  }
  console.log("Got public exploration data", data.Items);
  const trees = data.Items.map((d: any) => { return { move: d.sk, version: d.version, tree: d.tree } });
  return {
    statusCode: 200,
    body: JSON.stringify(trees),
    headers
  };
}

async function botMove(pars: { uid: string, token: string, metaGame: string, gameid: string, move: string }) {
  // validate token
  try {
    if (!validateToken(process.env.TOTP_KEY as string, pars.token, 2)) {
      return formatReturnError(`Invalid token provided: ${JSON.stringify(pars)}`);
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Something went wrong while validating the token: ${JSON.stringify(pars)}`);
  }

  // fetch game record and state
  let game: FullGame | undefined;
  try {
    const data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metaGame + "#0#" + pars.gameid
        },
      }));
    if (!data.Item)
      throw new Error(`No game ${pars.metaGame + "#0#" + pars.gameid} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);
    game = hydrateGameState(data.Item as FullGame);
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to load game ${pars.gameid} to make a bot move`);
  }

  // instantiate game object
  if (game === undefined) {
    throw new Error("Unable to load game object");
  }
  const engine = GameFactory(pars.metaGame, game.state);
  if (!engine)
    throw new Error(`Unknown metaGame ${pars.metaGame}`);

  // check for pie
  if (pars.move === "Swap") {
    return await invokePie(pars.uid, { id: pars.gameid, metaGame: pars.metaGame, cbit: 0 });
  }
  // check for triggered resignations (to clean up bot games)
  else if (pars.move === "resign") {
    return await submitMove(pars.uid, { id: pars.gameid, move: pars.move, metaGame: pars.metaGame, cbit: 0, draw: "" });
  }
  // all other moves
  else {
    // translate move
    const realmove = engine.translateAiai(pars.move);

    if (realmove === "Swap") {
      return await invokePie(pars.uid, { id: pars.gameid, metaGame: pars.metaGame, cbit: 0 });
    }

    // apply move
    return await submitMove(pars.uid, { id: pars.gameid, move: realmove, metaGame: pars.metaGame, cbit: 0, draw: "" });
  }

}

async function handleMove(claims: PartialClaims, pars: { gameid: string; move: string; metaGame: string; }) {
  const botId = claims.sub;
  console.log(`handleMove: Bot ${botId} is making move ${pars.move} in game ${pars.gameid}`);

  if (!pars.metaGame) {
    return {
      statusCode: 400,
      body: JSON.stringify({ message: "metaGame is required" }),
      headers
    };
  }

  const bot = await getBotRecord(botId);
  if (!bot) {
    return formatReturnError(`Unknown bot ${botId}`);
  }

  const game = await loadGameRecord(pars.metaGame, pars.gameid);
  if (!game) {
    return formatReturnError(`Unable to load game ${pars.gameid}`);
  }

  if (!game.players.some(p => p.id === botId)) {
    return formatReturnError(`Bot ${botId} is not a player in game ${pars.gameid}`);
  }

  const info = gameinfo.get(pars.metaGame);
  const simultaneous = info.flags !== undefined && info.flags.includes('simultaneous');
  const toMoveIds = getToMovePlayerIds(game, simultaneous);
  if (!toMoveIds.includes(botId)) {
    return formatReturnError(`It is not bot ${botId}'s turn in game ${pars.gameid}`);
  }

  return await submitMove(botId, {
    id: pars.gameid,
    move: pars.move,
    metaGame: pars.metaGame,
    cbit: 0,
    draw: "",
  });
}

async function newTournament(userid: string, pars: { metaGame: string, variants: string[] }) {
  const variantsKey = pars.variants.sort().join("|");
  const sk = pars.metaGame + "#" + variantsKey;
  let tournamentN = 0;
  let available = true;
  try {
    const tournamentNumber = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TOURNAMENTSCOUNTER",
          "sk": sk
        },
      })
    );
    if (tournamentNumber.Item !== undefined) {
      tournamentN = tournamentNumber.Item.count;
      available = tournamentNumber.Item.over;
      // console.log(`Found tournament ${sk} with count ${tournamentN} and over ${available}`);
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to fetch TOURNAMENTSCOUNTER for '${sk}'`);
  }
  if (!available) {
    return formatReturnError(`There is already a tournament for '${pars.metaGame}#${variantsKey}'`);
  }
  // Try to update counter
  try {
    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "TOURNAMENTSCOUNTER", "sk": sk },
      ExpressionAttributeValues: { ":val": tournamentN, ":inc": 1, ":zero": 0, ":f": false },
      ExpressionAttributeNames: { "#count": "count", "#over": "over" },
      ConditionExpression: "attribute_not_exists(#count) OR #count = :val",
      UpdateExpression: "set #count = if_not_exists(#count, :zero) + :inc, #over = :f"
    }));
  } catch (err: any) {
    if (err.name === 'ConditionalCheckFailedException') {
      // Failed to update TOURNAMENTSCOUNTER, probably someone else beat us to it. So no harm done.
      console.log(`Failed to update TOURNAMENTSCOUNTER for '${pars.metaGame}#${variantsKey}', count ${tournamentN} + 1`);
      return;
    }
    handleCommonErrors(err as { code: any; message: any });
    console.log(err);
    return formatReturnError(`Unable to update TOURNAMENTSCOUNTER for '${pars.metaGame}#${variantsKey}', count ${tournamentN} + 1`);
  }
  // Insert tournament
  const tournamentid = uuid();
  const data: Tournament = {
    "pk": "TOURNAMENT",
    "sk": tournamentid,
    "id": tournamentid,
    "metaGame": pars.metaGame,
    "variants": pars.variants,
    "number": tournamentN + 1,
    "started": false,
    "dateCreated": Date.now(),
    "datePreviousEnded": 0
  };
  try {
    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: data
    }));
  } catch (err) {
    handleCommonErrors(err as { code: any; message: any });
    return formatReturnError(`Unable to insert tournament for '${pars.metaGame}#${variantsKey}', count ${tournamentN} + 1`);
  }
  const ret = await joinTournament(userid, { tournamentid: tournamentid });
  if (ret === undefined) {
    return {
      statusCode: 200,
      body: "New tournament created",
      headers
    };
  } else {
    return ret;
  }
}

async function joinTournament(userid: string, pars: { tournamentid: string, once?: boolean }) {
  let tournament: Tournament;
  let playername = '';
  let once = false;
  if (pars.once !== undefined && pars.once) {
    once = true;
  }
  try {
    const tournamentGet = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TOURNAMENT",
          "sk": pars.tournamentid
        },
      }));
    const user = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USERS",
          "sk": userid
        },
      }));
    const [tournamentData, userData] = await Promise.all([tournamentGet, user]);
    if (!tournamentData.Item)
      throw new Error(`No tournament ${pars.tournamentid} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);
    tournament = tournamentData.Item as Tournament;
    playername = (userData.Item as User).name;
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournament ${pars.tournamentid} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  if (tournament.started)
    return formatReturnError(`Tournament ${pars.tournamentid} has already started`);
  const sk = `${pars.tournamentid}#1#${userid}`;
  const data: TournamentPlayer = {
    "pk": "TOURNAMENTPLAYER",
    "sk": sk,
    "playername": playername,
    "playerid": userid,
    "once": once,
  };
  try {
    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: data
    }));
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to add player ${userid} to tournament ${pars.tournamentid}`);
  }
}

async function withdrawTournament(userid: string, pars: { tournamentid: string }) {
  let tournament: Tournament;
  try {
    const tournamentData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TOURNAMENT",
          "sk": pars.tournamentid
        },
      }));
    if (!tournamentData.Item)
      throw new Error(`No tournament ${pars.tournamentid} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);
    tournament = tournamentData.Item as Tournament;
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournament ${pars.tournamentid} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  if (tournament.started)
    return formatReturnError(`Tournament ${pars.tournamentid} has already started`);
  const sk = `${pars.tournamentid}#1#${userid}`;
  try {
    await ddbDocClient.send(
      new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TOURNAMENTPLAYER", "sk": sk
        },
      })
    )
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to withdraw player ${userid} from tournament ${pars.tournamentid}`);
  }
}

async function getTournaments() {
  try {
    const tournamentsDataPromise = ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "TOURNAMENT" },
        ExpressionAttributeNames: { "#pk": "pk" }
      }));
    const tournamentPlayersDataPromise = ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "TOURNAMENTPLAYER" },
        ExpressionAttributeNames: { "#pk": "pk" }
      }));
    const [tournamentsData, tournamentPlayersData] = await Promise.all([tournamentsDataPromise, tournamentPlayersDataPromise]);
    return {
      statusCode: 200,
      body: JSON.stringify({ tournaments: tournamentsData.Items, tournamentPlayers: tournamentPlayersData.Items }),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournaments from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

async function getOldTournaments(pars: { metaGame: string }) {
  try {
    const tournamentsData = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        ExpressionAttributeValues: { ":pk": "COMPLETEDTOURNAMENT", ":sk": pars.metaGame + '#' },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
      }));
    return {
      statusCode: 200,
      body: JSON.stringify({ tournaments: tournamentsData.Items }),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournaments from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

async function archiveTournaments() {
  try {
    const tournamentsData = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "TOURNAMENT" },
        ExpressionAttributeNames: { "#pk": "pk" }
      }));
    // Check for "old" tournaments and "archive" them. Old = the next one already ended or ended more than 6 months ago.
    const latestCompleted: Map<string, number> = new Map();
    for (const tournament of tournamentsData.Items as Tournament[]) {
      if (tournament.dateEnded !== undefined) {
        const key = tournament.metaGame + "#" + tournament.variants.sort().join("|");
        const latest = latestCompleted.get(key);
        if (latest === undefined || tournament.dateEnded > latest) {
          latestCompleted.set(key, tournament.dateEnded);
        }
      }
    }
    const now = Date.now();
    const work: Promise<any>[] = [];
    const list: string[] = [];
    for (const tournament of tournamentsData.Items as Tournament[]) {
      if (tournament.dateEnded !== undefined) {
        const key = tournament.metaGame + "#" + tournament.variants.sort().join("|");
        if (tournament.dateEnded < latestCompleted.get(key)! || tournament.dateEnded < now - 1000 * 60 * 60 * 24 * 30 * 60) {
          work.push(archiveTournament(tournament));
          list.push(tournament.id);
        }
      }
    }
    await Promise.all(work);
    return {
      statusCode: 200,
      body: JSON.stringify({ message: "Archived old tournaments: " + list.join(", ") }),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournaments from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
}

async function archiveTournament(tournament: Tournament) {
  try {
    // Now that player won't change anymore, just add them to the tournament record and (more importantly) get them out of the TOURNAMENTPLAYER list
    const tournamentPlayersData = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        ExpressionAttributeValues: { ":pk": "TOURNAMENTPLAYER", ":sk": tournament.id + '#' },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
      })
    );
    const players = tournamentPlayersData.Items as TournamentPlayer[];

    // Get all tournament games so we can update their tournament references
    const tournamentGamesData = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        ExpressionAttributeValues: { ":pk": "TOURNAMENTGAME", ":sk": tournament.id + '#' },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
      })
    );
    const tournamentGames = tournamentGamesData.Items as TournamentGame[];

    // add archive (by metaGame)
    tournament.pk = "COMPLETEDTOURNAMENT";
    tournament.sk = tournament.metaGame + "#" + tournament.id;
    tournament.players = players;
    const work: Promise<any>[] = [];
    work.push(ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: tournament
    })));

    // Update all games to reference the new archived tournament format
    const newTournamentRef = tournament.metaGame + "#" + tournament.id;
    for (const tournamentGame of tournamentGames) {
      // Update completed games (all tournament games should be completed when archiving)
      work.push(ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "GAME", "sk": tournament.metaGame + '#1#' + tournamentGame.id },
        ExpressionAttributeValues: { ":newTournamentRef": newTournamentRef },
        UpdateExpression: "set tournament = :newTournamentRef",
      })));
    }

    // delete tournament
    work.push(ddbDocClient.send(
      new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TOURNAMENT",
          "sk": tournament.id
        },
      })
    ));
    // and tournament players
    for (const player of players) {
      work.push(ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "TOURNAMENTPLAYER",
            "sk": player.sk
          },
        })
      ));
    }
    return Promise.all(work);
  }
  catch (error) {
    logGetItemError(error);
  }
}

// gameId is only passed if we got here from a user that clicked on the "tournament" link in the game (and is used to fix broken references)
async function getTournament(pars: { tournamentid: string, metaGame: string, isArchived?: string, gameId?: string }) {
  try {
    const work: Promise<any>[] = [];
    const isArchived = pars.isArchived === 'true';
    let completedTournament = false;

    if (!isArchived) {
      // Look in active tournaments
      work.push(ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          ExpressionAttributeValues: { ":pk": "TOURNAMENT", ":sk": pars.tournamentid },
          ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
          KeyConditionExpression: "#pk = :pk and #sk = :sk",
        })
      ));
      work.push(ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          ExpressionAttributeValues: { ":pk": "TOURNAMENTPLAYER", ":sk": pars.tournamentid + '#' },
          ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
          KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        })
      ));
    } else {
      // Look in completed tournaments
      work.push(ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          ExpressionAttributeValues: { ":pk": "COMPLETEDTOURNAMENT", ":sk": pars.metaGame + '#' + pars.tournamentid },
          ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
          KeyConditionExpression: "#pk = :pk and #sk = :sk",
        })
      ));
      completedTournament = true;
    }

    work.push(ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        ExpressionAttributeValues: { ":pk": "TOURNAMENTGAME", ":sk": pars.tournamentid + '#' },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
      })
    ));

    const data = await Promise.all(work);

    // If tournament not found in active tournaments and we have gameId and metaGame, try archived
    if (!isArchived && pars.metaGame !== 'undefined' && data[0].Items.length === 0 && pars.gameId) {
      console.log(`Tournament ${pars.tournamentid} not found in active tournaments, trying completed tournaments`);

      const completedTournamentData = await ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          ExpressionAttributeValues: { ":pk": "COMPLETEDTOURNAMENT", ":sk": pars.metaGame + '#' + pars.tournamentid },
          ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
          KeyConditionExpression: "#pk = :pk and #sk = :sk",
        })
      );

      if (completedTournamentData.Items && completedTournamentData.Items.length > 0) {
        console.log(`Found tournament ${pars.tournamentid} in completed tournaments, fixing game reference`);
        completedTournament = true;

        // Update the game's tournament reference to point to the new archived format
        const newTournamentRef = pars.metaGame + '#' + pars.tournamentid;

        // Since tournament is archived, all games must be completed - update completed game
        await ddbDocClient.send(new UpdateCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: { "pk": "GAME", "sk": pars.metaGame + '#1#' + pars.gameId },
          ExpressionAttributeValues: { ":newTournamentRef": newTournamentRef },
          UpdateExpression: "set tournament = :newTournamentRef",
        }));

        // Replace the empty tournament data with the found completed tournament
        data[0] = completedTournamentData;
      }
    }

    if (!completedTournament) {
      return {
        statusCode: 200,
        body: JSON.stringify({
          tournament: data[0].Items,
          tournamentPlayers: data[1]?.Items || [],
          tournamentGames: data[2].Items
        }),
        headers
      };
    } else {
      return {
        statusCode: 200,
        body: JSON.stringify({
          tournament: data[0].Items,
          tournamentPlayers: [],
          tournamentGames: isArchived ? data[1].Items : data[2].Items
        }),
        headers
      };
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournament ${pars.tournamentid}. Error: ${error}`);
  }
}

async function startTournaments() {
  let count = 0;
  let newcount = 0;
  let cancelledcount = 0;
  let waitingcount = 0;
  try {
    console.log("Getting TOURNAMENTs");
    const tournamentsData = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "TOURNAMENT" },
        ExpressionAttributeNames: { "#pk": "pk" }
      }));
    const tournaments = tournamentsData.Items as Tournament[];
    console.log("Getting USERS");
    const data = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "USERS" },
        ExpressionAttributeNames: { "#pk": "pk", "#name": "name" },
        ProjectionExpression: "sk, #name, lastSeen"
      }));

    let users: UserLastSeen[] = [];
    if (data.Items)
      users = data.Items?.map(u => ({ "id": u.sk, "name": u.name, "lastSeen": u.lastSeen }));
    const now = Date.now();
    const oneWeek = 1000 * 60 * 60 * 24 * 7;
    const twoWeeks = oneWeek * 2;
    console.log(`Found ${tournaments.length} tournaments`);
    for (const tournament of tournaments) {
      if (
        !tournament.started && now > tournament.dateCreated + twoWeeks
        && (tournament.datePreviousEnded === 0 || now > tournament.datePreviousEnded + oneWeek)
      ) {
        console.log(`Starting tournament ${tournament.id}`);
        const status = await startTournament(users, tournament);
        if (status === -1) {
          cancelledcount++;
        } else if (status === 0) {
          waitingcount++;
        } else if (status === 1) {
          newcount++;
        }
      }
    }
    count = tournaments.length;
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournaments from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Checked ${count} tournaments, started ${newcount} new tournaments, waiting for ${waitingcount} tournaments and cancelled ${cancelledcount} tournaments`
    }),
    headers
  };
}

async function startATournament(userId: string, pars: { tournamentid: string }) {
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get user ${userId}. Error: ${error}`);
  }
  let tournament: Tournament;
  try {
    const tournamentData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TOURNAMENT",
          "sk": pars.tournamentid
        },
      }));
    if (!tournamentData.Item)
      throw new Error(`No tournament ${pars.tournamentid} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);
    tournament = tournamentData.Item as Tournament;
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournament ${pars.tournamentid} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  const now = Date.now();
  const oneWeek = 1000 * 60 * 60 * 24 * 7;
  const twoWeeks = oneWeek * 2;
  if (
    !tournament.started && now > tournament.dateCreated + twoWeeks
    && (tournament.datePreviousEnded === 0 || now > tournament.datePreviousEnded + oneWeek)
  ) {
    console.log("Getting USERS");
    const data = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "USERS" },
        ExpressionAttributeNames: { "#pk": "pk", "#name": "name" },
        ProjectionExpression: "sk, #name, lastSeen"
      }));

    let users: UserLastSeen[] = [];
    if (data.Items)
      users = data.Items?.map(u => ({ "id": u.sk, "name": u.name, "lastSeen": u.lastSeen }));
    console.log(`Starting tournament ${tournament.id}`);
    if (await startTournament(users, tournament)) {
      return {
        statusCode: 200,
        body: JSON.stringify({
          message: "Started"
        }),
        headers
      };
    } else {
      return {
        statusCode: 200,
        body: JSON.stringify({
          message: "Failed to start"
        }),
        headers
      };
    }
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: `Tournament ${tournament.id} either already started, or not ready to start.`
    }),
    headers
  };
}

async function startTournament(users: UserLastSeen[], tournament: Tournament) {
  // First, get the players
  let playersData;
  try {
    playersData = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        ExpressionAttributeValues: { ":pk": "TOURNAMENTPLAYER", ":sk": tournament.id + '#1#' },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
      })
    );
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get players for tournament ${tournament.id} from table ${process.env.ABSTRACT_PLAY_TABLE}. Error: ${error}`);
  }
  const players0 = playersData.Items as TournamentPlayer[];
  const remove: TournamentPlayer[] = [];
  const players = players0.filter((player, i) => {
    // If the player timed out in their last tournament game, and they haven't been seen in 30 days, remove them from the tournament.
    // Unless the tournament is in waiting status, then not seen in 30 days is enough to be removed.
    if (
      users?.find(u => u.id === player.playerid)?.lastSeen! < Date.now() - 1000 * 60 * 60 * 24 * 30
      && (tournament.waiting === true || player.timeout === true)
    ) {
      remove.push(player);
      if (player.timeout === true)
        console.log(`Removing player ${player.playerid} from tournament ${tournament.id} because of timeout`);
      else
        console.log(`Removing player ${player.playerid} from tournament ${tournament.id} because they haven't been seen in 30 days`);
      return false;
    } else
      return true;
  });
  let returnvalue = 0;
  if (players.length == 0) {
    // Cancel tournament. Everyone is gone.
    try {
      console.log(`Deleting tournament ${tournament.id}`);
      await ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "TOURNAMENT",
            "sk": tournament.id
          },
        }));
      const sk = tournament.metaGame + "#" + tournament.variants.sort().join("|");
      await ddbDocClient.send(
        new UpdateCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: { "pk": "TOURNAMENTSCOUNTER", "sk": sk },
          ExpressionAttributeValues: { ":t": true },
          ExpressionAttributeNames: { "#o": "over" },
          UpdateExpression: "set #o = :t"
        }));
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to delete tournament ${tournament.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
    }
    /*
    try {
      for (let player of players0) {
        work.push(ddbDocClient.send(
          new DeleteCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: {
              "pk": "TOURNAMENTPLAYER",
              "sk": player.sk
            },
          })));
      }
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to delete tournament players from table ${process.env.ABSTRACT_PLAY_TABLE}`);
    }
    // Send email to players
    await initi18n('en');
    const metaGameName = gameinfo.get(tournament.metaGame)?.name;
    for (let player of playersFull) {
      await changeLanguageForPlayer(player);
      let body = '';
      if (tournament.variants.length === 0)
        body = i18n.t("TournamentCancelBody", { "metaGame": metaGameName, "number": tournament.number });
      else
        body = i18n.t("TournamentCancelBodyVariants", { "metaGame": metaGameName, "number": tournament.number, "variants": tournament.variants.join(", ") });
      if ( (player.email !== undefined) && (player.email !== null) && (player.email !== "") )  {
        const comm = createSendEmailCommand(player.email, player.name, i18n.t("TournamentCancelSubject", { "metaGame": metaGameName }), body);
        work.push(sesClient.send(comm));
      }
    }
    await Promise.all(work);
    console.log("Tournament cancelled");
    */
    returnvalue = -1;
  } else if (players.length < 4) {
    // Not enough players yet
    if (tournament.waiting !== true) {
      try {
        console.log(`Updating tournament ${tournament.id} to waiting`);
        await ddbDocClient.send(new UpdateCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: { "pk": "TOURNAMENT", "sk": tournament.id },
          ExpressionAttributeValues: { ":t": true },
          UpdateExpression: "set waiting = :t"
        }));
      }
      catch (error) {
        logGetItemError(error);
        return formatReturnError(`Unable to update tournament ${tournament.id} to waiting`);
      }
    }
    returnvalue = 0;
  } else {
    // enough players, start the tournament!
    const clockStart = 72;
    const clockInc = 36;
    const clockMax = 120;
    // Sort players into divisions by rating
    const playersFull = await getPlayersSlowly(players.map(p => p.playerid));
    for (let i = 0; i < playersFull.length; i++) {
      players[i].rating = playersFull[i]?.ratings?.[tournament.metaGame]?.rating;
      if (players[i].rating === undefined)
        players[i].rating = 0;
      players[i].score = 0;
    }
    players.sort((a, b) => b.rating! - a.rating!);
    const allGamePlayers = players.map(p => { return { id: p.playerid, name: p.playername, time: clockStart * 3600000 } as User });
    // Sort playersFull in the same order as players
    const playersFull2: FullUser[] = [];
    for (const player of players)
      playersFull2.push(playersFull.find(p => p.id === player.playerid)!);
    // Create divisions
    const numDivisions = Math.ceil(players.length / 10.0); // at most 10 players per division
    const divisionSizeSmall = Math.floor(players.length / numDivisions);
    const numBigDivisions = players.length - divisionSizeSmall * numDivisions; // big divisions have one more player than small divisions!
    // Sort players into divisions by rating
    players.sort((a, b) => b.rating! - a.rating!);
    let division = 1;
    let count = 0;
    for (const player of players) {
      player.division = division;
      player.sk = tournament.id + "#" + division.toString() + '#' + player.playerid;
      try {
        console.log(`Adding player ${player.playerid} to tournament ${tournament.id} in division ${division}`);
        await ddbDocClient.send(new PutCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Item: player
        }));
      }
      catch (error) {
        logGetItemError(error);
        return formatReturnError(`Unable to add player ${player.playerid} to tournament ${tournament.id} with division ${division}. Error ${error}`);
      }
      if (division > 1) {
        try {
          console.log(`Deleting player ${player.playerid} from tournament ${tournament.id} with division 1 (so they can be put in the right division)`);
          await ddbDocClient.send(new DeleteCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: {
              "pk": "TOURNAMENTPLAYER", "sk": tournament.id + "#1#" + player.playerid
            },
          }));
        }
        catch (error) {
          logGetItemError(error);
          return formatReturnError(`Unable to delete player ${player.playerid} from tournament ${tournament.id} with division 1. Error ${error}`);
        }
      }
      count++;
      if ((division > numBigDivisions && count === divisionSizeSmall) || (division <= numBigDivisions && count === divisionSizeSmall + 1)) {
        division++;
        count = 0;
      }
    }
    // Create games
    const now = Date.now();
    let player0 = 0;
    const updatedGameIDs: string[][] = [];
    for (let i = 0; i < players.length; i++) {
      updatedGameIDs.push([]);
      if (playersFull2[i].games === undefined)
        playersFull2[i].games = [];
    }
    const divisions: { [division: number]: { numGames: number, numCompleted: number, processed: boolean } } = {};
    for (let division = 1; division <= numDivisions; division++) {
      divisions[division] = { numGames: 0, numCompleted: 0, processed: false };
      for (let i = 0; i < (division <= numBigDivisions ? divisionSizeSmall + 1 : divisionSizeSmall); i++) {
        for (let j = i + 1; j < (division <= numBigDivisions ? divisionSizeSmall + 1 : divisionSizeSmall); j++) {
          divisions[division].numGames += 1;
          const player1 = player0 + i;
          const player2 = player0 + j;
          const gameId = uuid();
          const gamePlayers: User[] = [];
          if ((i + j) % 2 === 1) {
            gamePlayers.push(allGamePlayers[player1]);
            gamePlayers.push(allGamePlayers[player2]);
          } else {
            gamePlayers.push(allGamePlayers[player2]);
            gamePlayers.push(allGamePlayers[player1]);
          }
          let whoseTurn: string | boolean[] = "0";
          const info = gameinfo.get(tournament.metaGame);
          if (info.flags !== undefined && info.flags.includes('simultaneous')) {
            whoseTurn = gamePlayers.map(() => true);
          }
          const variants = tournament.variants;
          let engine;
          if (info.playercounts.length > 1)
            engine = GameFactory(tournament.metaGame, 2, variants);
          else
            engine = GameFactory(tournament.metaGame, undefined, variants);
          if (!engine)
            throw new Error(`Unknown metaGame ${tournament.metaGame}`);
          const state = engine.serialize();
          try {
            console.log(`Creating game ${gameId} for tournament ${tournament.id} with division ${division}`);
            await ddbDocClient.send(new PutCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              Item: prepareGameStateForStorage({
                "pk": "GAME",
                "sk": tournament.metaGame + "#0#" + gameId,
                "id": gameId,
                "metaGame": tournament.metaGame,
                "numPlayers": 2,
                "rated": true,
                "players": info.flags !== undefined && info.flags.includes('perspective') ?
                  gamePlayers.map((p, ind) => { return (ind === 0 ? p : { ...p, settings: { "rotate": 180 } }) })
                  : gamePlayers,
                "clockStart": clockStart,
                "clockInc": clockInc,
                "clockMax": clockMax,
                "clockHard": true,
                "state": state,
                "toMove": whoseTurn,
                "lastMoveTime": now,
                "gameStarted": now,
                "variants": engine.variants,
                "tournament": tournament.id,
                "division": division
              })
            }));
          }
          catch (error) {
            logGetItemError(error);
            return formatReturnError(`Unable to create game ${gameId} for tournament ${tournament.id} with division ${division}. Error ${error}`);
          }
          // this should be all the info we want to show on the "my games" summary page.
          const game = {
            "id": gameId,
            "metaGame": tournament.metaGame,
            "players": gamePlayers,
            "clockHard": true,
            "toMove": whoseTurn,
            "lastMoveTime": now,
            "variants": engine.variants,
          } as Game;
          console.log(`Adding game ${gameId} to game lists`);
          await addToGameLists("CURRENTGAMES", game, now, false);
          const tournamentGame = {
            "pk": "TOURNAMENTGAME",
            "sk": tournament.id + "#" + division.toString() + '#' + gameId,
            "id": gameId,
            "player1": gamePlayers[0].id,
            "player2": gamePlayers[1].id
          };
          console.log(`Adding game ${gameId} to TOURNAMENTGAME list`);
          await ddbDocClient.send(new PutCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Item: tournamentGame
          }));
          // Update players
          playersFull2[player1].games.push(game);
          updatedGameIDs[player1].push(game.id);
          playersFull2[player2].games.push(game);
          updatedGameIDs[player2].push(game.id);
        }
      }
      player0 += division <= numBigDivisions ? divisionSizeSmall + 1 : divisionSizeSmall;
    }
    for (let i = 0; i < playersFull2.length; i++) {
      console.log(`Updating games for player ${playersFull2[i].id}`);
      await updateUserGames(playersFull2[i].id, playersFull2[i].gamesUpdate, updatedGameIDs[i], playersFull2[i].games);
    }
    const newTournamentid = uuid();
    console.log(`Updating tournament ${tournament.id} to started`);
    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "TOURNAMENT", "sk": tournament.id },
      ExpressionAttributeValues: { ":dt": now, ":t": true, ":nextid": newTournamentid, ":ds": divisions },
      UpdateExpression: "set started = :t, dateStarted = :dt, nextid = :nextid, divisions = :ds"
    }));
    // open next tournament for sign-up.
    console.log(`Opening next tournament ${newTournamentid} for sign-up. Update TOURNAMENTSCOUNTER for '${tournament.metaGame}#${tournament.variants.sort().join("|")}'`);
    try {
      await ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "TOURNAMENTSCOUNTER", "sk": tournament.metaGame + "#" + tournament.variants.sort().join("|") },
        ExpressionAttributeValues: { ":inc": 1, ":f": false },
        ExpressionAttributeNames: { "#count": "count", "#over": "over" },
        UpdateExpression: "set #count = #count + :inc, #over = :f"
      }));
    } catch (err) {
      logGetItemError(err);
      return formatReturnError(`Unable to update TOURNAMENTSCOUNTER for '${tournament.metaGame}#${tournament.variants.sort().join("|")}'. Error: ${err}`);
    }
    const data = {
      "pk": "TOURNAMENT",
      "sk": newTournamentid,
      "id": newTournamentid,
      "metaGame": tournament.metaGame,
      "variants": tournament.variants,
      "number": tournament.number + 1,
      "started": false,
      "dateCreated": now,
      "datePreviousEnded": 3000000000000
    };
    console.log(`Creating new tournament ${newTournamentid}`);
    try {
      await ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: data
      }));
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to insert new tournament ${newTournamentid}. Error: ${error}`);
    }
    // ... and register all current players for it
    for (const player of players) {
      let once = false;
      if (player.once !== undefined && player.once) {
        once = true;
      }
      if (!once) {
        const sk = `${newTournamentid}#1#${player.playerid}`;
        const playerdata: TournamentPlayer = {
          "pk": "TOURNAMENTPLAYER",
          "sk": sk,
          "playername": player.playername,
          "playerid": player.playerid,
        };
        try {
          console.log(`Adding player ${player.playerid} to new tournament ${newTournamentid}`);
          await ddbDocClient.send(new PutCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Item: playerdata
          }));
        } catch (err) {
          logGetItemError(err);
          return formatReturnError(`Unable to add player ${player.playerid} to tournament ${newTournamentid}`);
        }
      }
    }
    // Send e-mails to participants
    await initi18n('en');
    const metaGameName = gameinfo.get(tournament.metaGame)?.name;
    for (const player of playersFull2) {
      console.log(`Determining whether to send tournamentStart email to the following player:\n${JSON.stringify(player)}`);
      // eslint-disable-next-line no-prototype-builtins
      if ((player.settings?.all?.notifications === undefined) || (!player.settings.all.notifications.hasOwnProperty("tournamentStart")) || (player.settings.all.notifications.tournamentStart)) {
        console.log("Sending email");
        await changeLanguageForPlayer(player);
        let body = '';
        if (tournament.variants.length === 0)
          body = i18n.t("TournamentStartBody", { "metaGame": metaGameName, "number": tournament.number });
        else
          body = i18n.t("TournamentStartBodyVariants", { "metaGame": metaGameName, "number": tournament.number, "variants": tournament.variants.join(", ") });
        if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
          const comm = createSendEmailCommand(player.email, player.name, i18n.t("TournamentStartSubject", { "metaGame": metaGameName }), body);
          await sesClient.send(comm);
        }
        await sendPush({
          userId: player.id,
          topic: "tournament",
          title: i18n.t("PUSH.titles.tournament"),
          body,
          url: "/tournaments",
        });
      }
    }
    returnvalue = 1;
  }
  // Delete mia players
  if (remove.length > 0) {
    for (const player of remove) {
      console.log(`Deleting tournament player record for ${player.playerid} from tournament ${tournament.id}`);
      await ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "TOURNAMENTPLAYER", "sk": player.sk
          },
        })
      );
    }
    // Let them know they've been removed
    let playersFull: FullUser[] = [];
    try {
      playersFull = await getPlayersSlowly(remove.map(p => p.playerid));
    } catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to get removed players for tournament ${tournament.id} from table ${process.env.ABSTRACT_PLAY_TABLE}. Error: ${error}`);
    }
    await initi18n('en');
    const metaGameName = gameinfo.get(tournament.metaGame)?.name;
    for (const player of playersFull) {
      try {
        await changeLanguageForPlayer(player);
        let body = '';
        if (tournament.variants.length === 0)
          body = i18n.t("TournamentRemoveBody", { "metaGame": metaGameName, "number": tournament.number });
        else
          body = i18n.t("TournamentRemoveBodyVariants", { "metaGame": metaGameName, "number": tournament.number, "variants": tournament.variants.join(", ") });
        if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
          const comm = createSendEmailCommand(player.email, player.name, i18n.t("TournamentRemoveSubject", { "metaGame": metaGameName }), body);
          await sesClient.send(comm);
        }
        await sendPush({
          userId: player.id,
          topic: "tournament",
          title: i18n.t("PUSH.titles.tournament"),
          body,
          url: "/tournaments",
        });
      } catch (error) {
        logGetItemError(error);
        return formatReturnError(`Failed to send email to player ${player.name}, ${player.email}. Error: ${error}`);
      }
    }
  }
  return returnvalue;
}

async function endATournament(userId: string, pars: { tournamentid: string }) {
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get user ${userId}. Error: ${error}`);
  }
  let tournament: Tournament;
  try {
    const tournamentData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "TOURNAMENT",
          "sk": pars.tournamentid
        },
      }));
    if (!tournamentData.Item)
      throw new Error(`No tournament ${pars.tournamentid} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);
    tournament = tournamentData.Item as Tournament;
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get tournament ${pars.tournamentid} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  return endTournament(tournament);
}

async function endTournament(tournament: Tournament) {
  try {
    if (tournament.divisions) {
      const work: Promise<any>[] = [];
      let alldone = true;
      let tournamentUpdated = false;
      for (const [divisionNumber, division] of Object.entries(tournament.divisions)) {
        if (division.numCompleted < division.numGames) {
          alldone = false;
        }
        if (division.numCompleted === division.numGames && !division.processed) {
          // Get games
          const work2: Promise<QueryCommandOutput>[] = [];
          work2.push(sendCommandWithRetry<QueryCommandOutput>(
            new QueryCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
              ExpressionAttributeValues: { ":pk": "TOURNAMENTGAME", ":sk": tournament.id + '#' + divisionNumber + '#' },
              ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
            })));
          // And players (we need the ratings at the start of the tournament)
          work2.push(sendCommandWithRetry<QueryCommandOutput>(
            new QueryCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              ExpressionAttributeValues: { ":pk": "TOURNAMENTPLAYER", ":sk": tournament.id + '#' + divisionNumber + '#' },
              ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
              KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
            })));
          const [gamesData, playersData] = await Promise.all(work2);
          const gamelist = gamesData.Items as TournamentGame[];
          const players = playersData.Items as TournamentPlayer[];
          const tournamentPlayers: Map<string, TournamentPlayer> = new Map();
          for (let i = 0; i < players.length; i++) {
            players[i].tiebreak = 0;
            players[i].score = 0;
            tournamentPlayers.set(players[i].playerid, players[i]);
          }
          for (const game of gamelist) {
            if (game.winner?.length === 2) {
              tournamentPlayers.get(game.player1)!.score! += 0.5;
              tournamentPlayers.get(game.player2)!.score! += 0.5;
            } else {
              tournamentPlayers.get(game.winner![0])!.score! += 1;
            }
          }
          for (const game of gamelist) {
            if (game.winner?.length === 2) {
              tournamentPlayers.get(game.player1)!.tiebreak! += tournamentPlayers.get(game.player2)!.score! / 2;
              tournamentPlayers.get(game.player2)!.tiebreak! += tournamentPlayers.get(game.player1)!.score! / 2;
            } else if (game.winner![0] === game.player1) {
              tournamentPlayers.get(game.player1)!.tiebreak! += tournamentPlayers.get(game.player2)!.score!;
            } else {
              tournamentPlayers.get(game.player2)!.tiebreak! += tournamentPlayers.get(game.player1)!.score!;
            }
          }
          // Find winner
          let bestScore = 0;
          let bestTiebreak = 0;
          let bestRating = 0;
          let bestPlayer = '';
          let bestPlayerName = '';
          for (const player of players) {
            if (player.score! > bestScore) {
              bestScore = player.score!;
              bestTiebreak = player.tiebreak!;
              bestRating = player.rating!;
              bestPlayer = player.playerid;
              bestPlayerName = player.playername;
            } else if (player.score! === bestScore) {
              if (player.tiebreak! > bestTiebreak) {
                bestTiebreak = player.tiebreak!;
                bestRating = player.rating!;
                bestPlayer = player.playerid;
                bestPlayerName = player.playername;
              } else if (player.tiebreak! === bestTiebreak) {
                if (player.rating! > bestRating) {
                  bestRating = player.rating!;
                  bestPlayer = player.playerid;
                  bestPlayerName = player.playername;
                }
              }
            }
          }
          division.processed = true;
          division.winnerid = bestPlayer;
          division.winner = bestPlayerName;
          // Update tournament players
          for (const player of players) {
            work.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              Key: { "pk": "TOURNAMENTPLAYER", "sk": `${tournament.id}#${divisionNumber}#${player.playerid}` },
              ExpressionAttributeNames: { "#t": "tiebreak" },
              ExpressionAttributeValues: { ":t": player.tiebreak },
              UpdateExpression: "set #t = :t"
            })));
            if (player.timeout) {
              work.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
                TableName: process.env.ABSTRACT_PLAY_TABLE,
                Key: { "pk": "TOURNAMENTPLAYER", "sk": `${tournament.nextid}#1#${player.playerid}` },
                ExpressionAttributeNames: { "#t": "timeout" },
                ExpressionAttributeValues: { ":t": true },
                UpdateExpression: "set #t = :t",
                ConditionExpression: "attribute_exists(pk) AND attribute_exists(sk)"
              })).catch(error => {
                if (error.name === 'ConditionalCheckFailedException') {
                  console.log(`Player ${player.playerid} already left the next tournament, so no need to record timeout.`);
                } else {
                  throw error;
                }
              }));
            }
          }
          tournamentUpdated = true;
        }
      }
      if (tournamentUpdated) {
        // Update tournament
        if (!alldone) {
          work.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: { "pk": "TOURNAMENT", "sk": tournament.id },
            ExpressionAttributeValues: { ":ds": tournament.divisions },
            UpdateExpression: "set divisions = :ds",
          })));
        } else {
          const now = Date.now();
          work.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: { "pk": "TOURNAMENT", "sk": tournament.id },
            ExpressionAttributeValues: { ":ds": tournament.divisions, ":dt": now },
            UpdateExpression: "set divisions = :ds, dateEnded = :dt",
          })));
          // Start the clock for next tournament start
          work.push(sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: { "pk": "TOURNAMENT", "sk": tournament.nextid },
            ExpressionAttributeValues: { ":dt": now },
            UpdateExpression: "set datePreviousEnded = :dt",
          })));
          // Send e-mails to participants
          // Now we need ALL players, not just the ones in the current division
          const playersData = await sendCommandWithRetry<QueryCommandOutput>(
            new QueryCommand({
              TableName: process.env.ABSTRACT_PLAY_TABLE,
              ExpressionAttributeValues: { ":pk": "TOURNAMENTPLAYER", ":sk": tournament.id },
              ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
              KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
            }));
          const players = playersData.Items as TournamentPlayer[];
          // And, in fact, full players (just for e-mail!? and language... Don't want to put these in the tournament player because then those will have to be maintained if e-mail or language changes)
          const playersFull = await getPlayers(players.map(p => p.playerid));
          await initi18n('en');
          const metaGameName = gameinfo.get(tournament.metaGame)?.name;
          for (const player of playersFull) {
            console.log(`Determining whether to send tournamentEnd email to the following player:\n${JSON.stringify(player)}`);
            // eslint-disable-next-line no-prototype-builtins
            if ((player.settings?.all?.notifications === undefined) || (!player.settings.all.notifications.hasOwnProperty("tournamentEnd")) || (player.settings.all.notifications.tournamentEnd)) {
              console.log("Sending email");
              await changeLanguageForPlayer(player);
              let body = '';
              if (tournament.variants.length === 0)
                body = i18n.t("TournamentEndBody", { "metaGame": metaGameName, "number": tournament.number, "tournamentId": tournament.id });
              else
                body = i18n.t("TournamentEndBodyVariants", { "metaGame": metaGameName, "number": tournament.number, "tournamentId": tournament.id, "variants": tournament.variants.join(", ") });
              if ((player.email !== undefined) && (player.email !== null) && (player.email !== "")) {
                const comm = createSendEmailCommand(player.email, player.name, i18n.t("TournamentEndSubject", { "metaGame": metaGameName, }), body);
                work.push(sesClient.send(comm));
              }
              work.push(sendPush({
                userId: player.id,
                topic: "tournament",
                title: i18n.t("PUSH.titles.tournamentOver"),
                body,
                url: `/tournament/${tournament.id}`,
              }));
            }
          }
        }
      }
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Error during update tournament ${tournament.id}: {error}`);
  }
  return {
    statusCode: 200,
    body: "Done",
    headers
  };
}

// ORGANIZED EVENTS
async function eventGetEvent(pars: { eventid: string }) {
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }

    const players = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "ORGEVENTPLAYER", ":sk": pars.eventid },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      }));
    const games = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "ORGEVENTGAME", ":sk": pars.eventid },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      }));

    return {
      statusCode: 200,
      body: JSON.stringify({ event: event.Item, players: players.Items, games: games.Items }),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get organized event ${pars.eventid}. Error: ${error}`);
  }
}

async function eventGetEvents() {
  try {
    const work: Promise<any>[] = [];
    work.push(ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "ORGEVENT" },
        ExpressionAttributeNames: { "#pk": "pk" },
      })));
    work.push(ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "ORGEVENTPLAYER" },
        ExpressionAttributeNames: { "#pk": "pk" },
      })));
    work.push(ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "ORGEVENTGAME" },
        ExpressionAttributeNames: { "#pk": "pk" },
      })));
    const data = await Promise.all(work);
    return {
      statusCode: 200,
      body: JSON.stringify({ events: data[0].Items, players: data[1].Items, games: data[2].Items }),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get organized events. Error: ${error}`);
  }
}

async function eventCreate(userid: string, pars: { name: string, date: number, description: string, maxPlayers: number }) {
  // authorize first
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`createEvent: Unable to load user record to authorize ${userid}`);
  }
  try {
    const eventid = uuid();
    const eventRec: OrgEvent = {
      pk: "ORGEVENT",
      sk: eventid,
      name: pars.name,
      description: pars.description,
      organizer: userid,
      dateStart: pars.date,
      visible: false,
      invited: [],
      blocked: [],
      maxPlayers: pars.maxPlayers,
    };
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: eventRec,
      })
    );
    return {
      statusCode: 200,
      body: JSON.stringify({ eventid }),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to create event. Error: ${error}`);
  }
}

async function eventPublish(userid: string, pars: { eventid: string }) {
  // authorize first
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`createEvent: Unable to load user record to authorize ${userid}`);
  }
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && eventRec.organizer !== userid)) {
      return {
        statusCode: 401,
        headers
      };
    }
    // must be in the future and have nonempty description
    if (eventRec.dateStart <= Date.now() || /^\s*$/.test(eventRec.description)) {
      return {
        statusCode: 400,
        body: "The start date must be in the future and the description may not be empty.",
        headers,
      };
    }
    eventRec.visible = true;
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: eventRec,
      })
    );
    return {
      statusCode: 200,
      body: JSON.stringify(eventRec),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to publish event ${pars.eventid}. Error: ${error}`);
  }
}

async function eventDelete(userid: string, pars: { eventid: string }) {
  // authorize first
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`createEvent: Unable to load user record to authorize ${userid}`);
  }
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && eventRec.organizer !== userid)) {
      return {
        statusCode: 401,
        headers
      };
    }
    // get associated players and games
    const players = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "ORGEVENTPLAYER", ":sk": pars.eventid },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      }));
    const games = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "ORGEVENTGAME", ":sk": pars.eventid },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      }));

    // the event must not be over and there must not be any associated games
    if (eventRec.dateEnd !== undefined || (games.Items !== undefined && games.Items.length > 0)) {
      return {
        statusCode: 400,
        body: "You cannot delete events that are over or that have associated games.",
        headers,
      };
    }

    // delete associated player records
    if (players.Items !== undefined && players.Items.length > 0) {
      for (const { playerid } of players.Items as OrgEventPlayer[]) {
        await ddbDocClient.send(
          new DeleteCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: {
              "pk": "ORGEVENTPLAYER",
              "sk": `${pars.eventid}#${playerid}`
            },
          })
        );
      }
    }

    // now delete the event itself
    await ddbDocClient.send(
      new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid,
        },
      })
    );
    return {
      statusCode: 200,
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to delete event ${pars.eventid}. Error: ${error}`);
  }
}

async function eventRegister(userid: string, pars: { eventid: string }) {
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    // must be open for registration
    if (!eventRec.visible || eventRec.dateStart < Date.now() || eventRec.dateEnd !== undefined) {
      return {
        statusCode: 400,
        body: "You may only register for events that are open for registration.",
        headers,
      };
    }
    if (eventRec.blocked !== undefined && eventRec.blocked.includes(userid)) {
      return {
        statusCode: 400,
        body: "You are blocked from registering for this event.",
        headers,
      };
    }
    if (eventRec.invited !== undefined && eventRec.invited.length > 0 && !eventRec.invited.includes(userid)) {
      return {
        statusCode: 400,
        body: "This event is by invitation only.",
        headers,
      };
    }
    if (eventRec.maxPlayers > 0) {
      const players = await ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
          ExpressionAttributeValues: { ":pk": "ORGEVENTPLAYER", ":sk": pars.eventid },
          ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
          Select: "COUNT"
        }));
      if (players.Count !== undefined && players.Count >= eventRec.maxPlayers) {
        return {
          statusCode: 400,
          body: "This event is full.",
          headers,
        };
      }
    }
    const newRec: OrgEventPlayer = {
      pk: "ORGEVENTPLAYER",
      sk: `${pars.eventid}#${userid}`,
      playerid: userid,
    }
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: newRec,
      })
    );
    return {
      statusCode: 200,
      body: JSON.stringify(newRec),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to register for event ${pars.eventid}. Error: ${error}`);
  }
}

async function eventWithdraw(userid: string, pars: { eventid: string }) {
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    // must be open for registration
    if (!eventRec.visible || eventRec.dateStart < Date.now() || eventRec.dateEnd !== undefined) {
      return {
        statusCode: 400,
        body: "You may only withdraw from events that are open for registration.",
        headers,
      };
    }
    await ddbDocClient.send(
      new DeleteCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENTPLAYER",
          "sk": `${pars.eventid}#${userid}`
        },
      })
    );
    return {
      statusCode: 200,
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to withdraw from event ${pars.eventid}. Error: ${error}`);
  }
}

async function eventUpdateStart(userid: string, pars: { eventid: string, newDate: number }) {
  // authorize first
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`createEvent: Unable to load user record to authorize ${userid}`);
  }
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && eventRec.organizer !== userid)) {
      return {
        statusCode: 401,
        headers
      };
    }
    eventRec.dateStart = pars.newDate;
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: eventRec,
      })
    );
    return {
      statusCode: 200,
      body: JSON.stringify(eventRec),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to update event start date. Error: ${error}`);
  }
}

async function eventUpdateName(userid: string, pars: { eventid: string, name: string }) {
  // authorize first
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`createEvent: Unable to load user record to authorize ${userid}`);
  }
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && eventRec.organizer !== userid)) {
      return {
        statusCode: 401,
        headers
      };
    }
    eventRec.name = pars.name;
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: eventRec,
      })
    );
    return {
      statusCode: 200,
      body: JSON.stringify(eventRec),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to update event start date. Error: ${error}`);
  }
}

async function eventUpdateDesc(userid: string, pars: { eventid: string, description: string }) {
  // authorize first
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`createEvent: Unable to load user record to authorize ${userid}`);
  }
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && eventRec.organizer !== userid)) {
      return {
        statusCode: 401,
        headers
      };
    }
    eventRec.description = pars.description;
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: eventRec,
      })
    );
    return {
      statusCode: 200,
      body: JSON.stringify(eventRec),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to update event start date. Error: ${error}`);
  }
}

async function eventUpdateInvites(userid: string, pars: { eventid: string, invited: string[], blocked: string[] }) {
  // authorize first
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`eventUpdateInvites: Unable to load user record to authorize ${userid}`);
  }
  try {
    const event = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (event.Item === undefined) {
      return {
        statusCode: 404,
        headers,
      };
    }
    const eventRec = event.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && eventRec.organizer !== userid)) {
      return {
        statusCode: 401,
        headers
      };
    }
    eventRec.invited = pars.invited;
    eventRec.blocked = pars.blocked;
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: eventRec,
      })
    );
    return {
      statusCode: 200,
      body: JSON.stringify(eventRec),
      headers
    };
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to update event invites. Error: ${error}`);
  }
}

type PairingPlayer = {
  id: string;
  name: string;
  country: string;
  stars: string[];
  lastSeen: number;
};
type Pairing = {
  round: number;
  metagame: string;
  variants: string[];
  clockStart: number;
  clockInc: number;
  clockMax: number;
  p1: PairingPlayer;
  p2: PairingPlayer
};

async function eventUpdateResult(userid: string, pars: { eventid: string, gameid: string, result: string[] }) {
  // load event and authorize requester
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`eventCreateGames: Unable to load user record to authorize ${userid}`);
  }
  let event: OrgEvent;
  try {
    const eventRec = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (eventRec.Item === undefined) {
      console.log(`Error 404`);
      return {
        statusCode: 404,
        headers,
      };
    }
    event = eventRec.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && event.organizer !== userid)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Unable to load/validate the event record for event ${pars.eventid}. Error: ${error}`);
  }
  // update game record
  try {
    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "ORGEVENTGAME", "sk": `${pars.eventid}#${pars.gameid}` },
      ExpressionAttributeValues: { ":win": pars.result, ":arb": true },
      UpdateExpression: "set winner = :win, arbitrated = :arb",
    }));
    return {
      statusCode: 200,
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`eventUpdateResult: Unable to set result ${pars.result} for ${pars.eventid}#${pars.gameid}`);
  }
}

type DivisionTable = string[][];
async function eventUpdateDivisions(userid: string, pars: { eventid: string; divisions: DivisionTable }) {
  // (Do as much validation as possible before creating games and abort if anything's wrong.)
  console.log(`About to try updating division assignments for event ${pars.eventid}:\n${JSON.stringify(pars.divisions, null, 2)}`);
  // load event and authorize requester
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`eventCreateGames: Unable to load user record to authorize ${userid}`);
  }
  let event: OrgEvent;
  try {
    const eventRec = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (eventRec.Item === undefined) {
      console.log(`Error 404`);
      return {
        statusCode: 404,
        headers,
      };
    }
    event = eventRec.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && event.organizer !== userid)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Unable to load/validate the event record for event ${pars.eventid}. Error: ${error}`);
  }
  // get list of registered players
  let eventPlayers: OrgEventPlayer[];
  try {
    const pRecs = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "ORGEVENTPLAYER", ":sk": pars.eventid },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      }));
    if (pRecs.Items === undefined || pRecs.Items.length === 0) {
      console.log(`Error 400: No players`);
      return {
        statusCode: 400,
        body: "This event has no registered players!",
        headers
      };
    }
    eventPlayers = pRecs.Items as OrgEventPlayer[];
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Unable to load registered players for event ${pars.eventid}. Error: ${error}`);
  }

  // ensure there are at least 2 divisions
  if (pars.divisions.length < 2) {
    console.log(`Error 400: Too few divisions`);
    return {
      statusCode: 400,
      body: `There must be at least two divisions.`,
      headers
    };
  }

  // ensure that each division has at least 2 players assigned
  if (Math.min(...pars.divisions.map(d => d.length)) < 2) {
    console.log(`Error 400: Too-small division`);
    return {
      statusCode: 400,
      body: `Each division must have at least two players assigned.`,
      headers
    };
  }

  // ensure that all assigned players are registered or abort
  const idsRegistered = eventPlayers.map(p => p.playerid);
  for (const uid of pars.divisions.flat()) {
    if (!idsRegistered.includes(uid)) {
      console.log(`Error 400: Unregistered player`);
      return {
        statusCode: 400,
        body: `You may not assign divisions to players not registered for this event.`,
        headers
      };
    }
  }

  // ensure that all participating players have been assigned or abort
  const setRegistrants = new Set<string>(idsRegistered);
  for (const uid of pars.divisions.flat()) {
    setRegistrants.delete(uid);
  }
  if (setRegistrants.size > 0) {
    console.log(`Error 400: Not all players assigned`);
    return {
      statusCode: 400,
      body: `All registered players must be assigned to a division.`,
      headers
    };
  }

  // ensure there are no duplicates anywhere
  const seen = new Set<string>(pars.divisions.flat());
  if (seen.size < pars.divisions.flat().length) {
    console.log(`Error 400: Duplicates`);
    return {
      statusCode: 400,
      body: `Players must only be assigned to one division. No duplicates allowed.`,
      headers
    };
  }

  const list: Promise<any>[] = [];
  try {
    // for each division
    for (let d = 0; d < pars.divisions.length; d++) {
      const division = pars.divisions[d];
      for (const pid of division) {
        const cmd = ddbDocClient.send(new UpdateCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: { "pk": "ORGEVENTPLAYER", "sk": `${pars.eventid}#${pid}` },
          ExpressionAttributeValues: { ":div": d + 1 },
          UpdateExpression: "set division = :div",
        }));
        list.push(cmd);
      }
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventUpdateDivisions: Something went wrong assigning divisions for event ${pars.eventid}. Error: ${error}`);
  }
  // execute all updates
  try {
    await Promise.all(list);
    return {
      statusCode: 200,
      headers
    };
  } catch (error) {
    logGetItemError(error);
    throw new Error(`Something terrible happened while trying to assign divisions for event ${pars.eventid}`);
  }
}

async function eventCreateGames(userid: string, pars: { eventid: string; pairs: Pairing[] }) {
  // (Do as much validation as possible before creating games and abort if anything's wrong.)
  console.log(`About to try creating the following pairings for event ${pars.eventid}:\n${JSON.stringify(pars.pairs, null, 2)}`);
  // load event and authorize requester
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`eventCreateGames: Unable to load user record to authorize ${userid}`);
  }
  let event: OrgEvent;
  try {
    const eventRec = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (eventRec.Item === undefined) {
      console.log(`Error 404`);
      return {
        statusCode: 404,
        headers,
      };
    }
    event = eventRec.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && event.organizer !== userid)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Unable to load/validate the event record for event ${pars.eventid}. Error: ${error}`);
  }
  // get list of registered players
  let eventPlayers: OrgEventPlayer[];
  try {
    const pRecs = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "ORGEVENTPLAYER", ":sk": pars.eventid },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
      }));
    if (pRecs.Items === undefined || pRecs.Items.length === 0) {
      console.log(`Error 400: No players`);
      return {
        statusCode: 400,
        body: "This event has no registered players!",
        headers
      };
    }
    eventPlayers = pRecs.Items as OrgEventPlayer[];
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Unable to load registered players for event ${pars.eventid}. Error: ${error}`);
  }
  // ensure that all paired players are registered or abort
  const idsRegistered = eventPlayers.map(p => p.playerid);
  for (const pair of pars.pairs) {
    if (!idsRegistered.includes(pair.p1.id) || !idsRegistered.includes(pair.p2.id)) {
      console.log(`Error 400: Unregistered player`);
      return {
        statusCode: 400,
        body: `You may not create games for players not registered for this event.`,
        headers
      };
    }
  }
  // load all player records to be paired
  const idsPaired = new Set<string>();
  for (const pair of pars.pairs) {
    idsPaired.add(pair.p1.id);
    idsPaired.add(pair.p2.id);
  }
  let players: FullUser[];
  try {
    players = await getPlayers([...idsPaired.values()]);
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Unable to load full player records for registered players for event ${pars.eventid}. Error: ${error}`);
  }
  // try to initialize all requested metagame/variant combos to make sure they're valid
  try {
    const tried = new Set<string>();
    for (const pair of pars.pairs) {
      const id = [pair.metagame, ...pair.variants].join("|");
      if (tried.has(id)) {
        continue;
      } else {
        tried.add(id);
      }
      const info = gameinfo.get(pair.metagame);
      let engine;
      if (info.playercounts.length > 1)
        engine = GameFactory(pair.metagame, 2, pair.variants);
      else
        engine = GameFactory(pair.metagame, undefined, pair.variants);
      if (!engine) {
        console.log(`Error 400: No engine`);
        return {
          statusCode: 400,
          body: `The game engine could not be initialized for the game ${pair.metagame} and the variants "${pair.variants.join(", ")}".`,
          headers
        };
      }
      const varsReqd = [...pair.variants];
      varsReqd.sort((a, b) => a.localeCompare(b));
      const varsEngine = [...engine.variants];
      varsEngine.sort((a, b) => a.localeCompare(b));
      if (varsReqd.join("|") !== varsEngine.join("|")) {
        console.log(`Error 400: Missing variants`);
        return {
          statusCode: 400,
          body: `The variants requested (${JSON.stringify(varsReqd)}) do not match the variants asserted by the game engine (${JSON.stringify(varsEngine)}).`,
          headers
        };
      }
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Unable to validate metagame/variant combos for event ${pars.eventid}. Error: ${error}`);
  }

  const list: Promise<any>[] = [];
  try {
    // for each pairing
    const updatedGames = new Map<string, Game[]>();
    for (const pair of pars.pairs) {
      // create game record
      const gameId = uuid();
      const playerIDs = [pair.p1.id, pair.p2.id];
      let whoseTurn: string | boolean[] = "0";
      const info = gameinfo.get(pair.metagame);
      if (info.flags !== undefined && info.flags.includes('simultaneous')) {
        whoseTurn = playerIDs.map(() => true);
      }
      let engine: GameBase | GameBaseSimultaneous;
      if (info.playercounts.length > 1) {
        engine = GameFactory(pair.metagame, 2, pair.variants)!;
      } else {
        engine = GameFactory(pair.metagame, undefined, pair.variants)!;
      }
      const state = engine.serialize();
      const now = Date.now();
      const pInvolved = [players.find(p => p.id === pair.p1.id)!, players.find(p => p.id === pair.p2.id)!];
      // @ts-ignore
      if (pInvolved.includes(undefined)) {
        throw new Error("Could not find one of the players! This should never happen!");
      }
      const gamePlayers = pInvolved.map(p => { return { "id": p.id, "name": p.name, "time": pair.clockStart * 3600000 } }) as User[];
      if (info.flags !== undefined && info.flags.includes('perspective')) {
        let rot = 180;
        if (playerIDs.length > 2 && info.flags !== undefined && info.flags.includes('rotate90')) {
          rot = -90;
        }
        for (let i = 1; i < playerIDs.length; i++) {
          gamePlayers[i].settings = { "rotate": i * rot };
        }
      }
      // queue for update
      const addGame = sendCommandWithRetry(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: prepareGameStateForStorage({
          "pk": "GAME",
          "sk": pair.metagame + "#0#" + gameId,
          "id": gameId,
          "metaGame": pair.metagame,
          "numPlayers": 2,
          "rated": true,
          "players": gamePlayers,
          "clockStart": pair.clockStart,
          "clockInc": pair.clockInc,
          "clockMax": pair.clockMax,
          "clockHard": true,
          "noExplore": false,
          "state": state,
          "toMove": whoseTurn,
          "lastMoveTime": now,
          "gameStarted": now,
          "variants": engine.variants,
          "event": pars.eventid,
        } as FullGame)
      }));
      list.push(addGame);
      // this should be all the info we want to show on the "my games" summary page.
      const game = {
        "id": gameId,
        "metaGame": pair.metagame,
        "players": pInvolved.map(p => { return { "id": p.id, "name": p.name, "time": pair.clockStart * 3600000 } }),
        "clockHard": true,
        "noExplore": false,
        "toMove": whoseTurn,
        "lastMoveTime": now,
        "variants": engine.variants,
      } as Game;
      list.push(addToGameLists("CURRENTGAMES", game, now, false));
      // prepare to update player records and queue updates after the loop
      pInvolved.forEach(player => {
        let lst: Game[] = [];
        if (updatedGames.has(player.id)) {
          lst = updatedGames.get(player.id)!;
        }
        lst.push(game);
        updatedGames.set(player.id, lst);
      });
      // Create an OrgEventGame record to link this game to the event
      const eventGame: OrgEventGame = {
        pk: "ORGEVENTGAME",
        sk: [pars.eventid, gameId].join("#"),
        metaGame: pair.metagame,
        variants: engine.variants,
        round: pair.round,
        gameid: gameId,
        player1: pair.p1.id,
        player2: pair.p2.id,
      };
      list.push(
        sendCommandWithRetry(new PutCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Item: eventGame,
        }))
      );
    }
    // queue all player updates one time
    players.forEach(player => {
      let games = player.games;
      if (games === undefined) {
        games = [];
      }
      const updated = updatedGames.get(player.id);
      if (updated !== undefined) {
        const updatedGameIDs: string[] = [];
        for (const game of updated) {
          games.push(game);
          updatedGameIDs.push(game.id);

        }
        list.push(updateUserGames(player.id, player.gamesUpdate, updatedGameIDs, games));
      }
    });
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventCreateGames: Something went wrong generating pairings for event ${pars.eventid}. Error: ${error}`);
  }
  // execute all updates
  try {
    await Promise.all(list);
    return {
      statusCode: 200,
      headers
    };
  } catch (error) {
    logGetItemError(error);
    throw new Error(`Something terrible happened while trying to create paired games for event ${pars.eventid}`);
  }
}

async function eventClose(userid: string, pars: { eventid: string, winner: string[] }) {
  // load event and authorize requester
  let userRec: FullUser | undefined;
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userid
        },
      }));
    if (user.Item === undefined || (user.Item.admin !== true && user.Item.organizer !== true)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
    userRec = user.Item as FullUser;
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`eventClose: Unable to load user record to authorize ${userid}`);
  }
  let event: OrgEvent;
  try {
    const eventRec = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "ORGEVENT",
          "sk": pars.eventid
        },
      }));
    if (eventRec.Item === undefined) {
      console.log(`Error 404`);
      return {
        statusCode: 404,
        headers,
      };
    }
    event = eventRec.Item as OrgEvent;
    if (userRec === undefined || (userRec.admin !== true && event.organizer !== userid)) {
      console.log(`Error 401`);
      return {
        statusCode: 401,
        headers
      };
    }
  } catch (error) {
    logGetItemError(error);
    return formatReturnError(`eventClose: Unable to load/validate the event record for event ${pars.eventid}. Error: ${error}`);
  }
  // update event record
  try {
    if (event.dateEnd === undefined) {
      event.dateEnd = Date.now();
    }
    event.winner = pars.winner;
    await ddbDocClient.send(new PutCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Item: event
    })
    );
    return {
      statusCode: 200,
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`eventClose: Unable to close event ${pars.eventid}`);
  }
}

async function eventUpdates(pars: { eventid: string, gameid: string, winner: string[] }): Promise<any[]> {
  const work: Promise<any>[] = [];
  work.push(
    sendCommandWithRetry<UpdateCommandOutput>(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "ORGEVENTGAME", "sk": `${pars.eventid}#${pars.gameid}` },
      ExpressionAttributeValues: { ":win": pars.winner, ":arb": false },
      UpdateExpression: "set winner = :win, arbitrated = :arb",
    }))
  );
  return Promise.all(work);
}

// Delete every trace of a list of games. Only for admins and probably only for dev!
async function deleteGames(userId: string, pars: { metaGame: string, cbit: number, gameids: string }) {
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get user ${userId}. Error: ${error}`);
  }
  const gameids = pars.gameids.split(",");
  const work: Promise<any>[] = [];
  const work2: Promise<any>[] = [];
  try {
    for (const gameid of gameids) {
      work.push(ddbDocClient.send(
        new GetCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "GAME",
            "sk": pars.metaGame + "#" + pars.cbit + '#' + gameid.trim()
          },
        })
      ));
      work2.push(ddbDocClient.send(
        new QueryCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          KeyConditionExpression: "#pk = :pk",
          ExpressionAttributeValues: { ":pk": "GAMEEXPLORATION#" + gameid },
          ExpressionAttributeNames: { "#pk": "pk" },
        })));
      if (pars.cbit === 1) {
        work2.push(ddbDocClient.send(
          new QueryCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            KeyConditionExpression: "#pk = :pk",
            ExpressionAttributeValues: { ":pk": "PUBLICEXPLORATION#" + gameid },
            ExpressionAttributeNames: { "#pk": "pk" },
          })));
      }
    }
    const gamesData = await Promise.all(work);
    work.length = 0;
    const games = gamesData.map(g => g.Item as FullGame);
    // players to update
    const playersGameIDs = new Map<string, string[]>();
    for (const game of games) {
      for (const player of game.players) {
        if (!playersGameIDs.has(player.id))
          playersGameIDs.set(player.id, []);
        playersGameIDs.get(player.id)!.push(game.id);
      }
    }
    const playersFull = await getPlayers([...playersGameIDs.keys()]);
    for (const player of playersFull) {
      const gameIDs = playersGameIDs.get(player.id)!;
      const games = player.games.filter(g => !gameIDs.includes(g.id));
      work.push(updateUserGames(player.id, player.gamesUpdate, gameIDs, games));
    }
    // delete games
    for (const game of games) {
      work.push(ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "GAME",
            "sk": pars.metaGame + "#" + pars.cbit + '#' + game.id
          },
        })
      ));
      // delete from lists
      if (pars.cbit === 0)
        work.push(deleteFromGameLists("CURRENTGAMES", game));
      else
        work.push(deleteFromGameLists("COMPLETEDGAMES", game));
      // delete NOTES
      for (const player of game.players) {
        work.push(ddbDocClient.send(
          new DeleteCommand({
            TableName: process.env.ABSTRACT_PLAY_TABLE,
            Key: {
              "pk": "NOTE",
              "sk": game.id + '#' + player.id
            },
          })
        ));
      }
      // and COMMENTS
      work.push(ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "GAMECOMMENTS",
            "sk": game.id
          },
        })
      ));
    }
    // delete game explorations
    const gameExplorationsData = await Promise.all(work2);
    const gameExplorations = gameExplorationsData.map(g => g.Items).flat();
    console.log("gameExplorations", gameExplorations);
    if (gameExplorations !== undefined) {
      const batches = Math.ceil(gameExplorations.length / 25);
      for (let batch = 0; batch < batches; batch++) {
        const subset = gameExplorations.slice(batch * 25, 25);
        work.push(ddbDocClient.send(
          new BatchWriteCommand({
            "RequestItems": {
              [process.env.ABSTRACT_PLAY_TABLE!]: subset.map(item => ({
                DeleteRequest: {
                  Key: {
                    pk: item.pk,
                    sk: item.sk,
                  }
                }
              }))
            }
          })
        ));
      }
    }
    await Promise.all(work);
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: "Done"
      }),
      headers
    };
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to delete games ${pars.gameids}. Error: ${error}`);
  }
}

async function reportProblem(pars: { error: string }) {
  console.log("Reported problem:", pars.error);
  const data = await ddbDocClient.send(
    new QueryCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      KeyConditionExpression: "#pk = :pk",
      ExpressionAttributeValues: { ":pk": "USERS" },
      ExpressionAttributeNames: { "#pk": "pk", "#name": "name" },
      ProjectionExpression: "sk, #name, lastSeen, country, stars",
      ReturnConsumedCapacity: "INDEXES"
    }));
  const users = data.Items;
  const playerIDs = [];
  for (const user of users!)
    if (user.name === 'fritzd' || user.name === 'Fritz Deelman' || user.name === 'Perlkönig')
      playerIDs.push(user.sk);
  const errorAdmins = await getPlayers(playerIDs);
  const addresses = [];
  for (const admin of errorAdmins) {
    if (admin.email !== undefined && admin.email !== null && admin.email !== "")
      addresses.push(admin.email);
  }
  const email = new SendEmailCommand({
    Destination: {
      ToAddresses: addresses
    },
    Message: {
      Body: {
        Text: {
          Charset: "UTF-8",
          Data: pars.error
        },
      },
      Subject: {
        Charset: "UTF-8",
        Data: `AbstractPlay front end error report${process.env.ABSTRACT_PLAY_TABLE?.includes('-dev') ? ' (dev server)' : ''}`
      },
    },
    Source: "abstractplay@mail.abstractplay.com"
  });
  try {
    await sesClient.send(email);
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to send e-mail to error admins. Error: ${error}`);
  }
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: "Reported"
    }),
    headers
  };
}

async function sendPush(opts: PushOptions) {
  console.log(`Sending push: ${JSON.stringify(opts)}`);
  const { userId } = opts;
  let subscriptions;
  try {
    subscriptions = await queryPushSubscriptions(userId);
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to fetch push credentials for ${userId}`);
  }

  await sendPushToSubscriptions(opts, subscriptions, webpush.sendNotification.bind(webpush), logGetItemError);
}


async function invokePie(userid: string, pars: { id: string, metaGame: string, cbit: number }) {
  if (pars.cbit !== 0) {
    return formatReturnError("cbit must be 0");
  }
  let data: any;
  try {
    data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metaGame + "#0#" + pars.id
        },
      }));
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError(`Unable to get game ${pars.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  }
  if (!data.Item)
    throw new Error(`No game ${pars.id} in table ${process.env.ABSTRACT_PLAY_TABLE}`);
  try {
    const game = hydrateGameState(data.Item as FullGame);
    console.log("got game in invokePie:");
    console.log(game);
    if (("pieInvoked" in game) && (game.pieInvoked === true)) {
      console.log("Double pie detected! Aborting!");
      return {
        statusCode: 200,
        body: JSON.stringify(game),
        headers
      };
    } else {
      const engine = GameFactory(game.metaGame, game.state);
      if (!engine)
        throw new Error(`Unknown metaGame ${game.metaGame}`);
      const flags = gameinfo.get(game.metaGame).flags;
      if ((flags === undefined) || ((!flags.includes("pie")) && (!flags.includes("pie-even")))) {
        throw new Error(`Metagame ${pars.metaGame} does not have the "pie" flag. Aborting.`);
      }
      const lastMoveTime = (new Date(engine.stack[engine.stack.length - 1]._timestamp)).getTime();

      const player = game.players.find(p => p.id === userid);
      if (!player)
        throw new Error(`Player ${userid} isn't playing in game ${pars.id}`)

      const timestamp = Date.now();
      const timeUsed = timestamp - lastMoveTime;
      // console.log("timeUsed", timeUsed);
      // console.log("player", player);
      if (player.time! - timeUsed < 0)
        player.time = game.clockInc * 3600000; // If the opponent didn't claim a timeout win, and player moved, pretend his remaining time was zero.
      else
        player.time = player.time! - timeUsed + game.clockInc * 3600000;
      if (player.time > game.clockMax * 3600000) player.time = game.clockMax * 3600000;
      const playerIDs = game.players.map((p: { id: any; }) => p.id);
      // TODO: We are updating players and their games. This should be put in some kind of critical section!
      const players = await getPlayers(playerIDs);
      console.log(`Current player list: ${JSON.stringify(game.players)}`);
      const reversed = [...game.players].reverse();
      console.log(`Reversed: ${JSON.stringify(reversed)}`);
      game.players = [...reversed];
      game.pieInvoked = true;

      // if flag is `pie-even`, issue a "pass" command
      if (flags.includes("pie-even")) {
        try {
          engine.move("pass")
          game.state = engine.serialize();
          game.numMoves = engine.state().stack.length - 1; // stack has an entry for the board before any moves are made
          game.toMove = `${engine.currplayer! - 1}`;
        } catch (err) {
          logGetItemError(err);
          return formatReturnError('Error passing while invoking "pie-even"');
        }
      } else {
        // the other player needs to be given `timeUsed` back on their clock to account
        // for the fact that the game state is not changing (`lastMoveTime` isn't going
        // to change)
        const otherPlayer = game.players.find(p => p.id !== userid)!;
        otherPlayer.time = otherPlayer.time! + timeUsed;
      }

      // this should be all the info we want to show on the "my games" summary page.
      const playerGame = {
        "id": game.id,
        "metaGame": game.metaGame,
        // reverse the list of players
        "players": [...reversed],
        "clockHard": game.clockHard,
        "noExplore": game.noExplore || false,
        "toMove": game.toMove,
        "lastMoveTime": timestamp
      } as Game;
      const myGame = {
        "id": game.id,
        "metaGame": game.metaGame,
        // reverse the list of players
        "players": [...reversed],
        "clockHard": game.clockHard,
        "noExplore": game.noExplore || false,
        "toMove": game.toMove,
        "lastMoveTime": timestamp
      } as Game;
      const list: Promise<any>[] = [];
      game.lastMoveTime = timestamp;
      const updateGame = ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: prepareGameStateForStorage(game)
      }));
      list.push(updateGame);
      console.log("Scheduled update to game");
      // Update players
      for (const player of players) {
        const games: Game[] = [];
        (player.games ?? []).forEach(g => {
          if (g.id === playerGame.id) {
            if (player.id === userid)
              games.push(myGame);
            else
              games.push(playerGame);
          }
          else
            games.push(g)
        });
        list.push(updateUserGames(player.id, player.gamesUpdate, [playerGame.id], games));
        console.log(`Scheduled update to player ${player.id}, ${player.name}, with games`, games);
      }

      // insert a comment into the game log
      const thisPlayer = players.find(p => p.id === userid)!;
      list.push(submitComment("", { id: game.id, metaGame: pars.metaGame, comment: `${thisPlayer.name} elected to switch seats. As a result, the game record for ply 1 has been retroactively changed to look as if ${thisPlayer.name} made that move.`, moveNumber: 2 }));

      list.push(sendSubmittedMoveEmails(game, players.filter(p => p.email) as FullUser[], false, []));
      console.log("Scheduled emails");
      await Promise.all(list);
      console.log("All updates complete");
      await realPingBot(pars.metaGame, pars.id, game);
      return {
        statusCode: 200,
        body: JSON.stringify(game),
        headers
      };
    }
  }
  catch (error) {
    logGetItemError(error);
    return formatReturnError('Unable to process invoke pie');
  }
}

async function updateNote(userId: string, pars: { gameId: string; note?: string; }) {
  // if note is empty, delete the record
  if ((pars.note === undefined) || (pars.note === null) || (pars.note.length === 0)) {
    try {
      await ddbDocClient.send(
        new DeleteCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "NOTE", "sk": `${pars.gameId}#${userId}`,
          },
        })
      )
    } catch (err) {
      logGetItemError(err);
      return formatReturnError(`Unable to updateNote (delete, actually) ${userId}`);
    }
    // otherwise, just PUT it!
  } else {
    const note: Note = {
      pk: "NOTE",
      sk: `${pars.gameId}#${userId}`,
      note: pars.note,
    }
    console.log(`Setting note for user ${userId}, game ${pars.gameId}.`);
    try {
      await ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: note
      }));
    } catch (err) {
      logGetItemError(err);
      return formatReturnError(`Unable to updateNote ${userId}`);
    }
  }
  return {
    statusCode: 200,
    body: "",
    headers
  };
}

// updateCommented has no participant/admin gate today; client side effects of commented-flag updates are not fully understood.
async function updateCommented(userId: string, pars: { id: string; metaGame: string; cbit: number; commented: number; gameEnded?: number; }) {
  console.log(`Updating commented flag for game ${pars.id} to ${pars.commented}, cbit=${pars.cbit}, gameEnded=${pars.gameEnded}`);
  try {
    if (pars.cbit === 1 && pars.gameEnded !== undefined) {
      // For completed games, update COMPLETEDGAMES table
      await ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "COMPLETEDGAMES#" + pars.metaGame,
          "sk": pars.gameEnded + "#" + pars.id
        },
        ExpressionAttributeValues: { ":c": pars.commented },
        UpdateExpression: "set commented = :c",
        ConditionExpression: "attribute_exists(pk) AND attribute_exists(sk)"
      }));
      console.log(`Successfully updated commented flag in COMPLETEDGAMES for game ${pars.id} to ${pars.commented}`);
    } else if (pars.cbit === 0) {
      // For current games, update GAME table
      await ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "GAME",
          "sk": pars.metaGame + "#0#" + pars.id
        },
        ExpressionAttributeValues: { ":c": pars.commented },
        UpdateExpression: "set commented = :c",
        ConditionExpression: "attribute_exists(pk) AND attribute_exists(sk)"
      }));
      console.log(`Successfully updated commented flag in GAME for game ${pars.id} to ${pars.commented}`);
    }

    return {
      statusCode: 200,
      body: JSON.stringify({ success: true }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to update commented flag for game ${pars.id}: ${err}`);
  }
}

async function setLastSeen(userId: string, pars: { gameId: string; interval?: number; }) {
  // get USER rec
  let user: FullUser | undefined;
  try {
    const data = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      })
    );
    if (data.Item !== undefined) {
      user = data.Item as FullUser;
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to setLastSeen ${userId}`);
  }
  if (user !== undefined) {
    // find matching game
    const game = user.games.find(g => g.id === pars.gameId);
    if (game !== undefined) {
      // set lastSeen to "now" + interval
      let interval = 8;
      if (pars.interval !== undefined) {
        interval = pars.interval;
      }
      const now = new Date();
      const then = new Date();
      then.setDate(now.getDate() - interval);
      game.seen = then.getTime();
      console.log(`Setting lastSeen for ${game.id} to ${then.getTime()} (${then.toUTCString()}). It is currently ${new Date().toUTCString()}`);
      // you need to set `lastChat` as well or chats near the end of the game will be flagged
      game.lastChat = then.getTime();
      // save USER rec
      await ddbDocClient.send(new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: user
      }));
      return {
        statusCode: 200,
        body: "",
        headers
      };
    }
  }
  return {
    statusCode: 406,
    body: "",
    headers
  };
}

async function botManageChallenges() {
  const userId = process.env.AIAI_USERID;
  try {
    console.log(`Getting USER record`);
    const userData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (userData.Item === undefined) {
      throw new Error("Could not find a USER record for the AiAi bot");
    }
    const user = userData.Item as FullUser;
    let games = user.games;
    if (games === undefined)
      games = [];

    console.log(`Fetching challenges`);
    const challengesReceivedIDs: string[] = Array.from(user?.challenges_received ?? new Set());
    const data = await getChallenges(challengesReceivedIDs);
    const challengesReceived = data.map(r => r.Item as FullChallenge);
    console.log(`Got the following challenges:\n${JSON.stringify(challengesReceived, null, 2)}`);

    // process each challenge and accept/reject as appropriate
    for (const challenge of challengesReceived) {
      let accepted = false;
      // the overall meta must be supported
      const info = gameinfo.get(challenge.metaGame);
      if (info?.flags.includes("aiai")) {
        accepted = true;
      }
      // add any variant exceptions here too
      if (challenge.metaGame === "tumbleweed") {
        if (challenge.variants.includes("free-neutral") || challenge.variants.includes("capture-delay")) {
          accepted = false;
        }
      }

      // accept/reject challenge
      console.log(`About to ${accepted ? "accept" : "deny"} challenge ${challenge.sk}`)
      await respondedChallenge(process.env.AIAI_USERID!, { response: accepted, id: challenge.sk!, standing: challenge.standing, metaGame: challenge.metaGame, comment: "Let's play!" });
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to manage bot challenges: ${err}`);
  }

  // now get list of games where it's your turn and make moves
  // have to refetch, sadly!
  // but check for bot's turn early to avoid unnecessary refetches
  try {
    console.log(`Getting USER record`);
    const userData = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (userData.Item === undefined) {
      throw new Error("Could not find a USER record for the AiAi bot");
    }
    const user = userData.Item as FullUser;
    let games: Game[] = user.games;
    if (games === undefined)
      games = [];

    for (const game of games) {
      const info = gameinfo.get(game.metaGame);
      if (game.toMove !== null && game.toMove !== "") {
        const ids: string[] = [];
        if (info.flags.includes("simultaneous")) {
          const toMove = game.toMove as boolean[];
          if (toMove) {
            for (let i = 0; i < toMove.length; i++) {
              if (toMove[i]) {
                ids.push(game.players[i].id);
              }
            }
          }
        } else {
          ids.push(game.players[parseInt(game.toMove as string, 10)].id);
        }
        if (ids.includes(process.env.AIAI_USERID!)) {
          await realPingBot(game.metaGame, game.id);
        }
      }
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to manage bot challenges: ${err}`);
  }
}

async function onetimeFix(userId: string) {
  // Make sure people aren't getting clever
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      })
    );
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to onetimeFix ${userId}`);
  }

  let totalUnits = 0;
  // get all USER records
  let data: any;
  let users: FullUser[] = [];
  try {
    data = await ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "USER" },
        ExpressionAttributeNames: { "#pk": "pk" },
        ReturnConsumedCapacity: "INDEXES",
      })
    )
    if ((data !== undefined) && ("ConsumedCapacity" in data) && (data.ConsumedCapacity !== undefined) && ("CapacityUnits" in data.ConsumedCapacity) && (data.ConsumedCapacity.CapacityUnits !== undefined)) {
      totalUnits += data.ConsumedCapacity.CapacityUnits;
    } else {
      console.log(`Could not add consumed capacity: ${JSON.stringify(data?.ConsumedCapacity)}`);
    }
    users = data?.Items as FullUser[];
    console.log(JSON.stringify(users, null, 2));
    console.log(`Total units used: ${totalUnits}`);
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to onetimeFix get all users`);
  }

  const work: Promise<any>[] = [];
  for (const user of users) {
    work.push(
      ddbDocClient.send(new UpdateCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: { "pk": "USERS", "sk": user.id },
        ExpressionAttributeValues: { ":ss": user.stars || [], ":ls": user.lastSeen || 0, ":country": user.country },
        UpdateExpression: "set stars = :ss, lastSeen = :ls, country = :country",
      }))
    );
  }
  return Promise.all(work);
  //   const memoGame = new Map<string, FullGame>();
  //   const memoComments = new Map<string, Comment[]>();
  //   // foreach USER
  //   for (const user of users) {
  //     // foreach game in USER.games
  //     for (const game of user.games) {
  //         // check if game is already loaded
  //         if (! memoGame.has(game.id)) {
  //             // load and memoize
  //             let data: any;
  //             let cbit = "0";
  //             if ( (game.toMove === "") || (game.toMove === undefined) || ( (Array.isArray(game.toMove)) && (game.toMove.length === 0) ) ) {
  //                 cbit = "1";
  //             }
  //             try {
  //               data = await ddbDocClient.send(
  //                 new GetCommand({
  //                   TableName: process.env.ABSTRACT_PLAY_TABLE,
  //                   Key: {
  //                     "pk": "GAME",
  //                     "sk": `${game.metaGame}#${cbit}#${game.id}`
  //                   },
  //                   ReturnConsumedCapacity: "INDEXES",
  //                 }));
  //             } catch (error) {
  //               logGetItemError(error);
  //               return formatReturnError(`Unable to get comments for game ${game.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  //             }
  //             if ( (data !== undefined) && ("ConsumedCapacity" in data) && (data.ConsumedCapacity !== undefined) && ("CapacityUnits" in data.ConsumedCapacity) && (data.ConsumedCapacity.CapacityUnits !== undefined) ) {
  //                 totalUnits += data.ConsumedCapacity.CapacityUnits;
  //             } else {
  //               console.log(`Could not add consumed capacity: ${JSON.stringify(data?.ConsumedCapacity)}`);
  //             }
  //             const gameData = data.Item as FullGame;
  //             console.log("got game in onetimeFix:");
  //             console.log(gameData);
  //             memoGame.set(game.id, gameData);
  //         }
  //         const gameObj = memoGame.get(game.id);
  //         // check if comments already loaded
  //         if (! memoComments.has(game.id)) {
  //             // load and memoize
  //             let data: any;
  //             try {
  //               data = await ddbDocClient.send(
  //                 new GetCommand({
  //                   TableName: process.env.ABSTRACT_PLAY_TABLE,
  //                   Key: {
  //                     "pk": "GAMECOMMENTS",
  //                     "sk": game.id
  //                   },
  //                   ReturnConsumedCapacity: "INDEXES",
  //                 }));
  //             } catch (error) {
  //               logGetItemError(error);
  //               return formatReturnError(`Unable to get comments for game ${game.id} from table ${process.env.ABSTRACT_PLAY_TABLE}`);
  //             }
  //             if ( (data !== undefined) && ("ConsumedCapacity" in data) && (data.ConsumedCapacity !== undefined) && ("CapacityUnits" in data.ConsumedCapacity) && (data.ConsumedCapacity.CapacityUnits !== undefined) ) {
  //                 totalUnits += data.ConsumedCapacity.CapacityUnits;
  //             } else {
  //               console.log(`Could not add consumed capacity: ${JSON.stringify(data?.ConsumedCapacity)}`);
  //             }
  //             const commentsData = data.Item;
  //             console.log("got comments in onetimeFix:");
  //             console.log(commentsData);
  //             let comments: Comment[];
  //             if (commentsData === undefined)
  //               comments= []
  //             else
  //               comments = commentsData.comments;
  //             memoComments.set(game.id, comments);
  //         }
  //         const comments = memoComments.get(game.id)!;
  //         // if for some reason the game ID doesn't match a record, skip entirely
  //         if (gameObj === undefined) {
  //             console.log(`Could not find a full game record for the following: ${JSON.stringify(game)}`);
  //             continue;
  //         }
  //         let engine: GameBase|GameBaseSimultaneous|undefined;
  //         try {
  //             engine = GameFactory(gameObj.metaGame, gameObj.state);
  //         } catch (err) {
  //             console.log(`An error occured when trying to hydrate the following game: ${JSON.stringify(game)}`);
  //             console.log(err);
  //             continue;
  //         }
  //         if (engine === undefined) {
  //             return formatReturnError(`Unable to get engine for ${gameObj.metaGame} with state ${gameObj.state}`);
  //         }
  //         // add gameStarted
  //         game.gameStarted = new Date(engine.stack[0]._timestamp).getTime();
  //         // add gameEnded, if applicable
  //         if (engine.gameover) {
  //             game.gameEnded = new Date(engine.stack[engine.stack.length - 1]._timestamp).getTime();
  //         }
  //         // add lastChat, if applicable
  //         if (comments.length > 0) {
  //             game.lastChat = Math.max(...comments.map(c => c.timeStamp));
  //         }
  //     }
  //     console.log(`About to save updated USER record: ${JSON.stringify(user)}`);
  //     // save updated USER record
  //     await ddbDocClient.send(new PutCommand({
  //         TableName: process.env.ABSTRACT_PLAY_TABLE,
  //           Item: user
  //     }));
  //   }
  //   console.log(`All done! Total units used: ${totalUnits}`);
}

async function fixGames(userId: string, pars: { targetId: string }) {
  // Make sure people aren't getting clever
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      })
    );
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to onetimeFix ${userId}`);
  }

  try {
    const games = await getGamesForUser(pars.targetId);
    console.log(`Trying to set the following games:`, games);
    await ddbDocClient.send(new UpdateCommand({
      TableName: process.env.ABSTRACT_PLAY_TABLE,
      Key: { "pk": "USER", "sk": pars.targetId },
      ExpressionAttributeValues: { ":games": games || [] },
      UpdateExpression: "set games = :games",
    }));
    return {
      statusCode: 200,
      body: JSON.stringify({ message: `Rebuilt games for ${pars.targetId}` }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to fix_games for ${pars.targetId}`);
  }
}

async function testPush(userId: string) {
  // Make sure people aren't getting clever
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      })
    );
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to testPush ${userId}`);
  }

  await sendPush({
    userId,
    title: "Test",
    body: "Testing 1...2...3...",
    topic: "test",
    url: "/about",
  });
}

async function testAsync(userId: string, pars: { N: number; }) {
  // Make sure people aren't getting clever
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
    /*
    callback(null, {
      statusCode: 200,
      body: JSON.stringify({"n": pars.N}),
      headers
    });
    */
    console.log(`Calling makeWork with ${pars.N}`);
    // eslint-disable-next-line @typescript-eslint/no-floating-promises
    makeWork();
    console.log('Done calling makeWork');
    return {
      statusCode: 200,
      body: JSON.stringify({ "n": pars.N }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to test_async ${userId}`);
  }
}

async function pingBot(userId: string, pars: { metaGame: string, gameid: string }) {
  // Make sure people aren't getting clever
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      })
    );
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to testPush ${userId}`);
  }

  await realPingBot(pars.metaGame, pars.gameid);

  return {
    statusCode: 200,
    body: JSON.stringify({}),
    headers
  };
}

async function realPingBot(metaGame: string, gameid: string, game?: FullGame) {
  // fetch game record and state
  if (game === undefined) {
    try {
      const data = await ddbDocClient.send(
        new GetCommand({
          TableName: process.env.ABSTRACT_PLAY_TABLE,
          Key: {
            "pk": "GAME",
            "sk": metaGame + "#0#" + gameid
          },
        }));
      if (!data.Item)
        throw new Error(`No game ${metaGame + "#0#" + gameid} found in table ${process.env.ABSTRACT_PLAY_TABLE}`);
      game = hydrateGameState(data.Item as FullGame);
    }
    catch (error) {
      logGetItemError(error);
      return formatReturnError(`Unable to load game ${gameid} to make a bot move`);
    }
  }

  // instantiate game object
  if (game === undefined) {
    throw new Error("Unable to load game object");
  }
  const engine = GameFactory(metaGame, game.state);
  if (!engine)
    throw new Error(`Unknown metaGame ${metaGame}`);
  const info = gameinfo.get(metaGame);

  // notify AiAi bot, if necessary
  // get list of userIDs whose turn it is
  if (!engine.gameover) {
    const ids: string[] = [];
    if (info.flags.includes("simultaneous")) {
      for (let i = 0; i < (game.toMove as boolean[]).length; i++) {
        if (game.toMove[i]) {
          ids.push(game.players[i].id);
        }
      }
    } else {
      ids.push(game.players[parseInt(game.toMove as string, 10)].id);
    }
    if (ids.includes(process.env.AIAI_USERID!)) {
      // construct message
      const body = {
        meta: metaGame,
        mgl: engine.aiaiMgl(),
        gameid: gameid,
        history: engine.state2aiai(),
      }
      const input: SendMessageRequest = {
        QueueUrl: process.env.SQS_URL,
        MessageBody: JSON.stringify(body),
      }
      const cmd = new SendMessageCommand(input);
      await sqsClient.send(cmd);
    }
  }

  await notifyRegisteredBotsTurn(metaGame, gameid, game);
}

function makeWork() {
  return new Promise(function (resolve) {
    console.log("In makeWork");
    setTimeout(() => {
      console.log("End makeWork");
      resolve('resolved');
    }, 3000);
  });
}

function Set_toJSON(key: any, value: any) {
  if (typeof value === 'object' && value instanceof Set) {
    return [...value];
  }
  return value;
}

function shuffle(array: any[]) {
  let i = array.length, j;

  while (i > 1) {
    j = Math.floor(Math.random() * i);
    i--;
    const temp = array[i];
    array[i] = array[j];
    array[j] = temp;
  }
}

export async function changeLanguageForPlayer(player: { language: string | undefined; }) {
  const lng = player.language && REGISTERED_LANGUAGES.includes(player.language)
    ? player.language
    : 'en';
  if (i18n.language !== lng) {
    await i18n.changeLanguage(lng);
  }
}

export function createSendEmailCommand(toAddress: string, player: any, subject: any, body: string) {
  console.log("toAddress", toAddress, "player", player, "body", body);
  const fullbody = i18n.t("DearPlayer", { player }) + '\r\n\r\n' + body + "\r\n\r\n" + i18n.t("EmailOut");
  return new SendEmailCommand({
    Destination: {
      ToAddresses: [
        toAddress
      ],
    },
    Message: {
      Body: {
        Text: {
          Charset: "UTF-8",
          Data: fullbody
        },
      },
      Subject: {
        Charset: "UTF-8",
        Data: subject
      },
    },
    Source: "abstractplay@mail.abstractplay.com"
  });
}

export async function initi18n(language: string) {
  await i18n.init({
    lng: language,
    fallbackLng: 'en',
    resources: Object.fromEntries(
      Object.entries(LOCALE_RESOURCES).map(([lng, translation]) => [lng, { translation }])
    ),
  });
}

export function formatReturnError(message: string) {
  return {
    statusCode: 500,
    body: JSON.stringify({
      message: message
    }),
    headers
  };
}

// Handles errors during GetItem execution. Use recommendations in error messages below to
// add error handling specific to your application use-case.
export function logGetItemError(err: unknown) {
  if (!err) {
    console.error('Encountered error object was empty');
    return;
  }
  if (!(err as { code: any; message: any; }).code) {
    console.error(`An exception occurred, investigate and configure retry strategy. Error: ${JSON.stringify(err)}`);
    console.error('Full error object:', err);
    console.error('Stack trace:', new Error().stack);
    return;
  }
  // here are no API specific errors to handle for GetItem, common DynamoDB API errors are handled below
  handleCommonErrors(err as { code: any; message: any; });
}

export function handleCommonErrors(err: { code: any; message: any; }) {
  switch (err.code) {
    case 'InternalServerError':
      console.error(`Internal Server Error, generally safe to retry with exponential back-off. Error: ${err.message}`);
      return;
    case 'ProvisionedThroughputExceededException':
      console.error(`Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. `
        + `Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: ${err.message}`);
      return;
    case 'ResourceNotFoundException':
      console.error(`One of the tables was not found, verify table exists before retrying. Error: ${err.message}`);
      return;
    case 'ServiceUnavailable':
      console.error(`Had trouble reaching DynamoDB. generally safe to retry with exponential back-off. Error: ${err.message}`);
      return;
    case 'ThrottlingException':
      console.error(`Request denied due to throttling, generally safe to retry with exponential back-off. Error: ${err.message}`);
      return;
    case 'UnrecognizedClientException':
      console.error(`The request signature is incorrect most likely due to an invalid AWS access key ID or secret key, fix before retrying. `
        + `Error: ${err.message}`);
      return;
    case 'ValidationException':
      console.error(`The input fails to satisfy the constraints specified by DynamoDB, `
        + `fix input before retrying. Error: ${err.message}`);
      return;
    case 'RequestLimitExceeded':
      console.error(`Throughput exceeds the current throughput limit for your account, `
        + `increase account level throughput before retrying. Error: ${err.message}`);
      return;
    default:
      console.error(`An exception occurred, investigate and configure retry strategy. Error: ${err.message}`);
      return;
  }
}

async function* queryItemsGenerator(queryInput: QueryCommandInput): AsyncGenerator<unknown> {
  let lastEvaluatedKey: Record<string, any> | undefined
  do {
    const { Items, LastEvaluatedKey } = await ddbDocClient
      .send(new QueryCommand({ ...queryInput, ExclusiveStartKey: lastEvaluatedKey }));
    lastEvaluatedKey = LastEvaluatedKey
    if (Items !== undefined) {
      yield Items
    }
  } while (lastEvaluatedKey !== undefined)
}

function isRetiredCompletedGamesPk(pk: string, metaGameUids: Set<string>): boolean {
  if (pk === "COMPLETEDGAMES") {
    return true;
  }
  const parts = pk.split("#");
  if (parts.length !== 3 || parts[0] !== "COMPLETEDGAMES") {
    return false;
  }
  return metaGameUids.has(parts[1]);
}

async function purgeRetiredCompletedGames(userId: string) {
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }

    const metaGameUids = new Set<string>();
    gameinfo.forEach(g => metaGameUids.add(g.uid));

    let deleted = 0;
    let lastEvaluatedKey: Record<string, unknown> | undefined;
    do {
      const scan = await ddbDocClient.send(new ScanCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        FilterExpression: "begins_with(#pk, :prefix)",
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        ExpressionAttributeValues: { ":prefix": "COMPLETEDGAMES" },
        ProjectionExpression: "#pk, #sk",
        ExclusiveStartKey: lastEvaluatedKey,
      }));

      const toDelete = (scan.Items ?? []).filter(item =>
        isRetiredCompletedGamesPk(item.pk as string, metaGameUids)
      );

      for (let i = 0; i < toDelete.length; i += 25) {
        const chunk = toDelete.slice(i, i + 25);
        if (chunk.length === 0) {
          continue;
        }
        await ddbDocClient.send(new BatchWriteCommand({
          RequestItems: {
            [process.env.ABSTRACT_PLAY_TABLE!]: chunk.map(item => ({
              DeleteRequest: {
                Key: { pk: item.pk, sk: item.sk }
              }
            }))
          }
        }));
        deleted += chunk.length;
      }

      lastEvaluatedKey = scan.LastEvaluatedKey;
    } while (lastEvaluatedKey !== undefined);

    console.log(`purge_retired_completed_games deleted ${deleted} items`);
    return {
      statusCode: 200,
      body: JSON.stringify({ deleted }),
      headers
    };
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to purge retired completed games ${userId}`);
  }
}

async function updateMetaGameCounts(userId: string) {
  // Make sure people aren't getting clever
  try {
    const user = await ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "USER",
          "sk": userId
        },
      }));
    if (user.Item === undefined || user.Item.admin !== true) {
      return {
        statusCode: 200,
        body: JSON.stringify({}),
        headers
      };
    }

    const metaGamesDataWork = ddbDocClient.send(
      new GetCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Key: {
          "pk": "METAGAMES", "sk": "COUNTS"
        },
      }));

    const games: string[] = [];
    gameinfo.forEach((game) => games.push(game.uid));
    const currentgames = games.map(game => ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk and begins_with(#sk, :sk)",
        ExpressionAttributeValues: { ":pk": "GAME", ":sk": game + '#0#' },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        ProjectionExpression: "#pk, #sk"
      })));
    const completedgames = games.map(game => ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "COMPLETEDGAMES#" + game },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        ProjectionExpression: "#pk, #sk"
      })));
    const standingchallenges = games.map(game => ddbDocClient.send(
      new QueryCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        KeyConditionExpression: "#pk = :pk",
        ExpressionAttributeValues: { ":pk": "STANDINGCHALLENGE#" + game },
        ExpressionAttributeNames: { "#pk": "pk", "#sk": "sk" },
        ProjectionExpression: "#pk, #sk"
      })));

    const metaGamesData = await metaGamesDataWork;
    let metaGameCounts: MetaGameCounts;
    if (metaGamesData.Item === undefined)
      metaGameCounts = {};
    else
      metaGameCounts = metaGamesData.Item as MetaGameCounts;

    const work = await Promise.all([Promise.all(currentgames), Promise.all(completedgames), Promise.all(standingchallenges)]);
    console.log("work", work);

    // process stars
    const players = await getAllUsers();
    console.log("All players");
    console.log(JSON.stringify(players.map(p => p.name)));
    const starCounts = new Map<string, number>();
    for (const p of players) {
      if (p.stars !== undefined) {
        for (const star of p.stars) {
          if (starCounts.has(star)) {
            const val = starCounts.get(star)!;
            starCounts.set(star, val + 1);
          } else {
            starCounts.set(star, 1);
          }
        }
      }
    }

    games.forEach((game, ind) => {
      if (metaGameCounts[game] === undefined) {
        metaGameCounts[game] = {
          "currentgames": work[0][ind].Items ? work[0][ind].Items!.length : 0,
          "completedgames": work[1][ind].Items ? work[1][ind].Items!.length : 0,
          "standingchallenges": work[2][ind].Items ? work[2][ind].Items!.length : 0,
          "stars": starCounts.has(game) ? starCounts.get(game)! : 0,
        };
      } else {
        metaGameCounts[game].currentgames = work[0][ind].Items ? work[0][ind].Items!.length : 0;
        metaGameCounts[game].completedgames = work[1][ind].Items ? work[1][ind].Items!.length : 0;
        metaGameCounts[game].standingchallenges = work[2][ind].Items ? work[2][ind].Items!.length : 0;
        metaGameCounts[game].stars = starCounts.has(game) ? starCounts.get(game)! : 0;
      }
    });

    console.log(metaGameCounts);
    await ddbDocClient.send(
      new PutCommand({
        TableName: process.env.ABSTRACT_PLAY_TABLE,
        Item: {
          "pk": "METAGAMES",
          "sk": "COUNTS",
          ...metaGameCounts
        }
      })
    );
  } catch (err) {
    logGetItemError(err);
    return formatReturnError(`Unable to update meta game counts ${userId}`);
  }
}

// Make sure to increase the lamda timeout (from 6s) when you want to process all users. Just getting all users already takes about 2s.
const getAllUsers = async (): Promise<FullUser[]> => {
  const result: FullUser[] = []
  const queryInput: QueryCommandInput = {
    KeyConditionExpression: '#pk = :pk',
    ExpressionAttributeNames: {
      '#pk': 'pk',
    },
    ExpressionAttributeValues: {
      ':pk': 'USER',
    },
    TableName: process.env.ABSTRACT_PLAY_TABLE,
  }
  for await (const page of queryItemsGenerator(queryInput)) {
    result.push(...page as FullUser[]);
  }
  return result
}