import type { PersChar } from '../classes/PersChar';
import { Vector2 } from '../types/Vector2';
import { Vector3 } from '../types/Vector3';
import { Vector4 } from '../types/Vector4';
import { Color } from '../types/Color';
import { IHandle } from '../types/IHandle';
import { registerHandle, createFromHandle } from '../types/HandleRegistry';
import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f, int, uint, float, Hash, u8, u16, u32, u64, i8, i16, i32, i64 } from '../types/NativeAliases';

export class Volume implements IHandle {
  constructor(public handle: number) {}

  static fromHandle(handle: number): Volume | null {
    return handle === 0 ? null : new Volume(handle);
  }

  /**
   * @param typeHash 
   * @param pos 
   * @param rot 
   * @param scale 
   */
  addToVolumeAggregate(typeHash: string | number, pos: Vector3, rot: Vector3, scale: Vector3): void {
    inv<void>('0x12FCAA23F2320422', this.handle, _h(typeHash), f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(scale.x), f(scale.y), f(scale.z));
  }

  /**
   * @param rot 
   * @returns
   */
  setRotation(rot: Vector3): any {
    return inv<number>('0xA07CF1B21B56F041', this.handle, f(rot.x), f(rot.y), f(rot.z));
  }

  /**
   * @returns
   */
  get Rotation(): Vector3 {
    return Vector3.fromArray(inv<number[]>('0x18675BC914891122', this.handle, rav()));
  }

  deleteVolume(): void {
    inv<void>('0x43F867EF5C463A53', this.handle);
  }

  /**
   * @param p1 
   */
  N_0xD460135C98940274(p1: any): void {
    inv<void>('0xD460135C98940274', this.handle, p1);
  }

  /**
   * @param toggle 
   */
  set AntiGriefBlocksPlayer(toggle: boolean) {
    inv<void>('0x5B23DFF8E0948BB2', this.handle, toggle);
  }

  /**
   * @param toggle 
   * @returns The instance for method chaining
   */
  setAntiGriefBlocksPlayer(toggle: boolean): this {
    inv<void>('0x5B23DFF8E0948BB2', this.handle, toggle);
    return this;
  }

  /**
   * @param scale 
   * @returns
   */
  setScale(scale: Vector3): any {
    return inv<number>('0xA46E98BDC407E23D', this.handle, f(scale.x), f(scale.y), f(scale.z));
  }

  /**
   * @param persChar 
   * @param p2 
   * @returns The instance for method chaining
   */
  setOwnerPersistentCharacter(persChar: PersChar, p2: boolean): this {
    inv<void>('0xE2BE6FFA4A13CBB0', this.handle, persChar.handle, p2);
    return this;
  }

  /**
   * @returns min; max
   */
  get Bounds(): [Vector3, Vector3] {
    const result = inv<[number[], number[]]>('0x5737199AF2DC609F', this.handle, pvv(), pvv());
    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
  }

  /**
   * _ADD_R* - _ADD_V(OLUME?)*
   *
   * @param aggregate 
   */
  addBoundsToAggregateVolume(aggregate: Volume): void {
    inv<void>('0x6E0D3C3F828DA773', this.handle, aggregate.handle);
  }

  /**
   * @returns
   */
  get IsAggregateVolume(): boolean {
    return !!inv<boolean>('0xFEFF01B5725BCD22', this.handle, rai());
  }

  /**
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   */
  addBoxToVolumeAggregate(p1: float, p2: float, p3: float, p4: float, p5: float, p6: float, p7: float, p8: float, p9: float): void {
    inv<void>('0x39816F6F94F385AD', this.handle, f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9));
  }

  /**
   * @param p1 
   */
  N_0xB440F4E35393FC39(p1: any): void {
    inv<void>('0xB440F4E35393FC39', this.handle, p1);
  }

  /**
   * @returns
   */
  doesExist(): boolean {
    return !!inv<boolean>('0x92A78D0BEDB332A3', this.handle, rai());
  }

  /**
   * Returns relationshipGroup Hash
   *
   * @returns
   */
  get Relationship(): number {
    return (inv<number>('0x666C2F53ABEFC952', this.handle, rai())) & 0xFFFFFFFF;
  }

  /**
   * @param toggle 
   */
  set AntiGriefBlocksHorse(toggle: boolean) {
    inv<void>('0xBE551C2CC421185D', this.handle, toggle);
  }

  /**
   * @param toggle 
   * @returns The instance for method chaining
   */
  setAntiGriefBlocksHorse(toggle: boolean): this {
    inv<void>('0xBE551C2CC421185D', this.handle, toggle);
    return this;
  }

  /**
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   */
  addSphereToVolumeAggregate(p1: float, p2: float, p3: float, p4: float, p5: float, p6: float, p7: float, p8: float, p9: float): void {
    inv<void>('0x5B7D7BF36D2DE18B', this.handle, f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9));
  }

  /**
   * _REMOVE_E* - _REMOVE_R*
   *
   * @param aggregate 
   */
  removeBoundsFromAggregateVolume(aggregate: Volume): void {
    inv<void>('0xF92FA8890DECECF6', this.handle, aggregate.handle);
  }

  /**
   * @param relationshipGroup 
   */
  set Relationship(relationshipGroup: string | number) {
    inv<void>('0xFD010A2154B40676', this.handle, _h(relationshipGroup));
  }

  /**
   * @param relationshipGroup 
   * @returns The instance for method chaining
   */
  setRelationship(relationshipGroup: string | number): this {
    inv<void>('0xFD010A2154B40676', this.handle, _h(relationshipGroup));
    return this;
  }

  /**
   * @returns
   */
  get Coords(): Vector3 {
    return Vector3.fromArray(inv<number[]>('0xF70F00013A62F866', this.handle, rav()));
  }

  /**
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   */
  addCylinderToVolumeAggregate(p1: float, p2: float, p3: float, p4: float, p5: float, p6: float, p7: float, p8: float, p9: float): void {
    inv<void>('0xBCE668AAF83608BE', this.handle, f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9));
  }

  /**
   * Old name: _IS_POSITION_INSIDE_VOLUME
   *
   * @param pos 
   * @returns
   */
  isPointInVolume(pos: Vector3): boolean {
    return !!inv<boolean>('0xF256A75210C5C0EB', this.handle, f(pos.x), f(pos.y), f(pos.z), rai());
  }

  /**
   * @param pos 
   * @returns
   */
  setCoords(pos: Vector3): any {
    return inv<number>('0x541B8576615C33DE', this.handle, f(pos.x), f(pos.y), f(pos.z));
  }

  /**
   * @returns
   */
  get Scale(): Vector3 {
    return Vector3.fromArray(inv<number[]>('0x3E2A25B2416DD67E', this.handle, rav()));
  }

}

registerHandle('Volume', Volume);