using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using SimpleJson.Reflection;

namespace SimpleJson
{
	// Token: 0x020002E5 RID: 741
	[GeneratedCode("simple-json", "1.0.0")]
	internal class PocoJsonSerializerStrategy : IJsonSerializerStrategy
	{
		// Token: 0x060030AF RID: 12463 RVA: 0x00048130 File Offset: 0x00046330
		public PocoJsonSerializerStrategy()
		{
			this.ConstructorCache = new ReflectionUtils.ThreadSafeDictionary<Type, ReflectionUtils.ConstructorDelegate>(new ReflectionUtils.ThreadSafeDictionaryValueFactory<Type, ReflectionUtils.ConstructorDelegate>(this.ContructorDelegateFactory));
			this.GetCache = new ReflectionUtils.ThreadSafeDictionary<Type, IDictionary<string, ReflectionUtils.GetDelegate>>(new ReflectionUtils.ThreadSafeDictionaryValueFactory<Type, IDictionary<string, ReflectionUtils.GetDelegate>>(this.GetterValueFactory));
			this.SetCache = new ReflectionUtils.ThreadSafeDictionary<Type, IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>>>(new ReflectionUtils.ThreadSafeDictionaryValueFactory<Type, IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>>>(this.SetterValueFactory));
		}

		// Token: 0x060030B0 RID: 12464 RVA: 0x0004818C File Offset: 0x0004638C
		protected virtual string MapClrMemberNameToJsonFieldName(string clrPropertyName)
		{
			return clrPropertyName;
		}

		// Token: 0x060030B1 RID: 12465 RVA: 0x000481A4 File Offset: 0x000463A4
		internal virtual ReflectionUtils.ConstructorDelegate ContructorDelegateFactory(Type key)
		{
			return ReflectionUtils.GetContructor(key, (!key.IsArray) ? PocoJsonSerializerStrategy.EmptyTypes : PocoJsonSerializerStrategy.ArrayConstructorParameterTypes);
		}

		// Token: 0x060030B2 RID: 12466 RVA: 0x000481DC File Offset: 0x000463DC
		internal virtual IDictionary<string, ReflectionUtils.GetDelegate> GetterValueFactory(Type type)
		{
			IDictionary<string, ReflectionUtils.GetDelegate> dictionary = new Dictionary<string, ReflectionUtils.GetDelegate>();
			foreach (PropertyInfo propertyInfo in ReflectionUtils.GetProperties(type))
			{
				if (propertyInfo.CanRead)
				{
					MethodInfo getterMethodInfo = ReflectionUtils.GetGetterMethodInfo(propertyInfo);
					if (!getterMethodInfo.IsStatic && getterMethodInfo.IsPublic)
					{
						dictionary[this.MapClrMemberNameToJsonFieldName(propertyInfo.Name)] = ReflectionUtils.GetGetMethod(propertyInfo);
					}
				}
			}
			foreach (FieldInfo fieldInfo in ReflectionUtils.GetFields(type))
			{
				if (!fieldInfo.IsStatic && fieldInfo.IsPublic)
				{
					dictionary[this.MapClrMemberNameToJsonFieldName(fieldInfo.Name)] = ReflectionUtils.GetGetMethod(fieldInfo);
				}
			}
			return dictionary;
		}

		// Token: 0x060030B3 RID: 12467 RVA: 0x0004830C File Offset: 0x0004650C
		internal virtual IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>> SetterValueFactory(Type type)
		{
			IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>> dictionary = new Dictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>>();
			foreach (PropertyInfo propertyInfo in ReflectionUtils.GetProperties(type))
			{
				if (propertyInfo.CanWrite)
				{
					MethodInfo setterMethodInfo = ReflectionUtils.GetSetterMethodInfo(propertyInfo);
					if (!setterMethodInfo.IsStatic && setterMethodInfo.IsPublic)
					{
						dictionary[this.MapClrMemberNameToJsonFieldName(propertyInfo.Name)] = new KeyValuePair<Type, ReflectionUtils.SetDelegate>(propertyInfo.PropertyType, ReflectionUtils.GetSetMethod(propertyInfo));
					}
				}
			}
			foreach (FieldInfo fieldInfo in ReflectionUtils.GetFields(type))
			{
				if (!fieldInfo.IsInitOnly && !fieldInfo.IsStatic && fieldInfo.IsPublic)
				{
					dictionary[this.MapClrMemberNameToJsonFieldName(fieldInfo.Name)] = new KeyValuePair<Type, ReflectionUtils.SetDelegate>(fieldInfo.FieldType, ReflectionUtils.GetSetMethod(fieldInfo));
				}
			}
			return dictionary;
		}

