using UnityEngine;
using System.Collections;

public class FinalShipControl : MonoBehaviour {

	public bool queryUserInput;
	public float mass = 3000;
	//public int propulsorCount;
	//public float waveLenght;
	//public float waveHeight;
	//public float jerkingLength;
	//public float jerkingHeight;
	public float waterLevel;
	public float distanceFromWaterLevel;
	public float percentUnderWater;
	public AudioClip motorSound;
	public float motor;
	public float steer;
	public float rudder = 40;
	public float propellerTurningAngle = 20;
	public float rpmPitch;
	public float forwardVelo;
	public Vector3 propellerPos;
	public Vector3 propellerPosGlobal;
	public Vector3 propellerDir;
	public Vector3 drag = new Vector3(6.0f, 4.0f, 0.2f);
	public Vector3 dragForces;
	public Vector3 dragDirection;
	public Vector3 dragAttackPosition;
	public Vector3 buoyancyPos;
	public float depth;
	public float volume = 9000;
	public float steeringAngle;
	public float engineForce = 10000;
	public Vector3 gravity;
	public Vector3 size = new Vector3(3,3,10);
	public float angularDrag = 0.8f;
	public FloatableWater waterSurface = null;
	// Use this for initialization
	void Start () {
		//gravity = new Vector3(0, -9, 0);
		//size = GetComponent<BoxCollider>().size;
		rigidbody.mass = mass;
		rigidbody.angularDrag = angularDrag;
		rigidbody.interpolation = RigidbodyInterpolation.Interpolate;
	}

	// Update is called once per frame
	void FixedUpdate () {

		/*if(waveLenght <= 0)
		{
			waveLenght = 0.1f;
		}
		else if(jerkingLength <= 0)
		{
			jerkingLength = 0.1f;
		}*/

		//if there is no water surface we are colliding with, no boat physics   
		if(waterSurface == null)
		{		
			return;
		}

		//query input axes if necessarry
		//motor = 0.0f;
		//steer = 0.0f;
		
		if(queryUserInput)
		{
			motor = Input.GetAxis("Vertical");
			steer = Input.GetAxis("Horizontal");
		}
		
		//get water level and percent under water
		waterLevel=waterSurface.collider.bounds.max.y;
		distanceFromWaterLevel = transform.position.y-waterLevel;
		percentUnderWater = Mathf.Clamp01((-distanceFromWaterLevel + 0.5f*size.y)/size.y);

		//Buoyancy (the force which keeps the boat floating above water)
		//--------------------------------------------------------------
		//the point the buoyancy force is applied onto is calculated based 
		//on the boat's picth and roll, so it will always tilt upwards:
		buoyancyPos=transform.TransformPoint(-new Vector3(transform.right.y*size.x*0.5f,0,transform.forward.y*size.z*0.5f));
		//then it is shifted arcording to the current waves
		buoyancyPos.x+=waterSurface.waveXMotion1*Mathf.Sin(waterSurface.waveFreq1*Time.time)
			+waterSurface.waveXMotion2*Mathf.Sin(waterSurface.waveFreq2*Time.time)
				+waterSurface.waveXMotion3*Mathf.Sin(waterSurface.waveFreq3*Time.time);
		buoyancyPos.z+=waterSurface.waveYMotion1*Mathf.Sin(waterSurface.waveFreq1*Time.time)
			+waterSurface.waveYMotion2*Mathf.Sin(waterSurface.waveFreq2*Time.time)
				+waterSurface.waveYMotion3*Mathf.Sin(waterSurface.waveFreq3*Time.time);	
		//apply the force	
		rigidbody.AddForceAtPosition(- volume * percentUnderWater * Physics.gravity , buoyancyPos);
		//Engine	
		//--------------------------------------------------------------
		//calculate propeller position
		propellerPos = new Vector3(0,-size.y*0.5f,-size.z*0.5f);
		propellerPosGlobal=transform.TransformPoint(propellerPos);
		//apply force only if propeller is under water
		if(propellerPosGlobal.y<waterLevel)	
		{
			//direction propeller force is pointing to.
			//mostly forward, rotated a bit according to steering angle
			steeringAngle = steer * propellerTurningAngle * Mathf.Deg2Rad;		
			propellerDir = transform.forward*Mathf.Cos(steeringAngle) - transform.right*Mathf.Sin(steeringAngle);
			//apply propeller force
			rigidbody.AddForceAtPosition(propellerDir * engineForce * motor, propellerPosGlobal);

		}
		
		//Drag
		//--------------------------------------------------------------
		//calculate drag force
		dragDirection = transform.InverseTransformDirection(rigidbody.velocity);
		dragForces = -Vector3.Scale(dragDirection, drag);
		//depth of the boat under water (used to find attack point for drag force)
		depth = Mathf.Abs(transform.forward.y)*size.z*0.5f+Mathf.Abs(transform.up.y)*size.y*0.5f;
		//apply force
		dragAttackPosition = new Vector3(transform.position.x,waterLevel-depth,transform.position.z);
		rigidbody.AddForceAtPosition(transform.TransformDirection(dragForces) * rigidbody.velocity.magnitude * (1 + percentUnderWater * (waterSurface.waterDragFactor - 1)), dragAttackPosition);
		//linear drag (linear to velocity, for low speed movement)
		rigidbody.AddForce(transform.TransformDirection(dragForces)*500);
		//rudder torque for steering (square to velocity)
		forwardVelo = Vector3.Dot(rigidbody.velocity,transform.forward);
		rigidbody.AddTorque(transform.up*forwardVelo*forwardVelo*rudder*steer); 
		//Sound
		//--------------------------------------------------------------
		//audio.volume=0.3f+Mathf.Abs(motor);
		//slowly adjust pitch to power input
		rpmPitch=Mathf.Lerp(rpmPitch,Mathf.Abs(motor),Time.deltaTime*0.4f);
		//audio.pitch=0.3f+0.7f*rpmPitch;
		//reset water surface, so we have to stay in contact for boat physics.
		
		waterSurface = null;

		//this.transform.position = elevate(Time.time);
		//this.transform.rotation = jerk(Time.time);


	}

	void OnTriggerStay(Collider col)
	{
		if(col.GetComponent<FloatableWater>() != null)
		{
			waterSurface = col.GetComponent<FloatableWater>();
		}
	}

	/*public Vector3 elevate(float t)
	{
		//Vector3 newVec = 

		return new Vector3(this.transform.position.x, this.transform.position.y + (Mathf.Sin (t / waveLenght) * waveHeight), this.transform.position.z);
	}

	public Quaternion jerk(float t)
	{
		float val = (Mathf.Cos (t / jerkingLength) * jerkingHeight);
		return Quaternion.Euler(new Vector3(this.transform.rotation.eulerAngles.x + val, this.transform.rotation.eulerAngles.y, this.transform.rotation.eulerAngles.z + Random.Range(0, val)));
	}*/
}