using System.Collections.Generic;
using UnityEngine;

namespace Artngame.SKYMASTER
{
	public class WaterHeightSM : MonoBehaviour
	{
		public bool UseLocalWaves = true;

		public float LocalHeightAdjust = 4.5f;

		public float LocalYCutoff = 3f;

		public float LocalFreq = 0.3f;

		public float LocalStartRadius = 5f;

		public bool followCamera;

		public bool followBoat;

		public bool lerpFollow;

		public bool constantFollow;

		public float lerpFollowSpeed = 0.1f;

		public List<Transform> ThrowObjects = new List<Transform>();

		public List<Vector3> ThrowObjectsWaterPos = new List<Vector3>();

		public List<Vector3> ThrowObjectsStartPos = new List<Vector3>();

		public List<Transform> WaterObjects = new List<Transform>();

		public List<Vector3> WaterObjectsWaterPos = new List<Vector3>();

		public List<Vector3> WaterObjectsStartPos = new List<Vector3>();

		public GameObject ThrowItem;

		public float ThrowPower = 1150f;

		public bool ShiftHorPosition = true;

		public bool LerpMotion;

		public float lerpSpeed = 1f;

		public float lerpRotSpeed = 0.05f;

		public float BoatSpeed = 0.22f;

		public float BoatRotSpeed = 2.2f;

		public bool controlBoat;

		public Transform SampleCube;

		public Material WaterMaterial;

		public WaterHandlerSM Waterhandler;

		public Vector3 start_pos;

		private Vector3 prev_pos;

		private float CurrentRot;

		private void Start()
		{
			start_pos = SampleCube.transform.position;
			for (int i = 0; i < WaterObjects.Count; i++)
			{
				WaterObjectsStartPos[i] = WaterObjects[i].position;
			}
		}

