using System;
using System.Collections.Generic;
using UnityEngine;

namespace EnergyBarToolkit
{
	public abstract class EnergyBar3DBase : EnergyBarBase
	{
		public new enum Pivot
		{
			Left = 0,
			Top = 1,
			Right = 2,
			Bottom = 3,
			TopLeft = 4,
			TopRight = 5,
			BottomRight = 6,
			BottomLeft = 7,
			Center = 8
		}

		public enum BarType
		{
			Filled = 0,
			Repeated = 1,
			Sequence = 2,
			Transform = 3
		}

		public enum TextureMode
		{
			Textures = 0,
			TextureAtlas = 1
		}

		public enum LookAtMode
		{
			Disabled = 0,
			CustomObject = 1,
			MainCamera = 2
		}

		[Serializable]
		public class AtlasTex : AbstractTex
		{
			public string spriteGUID = string.Empty;

			public bool Valid
			{
				get
				{
					return !string.IsNullOrEmpty(spriteGUID);
				}
			}

			public override int GetHashCode()
			{
				int currentHash = 37;
				currentHash = MadHashCode.Add(currentHash, spriteGUID);
				return MadHashCode.Add(currentHash, color);
			}
		}

		public const int DepthSpace = 32;

		public MadPanel panel;

		public bool premultipliedAlpha;

		public int guiDepth = 1;

		public GameObject anchorObject;

		public Camera anchorCamera;

		public TextureMode textureMode;

		public Tex[] texturesBackground = new Tex[0];

		public Tex[] texturesForeground = new Tex[0];

		public MadAtlas atlas;

		public AtlasTex[] atlasTexturesBackground = new AtlasTex[0];

		public AtlasTex[] atlasTexturesForeground = new AtlasTex[0];

		public LookAtMode lookAtMode;

		public GameObject lookAtObject;

		public MadFont labelFont;

		public float labelScale = 32f;

		public Pivot labelPivot = Pivot.Center;

		public bool editorSelectable = true;

		[SerializeField]
		private bool underThePanel = true;

		private MadText labelSprite;

		private List<MadSprite> spriteObjectsBg = new List<MadSprite>();

		private List<MadSprite> spriteObjectsFg = new List<MadSprite>();

		private List<GameObject> hiddenObjects = new List<GameObject>();

		[SerializeField]
		private Pivot _pivot = Pivot.Center;

		private Transform anchorParentCache;

		private MadAnchor anchorCache;

		private Transform container;

		protected bool useAtlas
		{
			get
			{
				return textureMode == TextureMode.TextureAtlas;
			}
		}

		public virtual Pivot pivot
		{
			get
			{
				return _pivot;
			}
			set
			{
				_pivot = value;
			}
		}

		protected override void OnEnable()
		{
			base.OnEnable();
			EnableAllHidden();
		}

		protected override void Start()
		{
			base.Start();
			ReconnectPanelIfNeeded(true);
		}

		protected override void OnDisable()
		{
			base.OnDisable();
			DisableAllHidden();
		}

		protected virtual void OnDestroy()
		{
			DestroyAllHidden(true);
		}

		protected override void Update()
		{
			base.Update();
			ReconnectPanelIfNeeded(false);
			UpdatePanelInfo();
			UpdateContainer();
			UpdateLabel();
			UpdateAnchor();
			UpdateColors();
			UpdatePivot();
			UpdateLookAt();
		}

		protected void UpdateContainer()
		{
			if (container != null)
			{
				ApplyTransform(container);
			}
		}

		private void UpdateLabel()
		{
			if (!(labelSprite == null))
			{
				labelSprite.scale = labelScale;
				labelSprite.pivotPoint = Translate(labelPivot);
				labelSprite.transform.localPosition = base.LabelPositionPixels;
				labelSprite.text = LabelFormatResolve(labelFormat);
				labelSprite.tint = ComputeColor(labelColor);
			}
		}

		private void UpdateAnchor()
		{
			if (base.transform.parent != anchorParentCache)
			{
				anchorParentCache = base.transform.parent;
				if (anchorParentCache != null)
				{
					anchorCache = anchorParentCache.GetComponent<MadAnchor>();
				}
				else
				{
					anchorCache = null;
				}
			}
			if (anchorCache != null)
			{
				anchorObject = anchorCache.anchorObject;
				anchorCamera = anchorCache.anchorCamera;
			}
			else
			{
				anchorObject = null;
				anchorCamera = null;
			}
		}

