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

namespace NextechAR.ARitize.Plugin
{
    public class ARitizerUI
    {

        [MenuItem("GameObject/ARitize/Copy Target Path to Clipboard", false, 0)]
        static void TargetPathToClipboard() {
            

            GameObject mySelGO = UnityEditor.Selection.activeGameObject;

            if(mySelGO.name == "AnchorForAR")
            {
                EditorGUIUtility.systemCopyBuffer = "[root]";
                Debug.Log("[root] copied to clipboard");
                return;
            }



            string targetPath = mySelGO.name;

            bool gettingPath = true;

            Transform currentParent = mySelGO.transform.parent;

            if(currentParent == null)
            {
                gettingPath = false;
                Debug.LogError(mySelGO.name + " is not a child of the experience prefab");
                return;
            }



            while(gettingPath)
            {
                if(currentParent.gameObject.name == "AnchorForAR")
                {
                    gettingPath = false;
                }
                else
                {
                    targetPath = currentParent.name + "/" + targetPath;
                    currentParent = currentParent.parent;

                    if(currentParent == null)
                    {
                        gettingPath = false;
                        Debug.LogError(mySelGO.name + " is not a child of the experience prefab");
                        return;
                    }
                }
            }

            
            Debug.Log(targetPath + " copied to clipboard");
            EditorGUIUtility.systemCopyBuffer = targetPath;
        }

        public ARitizerEditorStyles editorStyles;
        Color defColor = Color.white;
        Vector2 homeScroll;
        Vector2 tutorialScroll;
        Vector2 changelogScroll;
        Vector2 experienceValidationScroll;
        ARitizer aritizer;
        bool hasInitializedStyles = false;

        public class ARitizerEditorStyles
        {
            public GUIStyle backButton;
            public GUIStyle menuButton;
            public GUIStyle badButton;
            public GUIStyle titleText;
            public GUIStyle sectionHeaderText;
            public GUIStyle experienceListButton;
            public GUIStyle bigButton;
            public GUIStyle boldFoldout;
            public GUIStyle centeredLargeText;
        }

        void SetStyles()
        {
            editorStyles.backButton = new GUIStyle("Button");
            editorStyles.backButton.fixedWidth = 50;

            editorStyles.menuButton = new GUIStyle("Button");
            editorStyles.menuButton.fixedWidth = 150;

            editorStyles.badButton = new GUIStyle("Button");
            editorStyles.badButton.fixedWidth = 150;
            editorStyles.badButton.normal.textColor = Color.red;

            editorStyles.experienceListButton = new GUIStyle("Button");
            editorStyles.experienceListButton.fixedWidth = 350;

            editorStyles.titleText = new GUIStyle("Label");
            editorStyles.titleText.fontSize = 20;
            editorStyles.titleText.alignment = TextAnchor.UpperCenter;
            editorStyles.titleText.fixedHeight = 200;

            editorStyles.sectionHeaderText = new GUIStyle("Label");
            editorStyles.sectionHeaderText.fontSize = 13;
            editorStyles.sectionHeaderText.alignment = TextAnchor.UpperLeft;
            editorStyles.sectionHeaderText.fontStyle = FontStyle.Bold;
            editorStyles.sectionHeaderText.fixedHeight = 200;

            editorStyles.bigButton = new GUIStyle("Button");
            editorStyles.bigButton.fixedHeight = 80;
            editorStyles.bigButton.fontSize = 20;

            editorStyles.boldFoldout = EditorStyles.foldout;
            editorStyles.boldFoldout.fontStyle = FontStyle.Bold;

            editorStyles.centeredLargeText = new GUIStyle("Label");
            editorStyles.centeredLargeText.alignment = TextAnchor.UpperCenter;
            editorStyles.centeredLargeText.fontSize = 20;
            editorStyles.centeredLargeText.fixedHeight = 80;

            hasInitializedStyles = true;
        }

        //ARitizer runs this OnEnable to setup some initial values
        public void Initialize(ARitizer newAritizer)
        {
            editorStyles = new ARitizerEditorStyles();
            defColor = GUI.color;
            aritizer = newAritizer;
            
        }

