package uk.co.samatkins.racing;

import uk.co.samatkins.Entity;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.BodyDef;
import com.badlogic.gdx.physics.box2d.BodyDef.BodyType;
import com.badlogic.gdx.physics.box2d.FixtureDef;
import com.badlogic.gdx.physics.box2d.PolygonShape;
import com.badlogic.gdx.physics.box2d.World;
import com.badlogic.gdx.physics.box2d.joints.RevoluteJoint;
import com.badlogic.gdx.physics.box2d.joints.RevoluteJointDef;

public class Car extends Entity {

    private Vector3 startPosition; // x and y = position, z = rotation

    private Body chassis;
    public float acceleration = 800;
    public float braking = 10;
    public float turning = 20;
    public float baseDampening = 10;

    private Body[] wheels = new Body[4];
    private Vector2 wheelSize = new Vector2(0.4f, 0.8f);

    private int checkpointId; // The furthest checkpoint reached

    private ShapeRenderer shapeRenderer;
    private Color chassisColor = Color.RED;
    private Color wheelColor = Color.BLACK;

    public Car(float x, float y, float angle) {
        this.setPosition(x, y);
        this.setRotation(angle);
        this.setSize(1.5f, 4);

        this.startPosition = new Vector3(x, y, angle);

        this.shapeRenderer = new ShapeRenderer();

        this.checkpointId = 0;
    }

    public void setColor(Color chassisColor) {
        this.chassisColor = chassisColor;
    }

    public void restart() {
        // Jump to start position
        this.setPosition(this.startPosition.x, this.startPosition.y);
        this.setRotation(this.startPosition.z);

        // Destroy physics bodies
        World world = this.chassis.getWorld();
        world.destroyBody(this.chassis);
        for (Body wheel: this.wheels) {
            world.destroyBody(wheel);
        }

        // Create new physics bodies
        this.assignPhysicsBody(world);
    }

    public void assignPhysicsBody(World world) {

        //// BUILD CHASSIS

        // Define body
        BodyDef bodyDef = new BodyDef();
        bodyDef.type = BodyType.DynamicBody;
        bodyDef.angularDamping = 1f;
        bodyDef.linearDamping = 0;// 0.8f;

        // Create body
        this.chassis = world.createBody(bodyDef);
        this.chassis.setUserData(this);

        // Define shapes
        PolygonShape box = new PolygonShape();
        box.setAsBox(getWidth() / 2, getHeight() / 2);

        // Define fixture
        FixtureDef fixtureDef = new FixtureDef();
        fixtureDef.shape = box;
        fixtureDef.density = 16f;
        fixtureDef.friction = 0.1f;

        // Create fixture
        this.chassis.createFixture(fixtureDef);

        //// WHEELS
        BodyDef wheelBodyDef = new BodyDef();
        wheelBodyDef.type = BodyType.DynamicBody;
        wheelBodyDef.angularDamping = 10f;
        wheelBodyDef.linearDamping = 10f;

        PolygonShape wheelShape = new PolygonShape();
        wheelShape.setAsBox(wheelSize.x, wheelSize.y);

        FixtureDef wheelDef = new FixtureDef();
        wheelDef.shape = wheelShape;
        wheelDef.isSensor = true;
        wheelDef.density = 1f;

        RevoluteJointDef wheelJointDef = new RevoluteJointDef();
        wheelJointDef.collideConnected = false;
        wheelJointDef.bodyA = this.chassis;

        Vector2[] wheelPositions = new Vector2[] {
            new Vector2(0.6f, 1),
            new Vector2(-0.6f, 1),
            new Vector2(0.6f, -1),
            new Vector2(-0.6f, -1)
        };

        // Create the wheels
        for (int i=0; i<this.wheels.length; i++) {
            this.wheels[i] = world.createBody(wheelBodyDef);
            this.wheels[i].createFixture(wheelDef);
            this.wheels[i].setTransform(wheelPositions[i], 0);

            wheelJointDef.bodyB = this.wheels[i];
            wheelJointDef.localAnchorA.set(wheelPositions[i].x, wheelPositions[i].y);
            wheelJointDef.localAnchorB.set(0,0);
            RevoluteJoint j = (RevoluteJoint) world.createJoint(wheelJointDef);
            j.enableLimit(false);
        }

        // Move everything
        float angle = this.getRotation() * MathUtils.degRad;
        Vector2 wheelPos;
        this.chassis.setTransform(this.getX(), this.getY(), angle);
        for (int i=0; i<this.wheels.length; i++) {
            wheelPos = this.chassis.getWorldPoint(wheelPositions[i]);
            this.wheels[i].setTransform(wheelPos.x, wheelPos.y, angle);
        }

        // Clean-up
        box.dispose();
        wheelShape.dispose();
    }

