#nullable enable
using System;
using System.Collections.Generic;
using System.Linq;
using Swan.Collections;
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 static partial class Json {
    #region Constants 

    internal const String AddMethodName = "Add";

    private const Char OpenObjectChar = '{';
    private const Char CloseObjectChar = '}';

    private const Char OpenArrayChar = '[';
    private const Char CloseArrayChar = ']';

    private const Char FieldSeparatorChar = ',';
    private const Char ValueSeparatorChar = ':';

    private const Char StringEscapeChar = '\\';
    private const Char StringQuotedChar = '"';

    private const String EmptyObjectLiteral = "{ }";
    private const String EmptyArrayLiteral = "[ ]";
    private const String TrueLiteral = "true";
    private const String FalseLiteral = "false";
    private const String NullLiteral = "null";

    #endregion

    private static readonly CollectionCacheRepository<String> IgnoredPropertiesCache = new CollectionCacheRepository<global::System.String>();

    #region Public API

    /// <summary>
    /// Serializes the specified object into a JSON string.
    /// </summary>
    /// <param name="obj">The object.</param>
    /// <param name="format">if set to <c>true</c> it formats and indents the output.</param>
    /// <param name="typeSpecifier">The type specifier. Leave null or empty to avoid setting.</param>
    /// <param name="includeNonPublic">if set to <c>true</c> non-public getters will be also read.</param>
    /// <param name="includedNames">The included property names.</param>
    /// <param name="excludedNames">The excluded property names.</param>
    /// <returns>
    /// A <see cref="System.String" /> that represents the current object.
    /// </returns>
    /// <example>
    /// The following example describes how to serialize a simple object.
    /// <code>
    /// using Swan.Formatters;
    /// 
    /// class Example
    /// {
    ///     static void Main()
    ///     {
    ///         var obj = new { One = "One", Two = "Two" };
    ///         
    ///         var serial = Json.Serialize(obj); // {"One": "One","Two": "Two"}
    ///     }
    /// }
    /// </code>
    /// 
    /// The following example details how to serialize an object using the <see cref="JsonPropertyAttribute"/>.
    /// 
    /// <code>
    /// using Swan.Attributes;
    /// using Swan.Formatters;
    /// 
    /// class Example
    /// {
    ///     class JsonPropertyExample
    ///     {
    ///         [JsonProperty("data")]
    ///         public string Data { get; set; }
    ///         
    ///         [JsonProperty("ignoredData", true)]
    ///         public string IgnoredData { get; set; }
    ///     }
    ///     
    ///     static void Main()
    ///     {
    ///         var obj = new JsonPropertyExample() { Data = "OK", IgnoredData = "OK" };
    ///         
    ///         // {"data": "OK"}
    ///         var serializedObj = Json.Serialize(obj);
    ///     }
    /// }
    /// </code>
    /// </example>
    public static String Serialize(Object? obj, Boolean format = false, String? typeSpecifier = null, Boolean includeNonPublic = false, String[]? includedNames = null, params String[] excludedNames) => Serialize(obj, format, typeSpecifier, includeNonPublic, includedNames, excludedNames, null, JsonSerializerCase.None);

    /// <summary>
    /// Serializes the specified object into a JSON string.
    /// </summary>
    /// <param name="obj">The object.</param>
    /// <param name="jsonSerializerCase">The json serializer case.</param>
    /// <param name="format">if set to <c>true</c> [format].</param>
    /// <param name="typeSpecifier">The type specifier.</param>
    /// <returns>
    /// A <see cref="System.String" /> that represents the current object.
    /// </returns>
    public static String Serialize(Object? obj, JsonSerializerCase jsonSerializerCase, Boolean format = false, String? typeSpecifier = null) => Serialize(obj, format, typeSpecifier, false, null, null, null, jsonSerializerCase);

    /// <summary>
    /// Serializes the specified object into a JSON string.
    /// </summary>
    /// <param name="obj">The object.</param>
    /// <param name="format">if set to <c>true</c> it formats and indents the output.</param>
    /// <param name="typeSpecifier">The type specifier. Leave null or empty to avoid setting.</param>
    /// <param name="includeNonPublic">if set to <c>true</c> non-public getters will be also read.</param>
    /// <param name="includedNames">The included property names.</param>
    /// <param name="excludedNames">The excluded property names.</param>
    /// <param name="parentReferences">The parent references.</param>
    /// <param name="jsonSerializerCase">The json serializer case.</param>
    /// <returns>
    /// A <see cref="System.String" /> that represents the current object.
    /// </returns>
    public static String Serialize(Object? obj, Boolean format, String? typeSpecifier, Boolean includeNonPublic, String[]? includedNames, String[]? excludedNames, List<WeakReference>? parentReferences, JsonSerializerCase jsonSerializerCase) {
      if(obj != null && (obj is String || Definitions.AllBasicValueTypes.Contains(obj.GetType()))) {
        return SerializePrimitiveValue(obj);
      }

      SerializerOptions options = new SerializerOptions(format, typeSpecifier, includedNames, GetExcludedNames(obj?.GetType(), excludedNames), includeNonPublic, parentReferences, jsonSerializerCase);

      return Serialize(obj, options);
    }

    /// <summary>
    /// Serializes the specified object using the SerializerOptions provided.
    /// </summary>
    /// <param name="obj">The object.</param>
    /// <param name="options">The options.</param>
    /// <returns>
    /// A <see cref="String" /> that represents the current object.
    /// </returns>
    public static String Serialize(Object? obj, SerializerOptions options) => Serializer.Serialize(obj, 0, options);

    /// <summary>
    /// Serializes the specified object only including the specified property names.
    /// </summary>
    /// <param name="obj">The object.</param>
    /// <param name="format">if set to <c>true</c> it formats and indents the output.</param>
    /// <param name="includeNames">The include names.</param>
    /// <returns>A <see cref="String" /> that represents the current object.</returns>
    /// <example>
    /// The following example shows how to serialize a simple object including the specified properties.
    /// <code>
    /// using Swan.Formatters;
    /// 
    /// class Example
    /// {
    ///     static void Main()
    ///     {
    ///         // object to serialize
    ///         var obj = new { One = "One", Two = "Two", Three = "Three" };
    ///         
    ///         // the included names
    ///         var includedNames  = new[] { "Two", "Three" };
    ///         
    ///         // serialize only the included names
    ///         var data = Json.SerializeOnly(basicObject, true, includedNames); 
    ///         // {"Two": "Two","Three": "Three" }
    ///     }
    /// }
    /// </code>
    /// </example>
    public static String SerializeOnly(Object? obj, Boolean format, params String[] includeNames) => Serialize(obj, new SerializerOptions(format, null, includeNames));

    /// <summary>
    /// Serializes the specified object excluding the specified property names.
    /// </summary>
    /// <param name="obj">The object.</param>
    /// <param name="format">if set to <c>true</c> it formats and indents the output.</param>
    /// <param name="excludeNames">The exclude names.</param>
    /// <returns>A <see cref="String" /> that represents the current object.</returns>
    /// <example>
    /// The following code shows how to serialize a simple object excluding the specified properties.
    /// <code>
    /// using Swan.Formatters;
    /// 
    /// class Example
    /// {
    ///     static void Main()
    ///     {
    ///         // object to serialize
    ///         var obj = new { One = "One", Two = "Two", Three = "Three" };
    ///         
    ///         // the excluded names
    ///         var excludeNames = new[] { "Two", "Three" };
    ///         
    ///         // serialize excluding
    ///         var data = Json.SerializeExcluding(basicObject, false, includedNames); 
    ///         // {"One": "One"}
    ///     }
    /// }
    /// </code>
    /// </example>
    public static String SerializeExcluding(Object? obj, Boolean format, params String[] excludeNames) => Serialize(obj, new SerializerOptions(format, null, null, excludeNames));

    /// <summary>
    /// Deserializes the specified json string as either a Dictionary[string, object] or as a List[object]
    /// depending on the syntax of the JSON string.
    /// </summary>
    /// <param name="json">The JSON string.</param>
    /// <param name="jsonSerializerCase">The json serializer case.</param>
    /// <returns>
    /// Type of the current deserializes.
    /// </returns>
    /// <example>
    /// The following code shows how to deserialize a JSON string into a Dictionary.
    /// <code>
    /// using Swan.Formatters;
    /// class Example
    /// {
    /// static void Main()
    /// {
    /// // json to deserialize
    /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}";
    /// // deserializes the specified json into a Dictionary&lt;string, object&gt;.
    /// var data = Json.Deserialize(basicJson, JsonSerializerCase.None);
    /// }
    /// }
    /// </code></example>
    public static Object? Deserialize(String? json, JsonSerializerCase jsonSerializerCase) => Converter.FromJsonResult(Deserializer.DeserializeInternal(json), jsonSerializerCase);

    /// <summary>
    /// Deserializes the specified json string as either a Dictionary[string, object] or as a List[object]
    /// depending on the syntax of the JSON string.
    /// </summary>
    /// <param name="json">The JSON string.</param>
    /// <returns>
    /// Type of the current deserializes.
    /// </returns>
    /// <example>
    /// The following code shows how to deserialize a JSON string into a Dictionary.
    /// <code>
    /// using Swan.Formatters;
    /// class Example
    /// {
    /// static void Main()
    /// {
    /// // json to deserialize
    /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}";
    /// // deserializes the specified json into a Dictionary&lt;string, object&gt;.
    /// var data = Json.Deserialize(basicJson);
    /// }
    /// }
    /// </code></example>
    public static Object? Deserialize(String? json) => Deserialize(json, JsonSerializerCase.None);

    /// <summary>
    /// Deserializes the specified JSON string and converts it to the specified object type.
    /// Non-public constructors and property setters are ignored.
    /// </summary>
    /// <typeparam name="T">The type of object to deserialize.</typeparam>
    /// <param name="json">The JSON string.</param>
    /// <param name="jsonSerializerCase">The JSON serializer case.</param>
    /// <returns>
    /// The deserialized specified type object.
    /// </returns>
    /// <example>
    /// The following code describes how to deserialize a JSON string into an object of type T.
    /// <code>
    /// using Swan.Formatters;
    /// class Example
    /// {
    /// static void Main()
    /// {
    /// // json type BasicJson to serialize
    /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}";
    /// // deserializes the specified string in a new instance of the type BasicJson.
    /// var data = Json.Deserialize&lt;BasicJson&gt;(basicJson);
    /// }
    /// }
    /// </code></example>
    public static T Deserialize<T>(String json, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) where T : notnull => (T)Deserialize(json, typeof(T), jsonSerializerCase: jsonSerializerCase)!;

    /// <summary>
    /// Deserializes the specified JSON string and converts it to the specified object type.
    /// </summary>
    /// <typeparam name="T">The type of object to deserialize.</typeparam>
    /// <param name="json">The JSON string.</param>
    /// <param name="includeNonPublic">if set to true, it also uses the non-public constructors and property setters.</param>
    /// <returns>The deserialized specified type object.</returns>
    public static T Deserialize<T>(String json, Boolean includeNonPublic) where T : notnull => (T)Deserialize(json, typeof(T), includeNonPublic)!;

    /// <summary>
    /// Deserializes the specified JSON string and converts it to the specified object type.
    /// </summary>
    /// <param name="json">The JSON string.</param>
    /// <param name="resultType">Type of the result.</param>
    /// <param name="includeNonPublic">if set to true, it also uses the non-public constructors and property setters.</param>
    /// <param name="jsonSerializerCase">The json serializer case.</param>
    /// <returns>
    /// Type of the current conversion from json result.
    /// </returns>
    public static Object? Deserialize(String json, Type resultType, Boolean includeNonPublic = false, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) => Converter.FromJsonResult(Deserializer.DeserializeInternal(json), jsonSerializerCase, resultType, includeNonPublic);

    #endregion

    #region Private API

    private static String[]? GetExcludedNames(Type? type, String[]? excludedNames) {
      if(type == null) {
        return excludedNames;
      }

      global::System.Collections.Generic.IEnumerable<global::System.String> excludedByAttr = IgnoredPropertiesCache.Retrieve(type, t => t.GetProperties()
                .Where(x => AttributeCache.DefaultCache.Value.RetrieveOne<JsonPropertyAttribute>(x)?.Ignored == true)
                .Select(x => x.Name));

      if(excludedByAttr?.Any() != true) {
        return excludedNames;
      }

      return excludedNames?.Any(String.IsNullOrWhiteSpace) == true
                ? excludedByAttr.Intersect(excludedNames.Where(y => !String.IsNullOrWhiteSpace(y))).ToArray()
                : excludedByAttr.ToArray();
    }

    private static String SerializePrimitiveValue(Object obj) => obj switch
    {
      String stringValue => stringValue,
      Boolean boolValue => boolValue ? TrueLiteral : FalseLiteral,
      _ => obj.ToString()!
    };

    #endregion
  }
}