        //main UI update method, run by ARitizer's OnGUI
        public void PluginGUI()
        {
            //this has to be triggered by OnGUI so we do it here with a check
            if(!hasInitializedStyles)
            {
                SetStyles();
            }

            if(!aritizer.IsCorrectUnityVersion())
            {
                WrongVersionUI();
                return;
            }
            
            //hide UI while code is compiling to reduce accidental clicks
            if(EditorApplication.isCompiling)
            {
                CompileGUI();
                return; 
            }

            //show appropriate menu
            if(aritizer.currentMenu == ARitizer.Menu.home)
            {
                HomeGUI();
            }
            else if(aritizer.currentMenu == ARitizer.Menu.experience)
            {
                ExperienceGUI(aritizer.currentSelectedExperience);
            }
            else if(aritizer.currentMenu == ARitizer.Menu.settings)
            {
                SettingsGUI();
            }

            //display plugin version so when someone complains I can ask if they're using the latest version
            GUILayout.BeginHorizontal();
            EditorGUILayout.LabelField(string.Format("version: {0}", aritizer.GetPluginVersion()), EditorStyles.centeredGreyMiniLabel);
            if(GUILayout.Button("Open Docs", editorStyles.menuButton))
            {
                Application.OpenURL("https://docs.nextechar.com/");
            }
            GUILayout.EndHorizontal();
        }

        void BackButton()
        {
            if(GUILayout.Button("◀︎ Back", editorStyles.backButton))
            {
                aritizer.currentMenu = ARitizer.Menu.home;
            }
        }

        void HomeGUI()
        {
            //update experience count 
            aritizer.ExperienceCountChanged();

            MenuTitle("ARitizer");
            
            //create new experience interface
            NewExperienceInterface();
            
            //experience list
            SectionHeader("Experiences");
            ExperienceListInterface();

            EditorGUILayout.Space();
            if(GUILayout.Button("Settings", editorStyles.menuButton))
            {
                aritizer.currentMenu = ARitizer.Menu.settings;
            }
        }

        void NewExperienceInterface()
        {
            if(!aritizer.creatingNew)
            {
                if(GUILayout.Button("New Experience", editorStyles.menuButton))
                {
                    aritizer.creatingNew = true;
                }
            }
            else
            {
                //check for enter key submission
                Event e = Event.current;
                if (e.keyCode == KeyCode.Return && e.type == EventType.KeyDown)
                {
                    //use event so we can clear focus of input field
                    Event.current.Use();
                    //we strip this out because it'll get used in filename because of the above line and unity will yell at us
                    aritizer.newExperienceInput = aritizer.newExperienceInput.Replace("\n", "");
                    OnCreateExperience();
                    return;
                }

                EditorGUILayout.BeginHorizontal();
                GUI.SetNextControlName("NewExpNameText");
                aritizer.newExperienceInput = EditorGUILayout.TextField("New Experience Name", aritizer.newExperienceInput);
                GUI.FocusControl("NewExpNameText"); 

                //check for button press submission
                if(GUILayout.Button("Create"))
                {
                    OnCreateExperience();
                    return;
                }
                if(GUILayout.Button("Cancel"))
                {
                    GUI.FocusControl(null); 
                    aritizer.newExperienceInput = "";
                    aritizer.creatingNew = false;
                }

                EditorGUILayout.EndHorizontal();
            }
        }

        void OnCreateExperience()
        {
            if(string.IsNullOrEmpty(aritizer.newExperienceInput))
            {
                Debug.LogError("Provide a name for the new experience");
            }
            else
            {
                GUI.FocusControl(null); 
                aritizer.CreateNewExperience(aritizer.newExperienceInput);
                aritizer.newExperienceInput = "";
                aritizer.creatingNew = false;
                EditorUtility.SetDirty(aritizer);
            }

        }        

        void ExperienceListInterface()
        {
            homeScroll = EditorGUILayout.BeginScrollView(homeScroll);
            string[] experienceFolders = aritizer.GetExperienceFolders();
            for(int i = 0; i < experienceFolders.Length; i++)
            {
                //hide example folder
                if(Path.GetFileName(experienceFolders[i]) == "Examples")
                {
                    continue;
                }

                EditorGUILayout.BeginHorizontal();
                // EditorGUILayout.LabelField(Path.GetFileName(experienceFolders[i]));
                if(GUILayout.Button(Path.GetFileName(experienceFolders[i]), editorStyles.experienceListButton))
                {
                    aritizer.SelectExperience(i);
                }			
                EditorGUILayout.EndHorizontal();

            }
            EditorGUILayout.EndScrollView();
        }

