using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Transform;
using GameServer;
using Newtonsoft.Json;
using NLog.LayoutRenderers;
using Org.BouncyCastle.Asn1.Ocsp;
using ServerCommon;
using ServerCore; using ServerBase;
using System;
using System.Collections.Concurrent;
using System.Diagnostics.CodeAnalysis;
using static ClientToGameReq.Types;

namespace GameServer
{
    public class WorldMapTree
    {
        public int WorldMetaId { get; }
        public string WorldMapFileName { get; }

        public Dictionary<int, LandMapTree> ChildLandMapTrees = new();
        public Dictionary<string, AnchorTree> Anchors = new();

        public WorldMapTree(int worldMetaId, string worldMapFileName)
        {
            WorldMetaId = worldMetaId;
            WorldMapFileName = worldMapFileName;
        }
    }

    public class LandMapTree
    {
        public int LandId { get; }
        public string LandMapFileName { get; }
        public WorldMapTree ParentWorldMapTree { get; }

        public BuildingMapTree? ChildBuildingMapTree;
        public Dictionary<string, AnchorTree> Anchors = new();

        public LandMapTree(int landMetaId, string landMapFileName, WorldMapTree parentWorldMapTree)
        {
            LandId = landMetaId;
            LandMapFileName = landMapFileName;
            ParentWorldMapTree = parentWorldMapTree;
        }
    }

    public class BuildingMapTree
    {
        public int BuildingMetaId { get; }
        public string BuildingMapFileName { get; }
        public LandMapTree ParentLandMapTree { get; }

        public Dictionary<int, RoomMapTree> ChildRoomMapTrees = new();
        public Dictionary<string, AnchorTree> Anchors = new();
        
        public BuildingMapTree(int buildingMetaId, string buildingMapFileName, LandMapTree parentLandMapTree)
        {
            BuildingMetaId = buildingMetaId;
            BuildingMapFileName = buildingMapFileName;
            ParentLandMapTree = parentLandMapTree;
        }
    }
    
    public class RoomMapTree
    {
        public int InstanceMetaId { get; }
        public string RoomMapFileName { get; }
        public BuildingMapTree ParentBuildingMapTree { get; }
        public string OwnerGuid { get; set; } = string.Empty;
        public string MyhomeGuid { get; set; } = string.Empty;
        public string InstanceName { get; set; } = string.Empty;
        public int ThumbnailImageId { get; set; }
        public int ListImageId { get; set; }
        public int EnterPlayerCount { get; set; }

        public Dictionary<string, AnchorTree> Anchors = new();
        public List<string> UgcNpcs = new();

        public RoomMapTree(int instanceMetaId, string roomMapFileName, BuildingMapTree parentBuildingMapTree)
        {
            InstanceMetaId = instanceMetaId;
            RoomMapFileName = roomMapFileName;
            ParentBuildingMapTree = parentBuildingMapTree;
        }
    }

    public class PersonalRoom
    {
        public Dictionary<string, AnchorTree> Anchors = new();
    }

    public class AnchorTree
    {
        public string ParentMapFileName;
        public string AnchorGuid;
        public Pos AnchorPos;
        public AnchorProp AnchorProp = new();

        public AnchorTree(string parentMapFileName, string anchorGuid, Pos anchorPos)
        {
            ParentMapFileName = parentMapFileName;
            AnchorGuid = anchorGuid;
            AnchorPos = anchorPos;
        }
    }

    public partial class MapManager
    {
        private static readonly MapManager _instance = new();
        static MapManager() { }
        private MapManager() { }
        public static MapManager Instance { get { return _instance; } }

        ConcurrentDictionary<string, WorldMapTree> WorldMapTrees = new();
        ConcurrentDictionary<string, LandMapTree> LandMapTrees = new();
        ConcurrentDictionary<string, BuildingMapTree> BuildingMapTrees = new();
        ConcurrentDictionary<string, RoomMapTree> RoomMapTrees = new();
        ConcurrentDictionary<string, AnchorTree> AnchorTrees = new();

        ConcurrentDictionary<string, PersonalRoom> PersonalRooms = new();
        ConcurrentDictionary<string, MyhomeUgcInfo> m_myhome_ugc_infos = new();

        List<Pos> BotStartPos = new();

