using System.Diagnostics.CodeAnalysis;


using Newtonsoft.Json;


using ServerCore;
using ServerBase;



namespace ServerCommon;

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

    Dictionary<string, string> m_map_paths = new();
    
    Dictionary<string, MapData> m_mapdatas = new();
    Dictionary<string, Anchor> m_anchors = new();

    public bool Load()
    {
        string mapDataPath = Path.GetFullPath("resource/map", Environment.CurrentDirectory);
        var all_map_paths = Directory.GetFiles(mapDataPath, "*.*", SearchOption.AllDirectories);

        foreach (var path in all_map_paths)
        {
            if (!m_map_paths.TryAdd(Path.GetFileName(path), path))
            {
                m_map_paths.TryGetValue(Path.GetFileName(path), out var duplicatePath);

                var duplicate_sub_path = duplicatePath?.Replace(mapDataPath, "");
                var sub_path = path.Replace(mapDataPath, "");

                Log.getLogger().error($"duplicate map name:{Path.GetFileName(path)} path_1:{duplicate_sub_path} path_2:{sub_path}");
            }
        }

        foreach (var data in MetaData.Instance._WorldMetaTable.Values)
        {
            if (string.IsNullOrEmpty(data.MapPath))
                continue;

            if (!LoadMapFile(data.MapPath))
                continue;

            if (m_mapdatas.TryGetValue(data.MapPath, out var mapData))
            {
                mapData.MapFileType = MapFileType.World;
                mapData.MapMetaId = data.Id;
            }
        }

        foreach (var data in MetaData.Instance._LandTable.Values)
        {
            if (string.IsNullOrEmpty(data.LandFile))
                continue;

            if (!LoadMapFile(data.LandFile))
                continue;

            if (m_mapdatas.TryGetValue(data.LandFile, out var mapData))
            {
                mapData.MapFileType = MapFileType.Land;
                mapData.MapMetaId = data.LandId;
            }
        }

        foreach (var data in MetaData.Instance._BuildingTable.Values)
        {
            if (string.IsNullOrEmpty(data.BuildingFile))
                continue;

            if (!LoadMapFile(data.BuildingFile))
                continue;

            if (m_mapdatas.TryGetValue(data.BuildingFile, out var mapData))
            {
                mapData.MapFileType = MapFileType.Building;
                mapData.MapMetaId = data.BuildingId;
            }
        }

        foreach (var data in MetaData.Instance._IndunTable.Values)
        {
            if (string.IsNullOrEmpty(data.RoomFile))
                continue;

            if (!LoadMapFile(data.RoomFile))
                continue;

            if (m_mapdatas.TryGetValue(data.RoomFile, out var mapData))
            {
                mapData.MapFileType = MapFileType.Instance;
                mapData.MapMetaId = data.Id;
            }
        }

        return true;
    }

    bool LoadMapFile(string fileName)
    {
        try
        {
            if (!m_map_paths.TryGetValue(fileName, out var filePath))
            {
                Log.getLogger().warn($"Not Found Map Path !!! : fileName:{fileName}");
                return false;
            }
            
            if (!File.Exists(filePath))
            {
                Log.getLogger().warn($"File is not Exist !!! : filePath:{filePath}");
                return false;
            }
            
            var json = File.ReadAllText(filePath);
            var list = JsonConvert.DeserializeObject<List<MapData>>(json);
            if (list == null)
            {
                Log.getLogger().error($"Failed to DeserializeObject() !!! : fileName:{fileName}");
                return false;
            }

            foreach (var one in list)
            {
                m_mapdatas.TryAdd(fileName, one);

                foreach (var anchor in one.Anchors)
                {
                    m_anchors.TryAdd(anchor.GUID, anchor);
                }
            }

            return true;
        }
        catch (Exception e)
        {
            Log.getLogger().fatal($"Failed to LoadMapFile() !!! : Exception:{e}");
            return false;
        }
    }

    public bool getMapData(string mapFileName, [MaybeNullWhen(false)] out MapData mapData)
    {
        return m_mapdatas.TryGetValue(mapFileName, out mapData);
    }

    public bool getAnchor(string anchorGuid, [MaybeNullWhen(false)] out Anchor anchor)
    {
        return m_anchors.TryGetValue(anchorGuid, out anchor);
    }

    public string GetRoomStartPosAnchorGuid(string mapFilename)
    {
        if (!m_mapdatas.TryGetValue(mapFilename, out var mapData))
        {
            return string.Empty;
        }

        foreach (var anchor in mapData.Anchors)
        {
            if (anchor.Type == "AT_StartPos")
                return anchor.GUID;
        }

        return string.Empty;
    }
    
}