using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using CIG3.ExtensionMethods;
using SUISS.Cloud;
using SUISS.Core;
using SUISS.Storage;
using SUISSEngine;
using UnityEngine;
using UnityEngine.SceneManagement;

public sealed class CIGIslandsManager : SingletonMonobehaviour<CIGIslandsManager>
{
	//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event CIGIslandsManager.IslandChangedEventHandler IslandChangedEvent;

	private void FireIslandChangedEvent(Island island, bool isVisiting)
	{
		if (this.IslandChangedEvent != null)
		{
			this.IslandChangedEvent(island, isVisiting);
		}
	}

	//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event CIGIslandsManager.VisitingStartedEventHandler VisitingStartedEvent;

	private void FireVisitingStartedEvent()
	{
		if (this.VisitingStartedEvent != null)
		{
			this.VisitingStartedEvent();
		}
	}

	//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event CIGIslandsManager.VisitingEndedEventHandler VisitingStoppedEvent;

	private void FireVisitingEndedEvent()
	{
		if (this.VisitingStoppedEvent != null)
		{
			this.VisitingStoppedEvent();
		}
	}

	private void Start()
	{
		SingletonMonobehaviour<CIGVisitingIslandsManager>.Instance.DataDownloadedEvent += this.OnVisitingIslandDataDownloaded;
		SingletonMonobehaviour<CIGWebService>.Instance.PullRequestCompleted += this.OnWebServicePullRequestCompleted;
		Singleton<CIGSettings>.Instance.LanguageChangedEvent += this.OnLanguageChanged;
		this._storage = Storage.Get(StorageLifecycle.Game).GetDictionary("WorldMapController");
		this.SkipWorldMapOnLoad = this._storage.GetBoolean("SkipWorldMapOnLoad", false);
		if (this.SkipWorldMapOnLoad)
		{
			this.LoadIsland(Island.GoneGreenlands, false);
		}
		else
		{
			SingletonMonobehaviour<CinematicEffect>.Instance.ShowInstant();
			SingletonMonobehaviour<WorldMap>.Instance.ShowInstant();
			SingletonMonobehaviour<CinematicEffect>.Instance.HideAnimated();
		}
	}

	protected override void OnDestroy()
	{
		if (SingletonMonobehaviour<CIGVisitingIslandsManager>.IsAvailable)
		{
			SingletonMonobehaviour<CIGVisitingIslandsManager>.Instance.DataDownloadedEvent -= this.OnVisitingIslandDataDownloaded;
		}
		if (SingletonMonobehaviour<CIGWebService>.IsAvailable)
		{
			SingletonMonobehaviour<CIGWebService>.Instance.PullRequestCompleted -= this.OnWebServicePullRequestCompleted;
		}
		if (Singleton<CIGSettings>.IsAvailable)
		{
			Singleton<CIGSettings>.Instance.LanguageChangedEvent -= this.OnLanguageChanged;
		}
		base.OnDestroy();
	}

	public void LoadIsland(Island island, bool animateIn)
	{
		if (this.IsLoading)
		{
			return;
		}
		if (this.IsVisiting)
		{
			base.StartCoroutine(this.LoadVisitingIslandRoutine(island));
		}
		else
		{
			base.StartCoroutine(this.LoadIslandRoutine(island, animateIn));
		}
	}

	public void StartVisiting(LeaderboardEntry player)
	{
		if (!this.IsVisiting && !this.IsLoading)
		{
			this._visitingPlayer = player;
			base.StartCoroutine(this.StartVisitingRoutine());
		}
	}

	public void StopVisiting()
	{
		if (this.IsVisiting)
		{
			this._visitingPlayer = null;
			base.StartCoroutine(this.StopVisitingRoutine());
		}
	}

	public bool IsUnlocked(Island island)
	{
		bool result;
		if (this.IsVisiting)
		{
			bool flag = SingletonMonobehaviour<CIGVisitingIslandsManager>.Instance.VisitingIslandDataAvaible(island, this._visitingPlayer.InstallUuid);
			bool flag2 = SingletonMonobehaviour<CIGVisitingIslandsManager>.Instance.IsUnlocked(island, this._visitingPlayer.InstallUuid);
			result = (flag && flag2);
		}
		else
		{
			result = SingletonMonobehaviour<CIGGameState>.Instance.IsIslandUnlocked(island);
		}
		return result;
	}

	public Island CurrentIsland
	{
		get
		{
			return this._currentIsland;
		}
	}

	public LeaderboardEntry VisitingPlayer
	{
		get
		{
			return this._visitingPlayer;
		}
	}

	public bool IsLoading { get; private set; }

	public bool IsVisiting
	{
		get
		{
			return this._visitingPlayer != null;
		}
	}

