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

namespace RecRoom.Challenges
{
	// Token: 0x02000B1A RID: 2842
	[HMFEEFDKPLO]
	public class TimedBufferChallenge : Challenge
	{
		// Token: 0x06015B21 RID: 88865 RVA: 0x0060601C File Offset: 0x0060421C
		public TimedBufferChallenge()
		{
		}

		// Token: 0x06015B22 RID: 88866 RVA: 0x00606074 File Offset: 0x00604274
		public TimedBufferChallenge(IChallenge challengeToCount, int count, float interval)
			: this(new IChallenge[] { challengeToCount }, count, interval)
		{
		}

		// Token: 0x06015B23 RID: 88867 RVA: 0x00606088 File Offset: 0x00604288
		public TimedBufferChallenge(IChallenge challengeToCount, int count, float interval, Func<float> getCurrentTimeFunc)
			: this(new IChallenge[] { challengeToCount }, count, interval, getCurrentTimeFunc)
		{
		}

		// Token: 0x06015B24 RID: 88868 RVA: 0x006060A0 File Offset: 0x006042A0
		public TimedBufferChallenge(IChallenge[] challengesToCount, int count, float interval)
			: this(challengesToCount, count, interval, TimedBufferChallenge.UnityTimeFunc)
		{
		}

		// Token: 0x06015B25 RID: 88869 RVA: 0x006060B0 File Offset: 0x006042B0
		public TimedBufferChallenge(IChallenge[] challengesToCount, int count, float interval, Func<float> getCurrentTimeFunc)
		{
			this.challengesToCount = new List<IChallenge>(challengesToCount);
			this.total = count;
			this.interval = interval;
			this.getCurrentTimeFunc = getCurrentTimeFunc;
			this.Initialize();
		}

		// Token: 0x17000901 RID: 2305
		// (get) Token: 0x06015B26 RID: 88870 RVA: 0x00606130 File Offset: 0x00604330
		public int BufferSize
		{
			get
			{
				return this.entryBuffer.Count;
			}
		}

		// Token: 0x06015B27 RID: 88871 RVA: 0x00606140 File Offset: 0x00604340
		protected override void Initialize()
		{
			base.Initialize();
			this.WithConditions.Clear();
			using (List<IChallenge>.Enumerator enumerator = this.challengesToCount.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					IChallenge challengeToCount = enumerator.Current;
					TimedBufferChallenge $this = this;
					challengeToCount.SkipSerialization = true;
					challengeToCount.ChallengeCompleteEvent += delegate(IChallenge challenge, ChallengeEvents.IChallengeEventData data)
					{
						TimedBufferChallenge.TimedBufferEntry timedBufferEntry = new TimedBufferChallenge.TimedBufferEntry
						{
							Time = $this.getCurrentTimeFunc(),
							EventData = data
						};
						$this.entryBuffer.Add(timedBufferEntry);
						challengeToCount.Reset();
					};
					this.WithConditions.Add(challengeToCount);
				}
			}
		}

		// Token: 0x06015B28 RID: 88872 RVA: 0x006061EC File Offset: 0x006043EC
		public override void Reset()
		{
			base.Reset();
			this.entryBuffer.Clear();
		}