		// Token: 0x060030B4 RID: 12468 RVA: 0x00048460 File Offset: 0x00046660
		public virtual bool TrySerializeNonPrimitiveObject(object input, out object output)
		{
			return this.TrySerializeKnownTypes(input, out output) || this.TrySerializeUnknownTypes(input, out output);
		}

		// Token: 0x060030B5 RID: 12469 RVA: 0x00048490 File Offset: 0x00046690
		public virtual object DeserializeObject(object value, Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			string text = value as string;
			object obj;
			if (type == typeof(Guid) && string.IsNullOrEmpty(text))
			{
				obj = default(Guid);
			}
			else if (value == null)
			{
				obj = null;
			}
			else
			{
				object obj2 = null;
				if (text != null)
				{
					if (text.Length != 0)
					{
						if (type == typeof(DateTime) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(DateTime)))
						{
							return DateTime.ParseExact(text, PocoJsonSerializerStrategy.Iso8601Format, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
						}
						if (type == typeof(DateTimeOffset) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(DateTimeOffset)))
						{
							return DateTimeOffset.ParseExact(text, PocoJsonSerializerStrategy.Iso8601Format, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
						}
						if (type == typeof(Guid) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(Guid)))
						{
							return new Guid(text);
						}
						return text;
					}
					else
					{
						if (type == typeof(Guid))
						{
							obj2 = default(Guid);
						}
						else if (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(Guid))
						{
							obj2 = null;
						}
						else
						{
							obj2 = text;
						}
						if (!ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(Guid))
						{
							return text;
						}
					}
				}
				else if (value is bool)
				{
					return value;
				}
				bool flag = value is long;
				bool flag2 = value is double;
				if ((flag && type == typeof(long)) || (flag2 && type == typeof(double)))
				{
					obj = value;
				}
				else if ((flag2 && type != typeof(double)) || (flag && type != typeof(long)))
				{
					obj2 = ((!typeof(IConvertible).IsAssignableFrom(type)) ? value : Convert.ChangeType(value, type, CultureInfo.InvariantCulture));
					if (ReflectionUtils.IsNullableType(type))
					{
						obj = ReflectionUtils.ToNullableType(obj2, type);
					}
					else
					{
						obj = obj2;
					}
				}
				else
				{
					IDictionary<string, object> dictionary = value as IDictionary<string, object>;
					if (dictionary != null)
					{
						IDictionary<string, object> dictionary2 = dictionary;
						if (ReflectionUtils.IsTypeDictionary(type))
						{
							Type[] genericTypeArguments = ReflectionUtils.GetGenericTypeArguments(type);
							Type type2 = genericTypeArguments[0];
							Type type3 = genericTypeArguments[1];
							Type type4 = typeof(Dictionary<, >).MakeGenericType(new Type[] { type2, type3 });
							IDictionary dictionary3 = (IDictionary)this.ConstructorCache[type4](null);
							foreach (KeyValuePair<string, object> keyValuePair in dictionary2)
							{
								dictionary3.Add(keyValuePair.Key, this.DeserializeObject(keyValuePair.Value, type3));
							}
							obj2 = dictionary3;
						}
						else if (type == typeof(object))
						{
							obj2 = value;
						}
						else
						{
							obj2 = this.ConstructorCache[type](null);
							foreach (KeyValuePair<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>> keyValuePair2 in this.SetCache[type])
							{
								object obj3;
								if (dictionary2.TryGetValue(keyValuePair2.Key, out obj3))
								{
									obj3 = this.DeserializeObject(obj3, keyValuePair2.Value.Key);
									keyValuePair2.Value.Value(obj2, obj3);
								}
							}
						}
					}
					else
					{
						IList<object> list = value as IList<object>;
						if (list != null)
						{
							IList<object> list2 = list;
							IList list3 = null;
							if (type.IsArray)
							{
								list3 = (IList)this.ConstructorCache[type](new object[] { list2.Count });
								int num = 0;
								foreach (object obj4 in list2)
								{
									list3[num++] = this.DeserializeObject(obj4, type.GetElementType());
								}
							}
							else if (ReflectionUtils.IsTypeGenericeCollectionInterface(type) || ReflectionUtils.IsAssignableFrom(typeof(IList), type))
							{
								Type type5 = ReflectionUtils.GetGenericTypeArguments(type)[0];
								Type type6 = typeof(List<>).MakeGenericType(new Type[] { type5 });
								list3 = (IList)this.ConstructorCache[type6](new object[] { list2.Count });
								foreach (object obj5 in list2)
								{
									list3.Add(this.DeserializeObject(obj5, type5));
								}
							}
							obj2 = list3;
						}
					}
					obj = obj2;
				}
			}
			return obj;
		}

