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

namespace CIG
{
	public sealed class AdProviderPool : SingletonMonobehaviour<AdProviderPool>
	{
		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event AdProviderPool.AdProviderAvailabilityChangedEventHandler AdAvailabilityChangedEvent;

		private void FireAdAvailabilityChangedEvent(AdProviderType providerType)
		{
			if (this.AdAvailabilityChangedEvent != null)
			{
				this.AdAvailabilityChangedEvent(providerType);
			}
		}

		protected override void Awake()
		{
			base.Awake();
			if (this._isValidNewInstance)
			{
				this._adProviders[AdProviderType.AdColony] = Singleton<AdColonyVideoAdsProvider>.Instance;
				this._adProviders[AdProviderType.Admob] = Singleton<AdMobInterstitialAdsProvider>.Instance;
				this._adProviders[AdProviderType.Chartboost] = Singleton<ChartboostVideoAdsProvider>.Instance;
				foreach (KeyValuePair<AdProviderType, IAdProvider> keyValuePair in this._adProviders)
				{
					keyValuePair.Value.AvailabilityChangedEvent += this.OnAvailabilityChanged;
				}
			}
		}

		private void Start()
		{
			if (this._adProviders.Count > 0)
			{
				CIGWebService instance = SingletonMonobehaviour<CIGWebService>.Instance;
				if (instance.HasPulled)
				{
					this.OnWebServicesPullRequestCompleted();
				}
				else
				{
					instance.PullRequestCompleted += this.OnWebServicesPullRequestCompleted;
				}
			}
		}

		protected override void OnDestroy()
		{
			if (SingletonMonobehaviour<CIGWebService>.IsAvailable)
			{
				SingletonMonobehaviour<CIGWebService>.Instance.PullRequestCompleted -= this.OnWebServicesPullRequestCompleted;
			}
			foreach (KeyValuePair<AdProviderType, IAdProvider> keyValuePair in this._adProviders)
			{
				keyValuePair.Value.AvailabilityChangedEvent -= this.OnAvailabilityChanged;
			}
			this.CancelInvoke(new Action(this.StartCaching));
			base.OnDestroy();
		}

		public bool AdProviderExists(AdProviderType providerType)
		{
			return this._adProviders.ContainsKey(providerType);
		}

		public bool IsReady(AdProviderType providerType)
		{
			if (this._watchingAd)
			{
				return false;
			}
			IAdProvider adProvider = this.GetAdProvider(providerType);
			return adProvider != null && adProvider.IsReady;
		}

		public bool ShowAd(AdProviderType providerType, Action<bool, bool> callback)
		{
			IAdProvider adProvider = this.GetAdProvider(providerType);
			if (!this._watchingAd && adProvider != null && adProvider.IsReady)
			{
				this._watchingAd = true;
				SingletonMonobehaviour<CIGSessionRestarter>.Instance.RegisterCriticalProcess(this);
				if (adProvider.ShowAd(delegate(bool success, bool clicked)
				{
					this.OnAdWatched(adProvider, success, clicked, callback);
				}))
				{
					return true;
				}
				SingletonMonobehaviour<CIGSessionRestarter>.Instance.UnregisterCriticalProcess(this);
				this._watchingAd = false;
				UnityEngine.Debug.LogErrorFormat("Failed to ShowAd for '{0}'", new object[]
				{
					providerType
				});
			}
			return false;
		}

		private IAdProvider GetAdProvider(AdProviderType providerType)
		{
			IAdProvider result;
			if (this._adProviders.TryGetValue(providerType, out result))
			{
				return result;
			}
			UnityEngine.Debug.LogWarningFormat("Missing AdProvider '{0}'", new object[]
			{
				providerType
			});
			return null;
		}

		private void OnWebServicesPullRequestCompleted()
		{
			SingletonMonobehaviour<CIGWebService>.Instance.PullRequestCompleted -= this.OnWebServicesPullRequestCompleted;
			foreach (KeyValuePair<AdProviderType, IAdProvider> keyValuePair in this._adProviders)
			{
				this._adProvidersRequiringToLoadAnAd.Add(keyValuePair.Value);
			}
			this.StartCaching();
		}

		private void StartCaching()
		{
			if (this._adProvidersRequiringToLoadAnAd.Count == 0)
			{
				return;
			}
			IAdProvider adProvider = this._adProvidersRequiringToLoadAnAd[0];
			this._adProvidersRequiringToLoadAnAd.RemoveAt(0);
			adProvider.StartCaching();
			if (this._adProvidersRequiringToLoadAnAd.Count > 0)
			{
				this.Invoke(new Action(this.StartCaching), 5f, false);
			}
		}

		private void OnAvailabilityChanged(IAdProvider adProvider)
		{
			this.FireAdAvailabilityChangedEvent(adProvider.AdProviderType);
		}

		private void OnAdWatched(IAdProvider adProvider, bool success, bool clicked, Action<bool, bool> callback)
		{
			if (success)
			{
				CIGGameStats instance = SingletonMonobehaviour<CIGGameStats>.Instance;
				AdType adType = adProvider.AdType;
				if (adType != AdType.Video)
				{
					if (adType != AdType.Interstitial)
					{
						UnityEngine.Debug.LogErrorFormat("Failed to count stats for AdType '{0}'", new object[]
						{
							adProvider.AdType
						});
					}
					else
					{
						instance.AddInterstitialWatched();
						if (clicked)
						{
							instance.AddInterstitialClicked();
						}
					}
				}
				else
				{
					instance.AddVideoWatched();
					if (clicked)
					{
						instance.AddVideoClicked();
					}
				}
			}
			SingletonMonobehaviour<CIGGameStats>.Instance.AddScreenViewed("none");
			this._watchingAd = false;
			SingletonMonobehaviour<CIGSessionRestarter>.Instance.UnregisterCriticalProcess(this);
			if (callback != null)
			{
				callback(success, clicked);
			}
		}

		public const float TimeBetweenAdLoadAttemptsInSeconds = 5f;

		private Dictionary<AdProviderType, IAdProvider> _adProviders = new Dictionary<AdProviderType, IAdProvider>();

		private List<IAdProvider> _adProvidersRequiringToLoadAnAd = new List<IAdProvider>();

		private bool _watchingAd;

		public delegate void AdProviderAvailabilityChangedEventHandler(AdProviderType providerType);
	}
}