using System;
using System.Collections.Generic;
using System.Linq;

using Syntriax.Engine.Core.Factory;

using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Serialization;

namespace Syntriax.Engine.Core.Serialization;

public class SerializedClassConverter : IEngineTypeYamlConverter
{
    public bool Accepts(Type type) => type == typeof(SerializedClass);

    public object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
    {
        SerializedClass serializedClass = new();

        parser.Consume<MappingStart>();

        if (parser.Consume<Scalar>().Value.CompareTo(nameof(SerializedClass.Type)) != 0)
            throw new();
        serializedClass.Type = parser.Consume<Scalar>().Value;

        if (parser.Consume<Scalar>().Value.CompareTo(nameof(SerializedClass.Public)) != 0)
            throw new();
        Dictionary<string, TypeContainer> publicDictionary = (Dictionary<string, TypeContainer>)rootDeserializer(typeof(Dictionary<string, TypeContainer>))!;

        if (parser.Consume<Scalar>().Value.CompareTo(nameof(SerializedClass.Private)) != 0)
            throw new();
        Dictionary<string, TypeContainer> privateDictionary = (Dictionary<string, TypeContainer>)rootDeserializer(typeof(Dictionary<string, TypeContainer>))!;

        parser.Consume<MappingEnd>();

        foreach ((string key, TypeContainer typeContainer) in publicDictionary)
            serializedClass.Public.Add(key, Serializer.Deserialize(typeContainer.Value!.ToString()!, TypeFactory.GetType(typeContainer.Type)));

        foreach ((string key, TypeContainer typeContainer) in privateDictionary)
            serializedClass.Private.Add(key, Serializer.Deserialize(typeContainer.Value!.ToString()!, TypeFactory.GetType(typeContainer.Type)));

        return serializedClass;
    }

    public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
    {
        SerializedClass serializedClass = (SerializedClass)value!;

        Dictionary<string, TypeContainer> publics = [];
        Dictionary<string, TypeContainer> privates = [];

        foreach ((string key, object? @object) in serializedClass.Public.Where(v => !v.GetType().HasAttribute<IgnoreSerializationAttribute>()))
            publics.Add(key, new TypeContainer(@object));

        foreach ((string key, object? @object) in serializedClass.Private.Where(v => !v.GetType().HasAttribute<IgnoreSerializationAttribute>()))
            privates.Add(key, new TypeContainer(@object));

        emitter.Emit(new MappingStart());

        emitter.Emit(new Scalar(nameof(SerializedClass.Type)));
        emitter.Emit(new Scalar(serializedClass.Type));

        emitter.Emit(new Scalar(nameof(SerializedClass.Public)));
        serializer(publics);

        emitter.Emit(new Scalar(nameof(SerializedClass.Private)));
        serializer(privates);

        emitter.Emit(new MappingEnd());
    }
}