		private void UpdateColors()
		{
			if (textureMode == TextureMode.Textures)
			{
				UpdateTextureColors(spriteObjectsBg, texturesBackground);
				UpdateTextureColors(spriteObjectsFg, texturesForeground);
			}
			else
			{
				UpdateTextureColors(spriteObjectsBg, atlasTexturesBackground);
				UpdateTextureColors(spriteObjectsFg, atlasTexturesForeground);
			}
		}

		private void UpdateTextureColors(List<MadSprite> sprites, AbstractTex[] textures)
		{
			if (sprites.Count != textures.Length)
			{
				return;
			}
			for (int i = 0; i < sprites.Count; i++)
			{
				MadSprite madSprite = sprites[i];
				AbstractTex abstractTex = textures[i];
				if (!(madSprite == null))
				{
					madSprite.visible = IsVisible();
					madSprite.tint = ComputeColor(abstractTex.color);
				}
			}
		}

		private void UpdatePivot()
		{
			MadSprite.PivotPoint pivotPoint = Translate(pivot);
			for (int i = 0; i < spriteObjectsBg.Count; i++)
			{
				MadSprite madSprite = spriteObjectsBg[i];
				if (madSprite != null)
				{
					madSprite.pivotPoint = pivotPoint;
				}
			}
			for (int j = 0; j < spriteObjectsFg.Count; j++)
			{
				MadSprite madSprite2 = spriteObjectsFg[j];
				if (madSprite2 != null)
				{
					madSprite2.pivotPoint = pivotPoint;
				}
			}
		}

		private void UpdateLookAt()
		{
			Transform transform;
			switch (lookAtMode)
			{
			case LookAtMode.Disabled:
				return;
			case LookAtMode.CustomObject:
				if (lookAtObject != null)
				{
					transform = lookAtObject.transform;
					break;
				}
				return;
			case LookAtMode.MainCamera:
			{
				Camera main = Camera.main;
				if (main != null)
				{
					transform = main.transform;
					break;
				}
				Debug.LogWarning("Cannot find camera tagged as MainCamera. Plase make sure that there is one.", this);
				return;
			}
			default:
				Debug.LogError("Unknown option: " + lookAtMode);
				return;
			}
			base.transform.LookAt(base.transform.position + (base.transform.position - transform.position));
		}

		private void ReconnectPanelIfNeeded(bool firstTime)
		{
			if (!(panel == null))
			{
				return;
			}
			panel = MadPanel.FirstOrNull(base.transform);
			if (panel == null && firstTime)
			{
				Debug.LogError("You have to initialize scene first! Please execute Tools -> Energy Bar Toolkit -> Initialize");
				return;
			}
			MadPanel madPanel = MadTransform.FindParent<MadPanel>(base.transform);
			bool flag = madPanel == panel;
			if (flag && !underThePanel)
			{
				base.transform.localScale /= panel.transform.lossyScale.x;
			}
			else if (!flag && underThePanel)
			{
				base.transform.localScale *= panel.transform.lossyScale.x;
			}
			underThePanel = flag;
		}

		private void UpdatePanelInfo()
		{
			if (panel != null && Application.isEditor && !Application.isPlaying)
			{
				MadPanel madPanel = MadTransform.FindParent<MadPanel>(base.transform);
				bool flag = madPanel == panel;
				underThePanel = flag;
			}
		}

		private void EnableAllHidden()
		{
			for (int i = 0; i < hiddenObjects.Count; i++)
			{
				hiddenObjects[i].SetActive(true);
			}
			if (container != null)
			{
				container.gameObject.SetActive(true);
			}
		}

		private void DisableAllHidden()
		{
			for (int i = 0; i < hiddenObjects.Count; i++)
			{
				hiddenObjects[i].SetActive(false);
			}
			if (container != null)
			{
				container.gameObject.SetActive(false);
			}
		}

		private void DestroyAllHidden(bool forceImmediate = false)
		{
			for (int i = 0; i < hiddenObjects.Count; i++)
			{
				DestroyHidden(hiddenObjects[i], forceImmediate);
			}
			hiddenObjects.Clear();
			if (container != null)
			{
				DestroyHidden(container.gameObject, forceImmediate);
				container = null;
			}
		}