        void WrongVersionUI()
        {
            EditorGUILayout.LabelField("");
            EditorGUILayout.LabelField("");
            EditorGUILayout.LabelField("");
            EditorGUILayout.LabelField("");

            EditorGUILayout.HelpBox("Error - Wrong version of Unity. Please download and use Unity version " + aritizer.GetRequiredUnityVersion(), MessageType.Error);
            
            // EditorGUILayout.LabelField("!", editorStyles.centeredLargeText);
        }

        void CompileGUI()
        { 
            EditorGUILayout.LabelField("");
            EditorGUILayout.LabelField("");
            EditorGUILayout.LabelField("");
            EditorGUILayout.LabelField("");
            
            EditorGUILayout.LabelField("Scripts are compiling.\n\nHang tight!", editorStyles.centeredLargeText);
        }  

        void MenuTitle(string content)
        {
            EditorGUILayout.LabelField(content, editorStyles.titleText);
            EditorGUILayout.Space();
            EditorGUILayout.Space();
        }

        void SectionHeader(string content)
        {
            EditorGUILayout.LabelField(content, editorStyles.sectionHeaderText);
        }

        void BulletPoint(string content)
        {
            EditorGUILayout.LabelField(string.Format(" ◆ {0}", content), EditorStyles.wordWrappedLabel);
        }

        void VersionInfo(string versionNumber, string[] changes)
        {
            SectionHeader(string.Format("Version {0}", versionNumber));
            for(int i = 0; i < changes.Length; i++)
            {
                BulletPoint(changes[i]);
            }
            EditorGUILayout.Space();
            EditorGUILayout.Space();
        }

        void OtherActionsGUI(int experienceIndex)
        { 
            string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
            string experiencePath = experienceFolders[experienceIndex];
            SectionHeader("Other Actions");
            if(!aritizer.previewMenuOpen)
            {
                if(GUILayout.Button("Preview", editorStyles.menuButton))
                {
                    aritizer.StartPreviewServer();
                    
                }
            }

            if(GUILayout.Button("Go to files", editorStyles.menuButton))
            {
                aritizer.OnExperienceSelected(experienceFolders[experienceIndex]);
            }
            
            if(GUILayout.Button("Export UnityPackage", editorStyles.menuButton))
            {
                aritizer.ExportUnityPackage(experiencePath);
            }

            if(GUILayout.Button("Duplicate", editorStyles.menuButton))
            {
                duplicateName = "";
                GUI.FocusControl(null);
                aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.duplicate;
            }

            
            GUI.color = Color.red;
            if(GUILayout.Button("Delete", editorStyles.badButton))
            {
                // isDeleting = true;
                aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.delete;
            }
            GUI.color = defColor;
        }

        void ExperienceGUI(int experienceIndex)
        {
            aritizer.editorBuildTarget = EditorUserBuildSettings.activeBuildTarget;

            if(aritizer.ExperienceCountChanged())
            {
                aritizer.currentMenu = ARitizer.Menu.home;
                return;
            }            

            if(aritizer.currentExperienceMenu == ARitizer.ExperienceMenu.home)
            {
                string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
                string experiencePath = experienceFolders[experienceIndex];
                
                string experienceName = Path.GetFileName(experiencePath);
                MenuTitle(string.Format("\"{0}\" Experience", experienceName));

                EditorGUILayout.BeginHorizontal();
                if(GUILayout.Button("Edit", editorStyles.bigButton))
                {
                    aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.edit;
                    
                }

                if(GUILayout.Button("Build", editorStyles.bigButton))
                {
                    aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.build;
                    
                } 

                EditorGUILayout.EndHorizontal();
                
                if(aritizer.previewMenuOpen)
                {
                    PreviewLinkGUI(experienceIndex);
                }

                OtherActionsGUI(experienceIndex);

                if(GUILayout.Button("◀︎ Back", editorStyles.backButton))
                {
                    aritizer.BackFromHome();
                }
            }
            else if(aritizer.currentExperienceMenu == ARitizer.ExperienceMenu.edit)
            {
                EditExperienceGUI(experienceIndex);
                
            }
            else if(aritizer.currentExperienceMenu == ARitizer.ExperienceMenu.editModule)
            {
                EditModuleGUI();
            }
            else if(aritizer.currentExperienceMenu == ARitizer.ExperienceMenu.build)
            {
                BuildExperienceGUI(experienceIndex);
                
            }
            else if(aritizer.currentExperienceMenu == ARitizer.ExperienceMenu.delete)
            {
                DeleteExperienceGUI(experienceIndex);
            }
            else if(aritizer.currentExperienceMenu == ARitizer.ExperienceMenu.duplicate)
            {
                DuplicateExperienceGUI(experienceIndex);
            }
            
        }