        public void Load()
        {
            foreach (var world_meta_data in MetaData.Instance._WorldMetaTable.Values)
            {
                var world_map_file_name = world_meta_data.MapPath;
                if (!MapDataTable.Instance.getMapData(world_map_file_name, out var world_map_data))
                {
                    Log.getLogger().error($"Not Exist MapData !!! : fileName:{world_map_file_name}");
                    continue;
                }

                var world_map_tree = new WorldMapTree(world_meta_data.Id, world_map_file_name);
                if (!WorldMapTrees.TryAdd(world_map_file_name, world_map_tree))
                {
                    WorldMapTrees.TryGetValue(world_map_file_name, out var duplicate_map_tree);
                    Log.getLogger().error($"Exist WorldMapFile:{world_map_file_name} - WorldMetaId:{world_meta_data.Id}, WorldMetaId:{duplicate_map_tree?.WorldMetaId}");
                    continue;
                }

                foreach (var anchor in world_map_data.Anchors)
                {
                    var new_anchor_pos = anchor.Position.toPos();
                    new_anchor_pos.Angle = (int)(anchor.Rotation.Yaw);

                    var anchor_tree = new AnchorTree(world_map_file_name, anchor.GUID, new_anchor_pos);

                    anchor_tree.AnchorProp.TableId = anchor.TableID;
                    if (anchor.MannequinItems.Count > 0)
                        anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();
                    
                    world_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
                    AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
                }

                // Land
                foreach (var land_name in world_map_data.LandNames)
                {
                    var land_map_file_name = $"{land_name}.land";
                    if (!MapDataTable.Instance.getMapData(land_map_file_name, out var land_map_data))
                    {
                        Log.getLogger().error($"Not Exist MapData !!! : fileName:{land_map_file_name} or CHECK LandData.xlsx");
                        continue;
                    }

                    if (land_map_data.MapFileType != MapFileType.Land)
                        continue;

                    var land_meta_id = land_map_data.MapMetaId;

                    var land_map_tree = new LandMapTree(land_meta_id, land_map_file_name, world_map_tree);
                    if (!LandMapTrees.TryAdd(land_map_file_name, land_map_tree))
                    {
                        LandMapTrees.TryGetValue(land_map_file_name, out var duplicate_map_tree);
                        Log.getLogger().error($"Exist LandMapFile:{land_map_file_name} - fileName:{world_map_file_name}, fileName:{duplicate_map_tree?.ParentWorldMapTree.WorldMapFileName}");
                        continue;
                    }

                    world_map_tree.ChildLandMapTrees.Add(land_meta_id, land_map_tree);

                    foreach (var anchor in land_map_data.Anchors)
                    {
                        var new_anchor_position = TransformHelper.rotate(anchor.Position, land_map_data.Rotation);

                        new_anchor_position.X += land_map_data.Position.X;
                        new_anchor_position.Y += land_map_data.Position.Y;
                        new_anchor_position.Z += land_map_data.Position.Z;

                        var new_anchor_pos = new_anchor_position.toPos();
                        new_anchor_pos.Angle = (int)(land_map_data.Rotation.Yaw + anchor.Rotation.Yaw);

                        var anchor_tree = new AnchorTree(land_map_file_name, anchor.GUID, new_anchor_pos);
                        
                        anchor_tree.AnchorProp.TableId = anchor.TableID;
                        if (anchor.MannequinItems.Count > 0)
                            anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();

                        land_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
                        AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
                    }

                    // Building
                    foreach (var building_data in land_map_data.BuildingDatas)
                    {
                        var building_map_file_name = Path.GetFileName(building_data.BuildingName);
                        if (!MapDataTable.Instance.getMapData(building_map_file_name, out var building_map_data))
                        {
                            Log.getLogger().error($"Not Exist MapData !!! : fileName:{building_map_file_name} or CHECK BuildingData.xlsx");
                            continue;
                        }

                        if (building_map_data.MapFileType != MapFileType.Building)
                            continue;

                        var building_meta_id = building_map_data.MapMetaId;

                        var building_map_tree = new BuildingMapTree(building_meta_id, building_map_file_name, land_map_tree);
                        if (!BuildingMapTrees.TryAdd(building_map_file_name, building_map_tree))
                        {
                            BuildingMapTrees.TryGetValue(building_map_file_name, out var duplicate_map_tree);
                            Log.getLogger().error($"Exist BuildingMapFile:{building_map_file_name} - filename:{land_map_file_name}, fileName:{duplicate_map_tree?.ParentLandMapTree.LandMapFileName}");
                            continue;
                        }

                        land_map_tree.ChildBuildingMapTree = building_map_tree;

                        foreach (var anchor in building_map_data.Anchors)
                        {
                            var new_anchor_position = TransformHelper.rotate(anchor.Position, building_map_data.Rotation);

                            new_anchor_position.X += building_data.Position.X;
                            new_anchor_position.Y += building_data.Position.Y;
                            new_anchor_position.Z += building_data.Position.Z;

                            new_anchor_position = TransformHelper.rotate(new_anchor_position, land_map_data.Rotation);

                            new_anchor_position.X += land_map_data.Position.X;
                            new_anchor_position.Y += land_map_data.Position.Y;
                            new_anchor_position.Z += land_map_data.Position.Z;

                            var new_anchor_pos = new_anchor_position.toPos();
                            new_anchor_pos.Angle = (int)(building_map_data.Rotation.Yaw + land_map_data.Rotation.Yaw + anchor.Rotation.Yaw);

                            var anchor_tree = new AnchorTree(building_map_file_name, anchor.GUID, new_anchor_pos);
                            
                            anchor_tree.AnchorProp.TableId = anchor.TableID;
                            if (anchor.MannequinItems.Count > 0)
                                anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();

                            building_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
                            AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
                        }

                        foreach (var room_data in building_map_data.RoomDatas)
                        {
                            var room_map_file_name = Path.GetFileName(room_data.RoomName);
                            if (!MapDataTable.Instance.getMapData(room_map_file_name, out var room_map_data))
                            {
                                Log.getLogger().error($"Not Exist MapData !!! : fileName:{room_map_file_name} or CHECK InstanceData.xlsx");
                                continue;
                            }

                            if (room_map_data.MapFileType != MapFileType.Instance)
                                continue;

                            var instance_meta_id = room_map_data.MapMetaId;
                            if (!MetaData.Instance._IndunTable.TryGetValue(instance_meta_id, out var indun_meta_data))
                            {
                                Log.getLogger().error($"Failed to MetaData.TryGetValue() !!! : instanceMetaId:{instance_meta_id}");
                                continue;
                            }

                            var room_map_tree = new RoomMapTree(instance_meta_id, room_map_file_name, building_map_tree);
                            if (!RoomMapTrees.TryAdd(room_map_file_name, room_map_tree))
                            {
                                RoomMapTrees.TryGetValue(room_map_file_name, out var duplicate_map_tree);
                                Log.getLogger().error($"Exist RoomMapFile:{room_map_file_name} - fileName:{building_map_file_name}, fileName:{duplicate_map_tree?.ParentBuildingMapTree.BuildingMapFileName}");
                                continue;
                            }

                            if (!building_map_tree.ChildRoomMapTrees.TryAdd(indun_meta_data.Building_Socket_, room_map_tree))
                            {
                                building_map_tree.ChildRoomMapTrees.TryGetValue(indun_meta_data.Building_Socket_, out var duplicate_room_map_tree);
                                Log.getLogger().error($"Exist Floor !!! buildingMetaId:{building_meta_id}, floor:{indun_meta_data.Building_Socket_} - fileName:{room_map_tree.RoomMapFileName}, fileName:{duplicate_room_map_tree?.RoomMapFileName}");
                                continue;
                            }

                            foreach (var anchor in room_map_data.Anchors)
                            {
                                var new_anchor_position = TransformHelper.rotate(anchor.Position, room_map_data.Rotation);

                                new_anchor_position.X += room_data.Position.X;
                                new_anchor_position.Y += room_data.Position.Y;
                                new_anchor_position.Z += room_data.Position.Z;

                                new_anchor_position = TransformHelper.rotate(new_anchor_position, building_map_data.Rotation);

                                new_anchor_position.X += building_data.Position.X;
                                new_anchor_position.Y += building_data.Position.Y;
                                new_anchor_position.Z += building_data.Position.Z;

                                new_anchor_position = TransformHelper.rotate(new_anchor_position, land_map_data.Rotation);

                                new_anchor_position.X += land_map_data.Position.X;
                                new_anchor_position.Y += land_map_data.Position.Y;
                                new_anchor_position.Z += land_map_data.Position.Z;

                                var new_anchor_pos = new_anchor_position.toPos();
                                new_anchor_pos.Angle = (int)(room_map_data.Rotation.Yaw + building_map_data.Rotation.Yaw + land_map_data.Rotation.Yaw + anchor.Rotation.Yaw);

                                var anchor_tree = new AnchorTree(room_map_file_name, anchor.GUID, new_anchor_pos);
                                
                                anchor_tree.AnchorProp.TableId = anchor.TableID;
                                if (anchor.MannequinItems.Count > 0)
                                    anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();

                                room_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
                                AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
                            }
                        }
                    }
                }
            }

            LoadPersonal(ServerCommon.Constant.DRESS_ROOM_INSTANCE_META_ID);
            LoadPersonal(ServerCommon.Constant.EDIT_ROOM_INSTANCE_META_ID);

            loadMyhomeUgcInfo();
        }

