using System.Collections.Generic;
using Unity.Collections;
using UnityEngine.XR.ARSubsystems;

#if !UNITY_2019_2_OR_NEWER
using UnityEngine.Experimental;
#endif

namespace UnityEngine.XR.ARFoundation
{
    /// <summary>
    /// A generic manager for components generated by features detected in the physical environment.
    /// </summary>
    /// <remarks>
    /// When the manager is informed that a trackable has been added, a new <c>GameObject</c>
    /// is created with an <c>ARTrackable</c> component on it. If
    /// <see cref="ARTrackableManager{TSubsystem, TSubsystemDescriptor, TSessionRelativeData, TTrackable}.prefab"/>
    /// is not null, then that prefab will be instantiated.
    /// </remarks>
    /// <typeparam name="TSubsystem">The <c>Subsystem</c> which provides this manager data.</typeparam>
    /// <typeparam name="TSubsystemDescriptor">The <c>SubsystemDescriptor</c> required to create the Subsystem.</typeparam>
    /// <typeparam name="TSessionRelativeData">A concrete struct used to hold data provided by the Subsystem.</typeparam>
    /// <typeparam name="TTrackable">The type of component this component will manage (i.e., create, update, and destroy).</typeparam>
    [RequireComponent(typeof(ARSessionOrigin))]
    [DisallowMultipleComponent]
    public abstract class ARTrackableManager<TSubsystem, TSubsystemDescriptor, TSessionRelativeData, TTrackable>
    : SubsystemLifecycleManager<TSubsystem, TSubsystemDescriptor>
        where TSubsystem : TrackingSubsystem<TSessionRelativeData, TSubsystemDescriptor>
        where TSubsystemDescriptor : SubsystemDescriptor<TSubsystem>
        where TSessionRelativeData : struct, ITrackable
        where TTrackable : ARTrackable<TSessionRelativeData, TTrackable>
    {
        /// <summary>
        /// A collection of all trackables managed by this component.
        /// </summary>
        public TrackableCollection<TTrackable> trackables
        {
            get
            {
                return new TrackableCollection<TTrackable>(m_Trackables);
            }
        }

        /// <summary>
        /// Iterates over every instantiated <see cref="ARTrackable"/> and
        /// activates or deactivates its <c>GameObject</c> based on the value of
        /// <paramref name="active"/>.
        /// This calls
        /// <a href="https://docs.unity3d.com/ScriptReference/GameObject.SetActive.html">GameObject.SetActive</a>
        /// on each trackable's <c>GameObject</c>.
        /// </summary>
        /// <param name="active">If <c>true</c> each trackable's <c>GameObject</c> is activated.
        /// Otherwise, it is deactivated.</param>
        public void SetTrackablesActive(bool active)
        {
            foreach (var trackable in trackables)
            {
                trackable.gameObject.SetActive(active);
            }
        }

        /// <summary>
        /// The <c>ARSessionOrigin</c> which will be used to instantiate detected trackables.
        /// </summary>
        protected ARSessionOrigin sessionOrigin { get; private set; }

        /// <summary>
        /// The name prefix that should be used when instantiating new <c>GameObject</c>s.
        /// </summary>
        protected abstract string gameObjectName { get; }

        /// <summary>
        /// The prefab that should be instantiated when adding a trackable.
        /// </summary>
        protected virtual GameObject GetPrefab()
        {
            return null;
        }

        /// <summary>
        /// A dictionary of all trackables, keyed by <c>TrackableId</c>.
        /// </summary>
        protected Dictionary<TrackableId, TTrackable> m_Trackables = new Dictionary<TrackableId, TTrackable>();

        /// <summary>
        /// A dictionary of trackables added via <see cref="CreateTrackableImmediate(TSessionRelativeData)"/> but not yet reported as added.
        /// </summary>
        protected Dictionary<TrackableId, TTrackable> m_PendingAdds = new Dictionary<TrackableId, TTrackable>();

        /// <summary>
        /// Invoked by Unity once when this component wakes up.
        /// </summary>
        protected virtual void Awake()
        {
            sessionOrigin = GetComponent<ARSessionOrigin>();
        }

        /// <summary>
        /// Update is called once per frame. This component's internal state
        /// is first updated, and then the <see cref="trackablesChanged"/> event is invoked.
        /// </summary>
        protected virtual void Update()
        {
            if (subsystem == null)
                return;

            using (var changes = subsystem.GetChanges(Allocator.Temp))
            {
                ClearAndSetCapacity(s_Added, changes.added.Length);
                foreach (var added in changes.added)
                    s_Added.Add(CreateOrUpdateTrackable(added));

                ClearAndSetCapacity(s_Updated, changes.updated.Length);
                foreach (var updated in changes.updated)
                    s_Updated.Add(CreateOrUpdateTrackable(updated));

                ClearAndSetCapacity(s_Removed, changes.removed.Length);
                foreach (var trackableId in changes.removed)
                {
                    TTrackable trackable;
                    if (m_Trackables.TryGetValue(trackableId, out trackable))
                    {
                        m_Trackables.Remove(trackableId);
                        s_Removed.Add(trackable);
                    }
                }
            }

            try
            {
                // User events
                if ((s_Added.Count) > 0 ||
                    (s_Updated.Count) > 0 ||
                    (s_Removed.Count) > 0)
                {
                    OnTrackablesChanged(s_Added, s_Updated, s_Removed);
                }
            }
            finally
            {
                // Make sure destroy happens even if a user callback throws an exception
                foreach (var removed in s_Removed)
                    DestroyTrackable(removed);
            }
        }

        /// <summary>
        /// Invoked when trackables have changed, i.e., added, updated, or removed.
        /// Use this to perform additional logic, or to invoke public events
        /// related to your trackables.
        /// </summary>
        /// <param name="added">A list of trackables added this frame.</param>
        /// <param name="updated">A list of trackables updated this frame.</param>
        /// <param name="removed">A list of trackables removed this frame.
        /// The trackable components are not destroyed until after this method returns.</param>
        protected virtual void OnTrackablesChanged(
            List<TTrackable> added,
            List<TTrackable> updated,
            List<TTrackable> removed)
        { }

        /// <summary>
        /// Invoked after creating the trackable. The trackable's <c>sessionRelativeData</c> property will already be set.
        /// </summary>
        /// <param name="trackable">The newly created trackable.</param>
        protected virtual void OnCreateTrackable(TTrackable trackable)
        { }

        /// <summary>
        /// Invoked just after session relative data has been set on a trackable.
        /// </summary>
        /// <param name="trackable">The trackable that has just been updated.</param>
        /// <param name="sessionRelativeData">The session relative data used to update the trackable.</param>
        protected virtual void OnAfterSetSessionRelativeData(
            TTrackable trackable,
            TSessionRelativeData sessionRelativeData)
        { }

        /// <summary>
        /// Creates a <see cref="TTrackable"/> immediately, leaving it in a "pending" state.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Trackables are usually created, updated, or destroyed during <see cref="Update()"/>.
        /// This method creates a trackable immediately, and marks it as "pending"
        /// until it is reported as added by the subsystem. This is useful for subsystems that deal
        /// with trackables that can be both detected and manually created.
        /// </para></<para>
        /// This method does not invoke <see cref="OnTrackablesChanged(List{TTrackable}, List{TTrackable}, List{TTrackable})"/>,
        /// so no "added" notifications will occur until the next call to <see cref="Update"/>.
        /// However, this method does invoke <see cref="ARTrackable{TSessionRelativeData, TTrackable}.updated"/>
        /// on the new trackable.
        /// </para><para>
        /// The trackable will appear in the <see cref="trackables"/> collection immediately.
        /// </para>
        /// </remarks>
        /// <returns>A new <c>TTrackable</c></returns>
        protected TTrackable CreateTrackableImmediate(TSessionRelativeData sessionRelativeData)
        {
            var trackable = CreateOrUpdateTrackable(sessionRelativeData);
            trackable.pending = true;
            m_PendingAdds.Add(trackable.trackableId, trackable);
            return trackable;
        }

        /// <summary>
        /// If in a "pending" state, the trackable with <paramref name="trackableId"/>'s
        /// <see cref="ARTrackable{TSessionRelativeData, TTrackable}.removed"/>
        /// event is invoked, and the trackable's <c>GameObject</c> destroyed if
        /// <see cref="ARTrackable{TSessionRelativeData, TTrackable}.destroyOnRemoval"/> is true.
        /// Otherwise, this method has no effect.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Trackables are usually removed only when the subsystem reports they
        /// have been removed during <see cref="Update"/>
        /// </para><para>
        /// This method will immediately remove a trackable only if it was created by
        /// <see cref="CreateTrackableImmediate(TSessionRelativeData)"/>
        /// and has not yet been reported as added by the
        /// <see cref="SubsystemLifecycleManager{TSubsystem, TSubsystemDescriptor}.subsystem"/>.
        /// </para><para>
        /// This can happen if the trackable is created and removed within the same frame, as the subsystem may never
        /// have a chance to report its existence. Derived classes should use this
        /// if they support the concept of manual addition and removal of trackables, as there may not
        /// be a removal event if the trackable is added and removed quickly.
        /// </para><para>
        /// If the trackable is not in a pending state, i.e., it has already been reported as "added",
        /// then this method does nothing.
        /// </para>
        /// <para>
        /// This method does not invoke <see cref="OnTrackablesChanged(List{TTrackable}, List{TTrackable}, List{TTrackable})"/>,
        /// so no "removed" notifications will occur until the next call to <see cref="Update"/> (and only if it was
        /// previously reported as "added").
        /// However, this method does invoke <see cref="ARTrackable{TSessionRelativeData, TTrackable}.removed"/>
        /// on the trackable.
        /// </para>
        /// </remarks>
        /// <returns><c>True</c> if the trackable is "pending" (i.e., not yet reported as "added").</returns>
        protected bool DestroyPendingTrackable(TrackableId trackableId)
        {
            TTrackable trackable;
            if (m_PendingAdds.TryGetValue(trackableId, out trackable))
            {
                m_PendingAdds.Remove(trackableId);
                m_Trackables.Remove(trackableId);
                DestroyTrackable(trackable);
                return true;
            }

            return false;
        }

        static void ClearAndSetCapacity(List<TTrackable> list, int capacity)
        {
            list.Clear();
            if (list.Capacity < capacity)
                list.Capacity = capacity;
        }

        string GetTrackableName(TrackableId trackableId)
        {
            return gameObjectName + " " + trackableId.ToString();
        }

        GameObject CreateGameObject()
        {
            var prefab = GetPrefab();
            if (prefab == null)
            {
                var go = new GameObject();
                go.transform.parent = sessionOrigin.trackablesParent;
                return go;
            }

            return Instantiate(prefab, sessionOrigin.trackablesParent);
        }

        GameObject CreateGameObject(string name)
        {
            var go = CreateGameObject();
            go.name = name;
            return go;
        }

        GameObject CreateGameObject(TrackableId trackableId)
        {
            return CreateGameObject(GetTrackableName(trackableId));
        }

        TTrackable CreateTrackable(TrackableId trackableId)
        {
            var go = CreateGameObject(trackableId);
            var trackable = go.GetComponent<TTrackable>();
            if (trackable == null)
                trackable = go.AddComponent<TTrackable>();

            return trackable;
        }

        TTrackable CreateOrUpdateTrackable(TSessionRelativeData sessionRelativeData)
        {
            var trackableId = sessionRelativeData.trackableId;
            TTrackable trackable;
            if (m_Trackables.TryGetValue(trackableId, out trackable))
            {
                m_PendingAdds.Remove(trackableId);
                trackable.pending = false;
                trackable.SetSessionRelativeData(sessionRelativeData);
            }
            else
            {
                trackable = CreateTrackable(trackableId);
                m_Trackables.Add(trackableId, trackable);
                trackable.SetSessionRelativeData(sessionRelativeData);
                OnCreateTrackable(trackable);
            }

            OnAfterSetSessionRelativeData(trackable, sessionRelativeData);
            trackable.OnAfterSetSessionRelativeData();
            return trackable;
        }

        void DestroyTrackable(TTrackable trackable)
        {
            if (trackable.destroyOnRemoval)
                Destroy(trackable.gameObject);
        }

        static List<TTrackable> s_Added = new List<TTrackable>();

        static List<TTrackable> s_Updated = new List<TTrackable>();

        static List<TTrackable> s_Removed = new List<TTrackable>();
    }
}