		// Token: 0x06015B29 RID: 88873 RVA: 0x00606200 File Offset: 0x00604400
		protected override bool EvaluateInternal(ChallengeEvents.IChallengeEventData challengeEventData)
		{
			base.EvaluateInternal(challengeEventData);
			IEnumerable<TimedBufferChallenge.TimedBufferEntry> enumerable = this.entryBuffer;
			if (this.interval > 0f)
			{
				enumerable = this.entryBuffer.Where((TimedBufferChallenge.TimedBufferEntry entry) => entry.Time > this.getCurrentTimeFunc() - this.interval);
			}
			int num = this.currentCount;
			this.currentCount = 0;
			switch (this.BufferCountMethod)
			{
			case TimedBufferChallenge.BufferCountMethods.UniqueToolCount:
				enumerable = (from _ in enumerable
					group _ by _.EventData.GetVar("t_vid")).Select(new Func<IGrouping<object, TimedBufferChallenge.TimedBufferEntry>, TimedBufferChallenge.TimedBufferEntry>(Enumerable.FirstOrDefault<TimedBufferChallenge.TimedBufferEntry>));
				this.currentCount = enumerable.Count<TimedBufferChallenge.TimedBufferEntry>();
				break;
			case TimedBufferChallenge.BufferCountMethods.UniqueAttackerCount:
				enumerable = (from _ in enumerable
					group _ by _.EventData.GetVar("ap_pid")).Select(new Func<IGrouping<object, TimedBufferChallenge.TimedBufferEntry>, TimedBufferChallenge.TimedBufferEntry>(Enumerable.FirstOrDefault<TimedBufferChallenge.TimedBufferEntry>));
				this.currentCount = enumerable.Count<TimedBufferChallenge.TimedBufferEntry>();
				break;
			case TimedBufferChallenge.BufferCountMethods.UniqueDefenderCount:
				enumerable = (from _ in enumerable
					group _ by _.EventData.GetVar("dp_pid")).Select(new Func<IGrouping<object, TimedBufferChallenge.TimedBufferEntry>, TimedBufferChallenge.TimedBufferEntry>(Enumerable.FirstOrDefault<TimedBufferChallenge.TimedBufferEntry>));
				this.currentCount = enumerable.Count<TimedBufferChallenge.TimedBufferEntry>();
				break;
			case TimedBufferChallenge.BufferCountMethods.GroupedToolMaxCount:
			{
				IEnumerable<IGrouping<object, TimedBufferChallenge.TimedBufferEntry>> enumerable2 = from entry in enumerable
					group entry by entry.EventData.GetVar("t_vid");
				int num2;
				if (enumerable2.Count<IGrouping<object, TimedBufferChallenge.TimedBufferEntry>>() > 0)
				{
					num2 = enumerable2.Max(new Func<IGrouping<object, TimedBufferChallenge.TimedBufferEntry>, int>(Enumerable.Count<TimedBufferChallenge.TimedBufferEntry>));
				}
				else
				{
					num2 = 0;
				}
				this.currentCount = num2;
				break;
			}
			case TimedBufferChallenge.BufferCountMethods.UniqueGameCount:
				enumerable = (from _ in enumerable
					group _ by _.EventData.GetVar("gid")).Select(new Func<IGrouping<object, TimedBufferChallenge.TimedBufferEntry>, TimedBufferChallenge.TimedBufferEntry>(Enumerable.FirstOrDefault<TimedBufferChallenge.TimedBufferEntry>));
				this.currentCount = enumerable.Count<TimedBufferChallenge.TimedBufferEntry>();
				break;
			default:
				this.currentCount = enumerable.Count<TimedBufferChallenge.TimedBufferEntry>();
				break;
			}
			this.entryBuffer = enumerable.ToList<TimedBufferChallenge.TimedBufferEntry>();
			if (num != this.currentCount)
			{
				if (this.notificationCounts.Contains(this.currentCount))
				{
					base.Notify(this.currentCount, this.total);
				}
				base.Dirty = true;
			}
			return this.currentCount >= this.total;
		}

		// Token: 0x17000902 RID: 2306
		// (get) Token: 0x06015B2A RID: 88874 RVA: 0x006064A4 File Offset: 0x006046A4
		public override ChallengeProgress Progress
		{
			get
			{
				TimedBufferChallenge.ProgressModes progressMode = this.ProgressMode;
				if (progressMode != TimedBufferChallenge.ProgressModes.Count)
				{
					return base.Progress;
				}
				return new ChallengeProgress
				{
					Count = this.currentCount,
					Total = this.total
				};
			}
		}

