import type { Entity } from '../classes/Entity';
import type { Ped } from '../classes/Ped';
import type { Player } from '../classes/Player';
import type { Prop } from '../classes/Prop';
import { Vector2 } from '../types/Vector2';
import { Vector3 } from '../types/Vector3';
import { Vector4 } from '../types/Vector4';
import { Color } from '../types/Color';
import { 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 Physics {
  /**
   * @param ropeId 
   * @param entity 
   */
  static detachRopeFromEntity(ropeId: int, entity: Entity): void {
    inv<void>('0xBCF3026912A8647D', ropeId, entity.handle);
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0xDEDE679ED29DD4E7(ropeId: int, p1: boolean): void {
    inv<void>('0xDEDE679ED29DD4E7', ropeId, p1);
  }

  /**
   * @param ropeId 
   */
  static stopRopeUnwindingBack(ropeId: int): void {
    inv<void>('0x10DAA76CB8A201A1', ropeId);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x483D4E917B0D35A9(p0: any, p1: any): void {
    inv<void>('0x483D4E917B0D35A9', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x32F4DBFDFCCCC735(p0: any, p1: any, p2: any): void {
    inv<void>('0x32F4DBFDFCCCC735', p0, p1, p2);
  }

  /**
   * Attaches a rope to two entities: binds two bones from two entities; one entity can be an object, i.e. a suspension point, the other an NPC bone
   *
   * @param ropeId 
   * @param entity1 
   * @param entity2 
   * @param ent1X 
   * @param ent1Y 
   * @param ent1Z 
   * @param ent2X 
   * @param ent2Y 
   * @param ent2Z 
   * @param boneName1 
   * @param boneName2 
   */
  static attachEntitiesToRope2(ropeId: int, entity1: Entity, entity2: Entity, ent1X: float, ent1Y: float, ent1Z: float, ent2X: float, ent2Y: float, ent2Z: float, boneName1: string, boneName2: string): void {
    inv<void>('0x462FF2A432733A44', ropeId, entity1.handle, entity2.handle, f(ent1X), f(ent1Y), f(ent1Z), f(ent2X), f(ent2Y), f(ent2Z), boneName1, boneName2);
  }

  /**
   * @param horse 
   */
  static unhitchHorse(horse: Ped): void {
    inv<void>('0x0348469DAA17576C', horse.handle);
  }

  /**
   * @param ropeId 
   * @param entity1 
   * @param entity2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   * @param p10 
   */
  static attachEntitesToRope3(ropeId: int, entity1: Entity, entity2: Entity, p3: float, p4: float, p5: float, p6: float, p7: float, p8: float, p9: any, p10: any): void {
    inv<void>('0xE9CD9A67834985A7', ropeId, entity1.handle, entity2.handle, f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), p9, p10);
  }

  /**
   * @param ropeId 
   * @returns
   */
  static getRopeVertexCount(ropeId: int): int {
    return inv<number>('0x3655F544CD30F0B5', ropeId, rai());
  }

  /**
   * @param horse 
   * @param pos 
   */
  static hitchHorse(horse: Ped, pos: Vector3): void {
    inv<void>('0x06AADE17334F7A40', horse.handle, f(pos.x), f(pos.y), f(pos.z));
  }

  /**
   * @param ropeId 
   * @returns
   */
  static ropeGetBreakerOfRope(ropeId: int): Player | null {
    return createFromHandle<Player>('Player', inv<number>('0xEE360CFC80C8B2BC', ropeId, rai()));
  }

  /**
   * *ROPE_SET**
   *
   * @param ropeId 
   * @param p1 
   */
  static N_0x8D59079C37C21D78(ropeId: int, p1: float): void {
    inv<void>('0x8D59079C37C21D78', ropeId, f(p1));
  }

  /**
   * @param ropeId 
   */
  static startRopeUnwindingBack(ropeId: int): void {
    inv<void>('0x00F611A794A3C36E', ropeId);
  }

  /**
   * Attaches entity 1 to entity 2.
   * If you use a boneName (p12/p13) make sure boneId (p15/p16) is set to -1.
   *
   * @param ropeId 
   * @param entity1 
   * @param entity2 
   * @param ent1X 
   * @param ent1Y 
   * @param ent1Z 
   * @param ent2X 
   * @param ent2Y 
   * @param ent2Z 
   * @param length 
   * @param alwaysZero1 
   * @param alwaysZero2 
   * @param boneName1 
   * @param boneName2 
   * @param p14 
   * @param boneId1 
   * @param boneId2 
   * @param alwaysZero3 
   * @param alwaysZero4 
   * @param p19 
   * @param p20 
   */
  static attachEntitiesToRope(ropeId: int, entity1: Entity, entity2: Entity, ent1X: float, ent1Y: float, ent1Z: float, ent2X: float, ent2Y: float, ent2Z: float, length: float, alwaysZero1: int, alwaysZero2: int, boneName1: string, boneName2: string, p14: boolean, boneId1: int, boneId2: int, alwaysZero3: int, alwaysZero4: int, p19: boolean, p20: boolean): void {
    inv<void>('0x3D95EC8B6D940AC3', ropeId, entity1.handle, entity2.handle, f(ent1X), f(ent1Y), f(ent1Z), f(ent2X), f(ent2Y), f(ent2Z), f(length), alwaysZero1, alwaysZero2, boneName1, boneName2, p14, boneId1, boneId2, alwaysZero3, alwaysZero4, p19, p20);
  }

  /**
   * @param visible 
   * @returns ropeId
   */
  static ropeChangeVisibility(visible: boolean): number {
    const result = inv<number>('0x7A54D82227A139DB', pvi(), visible);
    return result;
  }

  /**
   * @param ropeId 
   */
  static deleteChildRope(ropeId: int): void {
    inv<void>('0xAA5D6B1888E4DB20', ropeId);
  }

  /**
   * ropeTop returns top half of rope, ropeBottom returns bottom half of rope
   *
   * @param offset 
   * @param p6 
   * @returns ropeId; ropeTop; ropeBottom
   */
  static breakRope(offset: Vector3, p6: int): [number, number, number] {
    const result = inv<[number, number, number]>('0x4CFA2B7FAE115ECB', pvi(), pvi(), pvi(), f(offset.x), f(offset.y), f(offset.z), p6);
    return [result[0], result[1], result[2]];
  }

  /**
   * @param toggle 
   * @returns ropeId
   */
  static ropeDrawShadowEnabled(toggle: boolean): number {
    const result = inv<number>('0xF159A63806BB5BA8', pvi(), toggle);
    return result;
  }

  /**
   * @param p0 
   */
  static N_0x0CB16D05E03FB525(p0: any): void {
    inv<void>('0x0CB16D05E03FB525', p0);
  }

  /**
   * @param object 
   * @param toggle 
   */
  static setDisableFragDamage(object: Prop, toggle: boolean): void {
    inv<void>('0x01BA3AED21C16CFB', object.handle, toggle);
  }

  /**
   * @returns ropeId
   */
  static deleteRope(): number {
    const result = inv<number>('0x52B4829281364649', pvi());
    return result;
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0x1D97DA8ACB5D2582(ropeId: int, p1: int): void {
    inv<void>('0x1D97DA8ACB5D2582', ropeId, p1);
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0x461FCBDEB4D06717(ropeId: int, p1: boolean): void {
    inv<void>('0x461FCBDEB4D06717', ropeId, p1);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x5E981C764DF33117(p0: any, p1: any): void {
    inv<void>('0x5E981C764DF33117', p0, p1);
  }

  /**
   * @param ropeId 
   */
  static releaseRope(ropeId: int): void {
    inv<void>('0x6076213101A47B3B', ropeId);
  }

  /**
   * Forces a rope to a certain length.
   *
   * @param ropeId 
   * @param length 
   */
  static ropeForceLength(ropeId: int, length: float): void {
    inv<void>('0xD009F759A723DB1B', ropeId, f(length));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x3900491C0D61ED4B(p0: any, p1: any): void {
    inv<void>('0x3900491C0D61ED4B', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   */
  static N_0xF27F1A8DE4F50A1B(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any): void {
    inv<void>('0xF27F1A8DE4F50A1B', p0, p1, p2, p3, p4, p5, p6);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x31160EC47E7C9549(p0: any, p1: any): void {
    inv<void>('0x31160EC47E7C9549', p0, p1);
  }

  /**
   * @param ropeId 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0xD699E688B49C0FD2(ropeId: int, p1: float, p2: float, p3: float, p4: boolean): void {
    inv<void>('0xD699E688B49C0FD2', ropeId, f(p1), f(p2), f(p3), p4);
  }

  /**
   * @param p0 
   */
  static N_0x9C24846D0A4A2776(p0: any): void {
    inv<void>('0x9C24846D0A4A2776', p0);
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0x1FC92BDBA1106BD2(ropeId: int, p1: float): void {
    inv<void>('0x1FC92BDBA1106BD2', ropeId, f(p1));
  }

  /**
   * @param object 
   * @param toggle 
   */
  static setDisableBreaking(object: Prop, toggle: boolean): void {
    inv<void>('0x5CEC1A84620E7D5B', object.handle, toggle);
  }

  /**
   * @param entity 
   */
  static activatePhysics(entity: Entity): void {
    inv<void>('0x710311ADF0E20730', entity.handle);
  }

  /**
   * @param p0 
   */
  static N_0xEAF529446488EB18(p0: any): void {
    inv<void>('0xEAF529446488EB18', p0);
  }

  /**
   * @param ropeId 
   * @returns
   */
  static getRopeLastVertexCoord(ropeId: int): Vector3 {
    return Vector3.fromArray(inv<number[]>('0x21BB0FBD3E217C2D', ropeId, rav()));
  }

  /**
   * @param p0 
   */
  static N_0x751DF00EEFF122E3(p0: any): void {
    inv<void>('0x751DF00EEFF122E3', p0);
  }

  /**
   * @param ropeId 
   * @param p1 
   * @param pos 
   */
  static N_0xE54BF2CE6C7D23A9(ropeId: int, p1: int, pos: Vector3): void {
    inv<void>('0xE54BF2CE6C7D23A9', ropeId, p1, f(pos.x), f(pos.y), f(pos.z));
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0xF1EA2A881EB7F2CD(ropeId: int, p1: boolean): void {
    inv<void>('0xF1EA2A881EB7F2CD', ropeId, p1);
  }

  /**
   * @param p0 
   */
  static N_0x6EA0E93CFFA472CC(p0: any): void {
    inv<void>('0x6EA0E93CFFA472CC', p0);
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static ropeSetUpdateOrder(ropeId: int, p1: any): void {
    inv<void>('0xDC57A637A20006ED', ropeId, p1);
  }

  /**
   * @param ropeId 
   * @returns
   */
  static isRopeBroken(ropeId: int): boolean {
    return !!inv<boolean>('0x79C2BEC82CFD7F7F', ropeId, rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   */
  static N_0x69C810B72291D831(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any): void {
    inv<void>('0x69C810B72291D831', p0, p1, p2, p3, p4, p5, p6);
  }

  /**
   * @param entity 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   * @param p10 
   */
  static breakEntityGlass(entity: Entity, p1: float, p2: float, p3: float, p4: float, p5: float, p6: float, p7: float, p8: float, p9: any, p10: boolean): void {
    inv<void>('0x2E648D16F6E308F3', entity.handle, f(p1), f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), p9, p10);
  }

  /**
   * @param ropeId 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   * @param p10 
   */
  static N_0x21D0890D88DFB0B0(ropeId: int, p1: boolean, p2: float, p3: float, p4: float, p5: float, p6: float, p7: float, p8: float, p9: float, p10: int): void {
    inv<void>('0x21D0890D88DFB0B0', ropeId, p1, f(p2), f(p3), f(p4), f(p5), f(p6), f(p7), f(p8), f(p9), p10);
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0xB40EA9E0D2E2F7F3(ropeId: int, p1: float): void {
    inv<void>('0xB40EA9E0D2E2F7F3', ropeId, f(p1));
  }

  /**
   * @param pos 
   * @param rot 
   * @param length 
   * @param ropeType 
   * @param isNetworked 
   * @param p9 
   * @param p10 
   * @returns
   */
  static addRope2(pos: Vector3, rot: Vector3, length: float, ropeType: int, isNetworked: boolean, p9: int, p10: float): int {
    return inv<number>('0xE9C59F6809373A99', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(length), ropeType, isNetworked, p9, f(p10), rai());
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0xF8CA39D5C0D1D9A1(p0: any, p1: any): void {
    inv<void>('0xF8CA39D5C0D1D9A1', p0, p1);
  }

  /**
   * @param entity 
   * @param vertex 
   * @param value 
   */
  static setDamping(entity: Entity, vertex: int, value: float): void {
    inv<void>('0xEEA3B200A6FEB65B', entity.handle, vertex, f(value));
  }

  /**
   * @param ropeId 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   */
  static N_0xBB3E9B073E66C3C9(ropeId: int, p1: boolean, p2: boolean, p3: boolean, p4: boolean): void {
    inv<void>('0xBB3E9B073E66C3C9', ropeId, p1, p2, p3, p4);
  }

  /**
   * There are 19 types of rope, from type = 0 to type = 18
   * Rope definitions are stored in ropedata.xml
   * Rope types 0, 15 and 18 have proper physics for hanging objects (taut, do not sag, small to medium diameter, good aspect for a rope)
   *
   * @param pos 
   * @param rot 
   * @param length 
   * @param ropeType 
   * @param maxLength 
   * @param minLength 
   * @param p10 
   * @param p11 
   * @param p12 
   * @param rigid 
   * @param p14 
   * @param breakWhenShot 
   * @param p17 
   * @returns unkPtr
   */
  static addRope(pos: Vector3, rot: Vector3, length: float, ropeType: int, maxLength: float, minLength: float, p10: float, p11: boolean, p12: boolean, rigid: boolean, p14: float, breakWhenShot: boolean, p17: boolean): [int, number] {
    const result = inv<[number, number]>('0xE832D760399EB220', f(pos.x), f(pos.y), f(pos.z), f(rot.x), f(rot.y), f(rot.z), f(length), ropeType, f(maxLength), f(minLength), f(p10), p11, p12, rigid, f(p14), breakWhenShot, pvi(), p17, rai());
    return [result[0], result[1]];
  }

  /**
   * @param ropeId 
   */
  static stopRopeUnwindingFront(ropeId: int): void {
    inv<void>('0xFFF3A50779EFBBB3', ropeId);
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0xC89E7410A93AC19A(ropeId: int, p1: float): void {
    inv<void>('0xC89E7410A93AC19A', ropeId, f(p1));
  }

  /**
   * Combining this with ADD_ROPE enables winding
   * p1: mostly empty (0)
   * ropeModelType: RB_L_Wrist02, RB_R_Wrist02, ropeAttach, noose01x_Rope_03, SKEL_Neck0, SKEL_L_FOOT, SKEL_Neck1, Root_s_meatbit_Chunck_Xlarge01x
   * *CREATE**
   *
   * @param ropeId 
   * @param p1 
   * @param ropeModelType 
   * @param length 
   * @param p4 
   */
  static createRopeWindingAbility(ropeId: int, p1: string, ropeModelType: string, length: float, p4: boolean): void {
    inv<void>('0x3C6490D940FF5D0B', ropeId, p1, ropeModelType, f(length), p4);
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0xFB9153A54AC713E8(ropeId: int, p1: boolean): void {
    inv<void>('0xFB9153A54AC713E8', ropeId, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   * @param p8 
   * @param p9 
   */
  static N_0x8EEDFD8921389928(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any, p8: any, p9: any): void {
    inv<void>('0x8EEDFD8921389928', p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
  }

  /**
   * @param ropeId 
   * @param p1 
   * @param p2 
   */
  static N_0x522FA3F490E2F7AC(ropeId: int, p1: any, p2: any): void {
    inv<void>('0x522FA3F490E2F7AC', ropeId, p1, p2);
  }

  /**
   * @param ropeId 
   * @returns
   */
  static doesRopeExist(ropeId: int): boolean {
    return !!inv<boolean>('0xFD5448BE3111ED96', ropeId, rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   */
  static N_0xB7469CB9AC3C0FD4(p0: any, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
    inv<void>('0xB7469CB9AC3C0FD4', p0, p1, p2, p3, p4, p5, p6, p7);
  }

  /**
   * @param ropeId 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   */
  static N_0xC64E7A62632AD2FE(ropeId: int, p1: any, p2: any, p3: any, p4: any, p5: any, p6: any, p7: any): void {
    inv<void>('0xC64E7A62632AD2FE', ropeId, p1, p2, p3, p4, p5, p6, p7);
  }

  /**
   * @param p0 
   */
  static N_0xBDDA142759307528(p0: any): void {
    inv<void>('0xBDDA142759307528', p0);
  }

  /**
   * @param ropeId 
   * @returns
   */
  static ropeGetForcedLength(ropeId: int): float {
    return inv<number>('0x3D69537039F8D824', ropeId, raf());
  }

  /**
   * @param ropeId 
   * @param vertex 
   * @returns
   */
  static getRopeVertexCoord(ropeId: int, vertex: int): Vector3 {
    return Vector3.fromArray(inv<number[]>('0xEA61CA8E80F09E4D', ropeId, vertex, rav()));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x5A989B7EE3672A56(p0: any, p1: any): void {
    inv<void>('0x5A989B7EE3672A56', p0, p1);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x814D453FCFDF119F(p0: any, p1: any, p2: any): void {
    inv<void>('0x814D453FCFDF119F', p0, p1, p2);
  }

  /**
   * @param ropeId 
   */
  static startRopeWinding(ropeId: int): void {
    inv<void>('0x1461C72C889E343E', ropeId);
  }

  /**
   * @param ropeId 
   */
  static startRopeUnwindingFront(ropeId: int): void {
    inv<void>('0x538D1179EC1AA9A9', ropeId);
  }

  /**
   * @param ropeId 
   */
  static stopRopeWinding(ropeId: int): void {
    inv<void>('0xCB2D4AB84A19AA7C', ropeId);
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x5BD7457221CC5FF4(p0: any, p1: any): void {
    inv<void>('0x5BD7457221CC5FF4', p0, p1);
  }

  /**
   * @param ropeId 
   * @param entity 
   * @returns
   */
  static isRopeAttachedToEntity(ropeId: int, entity: Entity): boolean {
    return !!inv<boolean>('0x9B4F7E3E4F9C77B3', ropeId, entity.handle, rai());
  }

  /**
   * @param ropeId 
   * @param p1 
   */
  static N_0x76BAD9D538BCA1AA(ropeId: int, p1: float): void {
    inv<void>('0x76BAD9D538BCA1AA', ropeId, f(p1));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x423C6B1F3786D28B(p0: any, p1: any): void {
    inv<void>('0x423C6B1F3786D28B', p0, p1);
  }

}