using System.Collections.Generic;
using Steamworks;
using UnityEngine;
using UnityEngine.UI;

public class TournamentScene : MonoBehaviour
{
	[SerializeField]
	private Button[] TournamentCategoryButton;

	[SerializeField]
	private Sprite[] TournamentCategoryButtonSprite;

	[SerializeField]
	private Button[] TournamentNawigationButton;

	[SerializeField]
	private GameObject TournamentNawigationBarContent;

	[SerializeField]
	private GameObject TournamentPrefab;

	[SerializeField]
	private GameObject TournamentCreatorPrefab;

	[SerializeField]
	private GameObject PlayerTournamentItemPrefab;

	[SerializeField]
	private GameObject EmptyTournamentInfoPrefab;

	[SerializeField]
	private Transform TournamentViewContainer;

	[SerializeField]
	private Text TournamentLocationName;

	[SerializeField]
	private Text TournamentCounter;

	public TournamentManager.TournamentContentType currentTournamentContentType;

	private TournamentItem currentTournamentView;

	private PlayerTournamentItem currentPlayerTournamentView;

	[SerializeField]
	private WaitingPanel waitingPanel;

	private List<TournamentManager.CTournament> tournamentsSorts = new List<TournamentManager.CTournament>();

	private int indexOfAvailableTournaments = -1;

	private void Start()
	{
		waitingPanel.gameObject.SetActive(value: false);
		InvokeRepeating("RefreshTournamentFromServer", 1f, 1f);
		ChangeType();
		ServerManager.Instance.GetTournamentJoinedIds();
	}

	private void FixedUpdate()
	{
		if (tournamentsSorts.Count == 0 && TournamentManager.Instance.tournaments.Count > 0)
		{
			if (currentTournamentContentType != TournamentManager.TournamentContentType.Players && currentTournamentContentType != TournamentManager.TournamentContentType.MyTournaments && currentTournamentContentType != TournamentManager.TournamentContentType.CreatorTournament)
			{
				ChangeType();
			}
			if ((bool)Object.FindObjectOfType<BottomBar>())
			{
				Object.FindObjectOfType<BottomBar>().LoadingStuffPanel.SetActive(value: false);
			}
		}
		if ((bool)currentTournamentView && !CheckIsTournamentAvailable(currentTournamentView.tournament))
		{
			ChangeType(currentTournamentContentType.ToString());
		}
		if ((bool)currentPlayerTournamentView && !CheckIsTournamentAvailable(currentPlayerTournamentView.tournament))
		{
			ChangeType(currentTournamentContentType.ToString());
		}
	}

	private bool CheckIsTournamentAvailable(TournamentManager.CTournament tournament)
	{
		return TournamentManager.Instance.tournaments.Contains(tournament);
	}

	private void RefreshTournamentFromServer()
	{
		ServerManager.Instance.GetAllTournaments();
	}