		// Token: 0x06015B2B RID: 88875 RVA: 0x006064F0 File Offset: 0x006046F0
		public override Dictionary<string, object> Serialize()
		{
			Dictionary<string, object> dictionary = base.Serialize();
			dictionary["ccc"] = this.challengesToCount.Select((IChallenge _) => _.Serialize()).ToList<Dictionary<string, object>>();
			dictionary["t"] = this.total;
			dictionary["i"] = this.interval.ToString("F2", CultureInfo.InvariantCulture);
			dictionary["pm"] = (int)this.ProgressMode;
			if (this.notificationCounts.Count > 0)
			{
				dictionary["n"] = this.notificationCounts;
			}
			dictionary["pb"] = this.PersistBuffer;
			if (this.BufferCountMethod != TimedBufferChallenge.BufferCountMethods.Count)
			{
				dictionary["m"] = (int)this.BufferCountMethod;
			}
			if (this.entryBuffer.Count > 0 && this.PersistBuffer)
			{
				dictionary["b"] = this.entryBuffer.Select((TimedBufferChallenge.TimedBufferEntry _) => _.Serialize()).ToList<Dictionary<string, object>>();
			}
			return dictionary;
		}

		// Token: 0x06015B2C RID: 88876 RVA: 0x00606638 File Offset: 0x00604838
		protected override void DeserializeInternal(Dictionary<string, object> jsonDict)
		{
			base.DeserializeInternal(jsonDict);
			List<Dictionary<string, object>> list = OFPFHHLNHIC.NGILNLCIOJM<Dictionary<string, object>>("ccc", jsonDict);
			IEnumerable<IChallenge> enumerable = from _ in list.Select(new Func<Dictionary<string, object>, IChallenge>(ChallengeParser.FromJsonDict))
				where _ != null
				select _;
			this.challengesToCount = new List<IChallenge>(enumerable);
			this.total = OFPFHHLNHIC.KOFIKGFMMKD<int>("t", jsonDict);
			this.interval = OFPFHHLNHIC.EDMLGIIJCED("i", jsonDict);
			this.ProgressMode = (TimedBufferChallenge.ProgressModes)ChallengeParser.GetOptionalKey<int>("pm", jsonDict, 0);
			this.PersistBuffer = ChallengeParser.GetOptionalKey<bool>("pb", jsonDict, true);
			this.BufferCountMethod = (TimedBufferChallenge.BufferCountMethods)ChallengeParser.GetOptionalKey<int>("m", jsonDict, 0);
			if (jsonDict.ContainsKey("b"))
			{
				this.entryBuffer = OFPFHHLNHIC.NGILNLCIOJM<Dictionary<string, object>>("b", jsonDict).Select(new Func<Dictionary<string, object>, TimedBufferChallenge.TimedBufferEntry>(TimedBufferChallenge.TimedBufferEntry.DeserializeFromDict)).ToList<TimedBufferChallenge.TimedBufferEntry>();
			}
			if (jsonDict.ContainsKey("n"))
			{
				this.notificationCounts = OFPFHHLNHIC.NGILNLCIOJM<int>("n", jsonDict);
			}
		}

		// Token: 0x17000903 RID: 2307
		// (get) Token: 0x06015B2D RID: 88877 RVA: 0x0060676C File Offset: 0x0060496C
		public override ChallengeTypes ChallengeType
		{
			get
			{
				return ChallengeTypes.TimedBufferChallenge;
			}
		}

		// Token: 0x04003C6D RID: 15469
		public TimedBufferChallenge.BufferCountMethods BufferCountMethod;

		// Token: 0x04003C6E RID: 15470
		public TimedBufferChallenge.ProgressModes ProgressMode;

		// Token: 0x04003C6F RID: 15471
		protected static readonly Func<float> UnityTimeFunc = new Func<float>(Time.get_realtimeSinceStartup);

		// Token: 0x04003C70 RID: 15472
		private Func<float> getCurrentTimeFunc = new Func<float>(Time.get_realtimeSinceStartup);

		// Token: 0x04003C71 RID: 15473
		public const float IGNORE_INTERVAL = -1f;

		// Token: 0x04003C72 RID: 15474
		protected float interval;

		// Token: 0x04003C73 RID: 15475
		protected int total;

		// Token: 0x04003C74 RID: 15476
		private int currentCount;

