using System;
using System.Collections.Generic;
using System.Globalization;
using CIG;
using CIG.Translation;
using SUISS.Core;
using SUISSEngine;
using UnityEngine;

[RequireComponent(typeof(Serializing))]
public sealed class DailyRewardsManager : SingletonMonobehaviour<DailyRewardsManager>, IHasNotification
{
	private bool IsEnabled
	{
		get
		{
			CIGTutorialManager instance = SingletonMonobehaviour<CIGTutorialManager>.Instance;
			return SingletonMonobehaviour<CIGGameState>.Instance.Level >= this._minimumLevel && instance.HasDeserialized && instance.IsFinished && SingletonMonobehaviour<PopupManager>.Instance.AreStatesInitialized;
		}
	}

	private bool HasStarted
	{
		get
		{
			return this._endTimeStampUTC != null && this._streak != null;
		}
	}

	private bool HasDayLapsed
	{
		get
		{
			return this._endTimeStampUTC == null || this._endTimeStampUTC.Value < DateTime.UtcNow;
		}
	}

	protected override void OnDestroy()
	{
		if (SingletonMonobehaviour<CIGGameState>.IsAvailable)
		{
			SingletonMonobehaviour<CIGGameState>.Instance.LevelledUp -= this.OnLevelledUp;
		}
		if (SingletonMonobehaviour<CIGTutorialManager>.IsAvailable)
		{
			CIGTutorialManager instance = SingletonMonobehaviour<CIGTutorialManager>.Instance;
			instance.TutorialFinishedEvent -= this.OnTutorialFinished;
			instance.HasDeserializedEvent -= this.OnTutorialManagerDeserialized;
		}
		if (SingletonMonobehaviour<CIGLocalNotificationManager>.IsAvailable)
		{
			SingletonMonobehaviour<CIGLocalNotificationManager>.Instance.NoLongerHasNotification(this);
		}
		if (SingletonMonobehaviour<WorldMap>.IsAvailable)
		{
			SingletonMonobehaviour<WorldMap>.Instance.VisibilityChangedEvent -= this.OnWorldMapVisibilityChanged;
		}
		if (SingletonMonobehaviour<PopupManager>.IsAvailable)
		{
			SingletonMonobehaviour<PopupManager>.Instance.StatesInitializedEvent -= this.OnPopupManagerStatesInitialized;
		}
		base.OnDestroy();
	}

	public void Collect(object source)
	{
		if (this.HasStarted && !this._hasCollected)
		{
			this._hasCollected = true;
			DailyReward dailyReward = this._streak.GetDailyReward(this._dayIndex);
			dailyReward.CollectReward(source);
			if (this._dayIndex == this._streak.TotalDays - 1)
			{
				SingletonMonobehaviour<CIGGameStats>.Instance.AddDailyBonusStreakCompleted();
			}
			this._serializing.Serialize();
		}
	}

	private void TryLapseDay()
	{
		if (this.IsEnabled)
		{
			if (this.HasDayLapsed)
			{
				if (this.HasStarted)
				{
					this.IncrementStreak();
				}
				this._endTimeStampUTC = new DateTime?(this.GetMidnightDateTime());
				this._serializing.Serialize();
			}
			if (this.HasStarted && !this._hasShownPopup && !this._hasCollected && !SingletonMonobehaviour<WorldMap>.Instance.IsVisible)
			{
				SingletonMonobehaviour<PopupManager>.Instance.RequestPopup<DailyRewardPopupState>(delegate(State state)
				{
					((DailyRewardPopupState)state).ShowStreak(this._streak, this._dayIndex);
				});
				this._hasShownPopup = true;
			}
		}
	}

	private DailyRewardsManager.Streak GetStreak(int index)
	{
		return this._streaks[index % this._streaks.Count];
	}

	private void IncrementStreak()
	{
		TimeSpan timeSpan = (this._endTimeStampUTC == null) ? TimeSpan.Zero : (DateTime.UtcNow - this._endTimeStampUTC.Value);
		if (this._hasCollected && timeSpan.TotalDays < 1.0)
		{
			this._dayIndex++;
			this._hasCollected = false;
			if (this._dayIndex >= this._streak.TotalDays)
			{
				this.ResetStreak();
			}
		}
		else
		{
			this.ResetStreak();
		}
	}

	private void ResetStreak()
	{
		this._dayIndex = 0;
		this._streakIndex = UnityEngine.Random.Range(0, this._streaks.Count);
		this._hasCollected = false;
		this._streak = this.GetStreak(this._streakIndex);
	}

	private void OnTutorialFinished()
	{
		SingletonMonobehaviour<CIGTutorialManager>.Instance.TutorialFinishedEvent -= this.OnTutorialFinished;
		this.TryLapseDay();
	}

	private void OnLevelledUp(int level)
	{
		this.TryLapseDay();
	}

	private void OnWorldMapVisibilityChanged(bool isVisible)
	{
		this.TryLapseDay();
	}

	private DateTime GetMidnightDateTime()
	{
		TimeSpan value = DateTime.UtcNow - DateTime.Now;
		return DateTime.Today.AddDays(1.0).Add(value);
	}

