// automatically generated by the FlatBuffers compiler, do not modify

/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */

import * as flatbuffers from 'flatbuffers';

import {
  NestedStruct,
  NestedStructT,
} from '../../my-game/example/nested-struct.js';
import {OuterStruct, OuterStructT} from '../../my-game/example/outer-struct.js';

export class ArrayStruct
  implements flatbuffers.IUnpackableObject<ArrayStructT>
{
  bb: flatbuffers.ByteBuffer | null = null;
  bb_pos = 0;
  __init(i: number, bb: flatbuffers.ByteBuffer): ArrayStruct {
    this.bb_pos = i;
    this.bb = bb;
    return this;
  }

  aUnderscore(): number {
    return this.bb!.readFloat32(this.bb_pos);
  }

  bUnderscore(index: number): number | null {
    return this.bb!.readInt32(this.bb_pos + 4 + index * 4);
  }

  c(): number {
    return this.bb!.readInt8(this.bb_pos + 64);
  }

  d(index: number, obj?: NestedStruct): NestedStruct | null {
    return (obj || new NestedStruct()).__init(
      this.bb_pos + 72 + index * 1072,
      this.bb!,
    );
  }

  e(): number {
    return this.bb!.readInt32(this.bb_pos + 2216);
  }

  f(index: number, obj?: OuterStruct): OuterStruct | null {
    return (obj || new OuterStruct()).__init(
      this.bb_pos + 2224 + index * 208,
      this.bb!,
    );
  }

  g(index: number): bigint | null {
    return this.bb!.readInt64(this.bb_pos + 2640 + index * 8);
  }

  static getFullyQualifiedName(): string {
    return 'MyGame.Example.ArrayStruct';
  }

  static sizeOf(): number {
    return 2656;
  }

  static createArrayStruct(
    builder: flatbuffers.Builder,
    a_underscore: number,
    b_underscore: number[] | null,
    c: number,
    d: (any | NestedStructT)[] | null,
    e: number,
    f: (any | OuterStructT)[] | null,
    g: bigint[] | null,
  ): flatbuffers.Offset {
    builder.prep(8, 2656);

    for (let i = 1; i >= 0; --i) {
      builder.writeInt64(BigInt(g?.[i] ?? 0));
    }

    for (let i = 1; i >= 0; --i) {
      const item = f?.[i];

      if (item instanceof OuterStructT) {
        item.pack(builder);
        continue;
      }

      OuterStruct.createOuterStruct(
        builder,
        item?.a,
        item?.b,
        item?.cUnderscore?.a ?? 0,
        item?.cUnderscore?.b ?? [],
        item?.cUnderscore?.c ?? 0,
        item?.cUnderscore?.dUnderscore ?? BigInt(0),
        item?.d,
        item?.e?.a ?? 0,
        item?.e?.b ?? [],
        item?.e?.c ?? 0,
        item?.e?.dUnderscore ?? BigInt(0),
        item?.f,
      );
    }

    builder.pad(4);
    builder.writeInt32(e);

    for (let i = 1; i >= 0; --i) {
      const item = d?.[i];

      if (item instanceof NestedStructT) {
        item.pack(builder);
        continue;
      }

      NestedStruct.createNestedStruct(
        builder,
        item?.a,
        item?.b,
        item?.cUnderscore,
        item?.dOuter,
        item?.e,
      );
    }

    builder.pad(7);
    builder.writeInt8(c);

    for (let i = 14; i >= 0; --i) {
      builder.writeInt32(b_underscore?.[i] ?? 0);
    }

    builder.writeFloat32(a_underscore);
    return builder.offset();
  }

  unpack(): ArrayStructT {
    return new ArrayStructT(
      this.aUnderscore(),
      this.bb!.createScalarList<number>(this.bUnderscore.bind(this), 15),
      this.c(),
      this.bb!.createObjList<NestedStruct, NestedStructT>(this.d.bind(this), 2),
      this.e(),
      this.bb!.createObjList<OuterStruct, OuterStructT>(this.f.bind(this), 2),
      this.bb!.createScalarList<bigint>(this.g.bind(this), 2),
    );
  }

  unpackTo(_o: ArrayStructT): void {
    _o.aUnderscore = this.aUnderscore();
    _o.bUnderscore = this.bb!.createScalarList<number>(
      this.bUnderscore.bind(this),
      15,
    );
    _o.c = this.c();
    _o.d = this.bb!.createObjList<NestedStruct, NestedStructT>(
      this.d.bind(this),
      2,
    );
    _o.e = this.e();
    _o.f = this.bb!.createObjList<OuterStruct, OuterStructT>(
      this.f.bind(this),
      2,
    );
    _o.g = this.bb!.createScalarList<bigint>(this.g.bind(this), 2);
  }
}

export class ArrayStructT implements flatbuffers.IGeneratedObject {
  constructor(
    public aUnderscore: number = 0.0,
    public bUnderscore: number[] = [],
    public c: number = 0,
    public d: NestedStructT[] = [],
    public e: number = 0,
    public f: OuterStructT[] = [],
    public g: bigint[] = [],
  ) {}

  pack(builder: flatbuffers.Builder): flatbuffers.Offset {
    return ArrayStruct.createArrayStruct(
      builder,
      this.aUnderscore,
      this.bUnderscore,
      this.c,
      this.d,
      this.e,
      this.f,
      this.g,
    );
  }
}