		protected virtual void Rebuild()
		{
			spriteObjectsBg.Clear();
			spriteObjectsFg.Clear();
			DestroyAllHidden();
			List<MadSprite> list = MadTransform.FindChildren(base.transform, (MadSprite s) => (s.hideFlags | HideFlags.HideInHierarchy) != HideFlags.None, 0);
			if (list.Count > 0)
			{
				Debug.Log("There were " + list.Count + " hidden unmanaged sprites under this bar. I will remove them.");
				for (int num = 0; num < list.Count; num++)
				{
					MadGameObject.SafeDestroy(list[num].gameObject);
				}
			}
		}

		protected int BuildBackgroundTextures(int depth)
		{
			if (useAtlas)
			{
				return BuildTextures(atlasTexturesBackground, "bg_", depth, ref spriteObjectsBg);
			}
			return BuildTextures(texturesBackground, "bg_", depth, ref spriteObjectsBg);
		}

		protected int BuildForegroundTextures(int depth)
		{
			if (useAtlas)
			{
				return BuildTextures(atlasTexturesForeground, "fg_", depth, ref spriteObjectsFg);
			}
			return BuildTextures(texturesForeground, "fg_", depth, ref spriteObjectsFg);
		}

		private int BuildTextures<T>(T[] textures, string prefix, int startDepth, ref List<MadSprite> sprites)
		{
			int num = 0;
			foreach (T val in textures)
			{
				Tex tex = val as Tex;
				AtlasTex atlasTex = val as AtlasTex;
				if ((tex == null || tex.Valid) && (atlasTex == null || atlasTex.Valid))
				{
					string text = string.Format("_{0}{1:D2}", prefix, num + 1);
					MadSprite madSprite = CreateHidden<MadSprite>(text);
					madSprite.guiDepth = startDepth + num;
					if (tex != null)
					{
						madSprite.texture = tex.texture;
					}
					else
					{
						madSprite.inputType = MadSprite.InputType.TextureAtlas;
						madSprite.textureAtlas = atlas;
						madSprite.textureAtlasSpriteGUID = atlasTex.spriteGUID;
					}
					madSprite.tint = ((tex == null) ? atlasTex.color : tex.color);
					ColorBind colorBind = madSprite.gameObject.AddComponent<ColorBind>();
					colorBind.tex = tex;
					sprites.Add(madSprite);
					num++;
				}
			}
			return startDepth + num;
		}

		protected int RebuildLabel(int depth)
		{
			if (labelEnabled && labelFont != null)
			{
				labelSprite = CreateHidden<MadText>("_label");
				labelSprite.font = labelFont;
				labelSprite.guiDepth = depth++;
			}
			UpdateLabel();
			return depth;
		}

		public Rect AnyBackgroundOrForegroundSpriteSize()
		{
			MadSprite madSprite = null;
			if (spriteObjectsBg.Count > 0)
			{
				madSprite = spriteObjectsBg[0];
			}
			if (madSprite == null && spriteObjectsFg.Count > 0)
			{
				madSprite = spriteObjectsFg[0];
			}
			if (madSprite != null)
			{
				return madSprite.GetTransformedBounds();
			}
			Texture2D texture2D = null;
			if (texturesBackground.Length > 0)
			{
				texture2D = texturesBackground[0].texture;
			}
			if (texture2D == null && texturesForeground.Length > 0)
			{
				texture2D = texturesForeground[0].texture;
			}
			if (texture2D != null)
			{
				Vector2 vector = PivotOffset(pivot);
				float num = texture2D.width;
				float num2 = texture2D.height;
				return new Rect(vector.x * num, (1f - vector.y) * num2, num, num2);
			}
			return default(Rect);
		}

		protected void ApplyTransform(Component c)
		{
			if (c != null)
			{
				ApplyTransform(c.gameObject);
			}
		}

		protected void ApplyTransform(GameObject go)
		{
			if (go != null)
			{
				go.transform.position = base.transform.position;
				go.transform.localScale = base.transform.lossyScale;
				go.transform.rotation = base.transform.rotation;
			}
		}

		protected void DestroyHidden(GameObject go, bool forceImmediate)
		{
			if (forceImmediate)
			{
				UnityEngine.Object.DestroyImmediate(go);
			}
			else
			{
				MadGameObject.SafeDestroy(go);
			}
		}

