using System.Collections.Immutable;

namespace Dpz.Core.Service.OpenIddictStores;

internal static class OpenIddictBsonPropertySerializer
{
    private static readonly JsonSerializerOptions SerializerOptions = new(
        JsonSerializerDefaults.Web
    );

    public static ImmutableDictionary<string, JsonElement> ToProperties(BsonDocument? document)
    {
        if (document is null || document.ElementCount == 0)
        {
            return ImmutableDictionary<string, JsonElement>.Empty;
        }

        var builder = ImmutableDictionary.CreateBuilder<string, JsonElement>(
            StringComparer.Ordinal,
            JsonElementValueComparer.Instance
        );

        foreach (var element in document.Elements)
        {
            builder[element.Name] = ToJsonElement(element.Value);
        }

        return builder.ToImmutable();
    }

    public static BsonDocument? ToDocument(ImmutableDictionary<string, JsonElement> properties)
    {
        if (properties.Count == 0)
        {
            return null;
        }

        var document = new BsonDocument();
        foreach (var (key, value) in properties)
        {
            document[key] = ToBsonValue(value);
        }

        return document;
    }

    private static JsonElement ToJsonElement(BsonValue value)
    {
        using var document = JsonDocument.Parse(
            JsonSerializer.Serialize(ToClrValue(value), SerializerOptions)
        );
        return document.RootElement.Clone();
    }

    private static object? ToClrValue(BsonValue value)
    {
        if (value.IsBsonNull || value.IsBsonUndefined)
        {
            return null;
        }

        if (value.IsBsonDocument)
        {
            return value.AsBsonDocument.Elements.ToDictionary(
                element => element.Name,
                element => ToClrValue(element.Value),
                StringComparer.Ordinal
            );
        }

        if (value.IsBsonArray)
        {
            return value.AsBsonArray.Select(ToClrValue).ToArray();
        }

        if (value.IsBoolean)
        {
            return value.AsBoolean;
        }

        if (value.IsString)
        {
            return value.AsString;
        }

        if (value.IsInt32)
        {
            return value.AsInt32;
        }

        if (value.IsInt64)
        {
            return value.AsInt64;
        }

        if (value.IsDouble)
        {
            return value.AsDouble;
        }

        if (value.IsDecimal128)
        {
            return Decimal128.ToDecimal(value.AsDecimal128);
        }

        if (value.IsValidDateTime)
        {
            return value.ToUniversalTime();
        }

        if (value.IsObjectId)
        {
            return value.AsObjectId.ToString();
        }

        return value.ToString();
    }

    private static BsonValue ToBsonValue(JsonElement element)
    {
        return element.ValueKind switch
        {
            JsonValueKind.Object => ToBsonDocument(element),
            JsonValueKind.Array => ToBsonArray(element),
            JsonValueKind.String => new BsonString(element.GetString()),
            JsonValueKind.Number => ToBsonNumber(element),
            JsonValueKind.True => BsonBoolean.True,
            JsonValueKind.False => BsonBoolean.False,
            _ => BsonNull.Value,
        };
    }

    private static BsonDocument ToBsonDocument(JsonElement element)
    {
        var document = new BsonDocument();
        foreach (var property in element.EnumerateObject())
        {
            document[property.Name] = ToBsonValue(property.Value);
        }

        return document;
    }

    private static BsonArray ToBsonArray(JsonElement element)
    {
        var array = new BsonArray();
        foreach (var item in element.EnumerateArray())
        {
            array.Add(ToBsonValue(item));
        }

        return array;
    }

    private static BsonValue ToBsonNumber(JsonElement element)
    {
        if (element.TryGetInt32(out var int32))
        {
            return new BsonInt32(int32);
        }

        if (element.TryGetInt64(out var int64))
        {
            return new BsonInt64(int64);
        }

        if (element.TryGetDecimal(out var decimalValue))
        {
            return new BsonDecimal128(decimalValue);
        }

        return new BsonDouble(element.GetDouble());
    }
}