// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License

using UnityEngine;
using System.Collections.Generic;
using UnityEditorInternal;
using Object = UnityEngine.Object;

namespace UnityEditor
{
 class SubModuleUI : ModuleUI
 {
 SerializedProperty m_SubEmitters;

 private int m_CheckObjectIndex = -1;

 // Keep in sync with enum in ParticleSystemCommmon.h
 public enum SubEmitterType
 {
 None = -1,
 Birth = 0,
 Collision,
 Death,
 Trigger,
 Manual,
 TypesMax,
 }

 class Texts
 {
 public GUIContent create = EditorGUIUtility.TrTextContent("", "Create and assign a Particle System as sub-emitter.");
 public GUIContent inherit = EditorGUIUtility.TrTextContent("Inherit", "Determines what properties to inherit from the parent system.");
 public GUIContent emitProbability = EditorGUIUtility.TrTextContent("Emit Probability", "Determines the proportion of sub-emitter spawn events that successfully triggers the associated sub-emitter.");

 public GUIContent[] subEmitterTypes = new GUIContent[]
 {
 EditorGUIUtility.TrTextContent("Birth"),
 EditorGUIUtility.TrTextContent("Collision"),
 EditorGUIUtility.TrTextContent("Death"),
 EditorGUIUtility.TrTextContent("Trigger"),
 EditorGUIUtility.TrTextContent("Manual")
 };

 // Keep in sync with SubModule::InheritedProperties
 public string[] propertyTypes =
 {
 "Color",
 "Size",
 "Rotation",
 "Lifetime",
 "Duration"
 };
 }
 private static Texts s_Texts;

 ReorderableList m_EmittersList;

 static readonly float kSubEmitterPadding = EditorGUIUtility.standardVerticalSpacing * 2;

 public SubModuleUI(ParticleSystemUI owner, SerializedObject o, string displayName)
 : base(owner, o, "SubModule", displayName)
 {
 m_ToolTip = L10n.Tr("Sub emission of particles. This allows each particle to emit particles in another system.");
 Init(); // Init when created because we need to query if we have any subemitters referenced
 }

 protected override void Init()
 {
 // Already initialized?
 if (m_SubEmitters != null)
 return;
 if (s_Texts == null)
 s_Texts = new Texts();

 m_SubEmitters = GetProperty("subEmitters");
 m_EmittersList = new ReorderableList(m_SubEmitters.m_SerializedObject, m_SubEmitters, true, false, true, true);
 m_EmittersList.headerHeight = 0;
 m_EmittersList.drawElementCallback = DrawSubEmitterElementCallback;
 m_EmittersList.elementHeight = kSingleLineHeight * 3 + EditorGUIUtility.standardVerticalSpacing * 4 + kSubEmitterPadding * 2;
 m_EmittersList.drawElementBackgroundCallback = DrawSubEmitterElementBackgroundCallback;
 m_EmittersList.onAddCallback = OnAddSubEmitterElementCallback;
 }

 void OnAddSubEmitterElementCallback(ReorderableList list)
 {
 m_SubEmitters.InsertArrayElementAtIndex(m_SubEmitters.arraySize);
 SerializedProperty newSubEmitterData = m_SubEmitters.GetArrayElementAtIndex(m_SubEmitters.arraySize - 1);
 SerializedProperty newSubEmitter = newSubEmitterData.FindPropertyRelative("emitter");
 newSubEmitter.objectReferenceValue = null;
 }

 static void DrawSubEmitterElementBackgroundCallback(Rect rect, int index, bool isActive, bool isFocused)
 {
 GUI.Label(rect, GUIContent.none, EditorStyles.helpBox);
 ReorderableList.defaultBehaviours.DrawElementBackground(rect, index, isActive, isFocused, true);
 }