		protected T CreateHidden<T>(string name, Transform parent = null) where T : Component
		{
			if (container == null)
			{
				container = new GameObject("_container").transform;
				container.gameObject.hideFlags = HideFlags.HideAndDontSave;
			}
			if (parent == null)
			{
				parent = container;
			}
			T val = MadTransform.CreateChild<T>(parent, name, true);
			if (val is MadSprite)
			{
				MadSprite madSprite = val as MadSprite;
				madSprite.panel = panel;
				if (val.GetType() == typeof(MadSprite))
				{
					madSprite.hasPremultipliedAlpha = premultipliedAlpha;
				}
			}
			MadGameObject.SetActive(val.gameObject, true);
			val.gameObject.hideFlags = HideFlags.HideAndDontSave;
			hiddenObjects.Insert(0, val.gameObject);
			return val;
		}

		protected override bool IsVisible()
		{
			if (!base.IsVisible())
			{
				return false;
			}
			if (anchorObject != null)
			{
				Camera main;
				if (anchorCamera != null)
				{
					main = anchorCamera;
				}
				else
				{
					main = Camera.main;
					if (main == null)
					{
						return true;
					}
				}
				Vector3 lhs = anchorObject.transform.position - main.transform.position;
				float num = Vector3.Dot(lhs, main.transform.forward);
				return num >= 0f;
			}
			return true;
		}

		protected bool TextureValid(Texture2D tex, string atlasTex)
		{
			if (useAtlas)
			{
				return AtlasTextureValid(atlasTex);
			}
			return tex != null;
		}

		protected void SetTexture(MadSprite sprite, Texture2D tex, string atlasTex)
		{
			if (useAtlas)
			{
				sprite.inputType = MadSprite.InputType.TextureAtlas;
				sprite.textureAtlas = atlas;
				sprite.textureAtlasSpriteGUID = atlasTex;
				sprite.texture = null;
			}
			else
			{
				sprite.inputType = MadSprite.InputType.SingleTexture;
				sprite.textureAtlas = null;
				sprite.lastTextureAtlasSpriteGUID = null;
				sprite.texture = tex;
			}
		}

		protected bool AtlasTextureValid(string guid)
		{
			if (atlas == null)
			{
				return false;
			}
			MadAtlas.Item item = atlas.GetItem(guid);
			if (item != null)
			{
				return true;
			}
			return false;
		}

		protected static MadSprite.PivotPoint Translate(Pivot pivot)
		{
			switch (pivot)
			{
			case Pivot.Left:
				return MadSprite.PivotPoint.Left;
			case Pivot.Top:
				return MadSprite.PivotPoint.Top;
			case Pivot.Right:
				return MadSprite.PivotPoint.Right;
			case Pivot.Bottom:
				return MadSprite.PivotPoint.Bottom;
			case Pivot.TopLeft:
				return MadSprite.PivotPoint.TopLeft;
			case Pivot.TopRight:
				return MadSprite.PivotPoint.TopRight;
			case Pivot.BottomRight:
				return MadSprite.PivotPoint.BottomRight;
			case Pivot.BottomLeft:
				return MadSprite.PivotPoint.BottomLeft;
			case Pivot.Center:
				return MadSprite.PivotPoint.Center;
			default:
				Debug.Log("Unknown pivot point: " + pivot);
				return MadSprite.PivotPoint.Center;
			}
		}

		protected static Vector2 PivotOffset(Pivot pivot)
		{
			switch (pivot)
			{
			case Pivot.Left:
				return new Vector2(0f, -0.5f);
			case Pivot.Top:
				return new Vector2(-0.5f, -1f);
			case Pivot.Right:
				return new Vector2(-1f, -0.5f);
			case Pivot.Bottom:
				return new Vector2(-0.5f, 0f);
			case Pivot.TopLeft:
				return new Vector2(0f, -1f);
			case Pivot.TopRight:
				return new Vector2(-1f, -1f);
			case Pivot.BottomRight:
				return new Vector2(-1f, 0f);
			case Pivot.BottomLeft:
				return new Vector2(0f, 0f);
			case Pivot.Center:
				return new Vector2(-0.5f, -0.5f);
			default:
				Debug.Log("Unknown pivot point: " + pivot);
				return Vector2.zero;
			}
		}
	}
}