        void EditExperienceGUI(int experienceIndex)
        {
            string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
            string experiencePath = experienceFolders[experienceIndex];
            
            string experienceName = Path.GetFileName(experiencePath);
            MenuTitle(string.Format("\"{0}\" Experience", experienceName));

            if(aritizer.dataEditor == null)
                aritizer.SetDataEditor(experiencePath);


            if(aritizer.dataEditor != null)
            {
                aritizer.dataEditor.OnInspectorGUI();
            }
            else
            {
                EditorGUILayout.HelpBox("Error - Something's wrong with this experience's Data file", MessageType.Error);
            }

            if(GUILayout.Button("◀︎ Back", editorStyles.backButton))
            {
                aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.home;
                
            }

        }

        public void ResetScrolls()
        {
            moduleScroll = experienceValidationScroll = homeScroll = Vector2.zero;
        }

        
        Vector2 moduleScroll;
        void EditModuleGUI()
        {

            MenuTitle(string.Format("Editing {0}", aritizer.editingModuleName));

            if(aritizer.editorForModuleBeingInspected == null)
                aritizer.SetModuleEditor();

            moduleScroll = EditorGUILayout.BeginScrollView(moduleScroll);
            aritizer.editorForModuleBeingInspected.OnInspectorGUI();
            EditorGUILayout.EndScrollView();

            if(GUILayout.Button("◀︎ Back", editorStyles.backButton))
            {
                AssetDatabase.SaveAssets();
                aritizer.editorForModuleBeingInspected = null;
                EditorPrefs.DeleteKey("EditModulePath");
                EditorPrefs.DeleteKey("EditModule");
                aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.edit;			
            }
        }

        void DeleteExperienceGUI(int experienceIndex)
        {
            string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
            string experiencePath = experienceFolders[experienceIndex];
            
            string experienceName = Path.GetFileName(experiencePath);
            MenuTitle(string.Format("\"{0}\" Experience", experienceName));

            SectionHeader(string.Format("Do you really want to delete {0}?", experienceName));
            EditorGUILayout.BeginHorizontal();
            GUI.color = Color.red;
            if(GUILayout.Button("Delete", editorStyles.badButton))
            {
                aritizer.DeleteExperience(experiencePath);
            }
            GUI.color = defColor;
            if(GUILayout.Button("Cancel", editorStyles.menuButton))
            {
                aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.home;
            }
            EditorGUILayout.EndHorizontal();
        }

        string duplicateName = "";

        string nameIssue = "";

        bool IsValidExperienceName(string name)
        {
            //they enter a name at all?
            if(name.Replace(" ", "") == "")
            {
                nameIssue = "Please enter a name for the experience";
                return false;
            }
            else
            {
                bool alreadyExists = false;
                string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
                for(int i = 0; i < experienceFolders.Length; i++)
                {
                    string expName = Path.GetFileName(experienceFolders[i]);
                    if(name.ToLower() == expName.ToLower())
                    {
                        alreadyExists = true;
                        break;
                    }
                        
                    
                    // Debug.Log(expName);
                }

                if(alreadyExists)
                {
                    nameIssue = "Experience \"" + name + "\" already exists";
                    return false;
                }
                else
                {
                    return true;
                }
                
            }
            
        }

