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

using Syntriax.Engine.Core;
using Syntriax.Engine.Core.Factory;
using Syntriax.Engine.Core.Serialization;

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

namespace Syntriax.Engine.Serializers.Yaml;

public class SerializedClassConverter : EngineTypeYamlSerializerBase<SerializedClass>
{
    public override SerializedClass? Read(IParser parser, Type type, ObjectDeserializer rootDeserializer)
    {
        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
        ProgressionTracker.Set(isTrackingController ? .1f : ProgressionTracker.Progression, $"Reading class");

        SerializedClass serializedClass = new();
        Dictionary<string, TypeContainer> publicDictionary = [];
        Dictionary<string, TypeContainer> privateDictionary = [];

        parser.Consume<MappingStart>();

        while (!parser.TryConsume<MappingEnd>(out _))
        {
            string key = parser.Consume<Scalar>().Value;

            switch (key)
            {
                case nameof(SerializedClass.Type): serializedClass.Type = parser.Consume<Scalar>().Value; break;
                case nameof(SerializedClass.Public): publicDictionary = (Dictionary<string, TypeContainer>)rootDeserializer(typeof(Dictionary<string, TypeContainer>))!; break;
                case nameof(SerializedClass.Private): privateDictionary = (Dictionary<string, TypeContainer>)rootDeserializer(typeof(Dictionary<string, TypeContainer>))!; break;
            }
        }

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

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

        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Read {serializedClass.Type}");
        return serializedClass;
    }

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

        bool isTrackingController = ProgressionTracker.Progression.ApproximatelyEquals(0f);
        ProgressionTracker.Set(isTrackingController ? .25f : ProgressionTracker.Progression, $"Serializing {serializedClass.Type}");

        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));

        if (publics.Count > 0)
        {
            emitter.Emit(new Scalar(nameof(SerializedClass.Public)));
            serializer(publics);
        }

        if (privates.Count > 0)
        {
            emitter.Emit(new Scalar(nameof(SerializedClass.Private)));
            serializer(privates);
        }

        ProgressionTracker.Set(isTrackingController ? 1f : ProgressionTracker.Progression, $"Serialized {serializedClass.Type}");
        emitter.Emit(new MappingEnd());
    }
}