using System.Collections;
using System.Collections.Generic;
using I2.Loc;
using TMPro;
using UnityEngine;

public class LevelInteractor : InteractorBase
{
	public string sceneName;

	public string displayName;

	private LevelSelectManager levelSelectManager;

	private LevelProgressManager levelProgressManager;

	private LevelData myLevelData;

	[Header("Unlock Requirements")]
	[SerializeField]
	private bool unlockedInDemo;

	public LevelInteractor requirementThisLevelMustBeBeaten;

	[SerializeField]
	private string tooltipThisLevelMustBeBeaten = "Beat <lvlname> to unlock this level.";

	[Header("Setup")]
	[SerializeField]
	private GameObject focusPanel;

	[Header("Setup")]
	[SerializeField]
	private GameObject cantBePlayedPanel;

	[SerializeField]
	private TextMeshProUGUI cantBePlayedCue;

	[SerializeField]
	private GameObject lockedLevelVisuals;

	[SerializeField]
	private GameObject unlockedLevelVisuals;

	[SerializeField]
	private GameObject beatenLevelVisuals;

	[Header("Quests")]
	[SerializeField]
	private Transform rewardBuildingsParent;

	[SerializeField]
	private TMP_Text questsComplete;

	[SerializeField]
	private Color allQuestComplete;

	[SerializeField]
	private Color notAllQuestComplete;

	[SerializeField]
	private List<Quest> quests = new List<Quest>();

	[Header("Loadout")]
	public List<Equippable> fixedLoadout = new List<Equippable>();

	public static LevelInteractor lastActivatedLevelInteractor;

	private string tooltipGetTheFullGame => LocalizationManager.GetTranslation("Menu/Get Full Game");

	public List<Quest> Quests => quests;

	public bool HasFixedLoadout => fixedLoadout.Count > 0;

	public bool CanBePlayed
	{
		get
		{
			if (DebugController.SaveLoadModeToUse == DebugController.SaveLoadMode.LoadMaxedOutSaveFileOnStartup)
			{
				return true;
			}
			if (requirementThisLevelMustBeBeaten != null && !requirementThisLevelMustBeBeaten.Beaten)
			{
				return false;
			}
			return true;
		}
	}

	public string CanNotBePlayedReason
	{
		get
		{
			if ((bool)requirementThisLevelMustBeBeaten && !requirementThisLevelMustBeBeaten.Beaten)
			{
				return tooltipThisLevelMustBeBeaten.Replace("<lvlname>", requirementThisLevelMustBeBeaten.displayName);
			}
			return "";
		}
	}

	public bool Beaten
	{
		get
		{
			if (DebugController.SaveLoadModeToUse == DebugController.SaveLoadMode.LoadMaxedOutSaveFileOnStartup)
			{
				return true;
			}
			if (myLevelData == null)
			{
				levelProgressManager = LevelProgressManager.instance;
				myLevelData = levelProgressManager.GetLevelDataForScene(sceneName);
			}
			return myLevelData.beatenBest;
		}
	}

	public void UpdateVisualsOnStart()
	{
		if (myLevelData == null)
		{
			levelProgressManager = LevelProgressManager.instance;
			myLevelData = levelProgressManager.GetLevelDataForScene(sceneName);
		}
		lockedLevelVisuals.SetActive(value: false);
		unlockedLevelVisuals.SetActive(value: false);
		beatenLevelVisuals.SetActive(value: false);
		questsComplete.transform.parent.gameObject.SetActive(value: false);
		questsComplete.text = QuestsBeatenString();
		int num = QuestsComplete();
		if (num == QuestsTotal())
		{
			AchievementManager.LevelAllQuestsComplete(sceneName);
		}
		if (myLevelData.beatenBest)
		{
			AchievementManager.LevelBeaten(sceneName);
		}
		questsComplete.color = ((num >= QuestsTotal()) ? allQuestComplete : notAllQuestComplete);
		float num2 = (float)num / (float)QuestsTotal();
		int enabledBuildings = Mathf.FloorToInt((float)rewardBuildingsParent.childCount * (float)myLevelData.questsCompleteWhenLastVisitingMap);
		int num3 = Mathf.FloorToInt((float)rewardBuildingsParent.childCount * num2);
		myLevelData.questsCompleteWhenLastVisitingMap = num3;
		StartCoroutine(EnableBuildingsCoroutine(enabledBuildings, num3, 0.75f, 0.5f));
		if (!CanBePlayed)
		{
			lockedLevelVisuals.SetActive(value: true);
			return;
		}
		questsComplete.transform.parent.gameObject.SetActive(value: true);
		if (!Beaten)
		{
			unlockedLevelVisuals.SetActive(value: true);
		}
		else
		{
			beatenLevelVisuals.SetActive(value: true);
		}
	}

