Studio/Assets/Scripts/Studio/Managers/ProjectManager.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using TriLibCore.SFB;
using Studio.AssetTool;
using Studio.Util;
using UnityEngine;
using System.Linq;
using Studio.HierarchyTree;
using Studio.Command;
using Studio.AssetLibraryTree;
using Studio.Services;

namespace Studio.Manage
{
    public class ProjectManager : Manager
    {
        public string curProjectName;
        public string curProjectPath;
        public string curProjectTemplate;

        public ProjectData curProjectData;
        public ProjectData newProjectData;

        public Action onOpenSaveAndOpenChecker;
        public Action onOpenSaveAndNewChecker;
        public Action onNewProjectModal;
        public Action onOpenProjectModal;

        public override void Init()
        {
            var canvas_Popup = CanvasManager.instance.GetCanvas<Canvas_Popup>();
            onOpenSaveAndNewChecker += canvas_Popup.panel_saveandnewchecker.Open;
            onOpenSaveAndOpenChecker += canvas_Popup.panel_saveandopenchecker.Open;
            onNewProjectModal += canvas_Popup.panel_topmenunewprojectinfo.Open;
            onOpenProjectModal += canvas_Popup.panel_topmenuopenprojectinfo.Open;
        }
        private void ResetProjectSettingData()
        {
            var connector = ManagerHub.instance.Get<CustomAssetConnector>();
            var fbxFileManager = ManagerHub.instance.Get<FBXFileManager>();
            var assetManager = ManagerHub.instance.Get<AssetManager>();
            var sceneSettingService = ManagerHub.instance.Get<SceneStartSettingManager>();

            var sceneStartSetting = new SceneStartSetting();
            sceneSettingService.SetSceneStartSetting(sceneStartSetting);

            foreach (var customAssetData in fbxFileManager.dataRepo.assetDatas)
            {
                connector.assetScrollView.RemoveItem(customAssetData.folderName, AssetLibraryItemType.folder);
                connector.assetScrollView.RemoveItem(customAssetData.assetName, AssetLibraryItemType.file);
            }
            CommandInvoker.instance.Invoke(new RemoveAllObjectCommand());

            fbxFileManager.ClearFilePaths();
            assetManager.ClearFolderPathList();
            assetManager.InitRessourceAsset();
        }
        public void TopMenuNewProjectSettingData()
        {
            var connector = ManagerHub.instance.Get<CustomAssetConnector>();
            var comparerManager = ManagerHub.instance.Get<ProjectDataComparerManager>();

            List<AssetData> assetDatas = connector.connectedAssets
                   .Where(asset => asset.hierarchyItem.linkedObject.activeSelf)
                   .OrderBy(asset => asset.hierarchyItem.layerNum)
                   .ThenBy(asset => asset.hierarchyItem.GetSiblingIndex())
                   .Select(asset => CreateAssetData(asset))
                   .ToList();
            newProjectData = CreateProjectData(assetDatas);
            if (CompareSaveState(curProjectData, newProjectData))
            {
                onNewProjectModal?.Invoke();
            }
            else
            {
                onOpenSaveAndNewChecker?.Invoke();
            }
        }
        public void TopMenuOpenProjectSettingData()
        {
            var connector = ManagerHub.instance.Get<CustomAssetConnector>();
            var comparerManager = ManagerHub.instance.Get<ProjectDataComparerManager>();

            List<AssetData> assetDatas = connector.connectedAssets
                   .Where(asset => asset.hierarchyItem.linkedObject.activeSelf)
                   .OrderBy(asset => asset.hierarchyItem.layerNum)
                   .ThenBy(asset => asset.hierarchyItem.GetSiblingIndex())
                   .Select(asset => CreateAssetData(asset))
                   .ToList();
            newProjectData = CreateProjectData(assetDatas);
            Debug.Log(curProjectData);
            Debug.Log(newProjectData);

            if (CompareSaveState(curProjectData, newProjectData))
            {
                onOpenProjectModal?.Invoke();
            }
            else
            {
                onOpenSaveAndOpenChecker?.Invoke();
            }
        }
        public void NewProjectSettingData(string proejctName, string projectPath)
        {
            ResetProjectSettingData();

            curProjectName = proejctName;
            curProjectPath = projectPath;
            curProjectTemplate = string.Empty;
            List<AssetData> assetDatas = new List<AssetData>();
            curProjectData = CreateProjectData(assetDatas);
        }
        public void OpenProejctSettingData(string filePath)
        {
            var canvas_Popup = CanvasManager.instance.GetCanvas<Canvas_Popup>();
            var assetManager = ManagerHub.instance.Get<AssetManager>();
            var sceneSettingService = ManagerHub.instance.Get<SceneStartSettingManager>();

            ResetProjectSettingData();

            if (File.Exists(filePath))
            {
                string json = File.ReadAllText(filePath);

                curProjectName = Path.GetFileNameWithoutExtension(filePath);
                curProjectPath = Path.GetDirectoryName(filePath);
                curProjectData = JsonConvert.DeserializeObject<ProjectData>(json);

                sceneSettingService.SetAppSettingData(curProjectData.sceneStartSetting.appSetting);
                sceneSettingService.SetAPISettingData(curProjectData.sceneStartSetting.apiSetting);
                sceneSettingService.SetMQTTSettingData(curProjectData.sceneStartSetting.mqttSetting);

                assetManager.CombineAssetFolderPaths(curProjectData.assetManagerData.localAssetsPaths);
                assetManager.SetAssetManager(curProjectData.assetManagerData);
            }
            else
            {
                Debug.LogWarning("JSON file not found: " + filePath);
            }
        }
        public void SaveProjectSettingData()
        {
            var connector = ManagerHub.instance.Get<CustomAssetConnector>();

            bool isNewProject = string.IsNullOrEmpty(curProjectPath);
            string path = isNewProject ? GetSaveFilePath() : Path.Combine(curProjectPath, curProjectName + ".ocs");

            if (string.IsNullOrEmpty(path))
                return;

            List<AssetData> assetDatas = connector.connectedAssets
                   .Where(asset => asset.hierarchyItem.linkedObject.activeSelf)
                   .OrderBy(asset => asset.hierarchyItem.layerNum)
                   .ThenBy(asset => asset.hierarchyItem.GetSiblingIndex())
                   .Select(asset => CreateAssetData(asset))
                   .ToList();

            curProjectData = CreateProjectData(assetDatas);
            string json = JsonConvert.SerializeObject(curProjectData, Formatting.Indented);

            using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))
            {
                using (StreamWriter writer = new StreamWriter(fs, System.Text.Encoding.Unicode))
                {
                    writer.Write(json);
                    writer.Close();
                }
            }
        }

        public AssetData CreateAssetData(ConnectedAsset asset)
        {
            return new AssetData(
                asset.hierarchyItem.linkedObject.GetInstanceID(),
                asset.hierarchyItem.name,
                asset.renderObject.code,
                asset.renderObject.componetKey,
                asset.renderObject.topic,
                asset.renderObject.isAutoId,
                new SaveVector3(asset.hierarchyItem.linkedObject.transform.position),
                new SaveVector3(asset.hierarchyItem.linkedObject.transform.eulerAngles),
                new SaveVector3(asset.hierarchyItem.linkedObject.transform.localScale),
                
                asset.hierarchyItem.children.Select(x => x.linkedObject.GetInstanceID()).ToList()
            );
        }

        private ProjectData CreateProjectData(List<AssetData> assetDatas)
        {
            var projectData = new ProjectData();
            projectData.sceneStartSetting = CreateSceneStartSettingData();
            projectData.assetManagerData = CreateAssetManagerData();
            projectData.assetDatas = assetDatas;

            return projectData;
        }
        private SceneStartSetting CreateSceneStartSettingData()
        {
            var sceneStartSettingService = ManagerHub.instance.Get<SceneStartSettingManager>();
            var sceneStartSetting = sceneStartSettingService.GetSceneStartSettingData();

            return sceneStartSetting;
        }
        private AssetManagerData CreateAssetManagerData()
        {
            var assetManager = ManagerHub.instance.Get<AssetManager>();
            var assetManagerData = new AssetManagerData();
            assetManagerData.localAssetsPaths.AddRange(assetManager.localAssetPaths);

            return assetManagerData;
        }

        private string GetSaveFilePath()
        {
            var data = StandaloneFileBrowser.SaveFilePanel("SaveProject", "", curProjectName, ".ocs");
            return data.Name;
        }
        public bool CompareSaveState(ISaveData origin, ISaveData modified)
        {
            if (origin.GetType() != modified.GetType())
            {
                return false;
            }

            var originHash = origin.comparableData;
            var modifiedHash = modified.comparableData;

            if (originHash.Equals(modifiedHash))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}