        void LoadPersonal(int instanceId)
        {
            if (!MetaData.Instance._IndunTable.TryGetValue(instanceId, out var instanceData))
            {
                Log.getLogger().error($"Not Found InstanceData:{instanceId}");
                return;
            }

            if (!MapDataTable.Instance.getMapData(instanceData.RoomFile, out var personalMapData))
            {
                Log.getLogger().error($"Not Exist MapData {instanceData.RoomFile}");
                return;
            }

            var warp_pos = MapHelper.getWarpPos(instanceData.ContentsType);

            personalMapData.Position.X = warp_pos.X;
            personalMapData.Position.Y = warp_pos.Y;
            personalMapData.Position.Z = warp_pos.Z;

            var personalRoom = new PersonalRoom();

            foreach (var anchor in personalMapData.Anchors)
            {
                var newAnchorPosition = TransformHelper.rotate(anchor.Position, personalMapData.Rotation);
                newAnchorPosition.X += personalMapData.Position.X;
                newAnchorPosition.Y += personalMapData.Position.Y;
                newAnchorPosition.Z += personalMapData.Position.Z;

                var new_anchor_pos = newAnchorPosition.toPos();
                new_anchor_pos.Angle = (int)(personalMapData.Rotation.Yaw + anchor.Rotation.Yaw);

                var anchorTree = new AnchorTree(instanceData.RoomFile, anchor.GUID, new_anchor_pos);
                anchorTree.AnchorProp.TableId = anchor.TableID;
                if (anchor.MannequinItems.Count > 0)
                    anchorTree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();

                personalRoom.Anchors.TryAdd(anchor.GUID, anchorTree);
                AnchorTrees.TryAdd(anchor.GUID, anchorTree);
            }

            PersonalRooms.TryAdd(instanceData.RoomFile, personalRoom);
        }