	private IEnumerator EnableBuildingsCoroutine(int _enabledBuildings, int _enabledBuildingsUpTo, float _initialDelay, float _interval)
	{
		if (rewardBuildingsParent.childCount < _enabledBuildingsUpTo)
		{
			Debug.LogWarning("Not enough children in the rewardBuildingsParent to satisfy enabledBuildingsUpTo");
			yield break;
		}
		if (rewardBuildingsParent.childCount < _enabledBuildings)
		{
			Debug.LogWarning("Not enough children in the rewardBuildingsParent to satisfy enabledBuildings");
			yield break;
		}
		for (int j = 0; j < rewardBuildingsParent.childCount; j++)
		{
			rewardBuildingsParent.GetChild(j).gameObject.SetActive(value: false);
		}
		for (int k = 0; k < _enabledBuildings; k++)
		{
			rewardBuildingsParent.GetChild(k).gameObject.SetActive(value: true);
		}
		yield return new WaitForSeconds(_initialDelay);
		for (int i = _enabledBuildings; i < _enabledBuildingsUpTo; i++)
		{
			rewardBuildingsParent.GetChild(i).gameObject.SetActive(value: true);
			rewardBuildingsParent.GetChild(i).GetChild(0).gameObject.SetActive(value: true);
			yield return new WaitForSeconds(_interval);
		}
	}

	private void Start()
	{
		levelSelectManager = GetComponentInParent<LevelSelectManager>();
		levelProgressManager = LevelProgressManager.instance;
		myLevelData = levelProgressManager.GetLevelDataForScene(sceneName);
		focusPanel.SetActive(value: false);
		cantBePlayedPanel.SetActive(value: false);
		UpdateVisualsOnStart();
	}

	public override string ReturnTooltip()
	{
		if (CanBePlayed)
		{
			return LocalizationManager.GetTranslation("Menu/Level Interactor Cue");
		}
		return "";
	}

	private string GenerateCueText()
	{
		if (!CanBePlayed)
		{
			return CanNotBePlayedReason;
		}
		if (levelSelectManager.PreLevelMenuIsOpen)
		{
			return "";
		}
		return displayName;
	}

	public override void InteractionBegin(PlayerInteraction _player)
	{
		if (CanBePlayed)
		{
			lastActivatedLevelInteractor = this;
			UIFrameManager.TryOpenLevelSelect();
		}
	}

	public override void Focus(PlayerInteraction _player)
	{
		if (CanBePlayed)
		{
			focusPanel.SetActive(value: true);
			cantBePlayedPanel.SetActive(value: false);
		}
		else
		{
			cantBePlayedCue.text = GenerateCueText();
			cantBePlayedPanel.SetActive(value: true);
			focusPanel.SetActive(value: false);
		}
	}

	public override void Unfocus(PlayerInteraction _player)
	{
		focusPanel.SetActive(value: false);
		cantBePlayedPanel.SetActive(value: false);
	}

	public int QuestsComplete()
	{
		int num = 0;
		if (DebugController.SaveLoadModeToUse == DebugController.SaveLoadMode.LoadMaxedOutSaveFileOnStartup)
		{
			return quests.Count;
		}
		for (int i = 0; i < quests.Count; i++)
		{
			if (quests[i].CheckBeaten(myLevelData))
			{
				num++;
			}
		}
		return num;
	}

	public int QuestsTotal()
	{
		return quests.Count;
	}

	public string QuestsBeatenString()
	{
		return QuestsComplete() + "/" + QuestsTotal();
	}
}