		private void Update()
		{
			if (SampleCube != null && WaterMaterial != null)
			{
				float x = SampleCube.transform.position.x;
				float z = SampleCube.transform.position.z;
				float y = SampleCube.transform.position.y;
				Vector4 vector = WaterMaterial.GetVector("_GAmplitude");
				Vector4 vector2 = WaterMaterial.GetVector("_GFrequency");
				Vector4 vector3 = WaterMaterial.GetVector("_GSteepness");
				Vector4 vector4 = WaterMaterial.GetVector("_GSpeed");
				Vector4 vector5 = WaterMaterial.GetVector("_GDirectionAB");
				Vector4 vector6 = WaterMaterial.GetVector("_GDirectionCD");
				float num = 1f;
				if (Waterhandler != null)
				{
					num = (Waterhandler.waterScaleFactor.y / 1f + Waterhandler.waterScaleOffset.y) / 1f;
				}
				float num2 = 1f;
				if (Waterhandler != null)
				{
					num2 = base.transform.localScale.y * 1.1f;
				}
				for (int num3 = WaterObjects.Count - 1; num3 >= 0; num3--)
				{
					if (WaterObjects[num3] == null)
					{
						WaterObjects.RemoveAt(num3);
						WaterObjectsWaterPos.RemoveAt(num3);
						WaterObjectsStartPos.RemoveAt(num3);
					}
				}
				for (int num4 = ThrowObjects.Count - 1; num4 >= 0; num4--)
				{
					if (ThrowObjects[num4] == null)
					{
						ThrowObjects.RemoveAt(num4);
						ThrowObjectsWaterPos.RemoveAt(num4);
						ThrowObjectsStartPos.RemoveAt(num4);
					}
				}
				for (int i = 0; i < WaterObjects.Count; i++)
				{
					float x2 = WaterObjects[i].position.x;
					float z2 = WaterObjects[i].position.z;
					float y2 = WaterObjects[i].position.y;
					Vector3 vector7 = GerstnerOffset(new Vector2(x2, z2), y2, new Vector2(x2, z2), vector, vector2, vector3, vector4, vector5, vector6);
					WaterObjectsWaterPos[i] = new Vector3(vector7.x, vector7.y * num2, vector7.z);
				}
				for (int j = 0; j < WaterObjectsWaterPos.Count; j++)
				{
					if (LerpMotion)
					{
						WaterObjects[j].position = Vector3.Lerp(WaterObjects[j].position, new Vector3(WaterObjectsStartPos[j].x, base.transform.position.y - 1f, WaterObjectsStartPos[j].z) + WaterObjectsWaterPos[j], Time.deltaTime * lerpSpeed);
					}
					else
					{
						WaterObjects[j].position = new Vector3(WaterObjectsStartPos[j].x, base.transform.position.y - 1f, WaterObjectsStartPos[j].z) + WaterObjectsWaterPos[j];
					}
				}
				for (int k = 0; k < ThrowObjects.Count; k++)
				{
					float x3 = ThrowObjects[k].position.x;
					float z3 = ThrowObjects[k].position.z;
					float y3 = ThrowObjects[k].position.y;
					Vector3 vector8 = GerstnerOffset(new Vector2(x3, z3), y3, new Vector2(x3, z3), vector, vector2, vector3, vector4, vector5, vector6);
					ThrowObjectsWaterPos[k] = new Vector3(vector8.x, vector8.y * num2, vector8.z);
				}
				for (int l = 0; l < ThrowObjectsWaterPos.Count; l++)
				{
					if (ThrowObjectsWaterPos[l].y + base.transform.position.y > ThrowObjects[l].position.y)
					{
						ThrowObjects[l].GetComponent<Rigidbody>().isKinematic = true;
						WaterObjects.Add(ThrowObjects[l]);
						WaterObjectsStartPos.Add(ThrowObjects[l].position);
						WaterObjectsWaterPos.Add(ThrowObjectsWaterPos[l]);
						ThrowObjectsWaterPos.RemoveAt(l);
						ThrowObjects.RemoveAt(l);
						ThrowObjectsStartPos.RemoveAt(l);
					}
				}
				if (Input.GetMouseButtonDown(1) && ThrowItem != null)
				{
					GameObject gameObject = Object.Instantiate(ThrowItem, start_pos + new Vector3(0f, 5f, 0f), Quaternion.identity);
					gameObject.transform.localScale = gameObject.transform.localScale * 5f;
					ThrowObjects.Add(gameObject.transform);
					ThrowObjectsWaterPos.Add(new Vector3(0f, 0f, 0f));
					ThrowObjectsStartPos.Add(gameObject.transform.position);
					if (gameObject != null)
					{
						Rigidbody component = gameObject.GetComponent<Rigidbody>();
						if (component != null)
						{
							if (Camera.main != null)
							{
								component.AddForce(Camera.main.transform.forward * ThrowPower);
							}
							else
							{
								component.AddForce(SampleCube.transform.forward * ThrowPower);
							}
						}
					}
				}
				Vector3 vector9 = GerstnerOffset(new Vector2(x, z), y, new Vector2(x, z), vector, vector2, vector3, vector4, vector5, vector6);
				Vector3 vector10 = new Vector3(0f, vector9.y * num, 0f);
				if (ShiftHorPosition)
				{
					vector10 = new Vector3(vector9.x, vector9.y * num, vector9.z);
				}
				if (LerpMotion)
				{
					SampleCube.transform.position = Vector3.Lerp(SampleCube.transform.position, start_pos + vector10, Time.deltaTime * lerpSpeed);
				}
				else
				{
					SampleCube.transform.position = start_pos + vector10;
				}
				Vector3 normalized = (SampleCube.transform.position - prev_pos).normalized;
				if (!controlBoat)
				{
					SampleCube.transform.rotation = Quaternion.Lerp(SampleCube.transform.rotation, Quaternion.AngleAxis(100f * normalized.y, Vector3.up + normalized), Time.deltaTime * lerpRotSpeed);
				}
				else
				{
					SampleCube.transform.rotation = Quaternion.Lerp(SampleCube.transform.rotation, Quaternion.AngleAxis(30f * normalized.y, SampleCube.transform.right + SampleCube.transform.up * Random.Range(0f, 0.5f)), Time.deltaTime * lerpRotSpeed * 12f);
				}
				Vector3 vector11 = (SampleCube.transform.position - prev_pos) / Time.deltaTime;
				prev_pos = SampleCube.transform.position;
				if (controlBoat)
				{
					Vector3 vector12 = new Vector3(SampleCube.transform.forward.x, 0f, SampleCube.transform.forward.z);
					start_pos += vector12 * BoatSpeed * Input.GetAxis("Vertical");
					CurrentRot += Input.GetAxis("Horizontal") * BoatRotSpeed;
					SampleCube.transform.rotation = Quaternion.Lerp(SampleCube.transform.rotation, Quaternion.AngleAxis(CurrentRot, Vector3.up), Time.deltaTime * BoatRotSpeed);
					if (UseLocalWaves && WaterMaterial.HasProperty("_LocalWaveParams"))
					{
						WaterMaterial.SetVector("_LocalWaveParams", new Vector4(LocalYCutoff, LocalHeightAdjust * vector11.magnitude, LocalFreq, LocalStartRadius));
						WaterMaterial.SetVector("_LocalWavePosition", new Vector4(prev_pos.x, prev_pos.y, prev_pos.z, 5f));
						WaterMaterial.SetVector("_LocalWaveVelocity", new Vector4(vector11.x, vector11.y, vector11.z, 0f));
					}
				}
			}
			if (!Application.isPlaying || !(Waterhandler != null))
			{
				return;
			}
			if (followCamera && Camera.main != null)
			{
				Vector3 position = Camera.main.transform.position;
				Vector3 vector13 = new Vector3(position.x, Waterhandler.transform.position.y, position.z);
				if (!lerpFollow)
				{
					Waterhandler.transform.position = vector13;
				}
				else if (constantFollow)
				{
					if ((vector13 - Waterhandler.transform.position).magnitude > 1.5f)
					{
						Waterhandler.transform.position += (vector13 - Waterhandler.transform.position).normalized * Time.deltaTime * lerpFollowSpeed;
					}
				}
				else
				{
					Waterhandler.transform.position = Vector3.Lerp(Waterhandler.transform.position, vector13, Time.deltaTime * lerpFollowSpeed);
				}
			}
			if (!followBoat)
			{
				return;
			}
			Vector3 vector14 = new Vector3(SampleCube.position.x, Waterhandler.transform.position.y, SampleCube.position.z);
			if (!lerpFollow)
			{
				Waterhandler.transform.position = vector14;
			}
			else if (constantFollow)
			{
				if ((vector14 - Waterhandler.transform.position).magnitude > 1.5f)
				{
					Waterhandler.transform.position += (vector14 - Waterhandler.transform.position).normalized * Time.deltaTime * lerpFollowSpeed;
				}
			}
			else
			{
				Waterhandler.transform.position = Vector3.Lerp(Waterhandler.transform.position, vector14, Time.deltaTime * lerpFollowSpeed);
			}
		}