	public void ShowTournament(int val = -1)
	{
		TournamentNawigationBarContent.SetActive(value: true);
		waitingPanel.gameObject.SetActive(value: false);
		GetSortingTournaments();
		GameManager.TruncateContainer(TournamentViewContainer);
		if (tournamentsSorts.Count == 0)
		{
			if (currentTournamentContentType == TournamentManager.TournamentContentType.CreatorTournament)
			{
				TournamentNawigationBarContent.SetActive(value: false);
				Object.Instantiate(TournamentCreatorPrefab, TournamentViewContainer);
				if ((bool)Object.FindObjectOfType<BottomBar>())
				{
					Object.FindObjectOfType<BottomBar>().LoadingStuffPanel.SetActive(value: false);
				}
				return;
			}
			TournamentLocationName.text = LanguageManager.Instance.GetText("TOUNAMENT_NOT_AVAILABLE");
			TournamentCounter.text = "";
			TournamentNawigationButton[0].interactable = false;
			TournamentNawigationButton[1].interactable = false;
			GameManager.TruncateContainer(TournamentViewContainer);
			Object.Instantiate(EmptyTournamentInfoPrefab, TournamentViewContainer);
			if ((bool)Object.FindObjectOfType<BottomBar>())
			{
				Object.FindObjectOfType<BottomBar>().LoadingStuffPanel.SetActive(value: true);
			}
			return;
		}
		if (currentTournamentContentType == TournamentManager.TournamentContentType.CreatorTournament)
		{
			TournamentNawigationBarContent.SetActive(value: false);
			Object.Instantiate(PlayerTournamentItemPrefab, TournamentViewContainer).GetComponent<PlayerTournamentItem>().tournament = tournamentsSorts[0];
			if ((bool)Object.FindObjectOfType<BottomBar>())
			{
				Object.FindObjectOfType<BottomBar>().LoadingStuffPanel.SetActive(value: false);
			}
			waitingPanel.gameObject.SetActive(value: true);
			waitingPanel.tournament = tournamentsSorts[0];
			return;
		}
		indexOfAvailableTournaments += -val;
		if (indexOfAvailableTournaments == tournamentsSorts.Count)
		{
			indexOfAvailableTournaments = 0;
		}
		if (indexOfAvailableTournaments < 0)
		{
			indexOfAvailableTournaments = tournamentsSorts.Count - 1;
		}
		if ((bool)currentPlayerTournamentView)
		{
			currentPlayerTournamentView.animator.SetInteger("Hide", val);
		}
		if ((bool)currentTournamentView)
		{
			currentTournamentView.animator.SetInteger("Hide", val);
		}
		if (tournamentsSorts[indexOfAvailableTournaments].timeStart == 0L)
		{
			currentPlayerTournamentView = Object.Instantiate(PlayerTournamentItemPrefab, TournamentViewContainer).GetComponent<PlayerTournamentItem>();
			currentPlayerTournamentView.animator.SetInteger("Show", val);
			currentPlayerTournamentView.tournament = tournamentsSorts[indexOfAvailableTournaments];
			waitingPanel.gameObject.SetActive(value: true);
			waitingPanel.tournament = tournamentsSorts[indexOfAvailableTournaments];
			waitingPanel.currentViewTournament = currentPlayerTournamentView;
		}
		else
		{
			currentTournamentView = Object.Instantiate(TournamentPrefab, TournamentViewContainer).GetComponent<TournamentItem>();
			currentTournamentView.animator.SetInteger("Show", val);
			currentTournamentView.tournament = tournamentsSorts[indexOfAvailableTournaments];
		}
		TournamentLocationName.text = GameManager.Instance.gameLocations[tournamentsSorts[indexOfAvailableTournaments].mapId].name;
		TournamentCounter.text = indexOfAvailableTournaments + 1 + " / " + tournamentsSorts.Count;
		if (tournamentsSorts.Count < 2)
		{
			TournamentNawigationButton[0].interactable = false;
			TournamentNawigationButton[1].interactable = false;
		}
		else
		{
			TournamentNawigationButton[0].interactable = true;
			TournamentNawigationButton[1].interactable = true;
		}
	}