        bool loadMyhomeUgcInfo()
        {
            // 기본 마이홈
            var default_myhome_ugc_info_file_name = MetaHelper.GameConfigMeta.MyHomeDefaultSaveFileName;
            if (!loadMyhomeFile(default_myhome_ugc_info_file_name))
                return false;

            // TestUser
            foreach (var meta_data in MetaData.Instance.m_test_user_initial_meta_datas.Values)
            {
                if (meta_data.MyhomeFile == string.Empty)
                    continue;

                if (!loadMyhomeUgcInfoFile(meta_data.MyhomeFile))
                    return false;
            }

            return true;
        }

        bool loadMyhomeFile(string myhomeFileName)
        {
            var map_data_folder_path = Path.GetFullPath("resource/map/DefaultMap", Environment.CurrentDirectory);
            var myhome_file_path = Path.Combine(map_data_folder_path, myhomeFileName);

            if (!File.Exists(myhome_file_path))
            {
                Log.getLogger().warn($"{myhome_file_path} not exist !!!");
                return false;
            }

            var myhome_file_data = File.ReadAllText(myhome_file_path);
            var myhome_map_data = JsonConvert.DeserializeObject<MyhomeMapData>(myhome_file_data);
            if (myhome_map_data == null)
            {
                Log.getLogger().warn($"{myhome_file_path} convert fail !!!");
                return false;
            }

            var myhome_ugc_info = new MyhomeUgcInfo();

            myhome_ugc_info.RoomType = myhome_map_data.roomtype;

            foreach (var framework in myhome_map_data.Frameworks)
            {
                var ugcFrameworkInfo = new UgcFrameworkInfo();

                ugcFrameworkInfo.InteriorItemId = framework.tableid;
                ugcFrameworkInfo.Floor = framework.Floor;
                ugcFrameworkInfo.Coordinate = new();
                ugcFrameworkInfo.Coordinate.X = (float)framework.Position.X;
                ugcFrameworkInfo.Coordinate.Y = (float)framework.Position.Y;
                ugcFrameworkInfo.Coordinate.Z = (float)framework.Position.Z;
                ugcFrameworkInfo.Rotation = new();
                ugcFrameworkInfo.Rotation.Pitch = (float)framework.Rotation.Pitch;
                ugcFrameworkInfo.Rotation.Yaw = (float)framework.Rotation.Yaw;
                ugcFrameworkInfo.Rotation.Roll = (float)framework.Rotation.Roll;

                myhome_ugc_info.FrameworkInfos.Add(ugcFrameworkInfo);
            }

            foreach (var anchor in myhome_map_data.Anchors)
            {
                var ugcAnchorInfo = new UgcAnchorInfo();

                ugcAnchorInfo.AnchorGuid = anchor.GUID;
                ugcAnchorInfo.AnchorType = anchor.Type;
                ugcAnchorInfo.TableId = anchor.TableID;
                ugcAnchorInfo.EntityGuid = anchor.EntityGuid;
                ugcAnchorInfo.Coordinate = new();
                ugcAnchorInfo.Coordinate.X = (float)anchor.Position.X;
                ugcAnchorInfo.Coordinate.Y = (float)anchor.Position.Y;
                ugcAnchorInfo.Coordinate.Z = (float)anchor.Position.Z;
                ugcAnchorInfo.Rotation = new();
                ugcAnchorInfo.Rotation.Pitch = (float)anchor.Rotation.Pitch;
                ugcAnchorInfo.Rotation.Yaw = (float)anchor.Rotation.Yaw;
                ugcAnchorInfo.Rotation.Roll = (float)anchor.Rotation.Roll;

                myhome_ugc_info.AnchorInfos.Add(ugcAnchorInfo);
            }

            if (!m_myhome_ugc_infos.TryAdd(myhomeFileName, myhome_ugc_info))
            {
                Log.getLogger().warn($"{myhomeFileName} add fail !!!");
                return false;
            }

            return true;
        }