		public Vector3 GerstnerOffset(Vector2 Position, float PosY, Vector2 tileableVtx, Vector4 amplitude, Vector4 frequency, Vector4 steepness, Vector4 speed, Vector4 directionAB, Vector4 directionCD)
		{
			_ = Vector3.zero;
			float num = WaterMaterial.GetFloat("_GerstnerIntensity1");
			Vector4 vector = WaterMaterial.GetVector("_GerstnerIntensities");
			Vector4 vector2 = WaterMaterial.GetVector("_Gerstnerfactors2");
			Vector4 vector3 = WaterMaterial.GetVector("_Gerstnerfactors");
			Vector4 vector4 = WaterMaterial.GetVector("_GerstnerfactorsSteep");
			Vector4 vector5 = WaterMaterial.GetVector("_GerstnerfactorsDir");
			Vector2 vector6 = new Vector2(tileableVtx.x, tileableVtx.y);
			return GerstnerOffset4(vector6, steepness, amplitude, frequency, speed, directionAB, directionCD) + num * 0.5f * GerstnerOffset4(vector6 + new Vector2(0f, 0f), steepness / 36f, amplitude * 2.2f * 4f, frequency * 0.002f, speed * 0.1f, directionAB - new Vector4(11.1f, 0f, 10.2f, 0f), directionCD + new Vector4(111.1f, 0f, 10.2f, 0f)) + vector.x * 0.1f * tileableVtx.x * GerstnerOffset4(tileableVtx, vector4.x * steepness, (0f - vector2.x) * amplitude, vector3.x * frequency / 2f, -0.2f * speed, -0.2f * new Vector4(vector5.x * directionAB.x, directionAB.y, directionAB.z, directionAB.w), 0.3f * directionCD) + vector.y * 0.15f * tileableVtx.y * GerstnerOffset4(tileableVtx, vector4.y * steepness, (0f - vector2.y) * 0.1f * amplitude, vector3.y * 0.1f * frequency / 1.2f, -speed, -new Vector4(directionAB.x, vector5.y * directionAB.y, directionAB.z, directionAB.w), 0.4f * directionCD) + vector.z * 0.05f * PosY * GerstnerOffset4(tileableVtx, vector4.z * steepness, (0f - vector2.z) * 0.1f * amplitude, vector3.z * 0.2f * frequency / 0.9f, -0.5f * speed, -0.5f * new Vector4(vector5.z * directionAB.x, directionAB.y, directionAB.z, directionAB.w), directionCD);
		}

