import { batchify, Lazy } from "./lib/util/misc";

import { batchify, batchifySetState, Lazy } from "./lib/util/misc";

import { createQuest } from "./game/CreateQuest";

import { createQuest } from "./game/QuestFactory";

  let [batchedSetGameState, fireBatch] = useMemo(() => batchify(setGameState), [setGameState]);

  let [batchedSetGameState, fireBatch] = useMemo(() => batchifySetState(setGameState), [setGameState]);

          <div>{activeQuest.description}</div>

          <div>{activeQuest.resourceAmount} {activeQuest.resourceType}</div>

          <h3>Reward:</h3>
          <div>{'???'}</div>

          <h3>Score:</h3>
          <div>{'SS'}</div>

  description: string

  description: string | undefined,
  resourceType: ResourceType,
  resourceAmount: number,

import { GameState } from "../data/GameState";
import { UpdaterGeneratorType2 } from "../lib/util/updaterGenerator";

import { GameState, PlayerSaveState, PointNodeRef } from "../data/GameState";
import { canAllocate } from "./Neighbors";

// Things that should happen after allocation history is appended to , in order to maintain the game state in a good state
export function afterAppendAllocationHistory(updaters: UpdaterGeneratorType2<GameState>) {
  updaters.playerSave.enqueueUpdate((prev, prevGameState) => {
    let justAllocated = prevGameState.playerSave.justAllocated; // we are assuming that someone verified that this is good2go
    if (!justAllocated) { return prev; }

export function doTryAllocate(prev: PlayerSaveState, prevGameState: GameState, selfPointNodeRef: PointNodeRef): [PlayerSaveState, boolean] {
  if (canAllocate(
    selfPointNodeRef,
    prevGameState.worldGen,
    prevGameState.playerSave.allocatedPointNodeSet,
    prevGameState.playerSave.availableSp
  ) === 'yes') {
    // do the change
    const nextSet = prev.allocatedPointNodeSet.clone();
    nextSet.put(selfPointNodeRef);
    const nextHistory = [...prev.allocatedPointNodeHistory];
    nextHistory.push(selfPointNodeRef);
    let availableSp = prev.availableSp - 1;
    return [{
      ...prev,
      allocatedPointNodeHistory: nextHistory,
      allocatedPointNodeSet: nextSet,
      availableSp
    }, true];
  } else {
    return [prev, false];
  }
}

    let prevSet = prev.allocatedPointNodeSet;
    if (!prevSet.contains(justAllocated)) { // if it's new, add it to history, set, and decrement sp
      const nextSet = prev.allocatedPointNodeSet.clone();
      nextSet.put(justAllocated);
      const nextHistory = [...prev.allocatedPointNodeHistory];
      nextHistory.push(justAllocated);
      let availableSp = prev.availableSp - 1;
      return {
        ...prev,
        allocatedPointNodeHistory: nextHistory,
        allocatedPointNodeSet: nextSet,
        availableSp
      };
    }
    return prev;
  });

export function afterMaybeSpendingSp(prev: PlayerSaveState, prevGameState: GameState): PlayerSaveState {
  if (prev.availableSp === 0 && prev.activeQuest) {
    return {
      ...prev,
      availableSp: 5,
      batchesSinceQuestStart: prev.batchesSinceQuestStart + 1
    };
  }
  return prev;

import { GameState, Quest } from "../data/GameState";

import { GameState, Quest, ResourceType } from "../data/GameState";

      description: "placeholder"

      description: "",
      resourceType: ResourceType.Mana0,
      resourceAmount: 3000

}
/**
 * Same use case and types as [batchify], however, specifically we expect [fn] to be a setState function which takes value-or-callback
 * as its single argument, and instead of calling [fn] repeatedly for each callback in the batch, we apply the callbacks in the batch
 * sequentially to get a single state update which we then provide to [fn].
 */
export function batchifySetState<T>(
  fn: (arg: T) => void
): [((arg: T) => void), () => void] {
  let batch: T[] = [];
  return [(arg: T) => {
    batch.push(arg);
    console.log({ batchSize: batch.length });
  }, (() => {
      if (batch.length === 0) {
        return;
      }
      console.log({ fired: batch.length });
      let thisBatch = [...batch];
      batch = [];
      (fn as any)((prev: any) => {
        let next = prev;
        for (let valueOrCallback of thisBatch) {
          if (typeof valueOrCallback === 'function') {
            next = valueOrCallback(next);
          } else {
            next = valueOrCallback;
          }
        }
        return next;
      });
  })]

            // console.log({ newData });

        return (stateCallbackFunction as ((prev: T, prevWhole: T) => T))(prev, prev);

        const next = (stateCallbackFunction as ((prev: T, prevWhole: T) => T))(prev, prev);
        // console.log(" in updater generator 2", { next });
        return next;

type UpdaterFnParam<T> = (T extends Function ? never  : T) | ((prev: T) => T);

export type UpdaterFnParam<T> = (T extends Function ? never  : T) | ((prev: T) => T);

    console.log("base app rerender called", { size: props.gameState.playerSave.allocatedPointNodeSet.size() });

    console.log("base app rerender called", { playerUI: props.gameState.playerUI });

import { afterAppendAllocationHistory } from "../../game/OnAllocation";

import { afterMaybeSpendingSp, doTryAllocate } from "../../game/OnAllocation";

  justTriedToAllocate: boolean
  justSpentSp: boolean
  justFailedToAllocate: boolean
  numClicks:number

    this.state = {};

    this.state = {
      justTriedToAllocate: false,
      justSpentSp: false,
      justFailedToAllocate: false,
      numClicks: 0
    };

      this.state.numClicks++;

      updaters.playerSave.justAllocated.enqueueUpdate((prev: PointNodeRef | undefined, prevGameState) : PointNodeRef | undefined => {
        // if we were already selected, but not yet allocated, allocate us and add to the history (maybe this should be managed elsewhere??)
        if (prevGameState.playerUI.selectedPointNode?.pointNodeId === args.selfPointNodeRef.pointNodeId) {
          if (canAllocate(
            args.selfPointNodeRef,
            prevGameState.worldGen,
            prevGameState.playerSave.allocatedPointNodeSet,
            prevGameState.playerSave.availableSp
          ) === 'yes') {
            return args.selfPointNodeRef;

      // update selected to ourselves
      updaters.playerUI.selectedPointNode.enqueueUpdate((prev, gameState) => {
        if (prev?.pointNodeId === args.selfPointNodeRef.pointNodeId) {
          this.state.justTriedToAllocate = true;
        }
        return args.selfPointNodeRef;
      });
      // if we tried to allocate ourselves, see if we can
      updaters.playerSave.enqueueUpdate((prev, prevGameState) => {
        if (this.state.justTriedToAllocate) {
          this.state.justTriedToAllocate = false;
          let [next, succeeded] = doTryAllocate(prev, prevGameState, args.selfPointNodeRef);
          if (succeeded) {
            this.state.justSpentSp = true;
            return next;

            // happens +1 tick afterwards due to nested enqueue, but NBD
            updaters.playerUI.activeTab.enqueueUpdate((prev) => {
              return 1;
            })

            this.state.justFailedToAllocate = true;
            return prev;

      // whether or not we successfully allocated, run this just in case
      afterAppendAllocationHistory(updaters);

      // if we spent sp, remember to update quest status and such
      updaters.playerSave.enqueueUpdate((prev, prevGameState) => {
        if (this.state.justSpentSp) {
          this.state.justSpentSp = false;
          return afterMaybeSpendingSp(prev, prevGameState);
        }
        return prev;
      })

      // update selected to ourselves
      updaters.playerUI.selectedPointNode.enqueueUpdate((prev, gameState) => {
        return args.selfPointNodeRef;
      })

      // if we failed to allocate, shift the active tab so the player can see why
      updaters.playerUI.activeTab.enqueueUpdate((prev, prevGameState) => {
        if (this.state.justFailedToAllocate) {
          this.state.justFailedToAllocate = false;
          return 1;
        }
        return prev;
      });