        bool loadMyhomeUgcInfoFile(string myhomeUgcInfoFileName)
        {
            var map_data_folder_path = Path.GetFullPath("resource/map/DefaultMap", Environment.CurrentDirectory);
            var myhome_ugc_info_file_path = Path.Combine(map_data_folder_path, myhomeUgcInfoFileName);

            if (!File.Exists(myhome_ugc_info_file_path))
            {
                Log.getLogger().warn($"{myhome_ugc_info_file_path} not exist !!!");
                return false;
            }

            var myhome_ugc_info_file_data = File.ReadAllText(myhome_ugc_info_file_path);
            var myhome_ugc_info = JsonConvert.DeserializeObject<MyhomeUgcInfo>(myhome_ugc_info_file_data);
            if (myhome_ugc_info == null)
            {
                Log.getLogger().warn($"{myhome_ugc_info_file_path} convert fail !!!");
                return false;
            }

            if (!m_myhome_ugc_infos.TryAdd(myhomeUgcInfoFileName, myhome_ugc_info))
            {
                Log.getLogger().warn($"{myhomeUgcInfoFileName} add fail !!!");
                return false;
            }

            return true;
        }

        public bool UpdateProp(string anchorGuid, AnchorProp prop)
        {
            if (!AnchorTrees.TryGetValue(anchorGuid, out var anchorTree))
                return false;

            anchorTree.AnchorProp.TableId = prop.TableId;
            anchorTree.AnchorProp.GuidByType = prop.GuidByType;
            anchorTree.AnchorProp.Mannequins = prop.Mannequins;

            return true;
        }

        public void GetMapAnchorList(string mapFileName, out List<AnchorTree> anchorList)
        {
            anchorList = new List<AnchorTree>();

            switch (Path.GetExtension(mapFileName))
            {
                case ".zone":
                    {
                        if (!WorldMapTrees.TryGetValue(mapFileName, out var worldMapTree))
                            return;

                        anchorList = worldMapTree.Anchors.Values.ToList();
                    }
                    break;
                case ".land":
                    {
                        if (!LandMapTrees.TryGetValue(mapFileName, out var landMapTree))
                            return;

                        anchorList = landMapTree.Anchors.Values.ToList();
                    }
                    break;
                case ".build":
                    {
                        if (!BuildingMapTrees.TryGetValue(mapFileName, out var buildMapTree))
                            return;

                        anchorList = buildMapTree.Anchors.Values.ToList();
                    }
                    break;
                case ".room":
                    {
                        if (!RoomMapTrees.TryGetValue(mapFileName, out var roomMapTree))
                            return;

                        anchorList = roomMapTree.Anchors.Values.ToList();
                    }
                    break;
                default:
                    {
                        Log.getLogger().error($"{mapFileName} is not map file");
                    }
                    return;
            }
        }

