import type { Entity } from '../classes/Entity';
import type { Ped } from '../classes/Ped';
import type { Prop } from '../classes/Prop';
import type { Vehicle } from '../classes/Vehicle';
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 AnimScene implements IHandle {
  constructor(public handle: number) {}

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

  /**
   * @param p1 
   * @returns
   */
  isAnimSceneMetadataAssetInRangeLoading(p1: boolean): boolean {
    return !!inv<boolean>('0xF8D1D2DAB6007EEF', this.handle, p1, rai());
  }

  /**
   * @param entityName 
   * @returns
   */
  hasEntityExitedAnimScene(entityName: string): any {
    return inv<number>('0xB89FCFF19DAFFF28', this.handle, entityName);
  }

  /**
   * @param order 
   * @returns position; rotation
   */
  getAnimSceneOrigin(order: int): [Vector3, Vector3] {
    const result = inv<[number[], number[]]>('0xADF1D53F3B1FE0A7', this.handle, pvv(), pvv(), order);
    return [Vector3.fromArray(result[0]), Vector3.fromArray(result[1])];
  }

  /**
   * @param entityName 
   * @returns
   */
  doesAnimSceneOwnershipOfEntityExist(entityName: string): boolean {
    return !!inv<boolean>('0x9D1ECA9337BE9FC3', this.handle, entityName, rai());
  }

  /**
   * @param pos 
   * @param rot 
   * @param order 
   * @returns The instance for method chaining
   */
  setAnimSceneOrigin(pos: Vector3, rot: Vector3, order: int): this {
    inv<void>('0x020894BF17A02EF2', this.handle, f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), order);
    return this;
  }

  /**
   * @param name 
   * @returns
   */
  getAnimSceneBool(name: string): any {
    return inv<number>('0x07A6F6447ECA9B64', this.handle, name);
  }

  /**
   * @param phaseName 
   * @returns
   */
  getAnimScenePlaybackListPhaseAudioLoadStress(phaseName: string): int {
    return inv<number>('0x9E036D5204FFBBC8', this.handle, phaseName, rai());
  }

  /**
   * @param playlistName 
   * @returns
   */
  releaseAnimScenePlayList(playlistName: string): any {
    return inv<number>('0xAE6ADA8FE7E84ACC', this.handle, playlistName);
  }

  /**
   * @param entityName 
   * @param entity 
   * @param flags 
   * @returns The instance for method chaining
   */
  setAnimSceneEntity(entityName: string, entity: Entity, flags: int): this {
    inv<void>('0x8B720AD451CA2AB3', this.handle, entityName, entity.handle, flags);
    return this;
  }

  /**
   * @param rate 
   */
  set AnimSceneRate(rate: float) {
    inv<void>('0x75820B801CFF262A', this.handle, f(rate));
  }

  /**
   * @param rate 
   * @returns The instance for method chaining
   */
  setAnimSceneRate(rate: float): this {
    inv<void>('0x75820B801CFF262A', this.handle, f(rate));
    return this;
  }

  /**
   * @param entityId 
   * @returns
   */
  doesEntityWithIdExistInAnimScene(entityId: string): boolean {
    return !!inv<boolean>('0x6F1F0B17109309DA', this.handle, entityId, rai());
  }

  /**
   * @param playbackListName 
   */
  set AnimScenePlaybackList(playbackListName: string) {
    inv<void>('0xAB5E7CAB074D6B84', this.handle, playbackListName);
  }

  /**
   * @param playbackListName 
   * @returns The instance for method chaining
   */
  setAnimScenePlaybackList(playbackListName: string): this {
    inv<void>('0xAB5E7CAB074D6B84', this.handle, playbackListName);
    return this;
  }

  /**
   * @param entityName 
   * @param p2 
   * @param p3 
   * @returns
   */
  couldAnimSceneEntityReachExitNextFrame(entityName: string, p2: any, p3: any): any {
    return inv<number>('0x73616E64696C616E', this.handle, entityName, p2, p3);
  }

  /**
   * @returns
   */
  get AnimSceneCurrentActiveCameraCount(): int {
    return inv<number>('0x4822A65D5AF64E69', this.handle, rai());
  }

  /**
   * @param name 
   * @returns
   */
  getAnimSceneFloat(name: string): float {
    return inv<number>('0xCC24CB07F60B496E', this.handle, name, raf());
  }

  /**
   * @param p1 
   * @returns
   */
  isAnimSceneLoading(p1: boolean): boolean {
    return !!inv<boolean>('0x59606519FF9D3EC2', this.handle, p1, rai());
  }

  /**
   * @param entity 
   * @param boneId 
   */
  attachAnimSceneToEntity(entity: Entity, boneId: u32 = 0xFFFFFFFF): void {
    inv<void>('0xDC418495DBA327A1', this.handle, entity.handle, boneId);
  }

  /**
   * @param name 
   * @param value 
   * @param p3 
   * @param p4 
   * @returns The instance for method chaining
   */
  setAnimSceneFloat(name: string, value: float, p3: boolean, p4: boolean): this {
    inv<void>('0x6BC5104E68CBEFE8', this.handle, name, f(value), p3, p4);
    return this;
  }

  /**
   * Used in SP R* Scripts only
   * *IS_ANIM_SCENE**
   *
   * @returns
   */
  N_0x9AAE3C1148A09BCA(): boolean {
    return !!inv<boolean>('0x9AAE3C1148A09BCA', this.handle, rai());
  }

  /**
   * @param name 
   * @param value 
   * @param p3 
   * @returns The instance for method chaining
   */
  setAnimSceneInt(name: string, value: int, p3: boolean): this {
    inv<void>('0x3A379D2166CF5B92', this.handle, name, value, p3);
    return this;
  }

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

  /**
   * @param phaseName 
   * @returns
   */
  isAnimScenePlaybackListPhaseLoading(phaseName: string): boolean {
    return !!inv<boolean>('0x0DF57F86FE71DBE5', this.handle, phaseName, rai());
  }

  /**
   * _HAS_L* (?)
   *
   * @param entityName 
   * @returns
   */
  hasEntityEnteredAnimScene(entityName: string): any {
    return inv<number>('0x337F1CC8EE895601', this.handle, entityName);
  }

  /**
   * @param entityName 
   * @param p3 
   * @param playbackListName 
   * @param p5 
   * @returns matrix
   */
  getAnimSceneEntityLocationData(entityName: string, p3: boolean, playbackListName: string, p5: int): [any, Vector3] {
    const result = inv<[number, number[]]>('0x8398438D8F14F56D', this.handle, entityName, pvv(), p3, playbackListName, p5);
    return [result[0], Vector3.fromArray(result[1])];
  }

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

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

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

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

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

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

  /**
   * @param name 
   * @param isNetwork 
   * @returns
   */
  getAnimSceneVehicle(name: string, isNetwork: boolean): Vehicle | null {
    return createFromHandle<Vehicle>('Vehicle', inv<number>('0x430EE0A19BC5A287', this.handle, name, isNetwork, rai()));
  }

  /**
   * @returns
   */
  get AnimSceneTime(): float {
    return inv<number>('0x61BE7D6186260002', this.handle, raf());
  }

  /**
   * @param playlistName 
   * @param p2 
   * @returns The instance for method chaining
   */
  setAnimScenePlayList(playlistName: string, p2: boolean): this {
    inv<void>('0x15598CFB25F3DC7E', this.handle, playlistName, p2);
    return this;
  }

  /**
   * @returns
   */
  get AnimScenePhase(): float {
    return inv<number>('0x3FBC3F51BF12DFBF', this.handle, raf());
  }

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

  /**
   * @param entityName 
   * @param entity 
   */
  removeAnimSceneEntity(entityName: string, entity: Entity): void {
    inv<void>('0x2BF96692C67F3E53', this.handle, entityName, entity.handle);
  }

  /**
   * @param p1 
   */
  abortAnimScene(p1: boolean): void {
    inv<void>('0x718CF1328D20C2B3', this.handle, p1);
  }

  /**
   * @param playbackListName 
   * @returns
   */
  doesAnimScenePlayListExist(playbackListName: string): boolean {
    return !!inv<boolean>('0xA9016536015DE29D', this.handle, playbackListName, rai());
  }

  /**
   * @param phaseName 
   * @returns
   */
  isAnimScenePlaybackListPhaseActive(phaseName: string): boolean {
    return !!inv<boolean>('0x1F0E401031E20146', this.handle, phaseName, rai());
  }

  /**
   * @param phaseName 
   * @returns
   */
  isAnimScenePlaybackListPhaseLoaded(phaseName: string): boolean {
    return !!inv<boolean>('0x23E33CB9F4A3F547', this.handle, phaseName, rai());
  }

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

  /**
   * @param p1 
   * @returns
   */
  isAnimSceneFinished(p1: boolean): boolean {
    return !!inv<boolean>('0xD8254CB2C586412B', this.handle, p1, rai());
  }

  /**
   * @param name 
   * @param isNetwork 
   * @returns
   */
  getAnimSceneObject(name: string, isNetwork: boolean): Prop | null {
    return createFromHandle<Prop>('Prop', inv<number>('0xFB5674687A1B2814', this.handle, name, isNetwork, rai()));
  }

  /**
   * @returns
   */
  get AnimSceneRate(): float {
    return inv<number>('0x43C21623E42B821B', this.handle, raf());
  }

  /**
   * @param p1 
   * @returns
   */
  hasAnimSceneExited(p1: boolean): any {
    return inv<number>('0xF94692EB9DC15D74', this.handle, p1);
  }

  /**
   * @param p1 
   */
  fadeAnimSceneAudioIn(p1: float): void {
    inv<void>('0xA41351EA2A18A0AD', this.handle, f(p1));
  }

  /**
   * @returns
   */
  get AnimSceneDict(): number {
    return (inv<number>('0xAE5ADA4FE3E21ADC', this.handle, rai())) & 0xFFFFFFFF;
  }

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

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

  /**
   * @param p1 
   */
  fadeAnimSceneAudioOut(p1: float): void {
    inv<void>('0x323E3AD772BA5D57', this.handle, f(p1));
  }

  /**
   * @param entityName 
   * @returns
   */
  isEntityExitingAnimSceneThisFrame(entityName: string): boolean {
    return !!inv<boolean>('0x005E6F28DD7ED58D', this.handle, entityName, rai());
  }

  /**
   * @param p1 
   * @returns
   */
  isAnimSceneMetadataLoaded(p1: boolean): boolean {
    return !!inv<boolean>('0x95531A4A20CCE7BC', this.handle, p1, rai());
  }

  /**
   * Used in SP R* Scripts only
   * _IS_ANIM_SCENE_P*
   *
   * @param phaseName 
   * @returns
   */
  N_0x1C5D33A4293E6DDE(phaseName: string): boolean {
    return !!inv<boolean>('0x1C5D33A4293E6DDE', this.handle, phaseName, rai());
  }

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

  /**
   * @param entity 
   * @param p2 
   */
  attachAnimSceneToEntityPreservingLocation(entity: Entity, p2: int): void {
    inv<void>('0x1C0B105C3F30B88D', this.handle, entity.handle, p2);
  }

  /**
   * @param playlistName 
   * @returns
   */
  requestAnimScenePlayList(playlistName: string): any {
    return inv<number>('0xDF7B5144E25CD3FE', this.handle, playlistName);
  }

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

  /**
   * @param p1 
   * @returns
   */
  isAnimSceneRunning(p1: boolean): boolean {
    return !!inv<boolean>('0xCBFC7725DE6CE2E0', this.handle, p1, rai());
  }

  /**
   * Used in SP R* Scripts only
   * *IS_ANIM_SCENE**
   *
   * @returns
   */
  N_0xD70C7A30412F8FA0(): boolean {
    return !!inv<boolean>('0xD70C7A30412F8FA0', this.handle, rai());
  }

  /**
   * @param name 
   * @param value 
   * @param p3 
   * @returns The instance for method chaining
   */
  setAnimSceneBool(name: string, value: boolean, p3: boolean): this {
    inv<void>('0x519E96C2C68B404B', this.handle, name, value, p3);
    return this;
  }

  /**
   * Used in SP R* Scripts only
   * _CO* - _CR*
   *
   * @param p1 
   * @returns
   */
  N_0x73616E64696C132E(p1: boolean): boolean {
    return !!inv<boolean>('0x73616E64696C132E', this.handle, p1, rai());
  }

  /**
   * @returns
   */
  get AnimSceneDuration(): float {
    return inv<number>('0x49F1D143ADE32656', this.handle, raf());
  }

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

  /**
   * Used in SP R* Scripts only
   * *WAS_ANIM_SCENE**
   *
   * @returns
   */
  N_0xA96619FE85159ED2(): boolean {
    return !!inv<boolean>('0xA96619FE85159ED2', this.handle, rai());
  }

  /**
   * @param playbackListName 
   */
  resetAnimScene(playbackListName: string): void {
    inv<void>('0x8FDF221F13537936', this.handle, playbackListName);
  }

  /**
   * @param sectionName 
   * @param p2 
   * @returns
   */
  isAnimSceneInSection(sectionName: string, p2: boolean): boolean {
    return !!inv<boolean>('0x8D81E7824B7753F7', this.handle, sectionName, p2, rai());
  }

  /**
   * @param p1 
   * @param p2 
   * @returns
   */
  isAnimSceneLoaded(p1: boolean, p2: boolean): boolean {
    return !!inv<boolean>('0x477122B8D05E7968', this.handle, p1, p2, rai());
  }

  /**
   * Used in Script Function CUTSCENE_MANAGE_SKIP
   * *CHECK** (?)
   *
   * @returns
   */
  N_0x4B85B3CF91972222(): boolean {
    return !!inv<boolean>('0x4B85B3CF91972222', this.handle, rai());
  }

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

  /**
   * @param name 
   * @returns
   */
  getAnimSceneInt(name: string): int {
    return inv<number>('0x2B7277484CC095FD', this.handle, name, rai());
  }

  /**
   * @param name 
   * @param isNetwork 
   * @returns
   */
  getAnimScenePed(name: string, isNetwork: boolean): Ped | null {
    return createFromHandle<Ped>('Ped', inv<number>('0xE5822422197BBBA3', this.handle, name, isNetwork, rai()));
  }

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

  /**
   * @returns
   */
  wasAnimSceneSkipped(): any {
    return inv<number>('0xEF324E9550A394D5', this.handle);
  }

  /**
   * Used in SP R* Scripts only
   * Params: p1 = 2B-LowHonor, 2A-HighHonor
   *
   * @param p1 
   * @returns
   */
  N_0x1407F5115FB9583E(p1: string): boolean {
    return !!inv<boolean>('0x1407F5115FB9583E', this.handle, p1, rai());
  }

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

}

registerHandle('AnimScene', AnimScene);