export type ChunkComponentProps = Props;

type State = {}

  state!: {};

  state!: State;

    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])

    for (let childInfo of this._children) {
      if (childInfo.instance === childInstance) { // we found the instance in our _children array, now ensure it is in force updates array then return
        if (this.forceUpdates.indexOf(childInfo) === -1) {
          this.forceUpdates.push(childInfo);
        }
        return;
      }

    throw new Error(`Error, child ${childInstance} not found in ${this}`);

      let childProps = {
        delta: props.delta,
        args: {
          pointNodeTexture: props.args.pointNodeTexture,
          markForceUpdate: this.markForceUpdate,
        },
        selfPointNodeRef: pointNodeRef,
        updaters: props.updaters,
        position: pointNodeRef.pointNodeCoord.multiply(RenderedChunkConstants.SPACING_PX),
        pointNodeGen,
        isSelected: props.selectedPointNode?.pointNodeId === pointNodeRef.pointNodeId,
        isAllocated: props.allocatedPointNodeSubset.contains(pointNodeRef),
      };

      let childPropsFactory = (props: Props, state: State) => {
        return {
          delta: props.delta,
          args: {
            pointNodeTexture: props.args.pointNodeTexture,
            markForceUpdate: this.markForceUpdate,
          },
          selfPointNodeRef: pointNodeRef,
          updaters: props.updaters,
          position: pointNodeRef.pointNodeCoord.multiply(RenderedChunkConstants.SPACING_PX),
          pointNodeGen,
          isSelected: props.selectedPointNode?.pointNodeId === pointNodeRef.pointNodeId,
          isAllocated: props.allocatedPointNodeSubset.contains(pointNodeRef),
        };
      }

        childComponent.update(childProps);

        childComponent.update(childPropsFactory(props, this.state));

        childComponent = new PointNodeComponent(childProps);

        childComponent = new PointNodeComponent(childPropsFactory(props, this.state));

        this._children.push({
          childClass: ChunkComponent,
          instance: childComponent,
          propsFactory: childPropsFactory
        });

      this._children.splice(this._children.findIndex(it => it.instance === childComponent), 1);

        // note that children can add themselves into forceupdate next tick as well, if they need to ensure they're continuously in there

  // bridge while we migrate to lifecycle handler
  public _update(props: Props) { this.update(props); }

export type ChunkComponentProps = Props;

  private _staleProps: P;

  protected _staleProps: P; // need it for args

        hitArea: this.hitArea

        args: {
          markForceUpdate: this.markForceUpdate,
        },
        hitArea: this.hitArea,

    this._children.push({
      childClass: TooltippableAreaComponent,
      instance: this.tooltippableArea,
      propsFactory: this.tooltippableAreaPropsFactory,
    });

    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else if (this.forceUpdates.indexOf(childInstance) !== -1) {
      // already added to forceUpdates array, we can skip
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])

    for (let childInfo of this._children) {
      if (childInfo.instance === childInstance) { // we found the instance in our _children array, now ensure it is in force updates array then return
        if (this.forceUpdates.indexOf(childInfo) === -1) {
          this.forceUpdates.push(childInfo);
        }
        return;
      }

    throw new Error(`Error, child ${childInstance} not found in ${this}`);

  // bridge while we migrate to lifecycle handler
  public _update(props: Props) { this.update(props); }

    this._children.push({
      childClass: ZLevelComponent,
      instance: this.zLevel,
      propsFactory: this.zLevelPropsFactory,
    });

    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])

    for (let childInfo of this._children) {
      if (childInfo.instance === childInstance) { // we found the instance in our _children array, now ensure it is in force updates array then return
        if (this.forceUpdates.indexOf(childInfo) === -1) {
          this.forceUpdates.push(childInfo);
        }
        return;
      }

    throw new Error(`Error, child ${childInstance} not found in ${this}`);

    let prevSize = prevProps.gameState.playerSave.allocatedPointNodeSet.size()
    let nextSize = props.gameState.playerSave.allocatedPointNodeSet.size()
    if (prevSize !== nextSize) { console.log('rootapp shouldUpdate', { prevSize, nextSize }); }

    // let prevSize = prevProps.gameState.playerSave.allocatedPointNodeSet.size()
    // let nextSize = props.gameState.playerSave.allocatedPointNodeSet.size()
    // if (prevSize !== nextSize) { console.log('rootapp shouldUpdate', { prevSize, nextSize }); }

        // note that children can add themselves into forceupdate next tick as well, if they need to ensure they're continuously in there

  // bridge while we migrate to lifecycle handler
  public _update(props: Props) { this.update(props); }

  args: {
    markForceUpdate: (childInstance: any) => void,
  },

    this._staleProps.args.markForceUpdate(this);

    this._staleProps.args.markForceUpdate(this);

type State = {}

  state!: {};

  state!: State;

    if ((this._children as any[]).indexOf(childInstance) === -1) {
      throw new Error(`Error, child ${childInstance} not found in ${this}`);
    } else {
      this.forceUpdates.push(this._children[(this._children as any[]).indexOf(childInstance)])

    for (let childInfo of this._children) {
      if (childInfo.instance === childInstance) { // we found the instance in our _children array, now ensure it is in force updates array then return
        if (this.forceUpdates.indexOf(childInfo) === -1) {
          this.forceUpdates.push(childInfo);
        }
        return;
      }

    throw new Error(`Error, child ${childInstance} not found in ${this}`);

  doChild(props: Props, chunkCoord: Vector2, chunkGen: ChunkGen): { childKey: ChunkRef, childProps: ChunkComponentProps } {

  doChild(props: Props, chunkCoord: Vector2, chunkGen: ChunkGen): { childKey: ChunkRef, childPropsFactory: (p: Props, s: State) => ChunkComponentProps } {

    let childProps = {
      delta: props.delta,
      args: {
        pointNodeTexture: props.args.pointNodeTexture,
        markForceUpdate: this.markForceUpdate
      },
      selfChunkRef: chunkRef,
      updaters: props.updaters,
      position: chunkRef.chunkCoord.multiply(RenderedChunkConstants.CHUNK_SPACING_PX),
      chunkGen: chunkGen,
      // NOTE(bowei): for optimization, we dont tell other chunks about selected nodes in other chunks
      selectedPointNode: (props.selectedPointNode?.chunkCoord.equals(chunkRef.chunkCoord) ? props.selectedPointNode : undefined),
      allocatedPointNodeSubset,

    let childPropsFactory = (props: Props, state: State) => {
      return {
        delta: props.delta,
        args: {
          pointNodeTexture: props.args.pointNodeTexture,
          markForceUpdate: this.markForceUpdate
        },
        selfChunkRef: chunkRef,
        updaters: props.updaters,
        position: chunkRef.chunkCoord.multiply(RenderedChunkConstants.CHUNK_SPACING_PX),
        chunkGen: chunkGen,
        // NOTE(bowei): for optimization, we dont tell other chunks about selected nodes in other chunks
        selectedPointNode: (props.selectedPointNode?.chunkCoord.equals(chunkRef.chunkCoord) ? props.selectedPointNode : undefined),
        allocatedPointNodeSubset,
      };

      childProps

      childPropsFactory

      const { childKey, childProps } = this.doChild(props, chunkCoord, chunkGen);

      const { childKey, childPropsFactory } = this.doChild(props, chunkCoord, chunkGen);

        childComponent.update(childProps);

        childComponent.update(childPropsFactory(props, this.state));

        childComponent = new ChunkComponent(childProps);

        childComponent = new ChunkComponent(childPropsFactory(props, this.state));

        this._children.push({
          childClass: ChunkComponent,
          instance: childComponent,
          propsFactory: childPropsFactory
        });

      this._children.splice(this._children.findIndex(it => it.instance === childComponent), 1);

        // note that children can add themselves into forceupdate next tick as well, if they need to ensure they're continuously in there

  // bridge while we migrate to lifecycle handler
  public _update(props: Props) { this.update(props); }