        public void GetMapAnchorListForMapCreate(string mapFileName, out List<AnchorTree> anchorList)
        {
            anchorList = new List<AnchorTree>();

            switch (Path.GetExtension(mapFileName))
            {
                case ".zone":
                    {
                        if (!WorldMapTrees.TryGetValue(mapFileName, out var world))
                            return;

                        anchorList.AddRange(world.Anchors.Values);

                        foreach (var land in world.ChildLandMapTrees.Values)
                        {
                            anchorList.AddRange(land.Anchors.Values);

                            var building = land.ChildBuildingMapTree;
                            if (building == null)
                                continue;

                            anchorList.AddRange(building.Anchors.Values);
                        }
                    }
                    break;
                case ".room":
                    {
                        if (PersonalRooms.TryGetValue(mapFileName, out var personalRoom))
                        {
                            anchorList.AddRange(personalRoom.Anchors.Values);
                            return;
                        }

                        if (!RoomMapTrees.TryGetValue(mapFileName, out var room))
                            return;

                        anchorList.AddRange(room.Anchors.Values);
                    }
                    break;
                default:
                    {
                        Log.getLogger().error($"{mapFileName} is not map create file");
                    }
                    return;
            }
        }

        public Pos GetStartPos(string mapFileName)
        {
            Pos startPos = new();

            var startPosAnchorGuid = MapDataTable.Instance.GetRoomStartPosAnchorGuid(mapFileName);
            
            if (!AnchorTrees.TryGetValue(startPosAnchorGuid, out var startPosAnchor))
            {
                return startPos;
            }

            startPos.X = startPosAnchor.AnchorPos.X;
            startPos.Y = startPosAnchor.AnchorPos.Y;
            startPos.Z = startPosAnchor.AnchorPos.Z + 100;

            return startPos;
        }

        public bool GetWorldMapTree(string mapFileName, [MaybeNullWhen(false)] out WorldMapTree worldMapTree)
        {
            return WorldMapTrees.TryGetValue(mapFileName, out worldMapTree);
        }

        public bool GetLandMapTree(int landMetaId, [MaybeNullWhen(false)] out LandMapTree landMapTree)
        {
            landMapTree = null;

            if (!MetaData.Instance._LandTable.TryGetValue(landMetaId, out var landData))
            {
                var err_msg = $"Failed to MetaData.TryGetValue() !!! : LandMetaId:{landMetaId}";
                Log.getLogger().error(err_msg);

                return false;
            }

            return LandMapTrees.TryGetValue(landData.LandFile, out landMapTree);
        }

        public bool GetBuildingMapTree(int buildingMetaId, [MaybeNullWhen(false)] out BuildingMapTree buildingMapTree)
        {
            buildingMapTree = null;

            if (!MetaData.Instance._BuildingTable.TryGetValue(buildingMetaId, out var buildingData))
            {
                var err_msg = $"Failed to MetaData.TryGetValue() !!! : BuildingMetaId:{buildingMetaId}";
                Log.getLogger().error(err_msg);

                return false;
            }

            return BuildingMapTrees.TryGetValue(buildingData.BuildingFile, out buildingMapTree);
        }

        public bool getRoomMapTree(string myhomeGuid, [MaybeNullWhen(false)] out RoomMapTree roomMapTree)
        {
            if (!RoomMapTrees.TryGetValue(myhomeGuid, out roomMapTree))
                return false;

            return true;
        }

        public List<int> getLandMetaIds()
        {
            var land_meta_ids = new List<int>();

            foreach (var land_map_tree in LandMapTrees.Values)
            {
                land_meta_ids.Add(land_map_tree.LandId);
            }

            return land_meta_ids;
        }

        public List<int> getBuildingMetaIds()
        {
            var building_meta_ids = new List<int>();

            foreach (var building_map_tree in BuildingMapTrees.Values)
            {
                building_meta_ids.Add(building_map_tree.BuildingMetaId);
            }

            return building_meta_ids;
        }

        public bool tryGetLandChildBuildingMetaId(int landMetaId, out int childBuildingMetaId)
        {
            childBuildingMetaId = 0;

            if (!GetLandMapTree(landMetaId, out var land_map_tree))
                return false;

            if (land_map_tree.ChildBuildingMapTree == null)
                return false;

            childBuildingMetaId = land_map_tree.ChildBuildingMapTree.BuildingMetaId;

            return true;
        }

        public void ExchangeMannequinDisplayItem(string anchorGuid, List<int> displayItemIds)
        {
            if (!AnchorTrees.TryGetValue(anchorGuid, out var anchorTree))
                return;

            anchorTree.AnchorProp.Mannequins = displayItemIds;
            anchorTree.AnchorProp.IsMannequinsChanged = true;
        }