	private void GetSortingTournaments()
	{
		tournamentsSorts.Clear();
		int playerLevel = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLevel;
		for (int i = 0; i < TournamentManager.Instance.tournaments.Count; i++)
		{
			bool flag = true;
			if (TournamentManager.Instance.tournaments[i].levelRange.x <= (float)playerLevel && (TournamentManager.Instance.tournaments[i].levelRange.y > (float)playerLevel || TournamentManager.Instance.tournaments[i].levelRange.y == (float)playerLevel))
			{
				flag = true;
			}
			switch (currentTournamentContentType)
			{
			case TournamentManager.TournamentContentType.CreatorTournament:
				if (SteamUser.GetSteamID().m_SteamID.ToString() == TournamentManager.Instance.tournaments[i].creatorPlayerId && TournamentManager.Instance.tournaments[i].creatorProfileIndex == GameManager.Instance._playerData.currentPlayerProfileIndex && TournamentManager.Instance.tournaments[i].timeStart == 0L)
				{
					tournamentsSorts.Add(TournamentManager.Instance.tournaments[i]);
				}
				break;
			case TournamentManager.TournamentContentType.Cyclic:
				if (TournamentManager.Instance.tournaments[i].tournamentType == TournamentManager.TournamentContentType.Cyclic && (flag || TournamentManager.Instance.CheckIsTournamentJoined(TournamentManager.Instance.tournaments[i])))
				{
					tournamentsSorts.Add(TournamentManager.Instance.tournaments[i]);
				}
				break;
			case TournamentManager.TournamentContentType.Daily:
				if (TournamentManager.Instance.tournaments[i].tournamentType == TournamentManager.TournamentContentType.Daily && (flag || TournamentManager.Instance.CheckIsTournamentJoined(TournamentManager.Instance.tournaments[i])))
				{
					tournamentsSorts.Add(TournamentManager.Instance.tournaments[i]);
				}
				break;
			case TournamentManager.TournamentContentType.MyTournaments:
				if ((TournamentManager.Instance.CheckIsTournamentJoined(TournamentManager.Instance.tournaments[i]) || TournamentManager.Instance.CheckIsTournamentInvite(TournamentManager.Instance.tournaments[i])) && (TournamentManager.Instance.tournaments[i].tournamentType != TournamentManager.TournamentContentType.Players || TournamentManager.Instance.tournaments[i].timeCreate <= 300) && (flag || TournamentManager.Instance.CheckIsTournamentJoined(TournamentManager.Instance.tournaments[i])))
				{
					tournamentsSorts.Add(TournamentManager.Instance.tournaments[i]);
				}
				break;
			case TournamentManager.TournamentContentType.Players:
				if (TournamentManager.Instance.tournaments[i].tournamentType == TournamentManager.TournamentContentType.Players && TournamentManager.Instance.tournaments[i].timeCreate <= 300)
				{
					if (TournamentManager.Instance.tournaments[i].type == TournamentManager.TournamentType.Private && (TournamentManager.Instance.CheckIsTournamentJoined(TournamentManager.Instance.tournaments[i]) || TournamentManager.Instance.CheckIsTournamentInvite(TournamentManager.Instance.tournaments[i])))
					{
						tournamentsSorts.Add(TournamentManager.Instance.tournaments[i]);
					}
					else if (TournamentManager.Instance.tournaments[i].type == TournamentManager.TournamentType.Public && (flag || TournamentManager.Instance.CheckIsTournamentJoined(TournamentManager.Instance.tournaments[i])))
					{
						tournamentsSorts.Add(TournamentManager.Instance.tournaments[i]);
					}
				}
				break;
			}
		}
	}

	public void ChangeType(string type = "Cyclic")
	{
		TournamentCategoryButton[0].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[0];
		TournamentCategoryButton[1].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[0];
		TournamentCategoryButton[2].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[0];
		TournamentCategoryButton[3].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[0];
		TournamentCategoryButton[4].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[0];
		switch (type)
		{
		case "Cyclic":
			currentTournamentContentType = TournamentManager.TournamentContentType.Cyclic;
			TournamentCategoryButton[0].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[1];
			break;
		case "Daily":
			currentTournamentContentType = TournamentManager.TournamentContentType.Daily;
			TournamentCategoryButton[1].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[1];
			break;
		case "Players":
			currentTournamentContentType = TournamentManager.TournamentContentType.Players;
			TournamentCategoryButton[2].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[1];
			break;
		case "MyTournaments":
			currentTournamentContentType = TournamentManager.TournamentContentType.MyTournaments;
			TournamentCategoryButton[3].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[1];
			break;
		case "CreatorTournament":
			currentTournamentContentType = TournamentManager.TournamentContentType.CreatorTournament;
			TournamentCategoryButton[4].GetComponent<Image>().sprite = TournamentCategoryButtonSprite[1];
			break;
		}
		indexOfAvailableTournaments = -1;
		ShowTournament();
	}
}