using System;
using UnityEngine;

namespace EnergyBarToolkit
{
	public class SimpleEvent : MonoBehaviour
	{
		[Serializable]
		public class Action
		{
			public enum Type
			{
				IncreaseByValue = 0,
				IncreaseByPercent = 1,
				DecreaseByValue = 2,
				DecreaseByPercent = 3,
				SetToValue = 4,
				SetToPercent = 5
			}

			internal SimpleEvent simpleEvent;

			public bool changeBar;

			public Type changeBarType;

			public float changeBarValue;

			public bool intervaled;

			public float timeInterval = 1f;

			private float timeIntervalAccum;

			public bool sendMessage;

			public Signal[] signals;

			public void Invoke(GameObject collider)
			{
				if (intervaled)
				{
					timeIntervalAccum += Time.deltaTime;
					while (timeIntervalAccum >= timeInterval)
					{
						timeIntervalAccum -= timeInterval;
						InvokeActual(collider);
					}
				}
				else
				{
					InvokeActual(collider);
				}
			}

			private void InvokeActual(GameObject collider)
			{
				EnergyBar energyBar = simpleEvent.energyBar;
				if (changeBar)
				{
					if (energyBar != null)
					{
						switch (changeBarType)
						{
						case Type.IncreaseByValue:
							energyBar.valueCurrent += (int)changeBarValue;
							break;
						case Type.IncreaseByPercent:
							energyBar.ValueF += changeBarValue;
							break;
						case Type.DecreaseByValue:
							energyBar.valueCurrent -= (int)changeBarValue;
							break;
						case Type.DecreaseByPercent:
							energyBar.ValueF -= changeBarValue;
							break;
						case Type.SetToValue:
							energyBar.valueCurrent = (int)changeBarValue;
							break;
						case Type.SetToPercent:
							energyBar.ValueF = changeBarValue;
							break;
						default:
							Debug.LogError("Unknown option: " + changeBarType);
							break;
						}
					}
					else
					{
						Debug.LogError("Energy bar not set for this event.", simpleEvent);
					}
				}
				if (sendMessage)
				{
					Signal[] array = signals;
					foreach (Signal signal in array)
					{
						signal.Invoke(simpleEvent, collider);
					}
				}
			}

			public void Reset()
			{
				timeIntervalAccum = 0f;
			}
		}

		[Serializable]
		public class Signal
		{
			public enum ReceiverType
			{
				Self = 0,
				Collider = 1,
				FixedGameObject = 2
			}

			public enum MessageArgument
			{
				Caller = 0,
				BarValue = 1,
				BarValuePercent = 2
			}

			public ReceiverType receiverType;

			public GameObject receiver;

			public string methodName;

			public MessageArgument argument;

			public void Invoke(SimpleEvent simpleEvent, GameObject collider)
			{
				GameObject gameObject;
				switch (receiverType)
				{
				case ReceiverType.Self:
					gameObject = simpleEvent.gameObject;
					break;
				case ReceiverType.Collider:
					gameObject = collider;
					break;
				case ReceiverType.FixedGameObject:
					gameObject = receiver;
					break;
				default:
					Debug.LogError("Unknown option: " + receiverType);
					gameObject = null;
					break;
				}
				switch (argument)
				{
				case MessageArgument.Caller:
					gameObject.SendMessage(methodName, simpleEvent.gameObject, SendMessageOptions.RequireReceiver);
					break;
				case MessageArgument.BarValue:
					gameObject.SendMessage(methodName, simpleEvent.energyBar.valueCurrent, SendMessageOptions.RequireReceiver);
					break;
				case MessageArgument.BarValuePercent:
					gameObject.SendMessage(methodName, simpleEvent.energyBar.ValueF, SendMessageOptions.RequireReceiver);
					break;
				default:
					Debug.LogError("Unknown option: " + argument);
					break;
				}
			}
		}

		public enum Target
		{
			GameObjects = 0,
			Tags = 1
		}

		private enum TriggerType
		{
			Enter = 0,
			Stay = 1,
			Leave = 2
		}

		public EnergyBar energyBar;

		public Target targetType;

		public GameObject[] targetGameObjects;

		public string[] targetTags;

		public Action onTriggerEnterAction = new Action();

		public Action onTriggerStayAction = new Action();

		public Action onTriggerLeaveAction = new Action();

		private void OnEnable()
		{
			onTriggerEnterAction.simpleEvent = this;
			onTriggerStayAction.simpleEvent = this;
			onTriggerLeaveAction.simpleEvent = this;
		}

		private void OnTriggerEnter(Collider other)
		{
			OnTrigger(other.gameObject, TriggerType.Enter);
		}

		private void OnTriggerStay(Collider other)
		{
			OnTrigger(other.gameObject, TriggerType.Stay);
		}

		private void OnTriggerLeave(Collider other)
		{
			OnTrigger(other.gameObject, TriggerType.Leave);
			onTriggerLeaveAction.Reset();
		}

		private void OnTriggerEnter2D(Collider2D other)
		{
			OnTrigger(other.gameObject, TriggerType.Enter);
		}

		private void OnTriggerStay2D(Collider2D other)
		{
			OnTrigger(other.gameObject, TriggerType.Stay);
		}

		private void OnTriggerLeave2D(Collider2D other)
		{
			OnTrigger(other.gameObject, TriggerType.Leave);
			onTriggerLeaveAction.Reset();
		}

		private void OnTrigger(GameObject other, TriggerType type)
		{
			if (IsReactingTo(other))
			{
				switch (type)
				{
				case TriggerType.Enter:
					onTriggerEnterAction.Invoke(other);
					break;
				case TriggerType.Stay:
					onTriggerStayAction.Invoke(other);
					break;
				case TriggerType.Leave:
					onTriggerLeaveAction.Invoke(other);
					break;
				default:
					Debug.LogError("Unknown option: " + type);
					break;
				}
			}
		}

		private bool IsReactingTo(GameObject other)
		{
			switch (targetType)
			{
			case Target.GameObjects:
				return Array.Exists(targetGameObjects, (GameObject go) => go == other);
			case Target.Tags:
				return Array.Exists(targetTags, (string tag) => tag == other.tag);
			default:
				return false;
			}
		}
	}
}