        void DuplicateExperienceGUI(int experienceIndex)
        {
            bool validName = false;
            string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
            string experiencePath = experienceFolders[experienceIndex];
            string experienceName = Path.GetFileName(experiencePath);
            MenuTitle(string.Format("Duplicating \"{0}\"", experienceName));



            EditorGUILayout.HelpBox("This copies the prefab, data object, and any modules.\nReferences to art assets, animation objects, etc will be shared with the original and can be changed manually.", MessageType.Warning);

            duplicateName = EditorGUILayout.TextField("Name of copy", duplicateName);
            
            validName = IsValidExperienceName(duplicateName);

            
            if(validName)
            {
                if(GUILayout.Button("Duplicate", editorStyles.menuButton))
                {
                    aritizer.DuplicateExperience(experienceIndex, duplicateName);
                }
            }
            else
            {
                EditorGUILayout.HelpBox(nameIssue, MessageType.Error);
            }

            if(GUILayout.Button("Cancel", editorStyles.menuButton))
            {
                aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.home;
            }

            // SectionHeader(string.Format("Name of ", experienceName));
            
        }

        

        void BuildExperienceGUI(int experienceIndex)
        {
            string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
            string experiencePath = experienceFolders[experienceIndex];
            
            string experienceName = Path.GetFileName(experiencePath);
            MenuTitle(string.Format("\"{0}\" Experience", experienceName));

            ARitizer.ValidationResult validation = aritizer.ValidateExperience(experiencePath);

            if(validation.messages.Count > 0)
            {
                SectionHeader("Issues found: ");
                experienceValidationScroll = EditorGUILayout.BeginScrollView(experienceValidationScroll);
                for(int i = 0; i < validation.messages.Count; i++)
                {
                    if(validation.messages[i].messageType == ARitizer.ValidationResult.ValidationMessage.MessageType.warning)
                    {
                        EditorGUILayout.HelpBox(string.Format(validation.messages[i].message, aritizer.GetRequiredUnityVersion()), MessageType.Warning);
                    }
                    else if(validation.messages[i].messageType == ARitizer.ValidationResult.ValidationMessage.MessageType.error)
                    {
                        EditorGUILayout.HelpBox(string.Format(validation.messages[i].message, aritizer.GetRequiredUnityVersion()), MessageType.Error);
                    }
                }
                EditorGUILayout.EndScrollView();
            }

            if(validation.IsValid())
            {
                string ios_note = "";
                if(aritizer.editorBuildTarget != BuildTarget.iOS)
                {
                    ios_note = " (will reimport assets)";
                }

                string android_note = "";
                if(aritizer.editorBuildTarget != BuildTarget.Android)
                {
                    android_note = " (will reimport assets)";
                }          

                
                SectionHeader("ARitize Mobile App");
                if(GUILayout.Button("Build iOS" + ios_note))
                {
                    aritizer.BuildExperience(experiencePath, BuildTarget.iOS);
                }
                if(GUILayout.Button("Build Android" + android_note))
                {
                    aritizer.BuildExperience(experiencePath, BuildTarget.Android);
                }

                SectionHeader("AR eCommerce");
                if(GUILayout.Button("Build AR eCommerce"))
                {
                    aritizer.BuildForWeb(experiencePath);
                }
                
            }
            else
            {
                EditorGUILayout.HelpBox("Fix errors to build.", MessageType.Error);
            }

            if(GUILayout.Button("◀︎ Back", editorStyles.backButton))
            {
                aritizer.currentExperienceMenu = ARitizer.ExperienceMenu.home;
                aritizer.ClosePreviewServer();                
            }
        }