	private void OnTutorialManagerDeserialized()
	{
		CIGTutorialManager instance = SingletonMonobehaviour<CIGTutorialManager>.Instance;
		if (instance.IsFinished)
		{
			instance.TutorialFinishedEvent -= this.OnTutorialFinished;
		}
		instance.HasDeserializedEvent -= this.OnTutorialManagerDeserialized;
		this.TryLapseDay();
	}

	private void OnPopupManagerStatesInitialized()
	{
		SingletonMonobehaviour<PopupManager>.Instance.StatesInitializedEvent -= this.OnPopupManagerStatesInitialized;
		this.TryLapseDay();
	}

	PlannedNotification[] IHasNotification.GetNotifications()
	{
		List<PlannedNotification> list = new List<PlannedNotification>();
		if (this._endTimeStampUTC != null)
		{
			if (this._hasCollected)
			{
				list.Add(new PlannedNotification((int)(this._endTimeStampUTC.Value.AddDays(0.5) - DateTime.UtcNow).TotalSeconds, Localization.Key("notification_daily_reward1"), false));
				list.Add(new PlannedNotification((int)(this._endTimeStampUTC.Value.AddDays(0.75) - DateTime.UtcNow).TotalSeconds, Localization.Key("notification_daily_reward2"), false));
			}
			else
			{
				int num = (int)(this._endTimeStampUTC.Value.AddDays(-0.5) - DateTime.UtcNow).TotalSeconds;
				int num2 = (int)(this._endTimeStampUTC.Value.AddDays(-0.25) - DateTime.UtcNow).TotalSeconds;
				if (num > 0)
				{
					list.Add(new PlannedNotification(num, Localization.Key("notification_daily_reward1"), false));
				}
				if (num2 > 0)
				{
					list.Add(new PlannedNotification(num2, Localization.Key("notification_daily_reward2"), false));
				}
			}
		}
		return list.ToArray();
	}

	private void OnSerialize(Dictionary<string, object> values)
	{
		DateTime? endTimeStampUTC = this._endTimeStampUTC;
		if (endTimeStampUTC != null)
		{
			values["endTimeStampTicks"] = this._endTimeStampUTC.Value.Ticks;
		}
		else if (values.ContainsKey("endTimeStampTicks"))
		{
			values.Remove("endTimeStampTicks");
		}
		values["streakIndex"] = this._streakIndex;
		values["dayIndex"] = this._dayIndex;
		values["hasCollected"] = this._hasCollected;
	}

	private void OnDeserialize(Dictionary<string, object> values)
	{
		if (values.ContainsKey("endTimeStampTicks"))
		{
			long ticks = (long)values["endTimeStampTicks"];
			this._endTimeStampUTC = new DateTime?(new DateTime(ticks));
		}
		else
		{
			this._endTimeStampUTC = null;
		}
		this._streakIndex = values.GetInt("streakIndex", UnityEngine.Random.Range(0, this._streaks.Count));
		this._dayIndex = values.GetInt("dayIndex", 0);
		this._hasCollected = values.GetBoolean("hasCollected", false);
	}

	private void OnDeserialized()
	{
		if (this._streakIndex == -1)
		{
			this._streakIndex = UnityEngine.Random.Range(0, this._streaks.Count);
		}
		SingletonMonobehaviour<CIGLocalNotificationManager>.Instance.HasNotification(this);
		CIGTutorialManager instance = SingletonMonobehaviour<CIGTutorialManager>.Instance;
		SingletonMonobehaviour<CIGGameState>.Instance.LevelledUp += this.OnLevelledUp;
		instance.TutorialFinishedEvent += this.OnTutorialFinished;
		SingletonMonobehaviour<WorldMap>.Instance.VisibilityChangedEvent += this.OnWorldMapVisibilityChanged;
		this._streak = this.GetStreak(this._streakIndex);
		if (instance.HasDeserialized)
		{
			this.OnTutorialManagerDeserialized();
		}
		else
		{
			instance.HasDeserializedEvent += this.OnTutorialManagerDeserialized;
		}
		PopupManager instance2 = SingletonMonobehaviour<PopupManager>.Instance;
		if (instance2.AreStatesInitialized)
		{
			this.OnPopupManagerStatesInitialized();
		}
		else
		{
			instance2.StatesInitializedEvent += this.OnPopupManagerStatesInitialized;
		}
	}

	[SerializeField]
	private Serializing _serializing;

	[SerializeField]
	private List<DailyRewardsManager.Streak> _streaks;

	[SerializeField]
	private int _minimumLevel;

	private int _streakIndex = -1;

	private int _dayIndex;

	private bool _hasCollected;

	private bool _hasShownPopup;

	private DailyRewardsManager.Streak _streak;

	private DateTime? _endTimeStampUTC;

	private const string EndTimeStampTicksKey = "endTimeStampTicks";

	private const string StreakIndexKey = "streakIndex";

	private const string DayIndexKey = "dayIndex";

	private const string HasCollectedKey = "hasCollected";

	[Serializable]
	public class Streak
	{
		public string Identifier
		{
			get
			{
				return this._identifier;
			}
		}

		public DailyReward GetDailyReward(int dayIndex)
		{
			return this._dailyRewards[dayIndex];
		}

		public int TotalDays
		{
			get
			{
				return this._dailyRewards.Count;
			}
		}

		[SerializeField]
		private string _identifier;

		[SerializeField]
		private List<DailyReward> _dailyRewards;
	}
}