 void DrawSubEmitterElementCallback(Rect rect, int index, bool isActive, bool isFocused)
 {
 var subEmitterData = m_SubEmitters.GetArrayElementAtIndex(index);
 var subEmitter = subEmitterData.FindPropertyRelative("emitter");
 var type = subEmitterData.FindPropertyRelative("type");
 var properties = subEmitterData.FindPropertyRelative("properties");
 var emitProbability = subEmitterData.FindPropertyRelative("emitProbability");

 rect.height = kSingleLineHeight;
 rect.y += kSubEmitterPadding;

 Rect typeRect = new Rect(rect.x, rect.y, EditorGUIUtility.labelWidth - EditorGUI.kSpacing, rect.height);
 Rect objectRect = new Rect(rect.x + EditorGUIUtility.labelWidth, rect.y, rect.width - EditorGUIUtility.labelWidth - EditorGUI.kSpacing * 3, rect.height);
 GUIPopup(typeRect, GUIContent.none, type, s_Texts.subEmitterTypes);
 GUIObject(objectRect, GUIContent.none, subEmitter, null);
 if (subEmitter.objectReferenceValue == null)
 {
 Rect buttonRect = new Rect(objectRect.xMax + EditorGUI.kSpacing, rect.y + 4 , ParticleSystemStyles.Get().plus.fixedWidth, rect.height);
 if (GUI.Button(buttonRect, s_Texts.create, ParticleSystemStyles.Get().plus))
 {
 CreateSubEmitter(subEmitter, index, (SubEmitterType)type.intValue);
 }
 }

 rect.y += EditorGUIUtility.standardVerticalSpacing + rect.height;
 GUIMask(rect, s_Texts.inherit, properties, s_Texts.propertyTypes);
 rect.y += EditorGUIUtility.standardVerticalSpacing + rect.height;
 GUIFloat(rect, s_Texts.emitProbability, emitProbability);
 }

 void CreateSubEmitter(SerializedProperty objectRefProp, int index, SubEmitterType type)
 {
 GameObject subEmitter = m_ParticleSystemUI.m_ParticleEffectUI.CreateParticleSystem(m_ParticleSystemUI.m_ParticleSystems[0], type);
 subEmitter.name = "SubEmitter" + index;
 objectRefProp.objectReferenceValue = subEmitter.GetComponent<ParticleSystem>();
 }

 void Update()
 {
 if (m_CheckObjectIndex >= 0)
 {
 // Wait until the ObjectSelector is closed before checking object
 if (!ObjectSelector.isVisible)
 {
 SerializedProperty subEmitterData = m_SubEmitters.GetArrayElementAtIndex(m_CheckObjectIndex);
 SerializedProperty subEmitter = subEmitterData.FindPropertyRelative("emitter");
 Object obj = subEmitter.objectReferenceValue;
 ParticleSystem newSubEmitter = obj as ParticleSystem;
 if (newSubEmitter != null)
 {
 bool validSubemitter = true;

 if (ValidateSubemitter(newSubEmitter))
 {
 string errorMsg = ParticleSystemEffectUtils.CheckCircularReferences(newSubEmitter);
 if (errorMsg.Length == 0)
 {
 // Ok there is no circular references, now check if its a child
 if (!CheckIfChild(obj))
 validSubemitter = false;
 }
 else
 {
 // Circular references detected
 string circularRefErrorMsg = string.Format("'{0}' could not be assigned as subemitter on '{1}' due to circular referencing!\nBacktrace: {2} \n\nReference will be removed.", newSubEmitter.gameObject.name, m_ParticleSystemUI.m_ParticleSystems[0].gameObject.name, errorMsg);
 EditorUtility.DisplayDialog("Circular References Detected", circularRefErrorMsg, "Ok");
 validSubemitter = false;
 }
 }
 else
 {
 validSubemitter = false;
 }

 if (!validSubemitter)
 {
 subEmitter.objectReferenceValue = null; // remove invalid reference
 m_ParticleSystemUI.ApplyProperties();
 m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.Repaint();
 }
 }

 // Cleanup
 m_CheckObjectIndex = -1;
 EditorApplication.update -= Update;
 }
 }
 }

 internal static bool IsChild(ParticleSystem subEmitter, ParticleSystem root)
 {
 if (subEmitter == null || root == null)
 return false;

 ParticleSystem subRoot = ParticleSystemEditorUtils.GetRoot(subEmitter);
 return subRoot == root;
 }

