/**
 * RaycastWheel Runtime
 * @param physics GameLib.D3.Graphics
 * @param apiRaycastWheel GameLib.D3.API.RaycastWheel
 * @constructor
 */
GameLib.D3.RaycastWheel = function (
    physics,
    apiRaycastWheel
) {

    this.physics = physics;
    this.physics.isNotCannonThrow();

    if (GameLib.Utils.UndefinedOrNull(apiRaycastWheel)) {
        apiRaycastWheel = {};
    }

    if (apiRaycastWheel instanceof GameLib.D3.RaycastWheel) {
        return apiRaycastWheel;
    }

    GameLib.D3.API.RaycastWheel.call(
        this,
        apiRaycastWheel.id,
        apiRaycastWheel.name,
        apiRaycastWheel.radius,
        apiRaycastWheel.directionLocal,
        apiRaycastWheel.suspensionStiffness,
        apiRaycastWheel.suspensionRestLength,
        apiRaycastWheel.frictionSlip,
        apiRaycastWheel.dampingRelaxation,
        apiRaycastWheel.dampingCompression,
        apiRaycastWheel.maxSuspensionForce,
        apiRaycastWheel.rollInfluence,
        apiRaycastWheel.axleLocal,
        apiRaycastWheel.chassisConnectionPointLocal,
        apiRaycastWheel.maxSuspensionTravel,
        apiRaycastWheel.customSlidingRotationalSpeed,
        apiRaycastWheel.useCustomSlidingRotationalSpeed,
        apiRaycastWheel.parentEntity,
        apiRaycastWheel.parentMesh
    );

    this.directionLocal = new GameLib.Vector3(
        this.physics,
        this.directionLocal,
        this
    );

    this.axleLocal = new GameLib.Vector3(
        this.physics,
        this.axleLocal,
        this
    );

    this.chassisConnectionPointLocal = new GameLib.Vector3(
        this.physics,
        this.chassisConnectionPointLocal,
        this
    );

    GameLib.Component.call(
        this,
        GameLib.Component.COMPONENT_RAYCAST_WHEEL,
        {
            'parentMesh' : GameLib.D3.Mesh
        }
    );
};

GameLib.D3.RaycastWheel.prototype = Object.create(GameLib.D3.API.RaycastWheel.prototype);
GameLib.D3.RaycastWheel.prototype.constructor = GameLib.D3.RaycastWheel;

/**
 *
 * @returns {*}
 */
GameLib.D3.RaycastWheel.prototype.createInstance = function() {

    var instance = {
        radius: this.radius,
        directionLocal: this.directionLocal.instance,
        suspensionStiffness: this.suspensionStiffness,
        suspensionRestLength: this.suspensionRestLength,
        frictionSlip: this.frictionSlip,
        dampingRelaxation: this.dampingRelaxation,
        dampingCompression: this.dampingCompression,
        maxSuspensionForce: this.maxSuspensionForce,
        rollInfluence: this.rollInfluence,
        axleLocal: this.axleLocal.instance,
        chassisConnectionPointLocal: this.chassisConnectionPointLocal.instance,
        maxSuspensionTravel: this.maxSuspensionTravel,
        customSlidingRotationalSpeed: this.customSlidingRotationalSpeed,
        useCustomSlidingRotationalSpeed: this.useCustomSlidingRotationalSpeed
    };

    return instance;
};

GameLib.D3.RaycastWheel.prototype.updateInstance = function() {
	this.instance.radius = this.radius;
	this.instance.directionLocal = this.directionLocal.instance;
	this.instance.suspensionStiffness = this.suspensionStiffness;
	this.instance.suspensionRestLength = this.suspensionRestLength;
	this.instance.frictionSlip = this.frictionSlip;
	this.instance.dampingRelaxation = this.dampingRelaxation;
	this.instance.dampingCompression = this.dampingCompression;
	this.instance.maxSuspensionForce = this.maxSuspensionForce;
	this.instance.rollInfluence = this.rollInfluence;
	this.instance.axleLocal = this.axleLocal.instance;
	this.instance.chassisConnectionPointLocal = this.chassisConnectionPointLocal.instance;
	this.instance.maxSuspensionTravel = this.maxSuspensionTravel;
	this.instance.customSlidingRotationalSpeed = this.customSlidingRotationalSpeed;
	this.instance.useCustomSlidingRotationalSpeed = this.useCustomSlidingRotationalSpeed;
};

/**
 * GameLib.D3.RaycastWheel to GameLib.D3.API.RaycastWheel
 * @returns {GameLib.D3.API.RaycastWheel}
 */
GameLib.D3.RaycastWheel.prototype.toApiObject = function() {

    var apiRaycastWheel = new GameLib.D3.API.RaycastWheel(
        this.id,
        this.name,
        this.radius,
        this.directionLocal.toApiObject(),
        this.suspensionStiffness,
        this.suspensionRestLength,
        this.frictionSlip,
        this.dampingRelaxation,
        this.dampingCompression,
        this.maxSuspensionForce,
        this.rollInfluence,
        this.axleLocal.toApiObject(),
        this.chassisConnectionPointLocal.toApiObject(),
        this.maxSuspensionTravel,
        this.customSlidingRotationalSpeed,
        this.useCustomSlidingRotationalSpeed,
        GameLib.Utils.IdOrNull(this.parentEntity),
        GameLib.Utils.IdOrNull(this.parentMesh)
    );

    return apiRaycastWheel;
};

/**
 * GameLib.D3.RaycastWheel from Object RaycastWheel
 * @param physics
 * @param objectComponent
 * @returns {GameLib.D3.RaycastWheel}
 * @constructor
 */
GameLib.D3.RaycastWheel.FromObject = function(physics, objectComponent) {

    var apiRaycastWheel = GameLib.D3.API.RaycastWheel.FromObject(objectComponent);

    return new GameLib.D3.RaycastWheel(
        physics,
        apiRaycastWheel
    );
};

GameLib.D3.RaycastWheel.prototype.setChassisLocalConnectionPoint = function() {

    if (!this.parentMesh) {
        console.log('you need to set the parent mesh first');
    }

    this.chassisConnectionPointLocal.x = this.parentMesh.localPosition.x;
    this.chassisConnectionPointLocal.y = this.parentMesh.localPosition.y;
    this.chassisConnectionPointLocal.z = this.parentMesh.localPosition.z;

};