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

namespace RecRoom.Challenges
{
	// Token: 0x02000B18 RID: 2840
	[HMFEEFDKPLO]
	public class ChallengeCountChallenge : Challenge
	{
		// Token: 0x06015B0F RID: 88847 RVA: 0x00605BEC File Offset: 0x00603DEC
		public ChallengeCountChallenge()
		{
		}

		// Token: 0x06015B10 RID: 88848 RVA: 0x00605C18 File Offset: 0x00603E18
		public ChallengeCountChallenge(IChallenge challengeToCount, int count)
		{
			this.challengesToCount.Clear();
			this.challengesToCount.Add(challengeToCount);
			this.requiredCount = count;
			this.CurrentCount = 0;
			this.Initialize();
		}

		// Token: 0x170008FD RID: 2301
		// (get) Token: 0x06015B11 RID: 88849 RVA: 0x00605C78 File Offset: 0x00603E78
		public override ChallengeProgress Progress
		{
			get
			{
				return new ChallengeProgress
				{
					Count = this.CurrentCount,
					Total = this.RequiredCount
				};
			}
		}

		// Token: 0x170008FE RID: 2302
		// (get) Token: 0x06015B12 RID: 88850 RVA: 0x00605CA8 File Offset: 0x00603EA8
		// (set) Token: 0x06015B13 RID: 88851 RVA: 0x00605CB0 File Offset: 0x00603EB0
		public int CurrentCount { get; private set; }

		// Token: 0x170008FF RID: 2303
		// (get) Token: 0x06015B14 RID: 88852 RVA: 0x00605CBC File Offset: 0x00603EBC
		public int RequiredCount
		{
			get
			{
				return this.requiredCount;
			}
		}

		// Token: 0x06015B15 RID: 88853 RVA: 0x00605CC4 File Offset: 0x00603EC4
		protected override void Initialize()
		{
			this.WithConditions.Clear();
			base.Initialize();
			this.lastUpdateCount = this.CurrentCount;
			this.nextUpdateTime = Time.realtimeSinceStartup + 60f;
			foreach (IChallenge challenge2 in this.challengesToCount)
			{
				IChallenge c = challenge2;
				c.SkipSerialization = true;
				c.ChallengeCompleteEvent += delegate(IChallenge challenge, ChallengeEvents.IChallengeEventData data)
				{
					this.CurrentCount++;
					c.Reset();
					this.Dirty = true;
					this.UpdateServer |= this.ShouldUpdateServer();
				};
				this.WithConditions.Add(c);
			}
		}

		// Token: 0x06015B16 RID: 88854 RVA: 0x00605D90 File Offset: 0x00603F90
		private bool ShouldUpdateServer()
		{
			if (Time.realtimeSinceStartup > this.nextUpdateTime || Mathf.Abs(this.CurrentCount - this.lastUpdateCount) > Mathf.FloorToInt((float)this.RequiredCount * 0.1f))
			{
				this.nextUpdateTime = this.GetNextUpdateTime();
				return true;
			}
			return false;
		}

		// Token: 0x06015B17 RID: 88855 RVA: 0x00605DE8 File Offset: 0x00603FE8
		private float GetNextUpdateTime()
		{
			return Time.realtimeSinceStartup + this.updateInterval;
		}

		// Token: 0x06015B18 RID: 88856 RVA: 0x00605DF8 File Offset: 0x00603FF8
		protected override bool EvaluateInternal(ChallengeEvents.IChallengeEventData challengeEventData)
		{
			int currentCount = this.CurrentCount;
			base.EvaluateInternal(challengeEventData);
			if (this.CurrentCount != currentCount && this.notificationCounts.Contains(this.CurrentCount))
			{
				base.Notify(this.CurrentCount, this.RequiredCount);
			}
			return this.CurrentCount >= this.RequiredCount;
		}

		// Token: 0x06015B19 RID: 88857 RVA: 0x00605E5C File Offset: 0x0060405C
		public override void Reset()
		{
			this.CurrentCount = 0;
			base.Reset();
		}

		// Token: 0x06015B1A RID: 88858 RVA: 0x00605E6C File Offset: 0x0060406C
		public override Dictionary<string, object> Serialize()
		{
			Dictionary<string, object> dictionary = base.Serialize();
			if (this.challengesToCount.Count > 0)
			{
				List<Dictionary<string, object>> list = this.challengesToCount.Select((IChallenge _) => _.Serialize()).ToList<Dictionary<string, object>>();
				dictionary["ctc"] = list;
			}
			dictionary["t"] = this.RequiredCount;
			ChallengeBase.SerializeOptionalField<int>("cc", this.CurrentCount, 0, dictionary);
			return dictionary;
		}

		// Token: 0x06015B1B RID: 88859 RVA: 0x00605EF4 File Offset: 0x006040F4
		protected override void DeserializeInternal(Dictionary<string, object> jsonDict)
		{
			base.DeserializeInternal(jsonDict);
			this.CurrentCount = ChallengeParser.GetOptionalKey<int>("cc", jsonDict, 0);
			this.requiredCount = ChallengeParser.GetOptionalKey<int>("t", jsonDict, 1);
			this.challengesToCount.Clear();
			if (jsonDict.ContainsKey("ctc"))
			{
				List<Dictionary<string, object>> list = OFPFHHLNHIC.NGILNLCIOJM<Dictionary<string, object>>("ctc", 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);
				return;
			}
		}

		// Token: 0x17000900 RID: 2304
		// (get) Token: 0x06015B1C RID: 88860 RVA: 0x00605FA8 File Offset: 0x006041A8
		public override ChallengeTypes ChallengeType
		{
			get
			{
				return ChallengeTypes.ChallengeCountChallenge;
			}
		}

		// Token: 0x04003C5D RID: 15453
		[DHLJECKLFCF]
		protected List<IChallenge> challengesToCount = new List<IChallenge>();

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

		// Token: 0x04003C60 RID: 15456
		[SerializeField]
		private int requiredCount;

		// Token: 0x04003C61 RID: 15457
		private int lastUpdateCount;

		// Token: 0x04003C62 RID: 15458
		private float nextUpdateTime;

		// Token: 0x04003C63 RID: 15459
		private float updateInterval = 60f;

		// Token: 0x04003C64 RID: 15460
		public const string ARITHMETIC_CHALLENGE_KEY = "acc";

		// Token: 0x04003C65 RID: 15461
		public const string CHALLENGES_COUNT_CHALLENGE_KEY = "ctc";

		// Token: 0x04003C66 RID: 15462
		public const string CURRENT_COUNT_KEY = "cc";

		// Token: 0x04003C67 RID: 15463
		public const string COUNT_KEY = "t";
	}
}