        void PreviewLinkGUI(int experienceIndex)
        {
            SectionHeader("Preview");            

            string[] experienceFolders = AssetDatabase.GetSubFolders("Assets/_Experiences");
            string experiencePath = experienceFolders[experienceIndex];
            
            string experienceName = Path.GetFileName(experiencePath);

            BuildTarget targetPlatform = BuildTarget.NoTarget;

            if(aritizer.currentPreviewPlatform == ARitizer.PreviewPlatform.ios)
            {
                targetPlatform = BuildTarget.iOS;
            }
            else if(aritizer.currentPreviewPlatform == ARitizer.PreviewPlatform.droid)
            {
                targetPlatform = BuildTarget.Android;
            }

            string bundleAssetName = aritizer.GetName_NTAR(experienceName, targetPlatform);
            string bundlePath = aritizer.assetBundleDirectory + "/" + bundleAssetName;

            bool hasFile = false;
            

            if(aritizer.previewServer.Active)
            {
                GUILayout.Label("Hosting");
            }
            else
            {
                aritizer.previewMenuOpen = false;
            }

            if(aritizer.currentPreviewPlatform == ARitizer.PreviewPlatform.unknown)
            {
                GUILayout.Label("Waiting on connection from app");
                GUILayout.Label("Enter this IP into the app to connect: " + aritizer.localIp);
            }
            else
            {
                GUILayout.Label("Connected platform: " + aritizer.currentPreviewPlatform.ToString());

                if(!File.Exists(bundlePath))
                {
                    EditorGUILayout.HelpBox(string.Format("Need to build the ntar for {0} on {1} before you can send it!", experienceName, targetPlatform.ToString()), MessageType.Error);
                }
                else
                {
                    hasFile = true;
                }

                if(hasFile)
                {
                    if(GUILayout.Button("Send NTAR", editorStyles.menuButton))
                    {
                        aritizer.SendData(bundleAssetName);
                    }	
                }
            }

            if(GUILayout.Button("Close Preview Link", editorStyles.menuButton))
            {
                aritizer.ClosePreviewServer();
            }
        }

        void SettingsGUI()
        {
            MenuTitle("Settings");
            
            SectionHeader("Switch build target");
            if(EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
            {
                if(GUILayout.Button("iOS", editorStyles.menuButton))
                {
                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.iOS, BuildTarget.iOS);
                }
            }
            else if(EditorUserBuildSettings.activeBuildTarget == BuildTarget.iOS)
            {
                if(GUILayout.Button("Android", editorStyles.menuButton))
                {
                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Android, BuildTarget.Android);
                }
            }
            else
            {
                if(GUILayout.Button("iOS", editorStyles.menuButton))
                {
                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.iOS, BuildTarget.iOS);
                }
                if(GUILayout.Button("Android", editorStyles.menuButton))
                {
                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Android, BuildTarget.Android);
                }
            }

            DirectoryField("NTAR Directory", ref aritizer.assetBundleDirectory, ref aritizer.lastAssetBundleDirectory);
            DirectoryField("GLTF Directory", ref aritizer.gltfDirectory, ref aritizer.lastGltfDirectory);
            DirectoryField("UnityPackage Directory", ref aritizer.unityPackageDirectory, ref aritizer.lastUnityPackageDirectory);
            DirectoryField("Staging Directory", ref aritizer.stagingDirectory, ref aritizer.lastStagingDirectory);
            GUI.color = Color.red;
            if(GUILayout.Button("Uninstall", editorStyles.badButton))
            {
                aritizer.UninstallSelf();	
            }
            GUI.color = defColor;
            BackButton();
        }

        void DirectoryField(string directoryDescription, ref string directoryPath, ref string lastDirectoryPath)
        {
            EditorGUILayout.BeginHorizontal();
            directoryPath = EditorGUILayout.TextField(directoryDescription, directoryPath);

            if(lastDirectoryPath == directoryPath)
            {
                if(GUILayout.Button("Open in Finder"))
                {
                    FileManager.CreateDirectoryIfNeeded(directoryPath);
                    EditorUtility.RevealInFinder(directoryPath);
                }
            }
            else
            {
                if(GUILayout.Button("Save Changes"))
                {
                    lastDirectoryPath = directoryPath;
                    FileManager.CreateDirectoryIfNeeded(directoryPath);
                    if(directoryPath == aritizer.assetBundleDirectory)
                    {
                        EditorPrefs.SetString("assetBundleDirectory", directoryPath);
                    }
                    else if(directoryPath == aritizer.unityPackageDirectory)
                    {
                        EditorPrefs.SetString("unityPackageDirectory", aritizer.unityPackageDirectory);
                    }
                    else if(directoryPath == aritizer.stagingDirectory)
                    {
                        EditorPrefs.SetString("stagingDirectory", aritizer.stagingDirectory);
                    }
                    else if(directoryPath == aritizer.gltfDirectory)
                    {
                        EditorPrefs.SetString("gltfDirectory", aritizer.gltfDirectory);
                    }
                    
                }
                if(GUILayout.Button("Cancel"))
                {
                    directoryPath = lastDirectoryPath;
                }
            }

            
            EditorGUILayout.EndHorizontal();
        }        
    }
}