open System

open System.Collections

open System.Collections.Generic

open System.Linq

open System.Text

open System.IO

open System.Globalization

open System.Reflection

​

open Newtonsoft.Json

open Newtonsoft.Json.Linq

open Newtonsoft.Json.Converters

open Newtonsoft.Json.Serialization

​

open Microsoft.FSharpLu.Json

​

// https://stackoverflow.com/questions/62377246/another-failure-at-deserializing-data-with-discriminated-unions-in-f

//let inline isNotNull (x:^T when ^T : not struct) = (not (obj.ReferenceEquals (x, null)))

​

let inline isNull (x:^T when ^T : not struct) = obj.ReferenceEquals (x, null)

​

type Type with

    member t.BaseTypesAndSelf() =

        t |> Seq.unfold (fun state -> if isNull state then None else Some(state, state.BaseType))

    member t.DictionaryKeyValueTypes() = 

        t.BaseTypesAndSelf()

            |> Seq.filter (fun i -> i.IsGenericType && i.GetGenericTypeDefinition() = typedefof<Dictionary<_,_>>)

            |> Seq.map (fun i -> i.GetGenericArguments())

type JsonReader with

    member r.ReadAndAssert() = 

        if not (r.Read()) then raise (JsonReaderException("Unexpected end of JSON stream."))

        r

    member r.MoveToContentAndAssert() =

        if r.TokenType = JsonToken.None then r.ReadAndAssert() |> ignore

        while r.TokenType = JsonToken.Comment do r.ReadAndAssert() |> ignore

        r

​

type internal DictionaryReadOnlySurrogate<'TKey, 'TValue>(i : IDictionary<'TKey, 'TValue>) =

    interface IReadOnlyDictionary<'TKey, 'TValue> with

        member this.ContainsKey(key) = i.ContainsKey(key)

        member this.TryGetValue(key, value) = i.TryGetValue(key, &value)

        member this.Item with get(index) = i.[index]

        member this.Keys = i.Keys :> IEnumerable<'TKey>

        member this.Values = i.Values :> IEnumerable<'TValue>

        member this.Count = i.Count

        member this.GetEnumerator() = i.GetEnumerator()

        member this.GetEnumerator() = i.GetEnumerator() :> IEnumerator        

​

type DictionaryConverter () =

    // ReadJson adapted from this answer https://stackoverflow.com/a/28633769/3744182

    // To https://stackoverflow.com/questions/28451990/newtonsoft-json-deserialize-dictionary-as-key-value-list-from-datacontractjsonse

    // By https://stackoverflow.com/users/3744182/dbc

    inherit JsonConverter()

    override this.CanConvert(t) = (t.DictionaryKeyValueTypes().Count() = 1) // If ever implemented for IReadOnlyDictionary<'TKey, 'TValue> then reject DictionaryReadOnlySurrogate<'TKey, 'TValue>

​

    member private this.ReadJsonGeneric<'TKey, 'TValue> (reader : JsonReader, t : Type, existingValue : obj, serializer : JsonSerializer) : obj =

        let contract = serializer.ContractResolver.ResolveContract(t)

        let dict = if (existingValue :? IDictionary<'TKey, 'TValue>) then existingValue :?> IDictionary<'TKey, 'TValue> else contract.DefaultCreator.Invoke() :?> IDictionary<'TKey, 'TValue>

        match reader.MoveToContentAndAssert().TokenType with 

        | JsonToken.StartArray -> 

            let l = serializer.Deserialize<List<KeyValuePair<'TKey, 'TValue>>>(reader)

            for p in l do dict.Add(p) 

            dict :> obj

        | JsonToken.StartObject ->

            serializer.Populate(reader, dict)

            dict :> obj

        | JsonToken.Null -> null // Or throw an exception if you prefer

        | _ -> raise (JsonSerializationException(String.Format("Unexpected token {0}", reader.TokenType)))

​

    override this.ReadJson(reader, t, existingValue, serializer) = 

        let keyValueTypes = t.DictionaryKeyValueTypes().Single(); // Throws an exception if not exactly one.

        let m = typeof<DictionaryConverter>.GetMethod("ReadJsonGeneric", BindingFlags.NonPublic ||| BindingFlags.Instance ||| BindingFlags.Public);

        m.MakeGenericMethod(keyValueTypes).Invoke(this, [| reader; t; existingValue; serializer |])

​

    member private this.WriteJsonGeneric<'TKey, 'TValue> (writer : JsonWriter, value : obj, serializer : JsonSerializer) =

        let dict = value :?> IDictionary<'TKey, 'TValue>

        let keyContract = serializer.ContractResolver.ResolveContract(typeof<'Key>)

        // Wrap the value in an enumerator or read-only surrogate to prevent infinite recursion.

        match keyContract with

        | :? JsonPrimitiveContract -> serializer.Serialize(writer, new DictionaryReadOnlySurrogate<'TKey, 'TValue>(dict)) 

        | _ -> serializer.Serialize(writer, seq { yield! dict }) 

        ()

​

    override this.WriteJson(writer, value, serializer) = 

        let keyValueTypes = value.GetType().DictionaryKeyValueTypes().Single(); // Throws an exception if not exactly one.

        let m = typeof<DictionaryConverter>.GetMethod("WriteJsonGeneric", BindingFlags.NonPublic ||| BindingFlags.Instance ||| BindingFlags.Public);

        m.MakeGenericMethod(keyValueTypes).Invoke(this, [| writer; value; serializer |])

        ()

​

let settings =

    JsonSerializerSettings(

        NullValueHandling = NullValueHandling.Ignore,

        Converters = [| CompactUnionJsonConverter(true, true); DictionaryConverter() |]

    )

​

let serialize object =

    JsonConvert.SerializeObject(object, Formatting.Indented, settings)

​

let deserialize<'a> object =

    JsonConvert.DeserializeObject<'a>(object, settings)

​

// define the type used

type BookSide =

    | Bid

    | Ask

​

type BookEntry =

    {

        S : float

        P : float

    }

​

type BookSideData =

    Dictionary<int, BookEntry>

​

type BookData =

    {

        Data: Dictionary<BookSide, BookSideData>

    }

​

    static member empty =

        {

            Data = Dictionary<BookSide, BookSideData>(dict [ (BookSide.Bid, BookSideData()); (BookSide.Ask, BookSideData()) ])

        }

​

// make some sample data

let bookEntry = { S=3.; P=5. }

let bookData = BookData.empty

bookData.Data.[BookSide.Bid].Add(1, bookEntry)

​

// serialize. This part works

let s = serialize bookData

​

printf "%s" s

​

// deserialize. This part fails

let bookData2 = deserialize<BookData> s

​

let json2 = serialize bookData

​

if (s <> json2) then raise (Exception("Failed"))

​

//Saved for later use:

​

type Type with

    member t.InterfacesAndSelf() = 

        if t.IsInterface then seq { yield t; yield! t.GetInterfaces() }

        else t.GetInterfaces() :> IEnumerable<Type>

    member t.IDictionaryKeyValueTypes() = 

        t.InterfacesAndSelf()

            |> Seq.filter (fun i -> i.IsGenericType && i.GetGenericTypeDefinition() = typedefof<IDictionary<_,_>>)

            |> Seq.map (fun i -> i.GetGenericArguments())

type JsonReader with

    member r.ReadToContentAndAssert() = 

        r.ReadAndAssert().MoveToContentAndAssert()