import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { RigidBody, World } from '@dimforge/rapier3d-compat';

type SetInputFn = (input: Partial<{
    moveX: 1 | 0 | -1;
    moveY: 1 | 0 | -1;
    lookDeltaX: number;
    lookDeltaY: number;
    jump: boolean;
    shift: boolean;
    toggleView: boolean;
    toggleFly: boolean;
    toggleVehicle: boolean;
}>) => void;
declare class VirtualJoystick {
    private baseEl;
    private stickEl;
    private pointerId;
    private center;
    private radius;
    private onMove;
    private onEnd;
    constructor(zone: HTMLDivElement, size: number, onMove: (data: {
        vector: {
            x: number;
            y: number;
        };
        distance: number;
    }) => void, onEnd: () => void);
    private onPointerDown;
    private onPointerMove;
    private onPointerUp;
    private updateStick;
    destroy(): void;
}
declare class MobileControls {
    setInput: SetInputFn;
    controls: OrbitControls;
    joystick: VirtualJoystick | null;
    prevJoyState: {
        dirX: number;
        dirY: number;
        shift: boolean;
    };
    joystickZoneEl: HTMLDivElement | null;
    lookAreaEl: HTMLDivElement | null;
    jumpBtnEl: HTMLButtonElement | null;
    flyBtnEl: HTMLButtonElement | null;
    viewBtnEl: HTMLButtonElement | null;
    vehicleBtnEl: HTMLButtonElement | null;
    lookPointerId: number | null;
    isLookDown: boolean;
    lastTouchX: number;
    lastTouchY: number;
    constructor(setInput: SetInputFn, controls: OrbitControls);
    init(opts?: {
        joystick?: boolean;
        jump?: boolean;
        fly?: boolean;
        view?: boolean;
        vehicle?: boolean;
    }): Promise<void>;
    destroy(): void;
    syncVehicleBtn(show: boolean): void;
    syncControllerModeBtn(mode: 0 | 1): void;
    private onPointerDown;
    private onPointerMove;
    private onPointerUp;
    private blockTouch;
    private createBtn;
}

interface ObstacleChecker {
    isBlocked(start: THREE.Vector3, end: THREE.Vector3): boolean;
    getNavigationNodes(start: THREE.Vector3, goal: THREE.Vector3): THREE.Vector3[];
}
interface PathPlannerConfig {
    debugEnabled?: boolean;
    scene?: THREE.Scene;
    scale?: number;
}
declare class PathPlanner {
    obstacleChecker: ObstacleChecker;
    config: PathPlannerConfig;
    debugLines: THREE.Line[];
    debugPoints: THREE.Mesh[];
    constructor(obstacleChecker: ObstacleChecker, config?: PathPlannerConfig);
    private heuristic;
    findPath(start: THREE.Vector3, goal: THREE.Vector3): THREE.Vector3[];
    private reconstructPath;
    private smoothPath;
    private visualizePath;
    clearVisualization(): void;
    updateConfig(config: Partial<PathPlannerConfig>): void;
    dispose(): void;
}

