using System;
using System.Collections.Generic;
using System.Linq;
using RecNet;

namespace RecRoom.Challenges
{
	// Token: 0x02000B1F RID: 2847
	public abstract class RequiredObjectChallenge<T, SerializedT> : ChallengeBase where T : struct
	{
		// Token: 0x06015B3D RID: 88893 RVA: 0x0060692C File Offset: 0x00604B2C
		public RequiredObjectChallenge()
		{
		}

		// Token: 0x06015B3E RID: 88894 RVA: 0x00606950 File Offset: 0x00604B50
		public RequiredObjectChallenge(T[] requiredValues)
			: this(true, requiredValues)
		{
		}

		// Token: 0x06015B3F RID: 88895 RVA: 0x0060695C File Offset: 0x00604B5C
		public RequiredObjectChallenge(T requiredValue, params T[] requiredValues)
			: this(true, requiredValue, requiredValues)
		{
		}

		// Token: 0x06015B40 RID: 88896 RVA: 0x00606968 File Offset: 0x00604B68
		public RequiredObjectChallenge(bool inclusive, T requiredValue, params T[] requiredValues)
			: this(inclusive, requiredValues.Union(new T[] { requiredValue }).ToArray<T>())
		{
		}

		// Token: 0x06015B41 RID: 88897 RVA: 0x0060698C File Offset: 0x00604B8C
		public RequiredObjectChallenge(bool inclusive, T[] requiredValues)
		{
			this.Inclusive = inclusive;
			this.values.AddRange(requiredValues);
		}

		// Token: 0x06015B42 RID: 88898 RVA: 0x006069C0 File Offset: 0x00604BC0
		protected override bool EvaluateInternal(ChallengeEvents.IChallengeEventData challengeEventData)
		{
			T? valueFromData = this.GetValueFromData(challengeEventData);
			if (this.Inclusive)
			{
				return valueFromData != null && this.Matches(valueFromData.Value);
			}
			if (valueFromData == null)
			{
				return this.ExclusiveIncludesNull;
			}
			return !this.Matches(valueFromData.Value);
		}

		// Token: 0x06015B43 RID: 88899 RVA: 0x00606A28 File Offset: 0x00604C28
		protected virtual bool Matches(T value)
		{
			return this.values.Contains(value);
		}

		// Token: 0x06015B44 RID: 88900
		protected abstract T? GetValueFromData(ChallengeEvents.IChallengeEventData challengeEventData);

		// Token: 0x06015B45 RID: 88901
		protected abstract SerializedT SerializeValue(T value);

		// Token: 0x06015B46 RID: 88902
		protected abstract T DeserializeValue(SerializedT obj);

		// Token: 0x06015B47 RID: 88903 RVA: 0x00606A38 File Offset: 0x00604C38
		public override Dictionary<string, object> Serialize()
		{
			Dictionary<string, object> dictionary = base.Serialize();
			if (this.values.Count > 0)
			{
				dictionary["vs"] = this.values.Select((T _) => this.SerializeValue(_)).ToList<SerializedT>();
			}
			ChallengeBase.SerializeOptionalField<bool>("in", this.Inclusive, true, dictionary);
			ChallengeBase.SerializeOptionalField<bool>("ex", this.ExclusiveIncludesNull, true, dictionary);
			return dictionary;
		}

		// Token: 0x06015B48 RID: 88904 RVA: 0x00606AAC File Offset: 0x00604CAC
		protected override void DeserializeInternal(Dictionary<string, object> jsonDict)
		{
			if (jsonDict.ContainsKey("vs"))
			{
				this.values = (from _ in OFPFHHLNHIC.NGILNLCIOJM<SerializedT>("vs", jsonDict)
					select this.DeserializeValue(_)).ToList<T>();
			}
			else
			{
				this.values.Clear();
			}
			this.ExclusiveIncludesNull = ChallengeParser.GetOptionalKey<bool>("ex", jsonDict, true);
			this.Inclusive = ChallengeParser.GetOptionalKey<bool>("in", jsonDict, true);
		}

		// Token: 0x04003CA2 RID: 15522
		public bool Inclusive = true;

		// Token: 0x04003CA3 RID: 15523
		private const bool ExclusiveIncludesNullDefault = true;

		// Token: 0x04003CA4 RID: 15524
		public bool ExclusiveIncludesNull = true;

		// Token: 0x04003CA5 RID: 15525
		protected List<T> values = new List<T>();

		// Token: 0x04003CA6 RID: 15526
		private const string VALUES_KEY = "vs";

		// Token: 0x04003CA7 RID: 15527
		private const string INCLUSIVE_KEY = "in";

		// Token: 0x04003CA8 RID: 15528
		private const string EXCLUSIVE_INCLUDES_NULL_KEY = "ex";
	}
}