using System;
using System.Collections;
using System.Collections.Generic;
using CIG.Extensions;
using SUISS.Core;
using SUISS.Storage;
using SUISSEngine;
using UnityEngine;

public class IAPSaleScheduler : MonoBehaviour
{
	private void Start()
	{
		IAPPackDealManager instance = Singleton<IAPPackDealManager>.Instance;
		if (instance != null)
		{
			instance.DealStartedEvent += this.OnSaleStarted;
			instance.DealEndedEvent += this.OnSaleEnded;
		}
		this.CheckNextSaleInSequence();
	}

	private void OnDestroy()
	{
		if (SingletonMonobehaviour<CIGTutorialManager>.IsAvailable)
		{
			SingletonMonobehaviour<CIGTutorialManager>.Instance.TutorialFinishedEvent -= this.OnTutorialFinished;
		}
		if (Singleton<IAPPackDealManager>.IsAvailable)
		{
			IAPPackDealManager instance = Singleton<IAPPackDealManager>.Instance;
			instance.DealStartedEvent -= this.OnSaleStarted;
			instance.DealEndedEvent -= this.OnSaleEnded;
		}
		this.CancelInvoke(new Action(this.StartNextSale));
	}

	private void OnSaleStarted(string packName, DateTime start, TimeSpan duration)
	{
		if (IAPSaleScheduler.StateSaleMapping.ContainsKey(this.CurrentState) && packName == IAPSaleScheduler.StateSaleMapping[this.CurrentState])
		{
			this.OnDealChanged();
		}
	}

	private void OnSaleEnded(string packName)
	{
		if (IAPSaleScheduler.StateSaleMapping.ContainsKey(this.CurrentState) && packName == IAPSaleScheduler.StateSaleMapping[this.CurrentState])
		{
			this.OnDealChanged();
		}
	}

	private void OnDealChanged()
	{
		IAPPackDealManager instance = Singleton<IAPPackDealManager>.Instance;
		IAPPackDealManager.PackDeal packDeal = instance.FindFirstActive(IAPSaleScheduler.StateSaleMapping[this.CurrentState]);
		if (packDeal == null)
		{
			this.StorageDict["nextpack_firststarttime"] = DateTime.UtcNow.ToBinary();
		}
		else
		{
			DateTime dealEnds = packDeal.DealEnds;
			this.StorageDict["nextpack_firststarttime"] = dealEnds.ToBinary();
		}
	}

	private void StartSale(IAPSaleScheduler.State sale)
	{
		if (sale == IAPSaleScheduler.State.End || !SingletonMonobehaviour<CIGWebService>.Instance.UseIAPDeal)
		{
			return;
		}
		if (IAPSaleScheduler.StateSaleMapping.ContainsKey(sale))
		{
			string saleName = IAPSaleScheduler.StateSaleMapping[sale];
			base.StartCoroutine(this.StartSaleWhenProductAvailable(saleName, new TimeSpan(1, 0, 0)));
		}
		else
		{
			UnityEngine.Debug.LogErrorFormat("Sale state '{0}'has no associated sale name", new object[]
			{
				sale
			});
		}
	}

	private IEnumerator StartSaleWhenProductAvailable(string saleName, TimeSpan timespan)
	{
		while (!IAPPackManager.StoreHasIAPPack(saleName))
		{
			yield return new WaitForSeconds(2f);
		}
		Singleton<IAPPackDealManager>.Instance.StartDeal(saleName, timespan);
		yield break;
	}

	private void CheckNextSaleInSequence()
	{
		if (this.StorageDict.ContainsKey("nextpack_firststarttime"))
		{
			DateTime t = DateTime.FromBinary((long)this.StorageDict["nextpack_firststarttime"]);
			if (DateTime.UtcNow > t)
			{
				this.StartNextSale();
			}
		}
		else
		{
			CIGTutorialManager instance = SingletonMonobehaviour<CIGTutorialManager>.Instance;
			if (instance != null)
			{
				base.StartCoroutine(this.CheckTutorialFinishedRoutine(instance));
			}
		}
	}

	private IEnumerator CheckTutorialFinishedRoutine(CIGTutorialManager tm)
	{
		while (tm.state == CIGTutorialState.Initial)
		{
			yield return null;
		}
		if (tm.IsFinished)
		{
			this.OnTutorialFinished();
		}
		else
		{
			SingletonMonobehaviour<CIGTutorialManager>.Instance.TutorialFinishedEvent += this.OnTutorialFinished;
		}
		yield break;
	}

	private void OnTutorialFinished()
	{
		SingletonMonobehaviour<CIGTutorialManager>.Instance.TutorialFinishedEvent -= this.OnTutorialFinished;
		this.Invoke(new Action(this.StartNextSale), 120f, true);
	}

	private void StartNextSale()
	{
		if (SingletonMonobehaviour<CIGWebService>.Instance.UseIAPDeal)
		{
			this.MoveToNextState();
			this.StartSale(this.CurrentState);
		}
	}

	private void MoveToNextState()
	{
		this.CurrentState = this.NextState;
		this.NextState = this.CurrentState + 1;
	}

	private Dictionary<string, object> StorageDict
	{
		get
		{
			return Storage.Get(StorageLifecycle.Game).GetDictionary("iap_sale_scheduler");
		}
	}

	private IAPSaleScheduler.State CurrentState
	{
		get
		{
			if (this.StorageDict.ContainsKey("state"))
			{
				int value = (int)this.StorageDict["state"];
				return (IAPSaleScheduler.State)Mathf.Clamp(value, 0, 4);
			}
			return IAPSaleScheduler.State.WaitingForTutorial;
		}
		set
		{
			IAPSaleScheduler.State state = (IAPSaleScheduler.State)Mathf.Clamp((int)value, 0, 4);
			this.StorageDict["state"] = (int)state;
		}
	}

	private IAPSaleScheduler.State NextState
	{
		get
		{
			if (this.StorageDict.ContainsKey("next_state"))
			{
				int value = (int)this.StorageDict["next_state"];
				return (IAPSaleScheduler.State)Mathf.Clamp(value, 1, 4);
			}
			return IAPSaleScheduler.State.FourPack;
		}
		set
		{
			IAPSaleScheduler.State state = (IAPSaleScheduler.State)Mathf.Clamp((int)value, 1, 4);
			this.StorageDict["next_state"] = (int)state;
		}
	}

	private static readonly Dictionary<IAPSaleScheduler.State, string> StateSaleMapping = new Dictionary<IAPSaleScheduler.State, string>
	{
		{
			IAPSaleScheduler.State.FourPack,
			"pack_4x"
		},
		{
			IAPSaleScheduler.State.Level5Pack,
			"pack_5_levels"
		},
		{
			IAPSaleScheduler.State.TimeBoost12Pack,
			"pack_timeboost_12"
		}
	};

	private const float TutorialCompletedWaitTimeInSeconds = 120f;

	private const string StorageKey = "iap_sale_scheduler";

	private const string NextPackFirstStartTimestampKey = "nextpack_firststarttime";

	private const string StateKey = "state";

	private const string NextStateKey = "next_state";

	private enum State
	{
		WaitingForTutorial,
		FourPack,
		Level5Pack,
		TimeBoost12Pack,
		End
	}
}