type PlayerModelOptions = {
    url: string;
    scale: number;
    idleAnim: string;
    walkAnim: string;
    runAnim: string;
    jumpAnim: string | [startAnim: string, loopAnim: string, endAnim: string];
    leftWalkAnim?: string;
    rightWalkAnim?: string;
    backwardAnim?: string;
    flyAnim?: string;
    flyIdleAnim?: string;
    flyHoverForwardAnim?: string;
    flyHoverBackAnim?: string;
    flyHoverLeftAnim?: string;
    flyHoverRightAnim?: string;
    flyHoverUpAnim?: string;
    flyHoverDownAnim?: string;
    enterCarAnim?: string;
    exitCarAnim?: string;
    gravity?: number;
    jumpHeight?: number;
    speed?: number;
    flySpeed?: number;
    rotateY?: number;
    headBoneName?: string;
    firstPersonCameraOffset?: [number, number, number];
    capsuleRadiusRatio?: number;
    acceleration?: number;
    deceleration?: number;
};
type MobileControlsOptions = {
    joystick?: boolean;
    jump?: boolean;
    fly?: boolean;
    view?: boolean;
    vehicle?: boolean;
};
type KeyAction = "forward" | "backward" | "left" | "right" | "sprint" | "jump" | "toggleView" | "toggleFly" | "toggleVehicle";
type KeyMap = Partial<Record<KeyAction, string | string[] | null>>;
type PlayerControllerOptions = {
    scene: THREE.Scene;
    camera: THREE.PerspectiveCamera;
    controls: any;
    playerModelConfig: PlayerModelOptions;
    initPos?: THREE.Vector3;
    mouseSensitivity?: number;
    minCamDistance?: number;
    maxCamDistance?: number;
    camLookAtHeightRatio?: number;
    staticCollider?: THREE.Object3D | THREE.Object3D[];
    dynamicCollider?: THREE.Object3D | THREE.Object3D[];
    isShowMobileControls?: boolean;
    mobileControls?: MobileControlsOptions;
    thirdMouseMode?: 0 | 1 | 2 | 3 | 4 | 5;
    enableZoom?: boolean;
    enableOverShoulderView?: boolean;
    isFirstPerson?: boolean;
    enableSpringCamera?: boolean;
    springCameraTime?: number;
    timeScale?: number;
    keyMap?: KeyMap;
};
type VehicleOptions = {
    url: string;
    position: THREE.Vector3;
    wheelsNames: string[];
    scale?: number;
    animations: {
        openDoorAnim?: string;
    };
    boardingPoint: THREE.Vector3;
    seatOffset?: THREE.Vector3;
    chassisRatio?: number;
    suspensionRestLengthRatio?: number;
    followVehicleDirection?: boolean;
    speedMultiplier?: number;
};
type VehicleInstance = {
    vehicleGroup: THREE.Group;
    chassisBody: RigidBody;
    vehicleController: any;
    updateWheelVisuals: () => void;
    vehicleMixer?: THREE.AnimationMixer;
    vehicleActions?: Map<string, THREE.AnimationAction>;
    vehiclIsOpenDoor: boolean;
    vehicleBBox: THREE.Box3;
    pathPlanner: PathPlanner;
    scale: number;
    boardingPoint: THREE.Vector3;
    seatOffset: THREE.Vector3;
    enterVehicleTime: number;
    chassisRatio: number;
    suspensionRestLengthRatio: number;
    size: {
        l: number;
        w: number;
        h: number;
    };
    speedMultiplier: number;
    physicsBoxMesh?: THREE.Mesh;
};
type DynamicColliderEntry = {
    source: THREE.Object3D;
    mesh: THREE.Mesh;
    prevWorldMatrix: THREE.Matrix4;
    deltaPos: THREE.Vector3;
    deltaRotY: number;
};

declare class AnimationSystem {
    private ctrl;
    mixer?: THREE.AnimationMixer;
    mixerCb?: (ev: any) => void;
    actions?: Map<string, THREE.AnimationAction>;
    state: THREE.AnimationAction;
    sets: Map<string, Map<string, THREE.AnimationAction>>;
    currentLocomotionSet: string | null;
    recheckTimer: any;
    clips: THREE.AnimationClip[];
    hasThreePartJump: boolean;
    isOverrideAnimationPlaying: boolean;
    private overrideInputSnapshot;
    constructor(ctrl: playerController);
    playByName(name: string, fade?: number): void;
    register(key: string, clipName: string, opts?: {
        loop?: boolean;
        timeScale?: number;
        duration?: number;
        clampWhenFinished?: boolean;
        onFinished?: () => void;
    }): void;
    registerLocomotionSet(setName: string, map: Partial<Record<"idle" | "walking" | "walking_backward" | "running" | "jumping" | "flyidle" | "flying", string>>): void;
    switchLocomotionSet(setName: string, fade?: number): void;
    play(key: string, opts?: {
        fade?: number;
        force?: boolean;
        returnToPrev?: boolean;
    }): void;
    startJump(inAir?: boolean): void;
    onBecomeAirborne(): void;
    onLand(): void;
    isJumping(): boolean;
    getCurrentName(): string | null;
    updateMixers(delta: number): void;
    setAnimationByPressed(): void;
}

declare class CameraSystem {
    private ctrl;
    collisionLerp: number;
    epsilon: number;
    minDist: number;
    maxDist: number;
    originMaxDist: number;
    sensitivity: number;
    mouseMode: 0 | 1 | 2 | 3 | 4 | 5;
    zoomEnabled: boolean;
    lookAtHeightRatio: number;
    private lookAtPoint;
    enableSpringCamera: boolean;
    springCameraTime: number;
    private _springVelocity;
    private _springResult;
    raycaster: THREE.Raycaster;
    centerRay: THREE.Raycaster;
    centerMouse: THREE.Vector2;
    playerToCam: THREE.Vector3;
    constructor(ctrl: playerController);
    applySpringToTarget(delta: number): THREE.Vector3;
    getLookAtPoint(): THREE.Vector3;
    setOverShoulder(enable: boolean): void;
    changeView(): void;
    setFirstPerson(vertAngle?: number): void;
    setPointerLock(): void;
    setCamPos(): void;
    initControls(): void;
    resetControls(): void;
    setToward(dx: number, dy: number, speed: number): void;
    private orbit;
    updateWithRaycast(origin: THREE.Vector3, desiredDist: number, maxDist: number): void;
    getCenterHit(): THREE.Intersection | undefined;
}