		// Token: 0x060030B6 RID: 12470 RVA: 0x00048A7C File Offset: 0x00046C7C
		protected virtual object SerializeEnum(Enum p)
		{
			return Convert.ToDouble(p, CultureInfo.InvariantCulture);
		}

		// Token: 0x060030B7 RID: 12471 RVA: 0x00048AA4 File Offset: 0x00046CA4
		protected virtual bool TrySerializeKnownTypes(object input, out object output)
		{
			bool flag = true;
			if (input is DateTime)
			{
				output = ((DateTime)input).ToUniversalTime().ToString(PocoJsonSerializerStrategy.Iso8601Format[0], CultureInfo.InvariantCulture);
			}
			else if (input is DateTimeOffset)
			{
				output = ((DateTimeOffset)input).ToUniversalTime().ToString(PocoJsonSerializerStrategy.Iso8601Format[0], CultureInfo.InvariantCulture);
			}
			else if (input is Guid)
			{
				output = ((Guid)input).ToString("D");
			}
			else if (input is Uri)
			{
				output = input.ToString();
			}
			else
			{
				Enum @enum = input as Enum;
				if (@enum != null)
				{
					output = this.SerializeEnum(@enum);
				}
				else
				{
					flag = false;
					output = null;
				}
			}
			return flag;
		}

		// Token: 0x060030B8 RID: 12472 RVA: 0x00048B8C File Offset: 0x00046D8C
		protected virtual bool TrySerializeUnknownTypes(object input, out object output)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			output = null;
			Type type = input.GetType();
			bool flag;
			if (type.FullName == null)
			{
				flag = false;
			}
			else
			{
				IDictionary<string, object> dictionary = new JsonObject();
				IDictionary<string, ReflectionUtils.GetDelegate> dictionary2 = this.GetCache[type];
				foreach (KeyValuePair<string, ReflectionUtils.GetDelegate> keyValuePair in dictionary2)
				{
					if (keyValuePair.Value != null)
					{
						dictionary.Add(this.MapClrMemberNameToJsonFieldName(keyValuePair.Key), keyValuePair.Value(input));
					}
				}
				output = dictionary;
				flag = true;
			}
			return flag;
		}

		// Token: 0x040009A0 RID: 2464
		internal IDictionary<Type, ReflectionUtils.ConstructorDelegate> ConstructorCache;

		// Token: 0x040009A1 RID: 2465
		internal IDictionary<Type, IDictionary<string, ReflectionUtils.GetDelegate>> GetCache;

		// Token: 0x040009A2 RID: 2466
		internal IDictionary<Type, IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>>> SetCache;

		// Token: 0x040009A3 RID: 2467
		internal static readonly Type[] EmptyTypes = new Type[0];

		// Token: 0x040009A4 RID: 2468
		internal static readonly Type[] ArrayConstructorParameterTypes = new Type[] { typeof(int) };

		// Token: 0x040009A5 RID: 2469
		private static readonly string[] Iso8601Format = new string[] { "yyyy-MM-dd\\THH:mm:ss.FFFFFFF\\Z", "yyyy-MM-dd\\THH:mm:ss\\Z", "yyyy-MM-dd\\THH:mm:ssK" };
	}
}