// Animancer // https://kybernetik.com.au/animancer // Copyright 2018-2023 Kybernetik //
// FlexiMotion // https://kybernetik.com.au/flexi-motion // Copyright 2023 Kybernetik //

#pragma warning disable CS0649 // Field is never assigned to, and will always have its default value.

#if UNITY_EDITOR

using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;

namespace Animancer.Editor
//namespace FlexiMotion.Editor
{
    /// <summary>[Editor-Only] A welcome screen for an asset.</summary>
    /// https://kybernetik.com.au/animancer/api/Animancer.Editor/ReadMe
    /// https://kybernetik.com.au/flexi-motion/api/FlexiMotion.Editor/ReadMe
    /// 
    public abstract class ReadMe : ScriptableObject
    {
        /************************************************************************************************************************/
        #region Fields and Properties
        /************************************************************************************************************************/

        /// <summary>The release ID of the current version.</summary>
        protected abstract int ReleaseNumber { get; }

        /// <summary>The display name of this product version.</summary>
        protected abstract string VersionName { get; }

        /// <summary>The URL for the change log of this version.</summary>
        protected abstract string ChangeLogURL { get; }

        /// <summary>The key used to save the release number.</summary>
        protected abstract string PrefKey { get; }

        /// <summary>An introductory explanation of this asset.</summary>
        protected virtual string Introduction => null;

        /// <summary>The base name of this product (without any "Lite", "Pro", "Demo", etc.).</summary>
        protected abstract string BaseProductName { get; }

        /// <summary>The name of this product.</summary>
        protected virtual string ProductName => BaseProductName;

        /// <summary>The URL for the documentation.</summary>
        protected abstract string DocumentationURL { get; }

        /// <summary>The display name for the examples section.</summary>
        protected virtual string ExamplesLabel => "Examples";

        /// <summary>The URL for the example documentation.</summary>
        protected abstract string ExampleURL { get; }

        /// <summary>The URL to check for the latest version.</summary>
        protected virtual string UpdateURL => null;

        /************************************************************************************************************************/

        /// <summary>
        /// The <see cref="ReadMe"/> file name ends with the <see cref="VersionName"/> to detect if the user imported
        /// this version without deleting a previous version.
        /// </summary>
        /// <remarks>
        /// When Unity's package importer sees an existing file with the same GUID as one in the package, it will
        /// overwrite that file but not move or rename it if the name has changed. So it will leave the file there with
        /// the old version name.
        /// </remarks>
        private bool HasCorrectName => name.EndsWith(VersionName);

        /************************************************************************************************************************/

        [SerializeField] private DefaultAsset _ExamplesFolder;

        /// <summary>Sections to be displayed below the examples.</summary>
        public LinkSection[] LinkSections { get; set; }

        /// <summary>Extra sections to be displayed with the examples.</summary>
        public LinkSection[] ExtraExamples { get; set; }

        /************************************************************************************************************************/

        /// <summary>Creates a new <see cref="ReadMe"/> and sets the <see cref="LinkSections"/>.</summary>
        public ReadMe(params LinkSection[] linkSections)
        {
            LinkSections = linkSections;
            _CheckForUpdatesKey = $"{PrefKey}.{nameof(CheckForUpdates)}";
        }

        /************************************************************************************************************************/

        /// <summary>A heading with a link to be displayed in the Inspector.</summary>
        public class LinkSection
        {
            /************************************************************************************************************************/

            /// <summary>The main label.</summary>
            public readonly string Heading;

            /// <summary>A short description to be displayed near the <see cref="Heading"/>.</summary>
            public readonly string Description;

            /// <summary>A link that can be opened by clicking the <see cref="Heading"/>.</summary>
            public readonly string URL;

            /// <summary>An optional user-friendly version of the <see cref="URL"/>.</summary>
            public readonly string DisplayURL;

            /************************************************************************************************************************/

            /// <summary>Creates a new <see cref="LinkSection"/>.</summary>
            public LinkSection(string heading, string description, string url, string displayURL = null)
            {
                Heading = heading;
                Description = description;
                URL = url;
                DisplayURL = displayURL;
            }

            /************************************************************************************************************************/
        }

        /************************************************************************************************************************/

        /// <summary>Returns a <c>mailto</c> link.</summary>
        public static string GetEmailURL(string address, string subject)
            => $"mailto:{address}?subject={subject.Replace(" ", "%20")}";

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Show On Startup and Check for Updates
        /************************************************************************************************************************/

        [SerializeField] private bool _DontShowOnStartup;

        [NonSerialized] private string _CheckForUpdatesKey;
        [NonSerialized] private bool _CheckedForUpdates;
        [NonSerialized] private bool _NewVersionAvailable;
        [NonSerialized] private string _UpdateCheckFailureMessage;
        [NonSerialized] private string _LatestVersionName;
        [NonSerialized] private string _LatestVersionChangeLogURL;
        [NonSerialized] private int _LatestVersionNumber;

        private bool CheckForUpdates
        {
            get => EditorPrefs.GetBool(_CheckForUpdatesKey, true);
            set => EditorPrefs.SetBool(_CheckForUpdatesKey, value);
        }

        /************************************************************************************************************************/

        private static readonly Dictionary<Type, IDisposable>
            TypeToUpdateCheck = new Dictionary<Type, IDisposable>();

        static ReadMe()
        {
            AssemblyReloadEvents.beforeAssemblyReload += () =>
            {
                foreach (var webRequest in TypeToUpdateCheck.Values)
                    webRequest.Dispose();

                TypeToUpdateCheck.Clear();
            };
        }

        /************************************************************************************************************************/

        /// <summary>Automatically selects a <see cref="ReadMe"/> on startup.</summary>
        [InitializeOnLoadMethod]
        private static void ShowReadMe()
        {
            EditorApplication.delayCall += () =>
            {
                var instances = FindInstances(out var autoSelect);

                for (int i = 0; i < instances.Count; i++)
                    instances[i].StartCheckForUpdates();

                // Delay the call again to ensure that the Project window actually shows the selection.
                if (autoSelect != null)
                    EditorApplication.delayCall += () =>
                        Selection.activeObject = autoSelect;
            };
        }

        /************************************************************************************************************************/

        /// <summary>
        /// Finds the most recently modified <see cref="ReadMe"/> asset with <see cref="_DontShowOnStartup"/> disabled.
        /// </summary>
        private static List<ReadMe> FindInstances(out ReadMe autoSelect)
        {
            var instances = new List<ReadMe>();

            DateTime latestWriteTime = default;
            autoSelect = null;
            string autoSelectGUID = null;

            var guids = AssetDatabase.FindAssets($"t:{nameof(ReadMe)}");
            for (int i = 0; i < guids.Length; i++)
            {
                var guid = guids[i];

                var assetPath = AssetDatabase.GUIDToAssetPath(guid);
                var asset = AssetDatabase.LoadAssetAtPath<ReadMe>(assetPath);
                if (asset == null)
                    continue;

                instances.Add(asset);

                if (asset._DontShowOnStartup && asset.HasCorrectName)
                    continue;

                // Check if already shown since opening the Unity Editor.
                if (SessionState.GetBool(guid, false))
                    continue;

                var writeTime = File.GetLastWriteTimeUtc(assetPath);
                if (latestWriteTime < writeTime)
                {
                    latestWriteTime = writeTime;
                    autoSelect = asset;
                    autoSelectGUID = guid;
                }
            }

            if (autoSelectGUID != null)
                SessionState.SetBool(autoSelectGUID, true);

            return instances;
        }

        /************************************************************************************************************************/

        protected virtual void OnEnable()
        {
            var name = GetType().FullName;
            var updateText = SessionState.GetString(name, "");
            OnUpdateCheckComplete(updateText);
        }

        /************************************************************************************************************************/

        private void StartCheckForUpdates()
        {
            if (!CheckForUpdates ||
                _CheckedForUpdates)
                return;

            var type = GetType();
            if (TypeToUpdateCheck.ContainsKey(type))
                return;

            var url = UpdateURL;
            if (string.IsNullOrEmpty(url))
                return;

            _CheckedForUpdates = true;

            var webRequest = UnityEngine.Networking.UnityWebRequest.Get(url);
            TypeToUpdateCheck.Add(type, webRequest);
            webRequest.SendWebRequest().completed += _ =>
            {
                var name = GetType().FullName;

#if UNITY_2020_3_OR_NEWER
                if (webRequest.result == UnityEngine.Networking.UnityWebRequest.Result.Success)
#else
                if (!webRequest.isNetworkError &&
                    !webRequest.isHttpError)
#endif
                {
                    var text = webRequest.downloadHandler.text;
                    OnUpdateCheckComplete(text);
                    SessionState.SetString(name, text);
                }
                else
                {
                    _UpdateCheckFailureMessage = $"Update check failed: {webRequest.error}.";
                    SessionState.SetString(name, "");
                }

                TypeToUpdateCheck.Remove(GetType());
                webRequest.Dispose();
            };
        }

        /************************************************************************************************************************/

        private void OnUpdateCheckComplete(string text)
        {
            if (string.IsNullOrEmpty(text))
                return;

            _CheckedForUpdates = true;

            var lines = text.Split('\n');
            if (lines.Length < 3)
            {
                _UpdateCheckFailureMessage = "Update check failed: text is malformed.";
                return;
            }

            int.TryParse(lines[0], out _LatestVersionNumber);
            _LatestVersionName = lines[1].Trim();
            _LatestVersionChangeLogURL = $"{DocumentationURL}/{lines[2].Trim()}";

            if (ReleaseNumber >= _LatestVersionNumber)
                return;

            _NewVersionAvailable = true;

            Debug.Log($"{_LatestVersionName} is now available." +
                $"\n• Change Log: {_LatestVersionChangeLogURL}" +
                $"\n• This check can be disabled in the Read Me asset's Inspector.",
                this);

            Selection.activeObject = this;
        }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
        #region Custom Editor
        /************************************************************************************************************************/

        /// <summary>[Editor-Only] A custom Inspector for <see cref="ReadMe"/>.</summary>
        [CustomEditor(typeof(ReadMe), editorForChildClasses: true)]
        public class Editor : UnityEditor.Editor
        {
            /************************************************************************************************************************/

            private static readonly GUIContent
                GUIContent = new GUIContent();

            [NonSerialized] private ReadMe _Target;
            [NonSerialized] private Texture2D _Icon;
            [NonSerialized] private string _ReleaseNumberPrefKey;
            [NonSerialized] private int _PreviousVersion;
            [NonSerialized] private string _ExamplesDirectory;
            [NonSerialized] private List<ExampleGroup> _Examples;
            [NonSerialized] private string _Title;
            [NonSerialized] private SerializedProperty _DontShowOnStartupProperty;

            /************************************************************************************************************************/

            /// <summary>Don't use any margins.</summary>
            public override bool UseDefaultMargins() => false;

            /************************************************************************************************************************/

            protected virtual void OnEnable()
            {
                _Target = (ReadMe)target;
                _Icon = AssetPreview.GetMiniThumbnail(target);

                _ReleaseNumberPrefKey = _Target.PrefKey + "." + nameof(_Target.ReleaseNumber);
                _PreviousVersion = PlayerPrefs.GetInt(_ReleaseNumberPrefKey, -1);

                _Examples = ExampleGroup.Gather(_Target._ExamplesFolder, out _ExamplesDirectory);

                _Title = $"{_Target.ProductName}\n{_Target.VersionName}";
                _DontShowOnStartupProperty = serializedObject.FindProperty(nameof(_DontShowOnStartup));
            }

            /************************************************************************************************************************/

            protected override void OnHeaderGUI()
            {
                GUILayout.BeginHorizontal(Styles.TitleArea);
                {
                    GUIContent.text = _Title;
                    GUIContent.tooltip = null;

                    var iconWidth = Styles.Title.CalcHeight(GUIContent, EditorGUIUtility.currentViewWidth);
                    GUILayout.Label(_Icon, GUILayout.Width(iconWidth), GUILayout.Height(iconWidth));
                    GUILayout.Label(GUIContent, Styles.Title);
                }
                GUILayout.EndHorizontal();
            }

            /************************************************************************************************************************/

            /// <inheritdoc/>
            public override void OnInspectorGUI()
            {
                serializedObject.Update();

                DoIntroduction();

                DoSpace();

                DoWarnings();

                DoNewVersionDetails();

                DoCheckForUpdates();
                DoShowOnStartup();

                DoSpace();

                DoIntroductionBlock();

                DoSpace();

                DoExampleBlock();

                DoSpace();

                DoSupportBlock();

                DoSpace();

                DoCheckForUpdates();
                DoShowOnStartup();

                serializedObject.ApplyModifiedProperties();
            }

            /************************************************************************************************************************/

            protected static void DoSpace() => GUILayout.Space(EditorGUIUtility.singleLineHeight * 0.2f);

            /************************************************************************************************************************/

            private void DoIntroduction()
            {
                var introduction = _Target.Introduction;
                if (introduction == null)
                    return;

                DoSpace();
                GUILayout.Label(introduction, EditorStyles.wordWrappedLabel);
            }

            /************************************************************************************************************************/

            private void DoNewVersionDetails()
            {

                if (_Target._UpdateCheckFailureMessage != null)
                {
                    EditorGUILayout.HelpBox(_Target._UpdateCheckFailureMessage, MessageType.Info);
                    return;
                }

                if (_Target._LatestVersionName == null ||
                    _Target._LatestVersionChangeLogURL == null)
                    return;

                var message = _Target._NewVersionAvailable
                    ? $"{_Target._LatestVersionName} is now available.\nClick here to view the Change Log."
                    : $"{_Target.BaseProductName} is up to date.";

                EditorGUILayout.HelpBox(message, MessageType.Info);

                if (TryUseClickEventInLastRect())
                    Application.OpenURL(_Target._LatestVersionChangeLogURL);
            }

            /************************************************************************************************************************/

            private void DoCheckForUpdates()
            {
                if (string.IsNullOrEmpty(_Target.UpdateURL))
                    return;

                var area = GUILayoutUtility.GetRect(0, EditorGUIUtility.singleLineHeight);
                area.xMin += EditorGUIUtility.singleLineHeight * 0.2f;

                EditorGUI.BeginChangeCheck();
                var value = GUI.Toggle(area, _Target.CheckForUpdates, "Check For Updates");
                if (EditorGUI.EndChangeCheck())
                {
                    _Target.CheckForUpdates = value;
                    if (value)
                        _Target.StartCheckForUpdates();
                }
            }

            /************************************************************************************************************************/

            private void DoShowOnStartup()
            {
                var area = GUILayoutUtility.GetRect(0, EditorGUIUtility.singleLineHeight);
                area.xMin += EditorGUIUtility.singleLineHeight * 0.2f;

                GUIContent.text = _DontShowOnStartupProperty.displayName;
                GUIContent.tooltip = _DontShowOnStartupProperty.tooltip;

                var label = EditorGUI.BeginProperty(area, GUIContent, _DontShowOnStartupProperty);
                EditorGUI.BeginChangeCheck();
                var value = _DontShowOnStartupProperty.boolValue;
                value = GUI.Toggle(area, value, label);
                if (EditorGUI.EndChangeCheck())
                {
                    _DontShowOnStartupProperty.boolValue = value;
                    if (value)
                        PlayerPrefs.SetInt(_ReleaseNumberPrefKey, _Target.ReleaseNumber);
                }
                EditorGUI.EndProperty();
            }

            /************************************************************************************************************************/

            private void DoWarnings()
            {
                MessageType messageType;

                if (!_Target.HasCorrectName)
                {
                    messageType = MessageType.Error;
                }
                else if (_PreviousVersion >= 0 && _PreviousVersion < _Target.ReleaseNumber)
                {
                    messageType = MessageType.Warning;
                }
                else return;

                // Upgraded from any older version.

                DoSpace();

                var directory = AssetDatabase.GetAssetPath(_Target);
                if (string.IsNullOrEmpty(directory))
                    return;

                directory = Path.GetDirectoryName(directory);

                var productName = _Target.ProductName;

                string versionWarning;
                if (messageType == MessageType.Error)
                {
                    versionWarning = $"You must fully delete any old version of {productName} before importing a new version." +
                        $"\n1. Check the Upgrade Guide in the Change Log." +
                        $"\n2. Click here to delete '{directory}'." +
                        $"\n3. Import {productName} again.";
                }
                else
                {
                    versionWarning = $"You must fully delete any old version of {productName} before importing a new version." +
                        $"\n1. Ignore this message if you have already deleted the old version." +
                        $"\n2. Check the Upgrade Guide in the Change Log." +
                        $"\n3. Click here to delete '{directory}'." +
                        $"\n4. Import {productName} again.";
                }

                EditorGUILayout.HelpBox(versionWarning, messageType);
                CheckDeleteDirectory(directory);

                DoSpace();
            }

            /************************************************************************************************************************/

            /// <summary>Asks if the user wants to delete the `directory` and does so if they confirm.</summary>
            private void CheckDeleteDirectory(string directory)
            {
                if (!TryUseClickEventInLastRect())
                    return;

                var name = _Target.ProductName;

                if (!AssetDatabase.IsValidFolder(directory))
                {
                    Debug.Log($"{directory} doesn't exist." +
                        $" You must have moved {name} somewhere else so you will need to delete it manually.", this);
                    return;
                }

                if (!EditorUtility.DisplayDialog($"Delete {name}? ",
                    $"Would you like to delete {directory}?\n\nYou will then need to reimport {name} manually.",
                    "Delete", "Cancel"))
                    return;

                AssetDatabase.DeleteAsset(directory);
            }

            /************************************************************************************************************************/

            /// <summary>
            /// Returns true and uses the current event if it is <see cref="EventType.MouseUp"/> inside the specified
            /// `area`.
            /// </summary>
            public static bool TryUseClickEvent(Rect area, int button = -1)
            {
                var currentEvent = Event.current;
                if (currentEvent.type != EventType.MouseUp ||
                    (button >= 0 && currentEvent.button != button) ||
                    !area.Contains(currentEvent.mousePosition))
                    return false;

                GUI.changed = true;
                currentEvent.Use();

                if (currentEvent.button == 2)
                    GUIUtility.keyboardControl = 0;

                return true;
            }

            /// <summary>
            /// Returns true and uses the current event if it is <see cref="EventType.MouseUp"/> inside the last GUI Layout
            /// <see cref="Rect"/> that was drawn.
            /// </summary>
            public static bool TryUseClickEventInLastRect(int button = -1)
                => TryUseClickEvent(GUILayoutUtility.GetLastRect(), button);

            /************************************************************************************************************************/

            protected virtual void DoIntroductionBlock()
            {
                GUILayout.BeginVertical(Styles.Block);

                DoHeadingLink("Documentation", null, _Target.DocumentationURL);

                DoSpace();

                DoHeadingLink("Change Log", null, _Target.ChangeLogURL);

                GUILayout.EndVertical();
            }

            /************************************************************************************************************************/

            protected virtual void DoExampleBlock()
            {
                GUILayout.BeginVertical(Styles.Block);

                DoHeadingLink(_Target.ExamplesLabel, null, _Target.ExampleURL);
                if (_Target._ExamplesFolder != null)
                {
                    EditorGUILayout.ObjectField(_ExamplesDirectory, _Target._ExamplesFolder, typeof(SceneAsset), false);

                    ExampleGroup.DoExampleGUI(_Examples);
                }

                DoExtraExamples();

                GUILayout.EndVertical();
            }

            /************************************************************************************************************************/

            protected virtual void DoExtraExamples()
            {
                if (_Target.ExtraExamples == null)
                    return;

                for (int i = 0; i < _Target.ExtraExamples.Length; i++)
                {
                    if (i > 0)
                        DoSpace();

                    var section = _Target.ExtraExamples[i];
                    DoHeadingLink(
                        section.Heading,
                        section.Description,
                        section.URL,
                        section.DisplayURL,
                        GUI.skin.label.fontSize);
                }
            }

            /************************************************************************************************************************/

            protected virtual void DoSupportBlock()
            {
                GUILayout.BeginVertical(Styles.Block);

                for (int i = 0; i < _Target.LinkSections.Length; i++)
                {
                    if (i > 0)
                        DoSpace();

                    var section = _Target.LinkSections[i];
                    DoHeadingLink(
                        section.Heading,
                        section.Description,
                        section.URL,
                        section.DisplayURL);
                }

                GUILayout.EndVertical();
            }

            /************************************************************************************************************************/

            protected void DoHeadingLink(
                string heading,
                string description,
                string url,
                string displayURL = null,
                int fontSize = 22)
            {
                // Heading.
                var style = url == null
                    ? Styles.HeaderLabel
                    : Styles.HeaderLink;
                var area = DoLinkButton(heading, url, style, fontSize);

                // Description.

                area.y += EditorGUIUtility.standardVerticalSpacing;

                var urlHeight = Styles.URL.fontSize + Styles.URL.margin.vertical;
                area.height -= urlHeight;

                if (description != null)
                    GUI.Label(area, description, Styles.Description);

                // URL.

                area.y += area.height;
                area.height = urlHeight;

                if (displayURL == null)
                    displayURL = url;

                if (displayURL != null)
                {
                    GUIContent.text = displayURL;
                    GUIContent.tooltip = "Click to copy this link to the clipboard";

                    if (GUI.Button(area, GUIContent, Styles.URL))
                    {
                        GUIUtility.systemCopyBuffer = displayURL;
                        Debug.Log($"Copied '{displayURL}' to the clipboard.", this);
                    }

                    EditorGUIUtility.AddCursorRect(area, MouseCursor.Text);
                }
            }

            /************************************************************************************************************************/

            protected Rect DoLinkButton(string text, string url, GUIStyle style, int fontSize = 22)
            {
                GUIContent.text = text;
                GUIContent.tooltip = url;

                style.fontSize = fontSize;

                var size = style.CalcSize(GUIContent);
                var area = GUILayoutUtility.GetRect(0, size.y);

                var linkArea = new Rect(area.x, area.y, size.x, area.height);
                area.xMin += size.x;

                if (url == null)
                {
                    GUI.Label(linkArea, GUIContent, style);
                }
                else
                {
                    if (GUI.Button(linkArea, GUIContent, style))
                        Application.OpenURL(url);

                    EditorGUIUtility.AddCursorRect(linkArea, MouseCursor.Link);

                    DrawLine(
                        new Vector2(linkArea.xMin, linkArea.yMax),
                        new Vector2(linkArea.xMax, linkArea.yMax),
                        style.normal.textColor);
                }

                return area;
            }

            /************************************************************************************************************************/

            /// <summary>Draws a line between the `start` and `end` using the `color`.</summary>
            public static void DrawLine(Vector2 start, Vector2 end, Color color)
            {
                var previousColor = Handles.color;
                Handles.BeginGUI();
                Handles.color = color;
                Handles.DrawLine(start, end);
                Handles.color = previousColor;
                Handles.EndGUI();
            }

            /************************************************************************************************************************/

            /// <summary>Various <see cref="GUIStyle"/>s used by the <see cref="Editor"/>.</summary>
            protected static class Styles
            {
                /************************************************************************************************************************/

                public static readonly GUIStyle TitleArea = "In BigTitle";

                public static readonly GUIStyle Title = new GUIStyle(GUI.skin.label)
                {
                    fontSize = 26,
                };

                public static readonly GUIStyle Block = GUI.skin.box;

                public static readonly GUIStyle HeaderLabel = new GUIStyle(GUI.skin.label)
                {
                    stretchWidth = false,
                };

                public static readonly GUIStyle HeaderLink = new GUIStyle(HeaderLabel);

                public static readonly GUIStyle Description = new GUIStyle(GUI.skin.label)
                {
                    alignment = TextAnchor.LowerLeft,
                };

                public static readonly GUIStyle URL = new GUIStyle(GUI.skin.label)
                {
                    fontSize = 9,
                    alignment = TextAnchor.LowerLeft,
                };

                /************************************************************************************************************************/

                static Styles()
                {
                    HeaderLink.normal.textColor = HeaderLink.hover.textColor =
                        new Color32(0x00, 0x78, 0xDA, 0xFF);

                    URL.normal.textColor = Color.Lerp(URL.normal.textColor, Color.grey, 0.8f);
                }

                /************************************************************************************************************************/
            }

            /************************************************************************************************************************/

            /// <summary>A group of example scenes.</summary>
            private class ExampleGroup
            {
                /************************************************************************************************************************/

                /// <summary>The name of this group.</summary>
                public readonly string Name;

                /// <summary>The scenes in this group.</summary>
                public readonly List<SceneAsset> Scenes = new List<SceneAsset>();

                /// <summary>The folder paths of each of the <see cref="Scenes"/>.</summary>
                public readonly List<string> Directories = new List<string>();

                /// <summary>Indicates whether this group should show its contents in the GUI.</summary>
                private bool _IsExpanded;

                /// <summary>Is this group always expanded?</summary>
                private bool _AlwaysExpanded;

                /************************************************************************************************************************/

                public static List<ExampleGroup> Gather(DefaultAsset rootDirectoryAsset, out string examplesDirectory)
                {
                    if (rootDirectoryAsset == null)
                    {
                        examplesDirectory = null;
                        return null;
                    }

                    examplesDirectory = AssetDatabase.GetAssetPath(rootDirectoryAsset);
                    if (string.IsNullOrEmpty(examplesDirectory))
                        return null;

                    var directories = Directory.GetDirectories(examplesDirectory);
                    var groups = new List<ExampleGroup>();
                    var allGroupsHaveOneScene = true;

                    for (int i = 0; i < directories.Length; i++)
                    {
                        var group = Gather(examplesDirectory, directories[i]);
                        if (group != null)
                        {
                            groups.Add(group);
                            if (group.Scenes.Count > 1)
                                allGroupsHaveOneScene = false;
                        }
                    }

                    if (groups.Count == 0)
                    {
                        var group = Gather(examplesDirectory, examplesDirectory);
                        if (group != null)
                        {
                            groups.Add(group);
                            if (group.Scenes.Count > 1)
                                allGroupsHaveOneScene = false;
                        }
                    }

                    if (allGroupsHaveOneScene)
                        for (int i = 0; i < groups.Count; i++)
                            groups[i]._AlwaysExpanded = true;

                    examplesDirectory = Path.GetDirectoryName(examplesDirectory);

                    return groups;
                }

                /************************************************************************************************************************/

                public static ExampleGroup Gather(string rootDirectory, string directory)
                {
                    var files = Directory.GetFiles(directory, "*.unity", SearchOption.AllDirectories);

                    List<SceneAsset> scenes = null;

                    for (int j = 0; j < files.Length; j++)
                    {
                        var scene = AssetDatabase.LoadAssetAtPath<SceneAsset>(files[j]);
                        if (scene != null)
                        {
                            if (scenes == null)
                                scenes = new List<SceneAsset>();
                            scenes.Add(scene);
                        }
                    }

                    if (scenes == null)
                        return null;

                    return new ExampleGroup(rootDirectory, directory, scenes);
                }

                /************************************************************************************************************************/

                public ExampleGroup(string rootDirectory, string directory, List<SceneAsset> scenes)
                {
                    var start = rootDirectory.Length + 1;
                    Name = start < directory.Length ?
                        directory.Substring(start, directory.Length - start) :
                        Path.GetFileName(directory);
                    Scenes = scenes;

                    start = directory.Length + 1;

                    for (int i = 0; i < scenes.Count; i++)
                    {
                        directory = AssetDatabase.GetAssetPath(scenes[i]);

                        directory = directory.Substring(start, directory.Length - start);
                        directory = Path.GetDirectoryName(directory);
                        Directories.Add(directory);
                    }
                }

                /************************************************************************************************************************/

                public static void DoExampleGUI(List<ExampleGroup> examples)
                {
                    if (examples == null)
                        return;

                    for (int i = 0; i < examples.Count; i++)
                        examples[i].DoExampleGUI();
                }

                public void DoExampleGUI()
                {
                    if (_AlwaysExpanded)
                    {
                        for (int i = 0; i < Scenes.Count; i++)
                        {
                            EditorGUILayout.ObjectField(Directories[i], Scenes[i], typeof(SceneAsset), false);
                        }

                        return;
                    }

                    EditorGUI.indentLevel++;

                    GUIContent.text = Name;
                    GUIContent.tooltip = null;

                    _IsExpanded = EditorGUILayout.Foldout(_IsExpanded, GUIContent, true);

                    if (_IsExpanded)
                    {
                        EditorGUI.indentLevel++;

                        for (int i = 0; i < Scenes.Count; i++)
                        {
                            EditorGUILayout.ObjectField(Directories[i], Scenes[i], typeof(SceneAsset), false);
                        }

                        EditorGUI.indentLevel--;
                    }

                    EditorGUI.indentLevel--;
                }

                /************************************************************************************************************************/
            }

            /************************************************************************************************************************/
        }

        /************************************************************************************************************************/
        #endregion
        /************************************************************************************************************************/
    }
}

#endif