ConnectedAssetScriptableObjectHandler

using System.Collections;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif
using UnityEngine;
using System;
using System.IO;
using UnityEditor.UIElements;
using UnityEngine.UIElements;
using System.Linq;

public class ConnectedAssetScriptableObjectHandler : ScriptableObject {
    public List<ConnectedAssetSO> connectedAssetList;

    public void RenameConnectedAssets(string newName) {
        foreach (ConnectedAssetSO asset in connectedAssetList) {
            asset.NameExtension = newName + asset.BasePathType.ToString();
            asset.RenameConnectedAsset(newName);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
        }
    }
    public void CreateConnectedAssets() {
        foreach (ConnectedAssetSO asset in connectedAssetList) {
            bool doOnce = false;
            if (doOnce == false) {
                asset.CreateConnectedAsset(out doOnce);
            }
        }
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
        foreach (ConnectedAssetSO asset in connectedAssetList) {
            bool doOnce = false;
            if (doOnce == false) {
                asset.FinalObject = AssetDatabase.LoadAssetAtPath(asset.FinalPath, asset.BasePathType);
            }
        }
    }
#if UNITY_EDITOR
    public virtual void Awake() {
        //We want to Open the connected assets window then create assets specified on button click.

    }
#endif
}
#if UNITY_EDITOR
public class ConnectedAssetDatabase : EditorWindow {
    //private ConnectedAssetScriptableObjectHandler connectedAssetScriptableObject;

    private static List<ConnectedAssetSO> m_ConnectedAssetDatabase = new List<ConnectedAssetSO>();
    private VisualElement m_ConnectedAssetsTab;
    private static VisualTreeAsset m_ConnectedAssetRowTemplate;
    private ScrollView m_DetailSection;

    private ListView m_ConnectedAssetListView;
    private ConnectedAssetSO m_activeItem;

    private int m_ItemHeight = 60;
    [MenuItem("WUG/Connected Asset Database")]
    public static void Init() {
        ConnectedAssetDatabase wnd = GetWindow<ConnectedAssetDatabase>();
        wnd.titleContent = new GUIContent("Connected Asset Database");

        Vector2 size = new Vector2(1000, 475);
        wnd.minSize = size;
        wnd.maxSize = size;
    }
    public void CreateGUI() {
        // Import the UXML Window
        var visualTree = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>("Assets/Connected Assets/Editor/ConnectedAssetDatabase.uxml");
        VisualElement rootFromUXML = visualTree.Instantiate();
        rootVisualElement.Add(rootFromUXML);

        // Import the stylesheet
        var styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>("Assets/Connected Assets/Editor/ConnectedAssetDatabase.uss");
        rootVisualElement.styleSheets.Add(styleSheet);

        //Import the ListView Connected Asset Template
        m_ConnectedAssetRowTemplate = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>("Assets/Connected Assets/Editor/ConnectedAssetRowTemplate.uxml");
        //TODO Replace this with some sort of indicator for Connected Assets

        //Get references for later
        //this is how we query our created "template?" i am not sure since rootVisualElement is never "set"
        // this will query rootVisualElement (still not sure how this references our created data) for ScrollViewDetails
        m_DetailSection = rootVisualElement.Q<ScrollView>("ScrollView_Details");
        //This will query m_DetailSection(IE ScrollView_Details) for an element Named Icon
        //m_LargeDisplayIcon = m_DetailSection.Q<VisualElement>("Icon");

        //Load all existing item assets
        LoadAllConnectedAssets();

        //Populate the listview
        m_ConnectedAssetsTab = rootVisualElement.Q<VisualElement>("ConnectedAssetsTab");
        Debug.Log(m_ConnectedAssetsTab);
        GenerateListView();

        //Hook up button click events
        rootVisualElement.Q<Button>("Btn_AddItem").clicked += AddItem_OnClick;
        rootVisualElement.Q<Button>("Btn_DeleteItem").clicked += DeleteItem_OnClick;

        //Register Value Changed Callbacks for new items added to the ListView
        //m_DetailSection.Q<TextField>("ItemName").RegisterValueChangedCallback(evt => {
        //    m_activeItem.FriendlyName = evt.newValue;
        //    m_ConnectedAssetListView.Refresh();
        //});

        //m_DetailSection.Q<ObjectField>("IconPicker").RegisterValueChangedCallback(evt => {
        //    Sprite newSprite = evt.newValue as Sprite;
        //    m_activeItem.Icon = newSprite == null ? m_DefaultItemIcon : newSprite;
        //    m_LargeDisplayIcon.style.backgroundImage = newSprite == null ? m_DefaultItemIcon.texture : newSprite.texture;

        //    m_ConnectedAssetListView.Refresh();

        //});

    }
    /// <summary>
    /// Look through all items located in Assets/Data and load them into memory
    ///
    /// We should change this purpose since we have our list on
    /// </summary>
    private void LoadAllConnectedAssets() {
        m_ConnectedAssetDatabase.Clear();

        string[] allPaths = Directory.GetFiles("Assets/Connected Assets/Created Connected Assets", "*.asset", SearchOption.AllDirectories);

        foreach (string path in allPaths) {
            string cleanedPath = path.Replace("\\", "/");
            m_ConnectedAssetDatabase.Add((ConnectedAssetSO)AssetDatabase.LoadAssetAtPath(cleanedPath, typeof(ConnectedAssetSO)));
        }
    }
    /// <summary>
    /// Create the list view based on the asset data
    /// </summary>
    private void GenerateListView() {
        //Defining what each item will visually look like. In this case, the makeItem function is creating a clone of the ItemRowTemplate.
        Func<VisualElement> makeItem = () => m_ConnectedAssetRowTemplate.CloneTree();

        //Define the binding of each individual Item that is created. Specifically,
        //it binds the Icon visual element to the scriptable object’s Icon property and the
        //Name label to the FriendlyName property.
        Action<VisualElement, int> bindItem = (e, i) => {
            e.Q<TextField>("SOName").text = m_ConnectedAssetDatabase[i].SOName;
        };

        //Create the listview and set various properties
        m_ConnectedAssetListView = new ListView(m_ConnectedAssetDatabase, m_ItemHeight, makeItem, bindItem);
        m_ConnectedAssetListView.selectionType = SelectionType.Single;
        m_ConnectedAssetListView.style.height = m_ConnectedAssetDatabase.Count * m_ItemHeight + 5;
        m_ConnectedAssetsTab.Add(m_ConnectedAssetListView);

        m_ConnectedAssetListView.onSelectionChange += ListView_onSelectionChange;
        m_ConnectedAssetListView.SetSelection(0);
    }
    /// <summary>
    /// Delete the active Item asset from the Asset/Data folder
    /// </summary>
    private void DeleteItem_OnClick() {
        //Get the path of the fie and delete it through AssetDatabase
        string path = AssetDatabase.GetAssetPath(m_activeItem);
        AssetDatabase.DeleteAsset(path);

        //Purge the reference from the list and refresh the ListView
        m_ConnectedAssetDatabase.Remove(m_activeItem);
        m_ConnectedAssetListView.Refresh();

        //Nothing is selected, so hide the details section
        m_DetailSection.style.visibility = Visibility.Hidden;

    }