		private Vector3 GerstnerOffset4(Vector2 xzVtx, Vector4 steepness, Vector4 amp, Vector4 freq, Vector4 speed, Vector4 dirAB, Vector4 dirCD)
		{
			Vector3 zero = Vector3.zero;
			Vector4 vector = new Vector2(dirAB.x, dirAB.y);
			Vector4 vector2 = new Vector2(dirAB.z, dirAB.w);
			Vector4 vector3 = new Vector2(dirCD.x, dirCD.y);
			Vector4 vector4 = new Vector2(dirCD.z, dirCD.w);
			Vector4 vector5 = new Vector4(steepness.x * amp.x * dirAB.x, steepness.x * amp.x * dirAB.y, steepness.y * amp.y * dirAB.z, steepness.y * amp.y * dirAB.w);
			Vector4 vector6 = new Vector4(steepness.z * amp.z * dirCD.x, steepness.z * amp.z * dirCD.y, steepness.w * amp.w * dirCD.z, steepness.w * amp.w * dirCD.w);
			Vector4 vector7 = new Vector4(Vector2.Dot(vector, xzVtx), Vector2.Dot(vector2, xzVtx), Vector2.Dot(vector3, xzVtx), Vector2.Dot(vector4, xzVtx));
			Vector4 vector8 = new Vector4(freq.x * vector7.x, freq.y * vector7.y, freq.z * vector7.z, freq.w * vector7.w);
			Vector4 vector9 = Shader.GetGlobalVector("_Time").y * speed;
			Vector4 a = new Vector4(Mathf.Cos(vector8.x + vector9.x), Mathf.Cos(vector8.y + vector9.y), Mathf.Cos(vector8.z + vector9.z), Mathf.Cos(vector8.w + vector9.w));
			Vector4 a2 = new Vector4(Mathf.Sin(vector8.x + vector9.x), Mathf.Sin(vector8.y + vector9.y), Mathf.Sin(vector8.z + vector9.z), Mathf.Sin(vector8.w + vector9.w));
			zero.x = Vector4.Dot(a, new Vector4(vector5.x, vector5.z, vector6.x, vector6.z));
			zero.z = Vector4.Dot(a, new Vector4(vector5.y, vector5.w, vector6.y, vector6.w));
			zero.y = Vector4.Dot(a2, amp);
			return zero;
		}
	}
}