		// Token: 0x04003C75 RID: 15477
		private List<TimedBufferChallenge.TimedBufferEntry> entryBuffer = new List<TimedBufferChallenge.TimedBufferEntry>();

		// Token: 0x04003C76 RID: 15478
		public bool PersistBuffer;

		// Token: 0x04003C77 RID: 15479
		protected List<IChallenge> challengesToCount = new List<IChallenge>();

		// Token: 0x04003C78 RID: 15480
		[HEFNGMICCHG]
		public List<int> notificationCounts = new List<int>();

		// Token: 0x04003C79 RID: 15481
		public const string CHALLENGES_COUNT_CHALLENGE_KEY = "ccc";

		// Token: 0x04003C7A RID: 15482
		public const string INTERVAL_KEY = "i";

		// Token: 0x04003C7B RID: 15483
		public const string COUNT_KEY = "t";

		// Token: 0x04003C7C RID: 15484
		public const string METHOD_KEY = "m";

		// Token: 0x04003C7D RID: 15485
		public const string BUFFER_KEY = "b";

		// Token: 0x04003C7E RID: 15486
		public const string PERSIST_BUFFER_KEY = "pb";

		// Token: 0x04003C7F RID: 15487
		public const string PROGRESS_MODE_KEY = "pm";

		// Token: 0x04003C80 RID: 15488
		public const string NOTIFICATIONS_KEY = "n";

		// Token: 0x02000B1B RID: 2843
		public enum BufferCountMethods
		{
			// Token: 0x04003C93 RID: 15507
			Count,
			// Token: 0x04003C94 RID: 15508
			UniqueToolCount,
			// Token: 0x04003C95 RID: 15509
			UniqueAttackerCount,
			// Token: 0x04003C96 RID: 15510
			UniqueDefenderCount,
			// Token: 0x04003C97 RID: 15511
			GroupedToolMaxCount,
			// Token: 0x04003C98 RID: 15512
			UniqueGameCount
		}

		// Token: 0x02000B1C RID: 2844
		public enum ProgressModes
		{
			// Token: 0x04003C9A RID: 15514
			Complete,
			// Token: 0x04003C9B RID: 15515
			Count
		}

		// Token: 0x02000B1D RID: 2845
		public struct TimedBufferEntry : OBFEFLHKHJJ, INMKELLJKBO, EBHIILNPABI
		{
			// Token: 0x06015B38 RID: 88888 RVA: 0x00606838 File Offset: 0x00604A38
			public void Deserialize(Dictionary<string, object> dict)
			{
				this.Time = OFPFHHLNHIC.EDMLGIIJCED("t", dict);
				this.EventData = ChallengeEvents.ChallengeEventData.Parse(OFPFHHLNHIC.KOFIKGFMMKD<Dictionary<string, object>>("e", dict));
			}

			// Token: 0x06015B39 RID: 88889 RVA: 0x00606864 File Offset: 0x00604A64
			public Dictionary<string, object> Serialize()
			{
				return new Dictionary<string, object>
				{
					{
						"t",
						this.Time.ToString("F2", CultureInfo.InvariantCulture)
					},
					{
						"e",
						this.EventData.Serialize()
					}
				};
			}

			// Token: 0x06015B3A RID: 88890 RVA: 0x006068B0 File Offset: 0x00604AB0
			public static TimedBufferChallenge.TimedBufferEntry DeserializeFromDict(Dictionary<string, object> dict)
			{
				TimedBufferChallenge.TimedBufferEntry timedBufferEntry = default(TimedBufferChallenge.TimedBufferEntry);
				timedBufferEntry.Deserialize(dict);
				return timedBufferEntry;
			}

			// Token: 0x04003C9C RID: 15516
			public float Time;

			// Token: 0x04003C9D RID: 15517
			public ChallengeEvents.IChallengeEventData EventData;

			// Token: 0x04003C9E RID: 15518
			private const string TIME_KEY = "t";

			// Token: 0x04003C9F RID: 15519
			private const string EVENT_DATA_KEY = "e";
		}
	}
}