    /// <summary>
    /// Add a new Item asset to the Asset/Data folder
    /// Crashed unity
    /// </summary>
    private void AddItem_OnClick() {
        //Create an instance of the scriptable object
        ConnectedAssetSO connectedAsset = CreateInstance<ConnectedAssetSO>();

        //Create the asset
        AssetDatabase.CreateAsset(connectedAsset, $"Assets/Connected Assets/Created Connected Assets/{connectedAsset.iD}.asset");
        //Add it to the item list
        m_ConnectedAssetDatabase.Add(connectedAsset);
        //Refresh the ListView so everything is redrawn again
        m_ConnectedAssetListView.Refresh();
        m_ConnectedAssetListView.style.height = m_ConnectedAssetDatabase.Count * m_ItemHeight + 5;

        m_ConnectedAssetListView.SetSelection(m_ConnectedAssetDatabase.Count - 1);
    }
    /// <summary>
    ///
    /// </summary>
    /// <param name="selectedItems"></param>
    private void ListView_onSelectionChange(IEnumerable<object> selectedItems) {
        //Get the first item in the selectedItems list.
        //There will only ever be one because SelectionType is set to Single
        m_activeItem = (ConnectedAssetSO)selectedItems.First();

        //Create a new SerializedObject and bind the Details VE to it.
        //This cascades the binding to the children
        SerializedObject so = new SerializedObject(m_activeItem);
        m_DetailSection.Bind(so);

        //Set the icon if it exists
        //if (m_activeItem.Icon != null) {
        //    m_LargeDisplayIcon.style.backgroundImage = m_activeItem.Icon.texture;
        //}

        //Make sure the detail section is visible. This can turn off when you delete an item
        m_DetailSection.style.visibility = Visibility.Visible;
    }

    public void SaveScriptableObject(ConnectedAssetSO saveObj) {
        // If for some reason there is no current object you are recording changes into
        // then create a new instance to save your info into
        if (saveObj == null) {
            saveObj = ScriptableObject.CreateInstance<ConnectedAssetSO>();
            AssetDatabase.CreateAsset(saveObj, $"Assets/YourSavePath/YourObject.asset");
        }

        // Next Load it up with all your data, for example through some config function


        // Now flag the object as "dirty" in the editor so it will be saved
        EditorUtility.SetDirty(saveObj);

        // And finally, prompt the editor database to save dirty assets, committing your changes to disk.
        AssetDatabase.SaveAssets();
    }

}
#endif