	public bool SkipWorldMapOnLoad { get; private set; }

	private IEnumerator LoadIslandRoutine(Island newIsland, bool animateIn)
	{
		if (newIsland.IsValid())
		{
			this.IsLoading = true;
			if (animateIn)
			{
				yield return SingletonMonobehaviour<CinematicEffect>.Instance.ShowAnimated();
			}
			else
			{
				SingletonMonobehaviour<CinematicEffect>.Instance.ShowInstant();
			}
			if (newIsland != this._currentIsland)
			{
				if (this._currentIsland.IsValid())
				{
					yield return SceneManager.UnloadSceneAsync(this._currentIsland.GetSceneName());
				}
				this._currentIsland = newIsland;
				yield return SceneManager.LoadSceneAsync(newIsland.GetSceneName(), LoadSceneMode.Additive);
				yield return new WaitForEndOfFrame();
				yield return new WaitForEndOfFrame();
				yield return new WaitForEndOfFrame();
			}
			this.IsLoading = false;
			this.FireIslandChangedEvent(this._currentIsland, this.IsVisiting);
			yield return SingletonMonobehaviour<CinematicEffect>.Instance.HideAnimated();
		}
		yield break;
	}

	private IEnumerator LoadVisitingIslandRoutine(Island visitingIsland)
	{
		if (SingletonMonobehaviour<CIGVisitingIslandsManager>.Instance.LoadVisitingIslandData(visitingIsland, this._visitingPlayer.InstallUuid))
		{
			this.IsLoading = true;
			yield return SingletonMonobehaviour<CinematicEffect>.Instance.ShowAnimated();
			if (SceneManager.GetSceneByName("VisitingIsland").isLoaded)
			{
				yield return SceneManager.UnloadSceneAsync("VisitingIsland");
			}
			this._currentIsland = visitingIsland;
			yield return SceneManager.LoadSceneAsync("VisitingIsland", LoadSceneMode.Additive);
			yield return new WaitForEndOfFrame();
			yield return new WaitForEndOfFrame();
			yield return new WaitForEndOfFrame();
			this.IsLoading = false;
			this.FireIslandChangedEvent(this._currentIsland, this.IsVisiting);
			yield return SingletonMonobehaviour<CinematicEffect>.Instance.HideAnimated();
		}
		else
		{
			UnityEngine.Debug.LogError("Visiting Island data not loaded!");
		}
		yield break;
	}

	private IEnumerator StartVisitingRoutine()
	{
		this.IsLoading = true;
		yield return SingletonMonobehaviour<CinematicEffect>.Instance.ShowAnimated();
		if (this._currentIsland.IsValid())
		{
			yield return SceneManager.UnloadSceneAsync(this._currentIsland.GetSceneName());
			this._currentIsland = Island.None;
		}
		this.FireVisitingStartedEvent();
		yield return SingletonMonobehaviour<CinematicEffect>.Instance.HideAnimated();
		this.IsLoading = false;
		yield break;
	}

	private IEnumerator StopVisitingRoutine()
	{
		this.IsLoading = true;
		yield return SingletonMonobehaviour<CinematicEffect>.Instance.ShowAnimated();
		if (SceneManager.GetSceneByName("VisitingIsland").isLoaded)
		{
			yield return SceneManager.UnloadSceneAsync("VisitingIsland");
		}
		this._currentIsland = Island.None;
		this.FireVisitingEndedEvent();
		yield return SingletonMonobehaviour<CinematicEffect>.Instance.HideAnimated();
		this.IsLoading = false;
		yield break;
	}

	private void OnVisitingIslandDataDownloaded(Island island, string uuid)
	{
		SingletonMonobehaviour<WorldMap>.Instance.Refresh();
	}

	private void OnWebServicePullRequestCompleted()
	{
		this._storage["SkipWorldMapOnLoad"] = SingletonMonobehaviour<CIGWebService>.Instance.Properties.GetBoolean("SkipWorldMapOnLoad", false);
	}

	private void OnLanguageChanged()
	{
		SingletonMonobehaviour<WorldMap>.Instance.Refresh();
	}

	private const string StorageKey = "WorldMapController";

	private const string SkipWorldMapOnLoadKey = "SkipWorldMapOnLoad";

	private const StorageLifecycle storageLifecycle = StorageLifecycle.Game;

	private const string VisitingIslandSceneName = "VisitingIsland";

	private Island _currentIsland = Island.None;

	private LeaderboardEntry _visitingPlayer;

	private Dictionary<string, object> _storage;

	public delegate void IslandChangedEventHandler(Island island, bool isVisiting);

	public delegate void VisitingStartedEventHandler();

	public delegate void VisitingEndedEventHandler();
}