//////////////////////////////////////
// Player item entity               //
//////////////////////////////////////

ig.module(
    'game.entities.player'
)
.requires(
    'impact.entity',
    'plugins.box2d.entity'
)
.defines(function(){

    EntityPlayer = ig.Box2DEntity.extend({

        //box2d handles collisions so turn off impact collision handling
        collides: ig.Entity.COLLIDES.NEVER,
        checkAgainst: ig.Entity.TYPE.NONE,

        MAX_STEER_ANGLE : Math.PI/3,
        STEER_SPEED : 3,
        SIDEWAYS_FRICTION_FORCE : 10,
        HORSEPOWERS : 40,
        CAR_STARTING_POS : new b2.Vec2(30,140),

        leftRearWheelPosition : new b2.Vec2(-1.1,1.4),
        rightRearWheelPosition : new b2.Vec2(1.1,1.4),
        leftFrontWheelPosition : new b2.Vec2(-1.1,-1),
        rightFrontWheelPosition : new b2.Vec2(1.1,-1),

        init: function( x, y, settings ) {
            this.parent( x, y, settings );

        },


        createBody: function(x,y,settings) {
            this.parent(x,y,settings);


            this.engineSpeed=0;
            this.steeringAngle=0;

            // define our body
            var bodyDef = new b2.BodyDef();
            bodyDef.type = b2.dynamicBody;
            bodyDef.linearDamping = 1;
            bodyDef.angularDamping = 1;
            bodyDef.position = this.CAR_STARTING_POS.Copy()

            this.body = ig.world.CreateBody(bodyDef);
            this.body.SetMassFromShapes();

            var leftWheelDef = new b2.BodyDef();
            leftWheelDef.position = this.CAR_STARTING_POS.Copy();
            leftWheelDef.position.Add(this.leftFrontWheelPosition);
            this.leftWheel = ig.world.CreateBody(leftWheelDef);

            var rightWheelDef = new b2.BodyDef();
            rightWheelDef.position = this.CAR_STARTING_POS.Copy();
            rightWheelDef.position.Add(this.rightFrontWheelPosition);

            this.rightWheel = ig.world.CreateBody(rightWheelDef);
            var leftRearWheelDef = new b2.BodyDef();
            leftRearWheelDef.position = this.CAR_STARTING_POS.Copy();
            leftRearWheelDef.position.Add(this.leftRearWheelPosition);
            this.leftRearWheel = ig.world.CreateBody(leftRearWheelDef);

            var rightRearWheelDef = new b2.BodyDef();
            rightRearWheelDef.position = this.CAR_STARTING_POS.Copy();
            rightRearWheelDef.position.Add(this.rightRearWheelPosition);
            this.rightRearWheel = ig.world.CreateBody(rightRearWheelDef);

            // define our shapes
            var shapeDef = new b2.PolygonDef();
            shapeDef.SetAsBox(0.5,1.5);
            shapeDef.density = 1;
            this.body.CreateShape(shapeDef);

            //Left Wheel shape
            var leftWheelShapeDef = new b2.PolygonDef();
            leftWheelShapeDef.SetAsBox(0.2,0.5);
            leftWheelShapeDef.density = 1;
            //leftWheelShapeDef.isSensor = true;
            this.leftWheel.CreateShape(leftWheelShapeDef);

            //Right Wheel shape
            var rightWheelShapeDef = new b2.PolygonDef();
            rightWheelShapeDef.SetAsBox(0.2,0.5);
            rightWheelShapeDef.density = 1;
            //rightWheelShapeDef.isSensor = true;
            this.rightWheel.CreateShape(rightWheelShapeDef);

            //Left Wheel shape
            var leftRearWheelShapeDef = new b2.PolygonDef();
            leftRearWheelShapeDef.SetAsBox(0.2,0.5);
            leftRearWheelShapeDef.density = 1;
            //leftRearWheelShapeDef.isSensor = true;
            this.leftRearWheel.CreateShape(leftRearWheelShapeDef);

            //Right Wheel shape
            var rightRearWheelShapeDef = new b2.PolygonDef();
            rightRearWheelShapeDef.SetAsBox(0.2,0.5);
            rightRearWheelShapeDef.density = 1;
            //rightRearWheelShapeDef.isSensor = true;
            this.rightRearWheel.CreateShape(rightRearWheelShapeDef);

            this.body.SetMassFromShapes();
            this.leftWheel.SetMassFromShapes();
            this.rightWheel.SetMassFromShapes();
            this.leftRearWheel.SetMassFromShapes();
            this.rightRearWheel.SetMassFromShapes();

            // Joints
            var leftJointDef = new b2.RevoluteJointDef();
            leftJointDef.Initialize(this.body, this.leftWheel, this.leftWheel.GetWorldCenter());
            leftJointDef.enableMotor = true;
            leftJointDef.maxMotorTorque = 100;

            var rightJointDef = new b2.RevoluteJointDef();
            rightJointDef.Initialize(this.body, this.rightWheel, this.rightWheel.GetWorldCenter());
            rightJointDef.enableMotor = true;
            rightJointDef.maxMotorTorque = 100;

            this.leftJoint = ig.world.CreateJoint(leftJointDef);
            this.rightJoint= ig.world.CreateJoint(rightJointDef);

            var leftRearJointDef = new b2.PrismaticJointDef();
            leftRearJointDef.Initialize(this.body, this.leftRearWheel, this.leftRearWheel.GetWorldCenter(), new b2.Vec2(1,0));
            leftRearJointDef.enableLimit = true;
            leftRearJointDef.lowerTranslation = leftRearJointDef.upperTranslation = 0;

            var rightRearJointDef = new b2.PrismaticJointDef();
            rightRearJointDef.Initialize(this.body, this.rightRearWheel, this.rightRearWheel.GetWorldCenter(), new b2.Vec2(1,0));
            rightRearJointDef.enableLimit = true;
            rightRearJointDef.lowerTranslation = rightRearJointDef.upperTranslation = 0;

            ig.world.CreateJoint(leftRearJointDef);
            ig.world.CreateJoint(rightRearJointDef);
            console.log(this);
        },

        update: function(){
                //kill unwanted lateral wheel velocity
                this.killOrthogonalVelocity(this.leftWheel);
                this.killOrthogonalVelocity(this.rightWheel);
                this.killOrthogonalVelocity(this.leftRearWheel);
                this.killOrthogonalVelocity(this.rightRearWheel);

                //input states
                if(ig.input.pressed("up")){
                    this.body.WakeUp();
                    this.engineSpeed = -this.HORSEPOWERS;
                    console.log('enginespeed:'+this.engineSpeed);
                }

                if(ig.input.pressed("down")){
                    this.engineSpeed = this.HORSEPOWERS;
                    console.log('enginespeed:'+this.engineSpeed);
                }

                if (ig.input.pressed("left") || ig.input.pressed("leftButton")) {
                    this.steeringAngle = -this.MAX_STEER_ANGLE;
                    console.log('steeringangle:'+this.steeringAngle);
                }

                if (ig.input.pressed("right") || ig.input.pressed("rightButton")) {
                    this.steeringAngle = +this.MAX_STEER_ANGLE;
                    console.log('steeringangle:'+this.steeringAngle);
                }

                // Key released
                if(( ig.input.released('up') ) || (ig.input.released('down'))) {
                    this.engineSpeed = 0;
                    console.log('enginespeed:'+this.engineSpeed);
                }

                if(( ig.input.released('left') ) || (ig.input.released('right'))) {
                    this.steeringAngle = 0;
                    console.log('steeringangle:'+this.steeringAngle);
                }

                var ldirection = this.leftWheel.GetXForm().R.col2.Copy();
                var rdirection = this.rightWheel.GetXForm().R.col2.Copy();

                ldirection.Multiply(this.engineSpeed);
                rdirection.Multiply(this.engineSpeed);

                this.leftWheel.ApplyForce(ldirection, this.leftWheel.GetPosition());
                this.rightWheel.ApplyForce(rdirection, this.rightWheel.GetPosition());

                //Steering
                var mspeed;
                mspeed = this.steeringAngle - this.leftJoint.GetJointAngle();
                this.leftJoint.SetMotorSpeed(mspeed * this.STEER_SPEED);
                mspeed = this.steeringAngle - this.rightJoint.GetJointAngle();
                this.rightJoint.SetMotorSpeed(mspeed * this.STEER_SPEED);

            //call the parent
            this.parent();
        },
        killOrthogonalVelocity: function(targetBody) {
            var localPoint = new b2.Vec2(0,0);
            //console.log(targetBody);
            var velocity = targetBody.GetLinearVelocityFromLocalPoint(localPoint);

            var sidewaysAxis = targetBody.GetXForm().R.col2.Copy();
            sidewaysAxis.Multiply(b2.Math.Dot(velocity,sidewaysAxis));
                //sidewaysAxis.multiplyN(velocity.b2.Dot(sidewaysAxis));
            targetBody.SetLinearVelocity(sidewaysAxis);
            //targetBody.GetWorldPoint(localPoint);
        },
        draw: function(){
            this.parent();
        }

    });

});