        public bool getParentMapFileName(string anchorGuid, [MaybeNullWhen(false)] out string parentMapFileName)
        {
            parentMapFileName = null;

            if (!AnchorTrees.TryGetValue(anchorGuid, out var anchorTree))
                return false;

            parentMapFileName = anchorTree.ParentMapFileName;
            return true;
        }

        public bool getDefaultMyhomeUgcInfo(string myhomeUgcInfoFileName, [MaybeNullWhen(false)] out MyhomeUgcInfo myhomeUgcInfo)
        {
            return m_myhome_ugc_infos.TryGetValue(myhomeUgcInfoFileName, out myhomeUgcInfo);
        }

        public void addRoomMaptree(BuildingMapTree buildingMapTree, int floor, RoomMapTree roomMapTree)
        {
            buildingMapTree.ChildRoomMapTrees[floor] = roomMapTree;
            RoomMapTrees[roomMapTree.RoomMapFileName] = roomMapTree;
        }

        public async Task<Result> tryAddRoomMapTreeFromDb(BuildingFloorDoc buildingFloorDoc)
        {
            var result = new Result();
            var err_msg = string.Empty;

            var building_floor_attrib = buildingFloorDoc.getAttrib<BuildingFloorAttrib>();
            NullReferenceCheckHelper.throwIfNull(building_floor_attrib, () => $"building_floor_attrib is null !!!");

            (result, var myhome_attrib) = await MyhomeHelper.getEnterMyhomeAttribFromDynamoDb(building_floor_attrib.OwnerGuid, building_floor_attrib.MyhomeGuid);
            if (result.isFail() || null == myhome_attrib)
            {
                err_msg = $"Failed to getSelectedMyhomeUgcInfoFromDynamoDb() !!! : {result.toBasicString()}";
                Log.getLogger().error(err_msg);

                return result;
            }

            (result, var myhome_ugc_info) = await MyhomeHelper.getMyhomeUgcInfo(myhome_attrib);
            if (result.isFail() || null == myhome_ugc_info)
            {
                err_msg = $"Failed to getMyhomeUgcInfo() !!! : {result.toBasicString()}";
                Log.getLogger().error(err_msg);

                return result;
            }

            result = MyhomeHelper.getMyhomeInstanceId(myhome_ugc_info.RoomType, out var instance_meta_id);
            if (result.isFail())
            {
                err_msg = $"Fail to getMyhomeInstanceId() !!! : {result.toBasicString()}";
                Log.getLogger().error(err_msg);

                return result;
            }

            if (!MetaData.Instance._IndunTable.TryGetValue(instance_meta_id, out var indun_meta_data))
            {
                err_msg = $"Failed to MetaData.TryGetValue() !!! : instanceMetaId:{instance_meta_id}";
                result.setFail(ServerErrorCode.InstanceMetaDataNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            if (!GetBuildingMapTree(building_floor_attrib.BuildingMetaId, out var building_map_tree))
            {
                err_msg = $"Failed to GetBuildingMapTree() !!! : BuildingMetaId:{building_floor_attrib.BuildingMetaId}";
                result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            var server_logic = GameServerApp.getServerLogic();
            var db_client = server_logic.getDynamoDbClient();
            NullReferenceCheckHelper.throwIfNull(db_client, () => $"db_client is null !!!");

            var location_unique_id = server_logic.getMap().makeLOCATION_UNIQUE_IDByMetaIdWithLocationTargetType(LocationTargetType.Instance, building_floor_attrib.MyhomeGuid);

            var npc_location_in_target_doc = new NpcLocationInTargetDoc(location_unique_id, building_floor_attrib.MyhomeGuid);
            var query_config = db_client.makeQueryConfigForReadByPKOnly(npc_location_in_target_doc.getPK());
            
            (result, var read_docs) = await db_client.simpleQueryDocTypesWithQueryOperationConfig<NpcLocationInTargetDoc>(query_config);
            if (result.isFail())
            {
                err_msg = $"Failed to simpleQueryDocTypesWithQueryOperationConfig() !!! : {result.toBasicString()}";
                Log.getLogger().error(err_msg);

                return result;
            }
            NullReferenceCheckHelper.throwIfNull(read_docs, () => $"read_docs is null !!!");

            var ugc_npc_guids = new List<string>();

            foreach (var read_doc in read_docs)
            {
                var npc_location_in_target_attrib = read_doc.getAttrib<NpcLocationInTargetAttrib>();
                NullReferenceCheckHelper.throwIfNull(npc_location_in_target_attrib, () => $"npc_location_in_target_attrib is null !!!");

                ugc_npc_guids.Add(npc_location_in_target_attrib.NpcUniqueId);
            }

            var room_map_tree = new RoomMapTree(instance_meta_id, building_floor_attrib.MyhomeGuid, building_map_tree);

            room_map_tree.OwnerGuid = building_floor_attrib.OwnerGuid;
            room_map_tree.MyhomeGuid = building_floor_attrib.MyhomeGuid;
            room_map_tree.InstanceName = building_floor_attrib.InstanceName;
            room_map_tree.ThumbnailImageId = building_floor_attrib.ThumbnailImageId;
            room_map_tree.ListImageId = building_floor_attrib.ListImageId;
            room_map_tree.EnterPlayerCount = building_floor_attrib.EnterPlayerCount;
            room_map_tree.UgcNpcs = ugc_npc_guids;

            building_map_tree.ChildRoomMapTrees[building_floor_attrib.Floor] = room_map_tree;

            RoomMapTrees[room_map_tree.RoomMapFileName] = room_map_tree;

            return result;
        }

        public bool tryRemoveRoomMapTree(int building_meta_id, int floor, [MaybeNullWhen(false)] out RoomMapTree removedRoomMapTree)
        {
            removedRoomMapTree = default;

            if (!GetBuildingMapTree(building_meta_id, out var building_map_tree))
                return false;

            if (!building_map_tree.ChildRoomMapTrees.Remove(floor, out var room_map_tree))
                return false;

            return RoomMapTrees.TryRemove(room_map_tree.RoomMapFileName, out removedRoomMapTree);
        }

        public Result modifyFloorLinkedInfo(ModifyFloorLinkedInfo modifyFloorLinkedInfo)
        {
            var result = new Result();
            var err_msg = string.Empty;

            if (!GetBuildingMapTree(modifyFloorLinkedInfo.BuildingId, out var building_map_tree))
            {
                err_msg = $"Failed to GetBuildingMapTree() !!! : BuildingMetaId:{modifyFloorLinkedInfo.BuildingId}";
                result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            if (!building_map_tree.ChildRoomMapTrees.TryGetValue(modifyFloorLinkedInfo.Floor, out var room_map_tree))
            {
                err_msg = $"Failed to ChildRoomMapTrees.TryGetValue() !!! : floor:{modifyFloorLinkedInfo.Floor}";
                result.setFail(ServerErrorCode.BuildingMapTreeChildRoomNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            switch (modifyFloorLinkedInfo.ModifyType)
            {
                case ModifyType.Add:
                    {
                        room_map_tree.UgcNpcs.AddRange(modifyFloorLinkedInfo.FloorLinkedInfo.UgcNpcGuids);
                    }
                    break;
                case ModifyType.Delete:
                    {
                        foreach (var ugc_npc_guid in modifyFloorLinkedInfo.FloorLinkedInfo.UgcNpcGuids)
                        {
                            room_map_tree.UgcNpcs.Remove(ugc_npc_guid);
                        }
                    }
                    break;
            }

            return result;
        }

        public Result tryGetUsingFloorCountByLandMetaId(int landMetaId, out int usingFloorCount)
        {
            var result = new Result();
            var err_msg = string.Empty;

            usingFloorCount = 0;

            if (!GetLandMapTree(landMetaId, out var land_map_tree))
            {
                err_msg = $"Failed to GetLandMapTree() !!! : LandMetaId:{landMetaId}";
                result.setFail(ServerErrorCode.LandMapTreeDataNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            var building_map_tree = land_map_tree.ChildBuildingMapTree;
            if (building_map_tree == null)
            {
                err_msg = $"Not Exist LandMapTree ChildBuilding !!! : LandMap:{land_map_tree.LandMapFileName}";
                result.setFail(ServerErrorCode.LandMapTreeChildBuildingNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            return tryGetUsingFloorCountByBuildingMetaId(building_map_tree.BuildingMetaId, out usingFloorCount);
        }

        public Result tryGetUsingFloorCountByBuildingMetaId(int buildingMetaId, out int usingFloorCount)
        {
            var result = new Result();
            var err_msg = string.Empty;

            usingFloorCount = 0;

            if (!GetBuildingMapTree(buildingMetaId, out var building_map_tree))
            {
                err_msg = $"Failed to GetBuildingMapTree() !!! : BuildingMetaId:{buildingMetaId}";
                result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
                Log.getLogger().error(result.toBasicString());

                return result;
            }

            usingFloorCount = building_map_tree.ChildRoomMapTrees.Count;

            return result;
        }
    }
}