using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

​

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

//https://stackoverflow.com/questions/52232546/how-to-deal-with-json-that-changes#52232546

​

    public partial class TwitchData

    {

        [JsonProperty("data")]

        public Datum[] Data { get; set; }

​

        [JsonProperty("pagination")]

        public Pagination Pagination { get; set; }

    }

​

    public partial class Datum

    {

        [JsonProperty("id")]

        public string Id { get; set; }

​

        [JsonProperty("user_id")]

        [JsonConverter(typeof(ParseStringConverter))]

        public long UserId { get; set; }

​

        [JsonProperty("game_id")]

        [JsonConverter(typeof(ParseStringConverter))]

        public long GameId { get; set; }

​

        [JsonProperty("community_ids")]

        public object[] CommunityIds { get; set; }

​

        [JsonProperty("type")]

        public string Type { get; set; }

​

        [JsonProperty("title")]

        public string Title { get; set; }

​

        [JsonProperty("viewer_count")]

        public long ViewerCount { get; set; }

​

        [JsonProperty("started_at")]

        public DateTimeOffset StartedAt { get; set; }

​

        [JsonProperty("language")]

        public string Language { get; set; }

​

        [JsonProperty("thumbnail_url")]

        public string ThumbnailUrl { get; set; }

    }

​

    public partial class Pagination

    {

        [JsonProperty("cursor")]

        public string Cursor { get; set; }

    }

​

    public partial class TwitchData

    {

        public static TwitchData FromJson(string json) { return JsonConvert.DeserializeObject<TwitchData>(json, Converter.Settings); }

    }

​

    public static class Serialize

    {

        public static string ToJson(this TwitchData self) { return JsonConvert.SerializeObject(self, Converter.Settings); }

    }

​

    internal static class Converter

    {

        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings

        {

            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,

            DateParseHandling = DateParseHandling.None,

            Converters = {

                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }

            },

        };

    }

​

    internal class ParseStringConverter : JsonConverter

    {

        public override bool CanConvert(Type t) { return t == typeof(long) || t == typeof(long?); }

​

        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)

        {

            if (reader.TokenType == JsonToken.Null) return null;

            var value = serializer.Deserialize<string>(reader);

            long l;

            if (Int64.TryParse(value, out l))

            {

                return l;

            }

            throw new Exception("Cannot unmarshal type long");

        }

​

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)

        {

            if (untypedValue == null)

            {

                serializer.Serialize(writer, null);

                return;

            }

            var value = (long)untypedValue;

            serializer.Serialize(writer, value.ToString());

            return;

        }

​

        public static readonly ParseStringConverter Singleton = new ParseStringConverter();

    }

​

    class TestClass

    {

        public static void Test()

        {

            foreach (var json in GetJson())

                Test(json);

        }

        static void Test(string jsonString)

        {

            //var twitchData = PwdResetRequest.FromJson(jsonString);            

            var twitchData = TwitchData.FromJson(jsonString);           

            var json2 = Serialize.ToJson(twitchData);

            Console.WriteLine(json2);

        }

        static IEnumerable<string> GetJson()

        {

            return new []

            {

                @"{

  ""data"": [

    {

      ""id"": ""30356128676"",

      ""user_id"": ""59788312"",

      ""game_id"": ""498652"",

      ""community_ids"": [],

      ""type"": ""live"",

      ""title"": ""A stream"",

      ""viewer_count"": 1325,

      ""started_at"": ""2018-09-07T16:30:09Z"",

      ""language"": ""en"",

      ""thumbnail_url"": ""url""

    }

  ],

  ""pagination"": {

    ""cursor"": ""eydBIjpwdWGsLaJhIjp7IkGH4hNl6CH6MXr9""

  }

}",

                @"{

  ""data"": [],

  ""pagination"": {}

}",

            };

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

​