// SceneAssetAttribute.cs
namespace Sirenix.OdinInspector
{
    using System;

    /// <summary>
    /// <para>The SceneAsset attribute draws a dropdown for selecting scenes from the project to assign to a string field.</para>
    /// <para>Use this to make it easy to select scenes from the project and assign either their name or full path to the field the attribute has been applied to.</para>
    /// </summary>
    /// <example>
    /// <para>The following example demonstrates the use of the SceneAsset attribute.</para>
    /// <code>
    /// public class MyComponent : MonoBehaviour
    /// {
    ///     // On this field only the name of the scene will be assigned to the MySceneName field when a scene is selected.
    ///     [SceneAsset(false)]
    ///     public string MySceneName;
    ///     
    ///     // On this field the entire path to the scene will assigned to the MyScenePath field when a scene is selected.
    ///     [SceneAsset(true)]
    ///     public string MyScenePath;
    /// }
    /// </code>
    /// </example>
    /// <seealso cref="ValueDropdownAttribute"/>
    /// <seealso cref="AssetListAttribute"/>
    /// <seealso cref="TagSelectorAttribute"/>
    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
    public class SceneAssetAttribute : Attribute
    {
        /// <summary>
        /// If true, then the field will assign the path to the scene instead of the the name of the scene.
        /// </summary>
        public bool UseScenePath;

        /// <summary>
        /// Draws a selector for scenes in the inspector.
        /// </summary>
        /// <param name="useScenePath">If <c>true</c> the entire path of a scene will be used instead of just the name of the scene.</param>
        public SceneAssetAttribute(bool useScenePath)
        {
            this.UseScenePath = useScenePath;
        }
    }
}

// SceneAssetAttributeDrawer.cs
namespace Sirenix.OdinInspector.Editor.Drawers
{
    using System.IO;
    using System.Linq;
    using Sirenix.OdinInspector.Editor;
    using Sirenix.Utilities;
    using Sirenix.Utilities.Editor;
    using UnityEditor;
    using UnityEngine;

    public class SceneAssetAttributeDrawer : OdinAttributeDrawer<SceneAssetAttribute, string>
    {
        private bool currentSceneExists;

        private bool selectorChanged;
        private SceneAsset selectedScene;

        protected override void Initialize()
        {
            this.UpdateCurrentSceneExists();
        }

        protected override void DrawPropertyLayout(GUIContent label)
        {
            if (this.selectorChanged)
            {
                this.selectorChanged = false;
                this.SetScene(this.selectedScene);
            }

            if (string.IsNullOrEmpty(this.ValueEntry.SmartValue) == false && this.currentSceneExists == false)
            {
                SirenixEditorGUI.ErrorMessageBox("Could not find scene at path: " + this.ValueEntry.SmartValue);
            }

            EditorGUI.BeginChangeCheck();
            Rect rect = EditorGUILayout.GetControlRect(label != null);
            this.ValueEntry.SmartValue = SirenixEditorFields.TextField(rect.SubXMax(16), label, this.ValueEntry.SmartValue);

            if (EditorGUI.EndChangeCheck())
            {
                this.UpdateCurrentSceneExists();
            }

            if (SirenixEditorGUI.IconButton(rect.AlignRight(16), EditorIcons.TriangleDown))
            {
                var fieldRect = rect;
                if (label != null)
                {
                    fieldRect = fieldRect.AddXMin(GUIHelper.BetterLabelWidth);
                }

                this.ShowSelector(fieldRect);
            }
        }

        private void SetScene(SceneAsset asset)
        {
            var path = asset != null ? AssetDatabase.GetAssetPath(asset) : null;

            if (string.IsNullOrEmpty(path) || this.Attribute.UseScenePath)
            {
                this.ValueEntry.SmartValue = path;
            }
            else
            {
                this.ValueEntry.SmartValue = Path.GetFileNameWithoutExtension(path);
            }

            this.currentSceneExists = asset != null;
        }

        private void ShowSelector(Rect fieldRect)
        {
            var assets = AssetDatabase.FindAssets("t:scene").Select(g => AssetDatabase.LoadAssetAtPath<SceneAsset>(AssetDatabase.GUIDToAssetPath(g)));
            var selector = new GenericSelector<SceneAsset>(assets);

            var current = this.GetCurrentScene();
            selector.SetSelection(current);
            selector.SelectionCancelled += () => this.SetSelection(current);
            selector.SelectionChanged += e => this.SetSelection(e.FirstOrDefault());
            selector.SelectionConfirmed += e => this.SetSelection(e.FirstOrDefault());
            selector.ShowInPopup(fieldRect);
        }

        private void SetSelection(SceneAsset asset)
        {
            this.selectedScene = asset;
            this.selectorChanged = true;
        }

        private SceneAsset GetCurrentScene()
        {
            if (string.IsNullOrEmpty(this.ValueEntry.SmartValue) == false)
            {
                if (this.Attribute.UseScenePath)
                {
                    return AssetDatabase.LoadAssetAtPath<SceneAsset>(this.ValueEntry.SmartValue);
                }
                else
                {
                    // Since we're refering to scenes by name, we have no way of telling scenes with the same name apart.
                    // Therefore any scene with the correct name will do.
                    var path = AssetDatabase.FindAssets("t:scene " + this.ValueEntry.SmartValue)
                        .Select(g => AssetDatabase.GUIDToAssetPath(g))
                        .Where(p => Path.GetFileNameWithoutExtension(p) == this.ValueEntry.SmartValue)
                        .FirstOrDefault();

                    if (path != null)
                    {
                        return AssetDatabase.LoadAssetAtPath<SceneAsset>(path);
                    }
                }
            }

            return null;
        }

        private void UpdateCurrentSceneExists()
        {
            this.currentSceneExists = this.GetCurrentScene() != null;
        }
    }
}