declare class InputSystem {
    private ctrl;
    fwd: boolean;
    bkd: boolean;
    lft: boolean;
    rgt: boolean;
    space: boolean;
    shift: boolean;
    private boundKeydown;
    private boundKeyup;
    private boundMouseMove;
    private boundMouseClick;
    private boundBlur;
    private codeToAction;
    constructor(ctrl: playerController);
    buildKeyMap(userMap?: KeyMap): void;
    setInput(input: Partial<{
        moveX: 1 | 0 | -1;
        moveY: 1 | 0 | -1;
        lookDeltaX: number;
        lookDeltaY: number;
        jump: boolean;
        shift: boolean;
        toggleView: boolean;
        toggleFly: boolean;
        toggleVehicle: boolean;
    }>): void;
    bindEvents(): void;
    unbindEvents(): void;
    private resetKeys;
    private applyAction;
    private onKeydown;
    private onKeyup;
    private onMouseMove;
}

declare class VehicleSystem {
    private ctrl;
    list: VehicleInstance[];
    active: VehicleInstance | null;
    maxCount: number;
    RAPIER: any;
    world: World | null;
    params: {
        debug: {
            showPhysicsBox: boolean;
        };
        chassis: {
            linearDamping: number;
            angularDamping: number;
        };
        model: {
            rotation: number;
        };
        power: {
            accelerateForce: number;
            brakeForce: number;
            maxSpeed: number;
        };
        steering: {
            maxSteerAngle: number;
            steerSpeed: number;
            steerReturnSpeed: number;
        };
        followVehicleDirection: boolean;
    };
    steerQuat: THREE.Quaternion;
    rotQuat: THREE.Quaternion;
    camBehindDir: THREE.Vector3;
    isMovingToBoarding: boolean;
    waypoints: THREE.Vector3[];
    waypointIdx: number;
    targetDir: THREE.Vector3 | null;
    moveSpeed: number;
    rotSpeed: number;
    boardingPoint: THREE.Vector3 | null;
    isBoardingAnim: boolean;
    doorClosed: boolean;
    isExitAnim: boolean;
    exitDoorClosed: boolean;
    doorTimer: any;
    flip180: THREE.Quaternion;
    constructor(ctrl: playerController);
    initRapier(): Promise<void>;
    load(opts: VehicleOptions): Promise<void>;
    openDoor(isOpen?: boolean): void;
    enter(): void;
    updateMoveTo(delta: number): void;
    finalizeBoarding(delta: number): void;
    onEnterAnimFinished(): void;
    exit(): void;
    cancelBoarding(): void;
    updateVehicle(delta: number): void;
    updateInertia(delta: number): void;
    setTransition(): void;
    private clearVelocity;
}