 private bool ValidateSubemitter(ParticleSystem subEmitter)
 {
 if (subEmitter == null)
 return false;

 ParticleSystem root = ParticleSystemEditorUtils.GetRoot(m_ParticleSystemUI.m_ParticleSystems[0]);
 if (root.gameObject.activeInHierarchy && !subEmitter.gameObject.activeInHierarchy)
 {
 string kReparentText = "The assigned sub emitter is part of a prefab and can therefore not be assigned.";
 EditorUtility.DisplayDialog("Invalid Sub Emitter", kReparentText, "Ok");
 return false;
 }

 if (!root.gameObject.activeInHierarchy && subEmitter.gameObject.activeInHierarchy)
 {
 string kReparentText = "The assigned sub emitter is part of a scene object and can therefore not be assigned to a prefab.";
 EditorUtility.DisplayDialog("Invalid Sub Emitter", kReparentText, "Ok");
 return false;
 }


 return true;
 }

 private bool CheckIfChild(Object subEmitter)
 {
 ParticleSystem root = ParticleSystemEditorUtils.GetRoot(m_ParticleSystemUI.m_ParticleSystems[0]);
 ParticleSystem ps = subEmitter as ParticleSystem;
 if (IsChild(ps, root))
 {
 return true;
 }

 string kReparentText = string.Format("The assigned sub emitter is not a child of the current root particle system GameObject: '{0}' and is therefore NOT considered a part of the current effect. Do you want to reparent it?", root.gameObject.name);
 if (EditorUtility.DisplayDialog(
 "Reparent GameObjects",
 kReparentText,
 "Yes, Reparent",
 "No, Remove"))
 {
 if (EditorUtility.IsPersistent(subEmitter))
 {
 var newGo = Object.Instantiate(subEmitter) as GameObject;
 if (newGo != null)
 {
 newGo.transform.parent = m_ParticleSystemUI.m_ParticleSystems[0].transform;
 newGo.transform.localPosition = Vector3.zero;
 newGo.transform.localRotation = Quaternion.identity;
 }
 }
 else
 {
 if (ps != null)
 {
 Undo.SetTransformParent(ps.gameObject.transform.transform, m_ParticleSystemUI.m_ParticleSystems[0].transform, "Reparent sub emitter");
 }
 }

 return true;
 }
 else if (ps != null)
 {
 // Clear sub-emitters that have been deselected, to avoid having their particles left paused in the Scene View (case 946999)
 ps.Clear(true);
 }

 return false;
 }

 private List<Object> GetSubEmitterProperties()
 {
 List<Object> props = new List<Object>();
 var enumerator = m_SubEmitters.GetEnumerator();

 while (enumerator.MoveNext())
 {
 SerializedProperty subEmitterData = (SerializedProperty)enumerator.Current;
 props.Add(subEmitterData.FindPropertyRelative("emitter").objectReferenceValue);
 }

 return props;
 }

 override public void OnInspectorGUI(InitialModuleUI initial)
 {
 // only allow sub-emitter editing in single edit mode
 if (m_ParticleSystemUI.multiEdit)
 {
 EditorGUILayout.HelpBox("Sub Emitter editing is only available when editing a single Particle System", MessageType.Info, true);
 return;
 }

 // get array of subemitters
 List<Object> props = GetSubEmitterProperties();

 m_EmittersList.DoLayoutList();

 // get new list of subemitters, so we can check for changes
 List<Object> props2 = GetSubEmitterProperties();

 // validate any new subemitters we assigned
 for (int i = 0; i < Mathf.Min(props.Count, props2.Count); i++)
 {
 if (props[i] != props2[i])
 {
 if (m_CheckObjectIndex == -1)
 EditorApplication.update += Update; // ensure its not added more than once

 // We need to let the ObjectSelector finish its SendEvent and therefore delay showing dialog
 m_CheckObjectIndex = i;

 // Clear sub-emitters that have been deselected, to avoid having their particles left paused in the Scene View (case 946999)
 ParticleSystem ps = props[i] as ParticleSystem;
 if (ps)
 ps.Clear(true);
 }
 }
 }

 override public void UpdateCullingSupportedString(ref string text)
 {
 text += "\nSub Emitters module is enabled.";
 }
 }
} // namespace UnityEditor