#nullable enable
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Swan.Reflection;

namespace Swan.Formatters {
  /// <summary>
  /// A very simple, light-weight JSON library written by Mario
  /// to teach Geo how things are done
  /// 
  /// This is an useful helper for small tasks but it doesn't represent a full-featured
  /// serializer such as the beloved Json.NET.
  /// </summary>
  public class SerializerOptions {
    private static readonly ConcurrentDictionary<Type, Dictionary<Tuple<String, String>, MemberInfo>>        TypeCache = new ConcurrentDictionary<Type, Dictionary<Tuple<String, String>, MemberInfo>>();

    private readonly String[]? _includeProperties;
    private readonly String[]? _excludeProperties;
    private readonly Dictionary<Int32, List<WeakReference>> _parentReferences = new Dictionary<Int32, List<WeakReference>>();

    /// <summary>
    /// Initializes a new instance of the <see cref="SerializerOptions"/> class.
    /// </summary>
    /// <param name="format">if set to <c>true</c> [format].</param>
    /// <param name="typeSpecifier">The type specifier.</param>
    /// <param name="includeProperties">The include properties.</param>
    /// <param name="excludeProperties">The exclude properties.</param>
    /// <param name="includeNonPublic">if set to <c>true</c> [include non public].</param>
    /// <param name="parentReferences">The parent references.</param>
    /// <param name="jsonSerializerCase">The json serializer case.</param>
    public SerializerOptions(Boolean format, String? typeSpecifier, String[]? includeProperties, String[]? excludeProperties = null, Boolean includeNonPublic = true, IReadOnlyCollection<WeakReference>? parentReferences = null, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) {
      this._includeProperties = includeProperties;
      this._excludeProperties = excludeProperties;

      this.IncludeNonPublic = includeNonPublic;
      this.Format = format;
      this.TypeSpecifier = typeSpecifier;
      this.JsonSerializerCase = jsonSerializerCase;

      if(parentReferences == null) {
        return;
      }

      foreach(WeakReference parentReference in parentReferences.Where(x => x.IsAlive)) {
        _ = this.IsObjectPresent(parentReference.Target);
      }
    }

    /// <summary>
    /// Gets a value indicating whether this <see cref="SerializerOptions"/> is format.
    /// </summary>
    /// <value>
    ///   <c>true</c> if format; otherwise, <c>false</c>.
    /// </value>
    public Boolean Format {
      get;
    }

    /// <summary>
    /// Gets the type specifier.
    /// </summary>
    /// <value>
    /// The type specifier.
    /// </value>
    public String? TypeSpecifier {
      get;
    }

    /// <summary>
    /// Gets a value indicating whether [include non public].
    /// </summary>
    /// <value>
    ///   <c>true</c> if [include non public]; otherwise, <c>false</c>.
    /// </value>
    public Boolean IncludeNonPublic {
      get;
    }

    /// <summary>
    /// Gets the json serializer case.
    /// </summary>
    /// <value>
    /// The json serializer case.
    /// </value>
    public JsonSerializerCase JsonSerializerCase {
      get;
    }

    internal Boolean IsObjectPresent(Object? target) {
      if(target == null) {
        return false;
      }
      Int32 hashCode = target.GetHashCode();

      if(this._parentReferences.ContainsKey(hashCode)) {
        if(this._parentReferences[hashCode].Any(p => ReferenceEquals(p.Target, target))) {
          return true;
        }

        this._parentReferences[hashCode].Add(new WeakReference(target));
        return false;
      }

      this._parentReferences.Add(hashCode, new List<WeakReference> { new WeakReference(target) });
      return false;
    }

    internal Dictionary<String, MemberInfo> GetProperties(Type targetType) => this.GetPropertiesCache(targetType).When(() => this._includeProperties?.Length > 0, query => query.Where(p => this._includeProperties.Contains(p.Key.Item1))).When(() => this._excludeProperties?.Length > 0, query => query.Where(p => !this._excludeProperties.Contains(p.Key.Item1))).ToDictionary(x => x.Key.Item2, x => x.Value);

    private Dictionary<Tuple<String, String>, MemberInfo> GetPropertiesCache(Type targetType) {
      if(TypeCache.TryGetValue(targetType, out Dictionary<Tuple<String, String>, MemberInfo>? current)) {
        return current;
      }

      List<MemberInfo> fields = new List<MemberInfo>(PropertyTypeCache.DefaultCache.Value.RetrieveAllProperties(targetType).Where(p => p.CanRead));

      // If the target is a struct (value type) navigate the fields.
      if(targetType.IsValueType) {
        fields.AddRange(FieldTypeCache.DefaultCache.Value.RetrieveAllFields(targetType));
      }

      Dictionary<Tuple<String, String>, MemberInfo> value = fields.ToDictionary(x => Tuple.Create(x.Name, x.GetCustomAttribute<JsonPropertyAttribute>()?.PropertyName ?? x.Name.GetNameWithCase(this.JsonSerializerCase)), x => x);

      _ = TypeCache.TryAdd(targetType, value);

      return value;
    }
  }
}