declare class playerController {
    loader: GLTFLoader;
    scene: THREE.Scene;
    camera: THREE.PerspectiveCamera;
    controls: OrbitControls;
    playerModelConfig: PlayerModelOptions;
    private initPos;
    gravity: number;
    jumpHeight: number;
    playerSpeed: number;
    playerFlySpeed: number;
    private curPlayerSpeed;
    enableOverShoulderView: boolean;
    private isShowMobileControls;
    private playerCapsuleRadius;
    private playerCapsuleRadiusRatio;
    private playerCapsuleHeight;
    isFirstPerson: boolean;
    controllerMode: 0 | 1;
    playerIsOnGround: boolean;
    isupdate: boolean;
    timeScale: number;
    isFlying: boolean;
    isChangeControllerTransitionTimer: any;
    enableToward: boolean;
    playerCapsule: THREE.Mesh & {
        capsuleInfo?: any;
    };
    playerModel: THREE.Object3D | null;
    playerModelHead: THREE.Object3D | null;
    collider: THREE.Mesh | null;
    private visualizer;
    collected: THREE.BufferGeometry[];
    private dynamicColliders;
    activeDynamicCollider: DynamicColliderEntry | null;
    private readonly slopeAngleThreshold;
    private readonly maxStepHeight;
    mobileControls: MobileControls | null;
    private isNearVehicle;
    private nearCheckLocal;
    private nearCheckWorld;
    private displayPlayer;
    private displayCollider;
    private displayVisualizer;
    private rotationSpeed;
    upVector: THREE.Vector3;
    private DIR_FWD;
    private DIR_BKD;
    private DIR_LFT;
    private DIR_RGT;
    playerAcceleration: number;
    playerDeceleration: number;
    private decelBase;
    playerVelocity: THREE.Vector3;
    private camDir;
    private moveDir;
    private xzDir;
    targetQuat: THREE.Quaternion;
    targetMat: THREE.Matrix4;
    private staticTemps;
    private dynTemps;
    private groundRaycaster;
    onAnimationChange?: (name: string, action: THREE.AnimationAction) => void;
    onBeforeViewChange?: (isFirstPerson: boolean) => void;
    onViewChange?: (isFirstPerson: boolean) => void;
    onGroundChange?: (onGround: boolean) => void;
    onVehicleEnter?: (vehicle: VehicleInstance) => void;
    onVehicleExit?: (vehicle: VehicleInstance) => void;
    onTowardChange?: (dx: number, dy: number, speed: number) => void;
    animation: AnimationSystem;
    cam: CameraSystem;
    input: InputSystem;
    vehicle: VehicleSystem;
    constructor();
    init(opts: PlayerControllerOptions, callback?: () => void): Promise<void>;
    private initLoader;
    private loadPlayerModelGLB;
    switchPlayerModel(newPlayerModel: PlayerModelOptions): Promise<void>;
    private getBbox;
    private ensureAttributesMinimal;
    private unifiedAttribute;
    buildStaticCollider(sources?: THREE.Object3D | THREE.Object3D[]): void;
    addDynamicCollider(source: THREE.Object3D): void;
    removeDynamicCollider(source: THREE.Object3D): void;
    clearDynamicColliders(): void;
    private updateDynamicColliders;
    private shouldSkipTriCollision;
    update(delta?: number): Promise<void>;
    updatePlayer(delta: number): void;
    syncDebugVisibility(): void;
    setOnGround(val: boolean): void;
    private applyGravity;
    private snapToGround;
    setPlayerScale(newScale: number): void;
    reset(position?: THREE.Vector3): void;
    getPosition(): THREE.Vector3;
    getVelocity(): THREE.Vector3;
    getIsFirstPerson(): boolean;
    getIsFlying(): boolean;
    getIsOnGround(): boolean;
    getControllerMode(): 0 | 1;
    getPlayerModel(): THREE.Object3D<THREE.Object3DEventMap> | null;
    getPlayerCapsule(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap> & {
        capsuleInfo?: any;
    };
    getActiveVehicle(): VehicleInstance | null;
    getAllVehicles(): VehicleInstance[];
    getCollider(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap> | null;
    getActiveDynamicCollider(): DynamicColliderEntry | null;
    setMouseSensitivity(value: number): void;
    setGravity(gravity: number): void;
    setJumpHeight(jumpHeight: number): void;
    setPlayerSpeed(speed: number): void;
    setPlayerFlySpeed(flySpeed: number): void;
    setEnableToward(v: boolean): void;
    setMinCamDistance(dist: number): void;
    setMaxCamDistance(dist: number): void;
    setCamLookAtHeightRatio(ratio: number): void;
    setThirdMouseMode(mode: 0 | 1 | 2 | 3 | 4 | 5): void;
    setEnableZoom(enable: boolean): void;
    setDebug(debug: boolean): void;
    playPlayerAnimationByName(name: string, fade?: number): void;
    registerAnimation(key: string, clipName: string, opts?: Parameters<AnimationSystem["register"]>[2]): void;
    playAnimation(key: string, opts?: Parameters<AnimationSystem["play"]>[1]): void;
    registerLocomotionSet(setName: string, map: Parameters<AnimationSystem["registerLocomotionSet"]>[1]): void;
    switchLocomotionSet(setName: string, fade?: number): void;
    getCurrentPlayerAnimationName(): string | null;
    getCurrentLocomotionSet(): string | null;
    changeView(): void;
    setFirstPersonCamera(v?: number): void;
    setOverShoulderView(v: boolean): void;
    getCenterScreenRaycastHit(): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | undefined;
    setInput(input: Parameters<InputSystem["setInput"]>[0]): void;
    setKeyMap(map?: KeyMap): void;
    onAllEvent(): void;
    offAllEvent(): void;
    loadVehicleModel(opts: VehicleOptions): Promise<void>;
    destroy(): void;
}

export { playerController };