    @Override
    public void act(float delta) {
        super.act(delta);

        this.setPosition(this.chassis.getPosition());
        this.setRotation(this.chassis.getAngle() * MathUtils.radiansToDegrees);

        this.wheels[2].setTransform(this.wheels[2].getPosition(), this.chassis.getAngle());
        this.wheels[3].setTransform(this.wheels[3].getPosition(), this.chassis.getAngle());
    }

    /**
     * Accelerate or decelerate. Currently braking and going backwards are the same thing.
     * @param amount - How much to accelerate/decelerate, from -1 for full reverse, to 1 for full forward.
     */
    public void accelerate(float amount) {
        Vector2 force = this.wheels[0].getWorldVector(new Vector2(0, this.acceleration * amount));
        this.wheels[0].applyForceToCenter(force);
        this.wheels[1].applyForceToCenter(force);
    }

    public void brake(float amount) {
        for (Body wheel: this.wheels) {
            wheel.setLinearDamping((amount * braking) + baseDampening);
        }
    }

    /**
     * Steer the car
     * @param rotation - How far the steering wheel is turned left or right. -1 = full left, 1 full right
     */
    public void steer(float rotation) {
        float rot = this.chassis.getAngle() + (rotation * -1 * this.turning * MathUtils.degRad);
        this.wheels[0].setTransform(this.wheels[0].getPosition(), rot);
        this.wheels[1].setTransform(this.wheels[1].getPosition(), rot);
    }

    public float getSpeed() {

        float speed = this.chassis.getLinearVelocity().len() * 0.1f;

//      if (this.body.getLinearVelocity().angle() == this.body.getAngle() * MathUtils.radDeg) {
//
//      }

        // DANGER!!!! I think the angle will change depending on the track...

        return speed;// * this.getMovementDirection();
    }

    /**
     *
     * @return 1 = forwards, -1 = backwards
     */
    public int getMovementDirection() {
        float velDeg = this.chassis.getLinearVelocity().angle();
        float facingDeg = ((this.chassis.getAngle() * MathUtils.radDeg) + 90) % 360;

        if (facingDeg - 90 < velDeg && velDeg < facingDeg + 90) {
            return 1;
        } else {
            return -1;
        }
    }

    @Override
    public void draw(SpriteBatch batch, float parentAlpha) {
        batch.end();

        this.shapeRenderer.setProjectionMatrix(world.getCamera().combined);
        this.shapeRenderer.begin(ShapeType.FilledRectangle);

        // Chassis
        this.shapeRenderer.setColor(this.chassisColor);
        this.shapeRenderer.identity();
        this.shapeRenderer.translate(getX() * this.getScaleX(), getY() * this.getScaleY(), 0);
        this.shapeRenderer.rotate(0, 0, 1, this.getRotation());
        this.shapeRenderer.filledRect(-getWidth()/2 * this.getScaleX(), -getHeight()/2 * this.getScaleY(),
                getWidth() * this.getScaleX(), getHeight() * this.getScaleY());

        // Wheels
        this.shapeRenderer.setColor(this.wheelColor);
        Vector2 pos;
        for (Body wheel : this.wheels) {
            this.shapeRenderer.identity();
            pos = wheel.getPosition();
            this.shapeRenderer.translate(pos.x * this.getScaleX(), pos.y * this.getScaleY(), 0);
            this.shapeRenderer.rotate(0, 0, 1, wheel.getAngle() * MathUtils.radDeg);
            this.shapeRenderer.filledRect(-wheelSize.x/2 * this.getScaleX(), -wheelSize.y/2 * this.getScaleY(),
                    wheelSize.x * this.getScaleX(), wheelSize.y * this.getScaleY());
        }

        this.shapeRenderer.end();

        batch.begin();
    }

    public void reachedCheckpoint(int id) {
        if (this.checkpointId == id-1) {
            Gdx.app.debug("Checkpoint", "Reached checkpoint #" + id);
            this.checkpointId = id;
        } else if (id == 0) {
            // See if we just completed a lap
            int checkpointCount = ((PlayScene)this.getStage()).getTrack().getNumberOfCheckpoints();
            if (this.checkpointId == checkpointCount-1) {
                ((PlayScene)this.world).lapComplete();
                this.checkpointId = 0;
            }
        }

    }

}