XRLib/Assets/Scripts/Simulator/Components/AGV/AGVPoolManager.cs

using Cysharp.Threading.Tasks;
using System;
using System.Collections.Generic;
using UnityEngine;
using UVC.Data;
using UVC.Data.Core;
using UVC.Pool;

namespace Simulator.Data.Transport
{
    public class AGVPoolManager
    {
        private readonly Transform _parent;
        private readonly Dictionary<string, string> prefabPaths = new Dictionary<string, string>()
        {
            {"agv","prefabs/agv"},
            {"afl","prefabs/afl"},
            {"forkLift","prefabs/forkLift"}
        };

        private GameObjectPool<AGV> agvPool;
        private GameObjectPool<AGV> aflPool;
        private GameObjectPool<AGV> forkLiftPool;

        private DataMapper agvMoveMapper;
        private DataMapper agvLoadMapper;
        private DataMapper agvUnLoadMapper;

        private readonly Dictionary<string, AGV> agvMap = new Dictionary<string, AGV>();

        public DataMapper AgvMoveMapper => agvMoveMapper;
        public DataMapper AgvLoadMapper => agvLoadMapper;
        public DataMapper AgvUnLoadMapper => agvUnLoadMapper;

        public AGVPoolManager(Transform parent)
        {
            _parent = parent;
        }

        public void InitializeAllPools()
        {
            InitializeAGVPoolAsync().ContinueWith(() =>
            {
                InitializeDataMappers();
            });
            InitializeAFLPoolAsync().ContinueWith(() => { });
            InitializeForkLiftPoolAsync().ContinueWith(() => { });
        }

        private void InitializeDataMappers()
        {
            var agvMoveDataMask = new DataMask();
            agvMoveDataMask.ObjectName = "agv";
            agvMoveDataMask.ObjectIdKey = "component_id";
            agvMoveDataMask["component_id"] = "";
            agvMoveDataMask["component_type"] = "";
            agvMoveDataMask["event_name"] = "";
            agvMoveDataMask["timestamp"] = new DateTime();
            agvMoveDataMask["data"] = new DataMask()
            {
                ["from_node"] = "",
                ["to_node"] = "",
                ["timing"] = new DataMask()
                {
                    ["duration"] = new DataMask()
                    {
                        ["real_seconds"] = 0.0f
                    }
                }
            };
            agvMoveMapper = new DataMapper(agvMoveDataMask);

            var agvLoadDataMask = new DataMask();
            agvLoadDataMask.ObjectName = "agv";
            agvLoadDataMask.ObjectIdKey = "component_id";
            agvLoadDataMask["component_id"] = "";
            agvLoadDataMask["component_type"] = "";
            agvLoadDataMask["event_name"] = "";
            agvLoadDataMask["timestamp"] = new DateTime();
            agvLoadDataMask["data"] = new DataMask()
            {
                ["from_node"] = "",
                ["to_node"] = "",
                ["entity_ids"] = new DataMask()
                {
                    ["entity_id"] = ""
                }
            };
            agvLoadMapper = new DataMapper(agvLoadDataMask);

            var agvUnLoadDataMask = new DataMask();
            agvUnLoadMapper = new DataMapper(agvUnLoadDataMask);
        }

        public void SpawnAGV(List<AGVData> datas, string type)
        {
            foreach (var data in datas)
            {
                switch (type)
                {
                    case "agv":
                        if (data.initial_node == null)
                        {
                            return;
                        }
                        var agv = agvPool.GetItem($"{data.name}");
                        agv.data = data;
                        agv.UpdatePosition(AGVNodeManager.Instance.GetNodePosition(data.initial_node));
                        agvMap[data.name] = agv;
                        agv.dataType = AGVDataType.Idle;
                        PlayerPropertyDataBase.Instance.CollectSpawnAGV(agv);
                        break;
                    case "afl":
                        var afl = aflPool.GetItem($"{data.name}");
                        afl.data = data;
                        afl.UpdatePosition(AGVNodeManager.Instance.GetNodePosition(data.initial_node));
                        agvMap[data.name] = afl;
                        afl.dataType = AGVDataType.Idle;
                        PlayerPropertyDataBase.Instance.CollectSpawnAGV(afl);
                        break;
                    case "forklift":
                        var forkLift = forkLiftPool.GetItem($"{data.name}");
                        forkLift.data = data;
                        forkLift.UpdatePosition(AGVNodeManager.Instance.GetNodePosition(data.initial_node));
                        agvMap[data.name] = forkLift;
                        forkLift.dataType = AGVDataType.Idle;
                        PlayerPropertyDataBase.Instance.CollectSpawnAGV(forkLift);
                        break;
                }
            }
        }

        public AGV FindAGV(string name)
        {
            return agvMap.TryGetValue(name, out var agv) ? agv : null;
        }

        private async UniTask InitializeAGVPoolAsync()
        {
            if (agvPool != null) return;

            var prefab = await Resources.LoadAsync<GameObject>(prefabPaths["agv"]) as GameObject;
            if (prefab == null)
            {
                Debug.LogError($"Prefab not found at path: {prefabPaths["agv"]}");
                return;
            }
            agvPool = new GameObjectPool<AGV>(prefab, _parent);
        }

        private async UniTask InitializeAFLPoolAsync()
        {
            if (aflPool != null) return;

            var prefab = await Resources.LoadAsync<GameObject>(prefabPaths["afl"]) as GameObject;
            if (prefab == null)
            {
                Debug.LogError($"Prefab not found at path: {prefabPaths["afl"]}");
                return;
            }
            aflPool = new GameObjectPool<AGV>(prefab, _parent);
        }

        private async UniTask InitializeForkLiftPoolAsync()
        {
            if (forkLiftPool != null) return;

            var prefab = await Resources.LoadAsync<GameObject>(prefabPaths["forkLift"]) as GameObject;
            if (prefab == null)
            {
                Debug.LogError($"Prefab not found at path: {prefabPaths["forkLift"]}");
                return;
            }
            forkLiftPool = new GameObjectPool<AGV>(prefab, _parent);
        }
    }
}