using Robust.Shared.Serialization.Manager;
using Robust.Shared.Serialization.Markdown;
using Robust.Shared.Serialization.Markdown.Mapping;
using Robust.Shared.Serialization.Markdown.Validation;
using Robust.Shared.Serialization.TypeSerializers.Interfaces;

namespace Content.Server.Atmos.Serialization;

public sealed class TileAtmosCollectionSerializer : ITypeSerializer<Dictionary<Vector2i, TileAtmosphere>, MappingDataNode>
{
    public ValidationNode Validate(ISerializationManager serializationManager, MappingDataNode node,
        IDependencyCollection dependencies, ISerializationContext? context = null)
    {
        return serializationManager.ValidateNode<TileAtmosData>(node, context);
    }

    public Dictionary<Vector2i, TileAtmosphere> Read(ISerializationManager serializationManager, MappingDataNode node, IDependencyCollection dependencies,
        bool skipHook, ISerializationContext? context = null, Dictionary<Vector2i, TileAtmosphere>? value = default)
    {
        var data = serializationManager.Read<TileAtmosData>(node, context, skipHook);
        var tiles = new Dictionary<Vector2i, TileAtmosphere>();
        if (data.TilesUniqueMixes != null)
        {
            foreach (var (indices, mix) in data.TilesUniqueMixes)
            {
                try
                {
                    tiles.Add(indices, new TileAtmosphere(EntityUid.Invalid, indices,
                        data.UniqueMixes![mix].Clone()));
                }
                catch (ArgumentOutOfRangeException)
                {
                    Logger.Error(
                        $"Error during atmos serialization! Tile at {indices} points to an unique mix ({mix}) out of range!");
                }
            }
        }

        return tiles;
    }

    public DataNode Write(ISerializationManager serializationManager, Dictionary<Vector2i, TileAtmosphere> value, IDependencyCollection dependencies,
        bool alwaysWrite = false, ISerializationContext? context = null)
    {
        var uniqueMixes = new List<GasMixture>();
        var uniqueMixHash = new Dictionary<GasMixture, int>();
        var tiles = new Dictionary<Vector2i, int>();

        foreach (var (indices, tile) in value)
        {
            if (tile.Air == null) continue;

            if (uniqueMixHash.TryGetValue(tile.Air, out var index))
            {
                tiles[indices] = index;
                continue;
            }

            uniqueMixes.Add(tile.Air);
            var newIndex = uniqueMixes.Count - 1;
            uniqueMixHash[tile.Air] = newIndex;
            tiles[indices] = newIndex;
        }

        if (uniqueMixes.Count == 0) uniqueMixes = null;
        if (tiles.Count == 0) tiles = null;

        return serializationManager.WriteValue(new TileAtmosData
        {
            UniqueMixes = uniqueMixes,
            TilesUniqueMixes = tiles
        }, alwaysWrite, context);
    }

    public Dictionary<Vector2i, TileAtmosphere> Copy(ISerializationManager serializationManager, Dictionary<Vector2i, TileAtmosphere> source, Dictionary<Vector2i, TileAtmosphere> target, bool skipHook,
        ISerializationContext? context = null)
    {
        serializationManager.Copy(source, ref target, context, skipHook);
        return target;
    }

    [DataDefinition]
    private struct TileAtmosData
    {
        [DataField("uniqueMixes")] public List<GasMixture>? UniqueMixes;

        [DataField("tiles")] public Dictionary<Vector2i, int>? TilesUniqueMixes;
    }
}