using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using UnityStandardAssets.Characters.FirstPerson;

public class ChatManager : Singleton<ChatManager>, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
{
	[Serializable]
	public class Message
	{
		public enum MessageType
		{
			Normal = 0,
			System = 1,
			FishCatch = 2,
			JoinInfo = 3,
			LeaveInfo = 4
		}

		public string chatmessage;

		public Color chatcolor;

		public string playerName;

		public MessageType messageType;

		public string countryCode;

		public void SetMessage(MessageType type, string country, string player, string message)
		{
			switch (type)
			{
			case MessageType.FishCatch:
				chatmessage = "<color=#70ea46>" + player + " " + message + "</color>";
				break;
			case MessageType.Normal:
				chatmessage = "<color=#2cb1bd>[" + country + "] " + player + "</color> " + message;
				break;
			case MessageType.System:
				chatmessage = "<color=#00dcff> [" + player + "] " + message + " </color>";
				break;
			case MessageType.JoinInfo:
				chatmessage = "<color=#6f969a>" + player + " " + LanguageManager.Instance.GetText("JOIN_TO_ROOM") + "</color>";
				break;
			case MessageType.LeaveInfo:
				chatmessage = "<color=#6f969a>" + player + " " + LanguageManager.Instance.GetText("LEAVE_THE_ROOM") + "</color>";
				break;
			}
			playerName = player;
			countryCode = country;
			messageType = type;
		}
	}

	public enum LanguageFiltr
	{
		General = 0,
		System = 1,
		Polish = 2,
		English = 3,
		Russian = 4,
		Ukrainian = 5,
		Deutsch = 6,
		French = 7,
		Italian = 8,
		Portuguese = 9,
		Spanish = 10,
		Chinese = 11,
		Japanese = 12,
		Turkish = 13,
		Dutch = 14
	}

	[SerializeField]
	private GameObject chatBg;

	[SerializeField]
	private InputField chatInputField;

	public bool pointerOnChat;

	public bool IsChatOpen;

	public Text chatFiltr;

	public Text timeText;

	public Text mapNameText;

	public GameObject messPrefab;

	public GameObject chatContainer;

	public GameObject closeMessPrefab;

	public GameObject closeChatMessageContainer;

	public GameObject userPrefab;

	public GameObject userContainer;

	public List<Message> chatMessages = new List<Message>();

	private FirstPersonController firstPersonController;

	public float writeTime;

	public GameObject[] chatGameObjects;

	public LanguageFiltr languageFiltr;

	private void Start()
	{
		if (!Singleton<SaveDataManager>.Instance.SettingsData.IsChatEnabled)
		{
			base.gameObject.SetActive(value: false);
			return;
		}
		writeTime = Time.time;
		int sceneID = FScriptsHandler.Instance.m_SceneSettings.sceneID;
		mapNameText.text = GameManager.Instance.gameLocations[sceneID].name;
		firstPersonController = FScriptsHandler.Instance.m_PlayerMain?.firstPersonController;
		chatFiltr.text = "[" + languageFiltr.ToString() + "]";
		string locationId = sceneID.ToString();
		if (GameManager.Instance.currentSceneLoadedType == GameManager.SceneLoadedType.Tournament)
		{
			locationId = "Tournament#" + TournamentManager.Instance.currentPlayTournament.id;
		}
		ServerManager.Instance.JoinToChat(locationId, this);
		StartCoroutine(UpdateContentHeight());
	}

	private void OnEnable()
	{
		ChatBackendPUN.On_MessageReceived += ChatBackendPUN_On_MessageReceived;
		ChatBackendPUN.On_MessageReceivedFishCatch += ChatBackendPUN_On_MessageReceivedFishCatch;
		ChatBackendPUN.On_ReceivePreviousMessages += ChatBackendPUN_On_ReceivePreviousMessages;
	}

	private void OnDisable()
	{
		ChatBackendPUN.On_MessageReceived -= ChatBackendPUN_On_MessageReceived;
		ChatBackendPUN.On_MessageReceivedFishCatch -= ChatBackendPUN_On_MessageReceivedFishCatch;
		ChatBackendPUN.On_ReceivePreviousMessages -= ChatBackendPUN_On_ReceivePreviousMessages;
	}

	public void ChangeFiltr()
	{
		int num = (int)languageFiltr;
		num++;
		if (num == Enum.GetValues(typeof(LanguageFiltr)).Length)
		{
			num = 0;
		}
		languageFiltr = (LanguageFiltr)num;
		chatFiltr.text = "[" + languageFiltr.ToString() + "]";
		StartCoroutine(RefreshChat());
	}

	public IEnumerator RefreshChat()
	{
		yield return null;
		for (int i = 0; i < chatContainer.transform.childCount; i++)
		{
			if (i == 50)
			{
				UnityEngine.Object.Destroy(chatContainer.transform.GetChild(0).gameObject);
			}
			chatContainer.transform.GetChild(i).gameObject.SetActive(value: false);
			if (chatContainer.transform.GetChild(i).GetComponent<ChatMessageItem>().langugaeFiltr == languageFiltr.ToString() || languageFiltr.ToString() == LanguageFiltr.General.ToString())
			{
				chatContainer.transform.GetChild(i).gameObject.SetActive(value: true);
			}
		}
		StartCoroutine(UpdateContentHeight());
	}

	private IEnumerator InstantiateMessage(Message mess, Message.MessageType type, GameObject prefab, Transform transform)
	{
		if (!Singleton<SaveDataManager>.Instance.SettingsData.IsChatEnabled)
		{
			yield return null;
		}
		GameObject gameObject = UnityEngine.Object.Instantiate(prefab, transform.transform);
		if (prefab == closeMessPrefab)
		{
			gameObject.GetComponentInChildren<Text>().text = mess.chatmessage;
		}
		else
		{
			gameObject.GetComponent<Text>().text = mess.chatmessage;
		}
		gameObject.transform.SetAsLastSibling();
		if (prefab != closeMessPrefab)
		{
			gameObject.GetComponent<ChatMessageItem>().langugaeFiltr = mess.countryCode;
		}
		if (prefab != closeMessPrefab)
		{
			switch (type)
			{
			case Message.MessageType.FishCatch:
			case Message.MessageType.JoinInfo:
				gameObject.GetComponent<Text>().fontStyle = FontStyle.Italic;
				break;
			case Message.MessageType.System:
				gameObject.GetComponent<Text>().fontStyle = FontStyle.Bold;
				break;
			}
		}
		else
		{
			switch (type)
			{
			case Message.MessageType.FishCatch:
			case Message.MessageType.JoinInfo:
				gameObject.GetComponentInChildren<Text>().fontStyle = FontStyle.Italic;
				break;
			case Message.MessageType.System:
				gameObject.GetComponentInChildren<Text>().fontStyle = FontStyle.Bold;
				break;
			}
		}
		yield return null;
	}

	public IEnumerator ShowSystemMessage(string text)
	{
		Message message = new Message();
		message.messageType = Message.MessageType.System;
		message.chatmessage = text;
		message.countryCode = LanguageFiltr.System.ToString();
		message.SetMessage(Message.MessageType.System, LanguageFiltr.System.ToString(), "System", text);
		if (IsChatOpen)
		{
			StartCoroutine(InstantiateMessage(message, message.messageType, messPrefab, chatContainer.transform));
			StartCoroutine(UpdateContentHeight());
		}
		else if (message.countryCode == languageFiltr.ToString() || languageFiltr.ToString() == LanguageFiltr.General.ToString())
		{
			StartCoroutine(InstantiateMessage(message, message.messageType, closeMessPrefab, closeChatMessageContainer.transform));
			StartCoroutine(InstantiateMessage(message, message.messageType, messPrefab, chatContainer.transform));
		}
		yield return null;
	}

	public void ReceiveMesage(ServerManager.Message messageData)
	{
		if (base.gameObject.activeSelf)
		{
			Debug.Log("New message");
			StartCoroutine(RefreshChat());
			Message message = new Message();
			Message.MessageType type = (Message.MessageType)Enum.Parse(typeof(Message.MessageType), messageData.MESSAGE_TYPE);
			message.SetMessage(type, messageData.COUNTRY, messageData.PLAYER_NAME, messageData.MESSAGE);
			if (IsChatOpen)
			{
				StartCoroutine(InstantiateMessage(message, type, messPrefab, chatContainer.transform));
				StartCoroutine(UpdateContentHeight());
			}
			else if (message.countryCode == languageFiltr.ToString() || languageFiltr.ToString() == LanguageFiltr.General.ToString())
			{
				StartCoroutine(InstantiateMessage(message, type, closeMessPrefab, closeChatMessageContainer.transform));
				StartCoroutine(InstantiateMessage(message, type, messPrefab, chatContainer.transform));
			}
			chatMessages.Add(message);
		}
	}

	public void ReceiveFishMesage(ServerManager.FishMessage messageData)
	{
		if (base.gameObject.activeSelf)
		{
			Debug.Log("New fish message");
			StartCoroutine(RefreshChat());
			Message message = new Message();
			Message.MessageType type = Message.MessageType.FishCatch;
			string message2 = LanguageManager.Instance.GetText("CHAT_FISH_CATCH") + " " + GameManager.GetFishNameFromSpecies((GameManager.FishSpecies)messageData.FISH_ID) + " " + GameManager.Instance.ConvertWeight(messageData.FISH_WEIGHT);
			message.SetMessage(type, "", messageData.PLAYER_NAME, message2);
			if (IsChatOpen)
			{
				StartCoroutine(InstantiateMessage(message, type, messPrefab, chatContainer.transform));
				StartCoroutine(UpdateContentHeight());
			}
			else if (languageFiltr.ToString() == LanguageFiltr.General.ToString())
			{
				StartCoroutine(InstantiateMessage(message, type, closeMessPrefab, closeChatMessageContainer.transform));
				StartCoroutine(InstantiateMessage(message, type, messPrefab, chatContainer.transform));
			}
			chatMessages.Add(message);
		}
	}

	public void SendMessageChat(Message.MessageType type, string countryCode, string playerName, string message)
	{
		_ = new string[3] { "[b]", "[i]", "[red]" };
		_ = new string[3] { "[/b]", "[/i]", "[/red]" };
		new Message
		{
			countryCode = countryCode,
			playerName = playerName,
			messageType = type,
			chatmessage = message
		};
		_ = languageFiltr;
		_ = 1;
	}

	public void closeChatCointainer()
	{
		chatInputField.enabled = false;
		chatInputField.placeholder.GetComponent<Text>().text = LanguageManager.Instance.GetText("CHAT_ENTER_TO_CHAT");
		chatInputField.DeactivateInputField();
		IsChatOpen = false;
		chatInputField.text = "";
		firstPersonController.frezzeRotation = false;
		GameManager.Instance.SetMouseCurrsor(val: false);
		chatBg.SetActive(value: false);
	}

	private void FixedUpdate()
	{
		if ((bool)ServerManager.Instance)
		{
			string text = GameManager.Instance.ConvertTextGameTime(new Vector2(DateTime.Now.Hour, DateTime.Now.Minute));
			timeText.text = text ?? "";
		}
	}

	private void Update()
	{
		if (!Singleton<SaveDataManager>.Instance.SettingsData.IsChatEnabled && chatGameObjects[2].activeSelf)
		{
			for (int i = 0; i < chatGameObjects.Length; i++)
			{
				chatGameObjects[i].SetActive(value: false);
			}
		}
		else if (Singleton<SaveDataManager>.Instance.SettingsData.IsChatEnabled && !chatGameObjects[2].activeSelf)
		{
			for (int j = 0; j < chatGameObjects.Length; j++)
			{
				if (j == 1)
				{
					chatGameObjects[1].SetActive(value: false);
					GameManager.TruncateContainer(closeChatMessageContainer.transform);
				}
				else
				{
					chatGameObjects[j].SetActive(value: true);
				}
			}
		}
		if (Input.GetMouseButtonDown(0) && !pointerOnChat && IsChatOpen)
		{
			closeChatCointainer();
		}
		if ((Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.KeypadEnter)) && InputManager.showUI && Singleton<SaveDataManager>.Instance.SettingsData.IsChatEnabled && !DebugTools.IsDebugMode)
		{
			if (!IsChatOpen)
			{
				if (SRDebug.Instance.IsDebugPanelVisible)
				{
					return;
				}
				InputManager.isReelReeling = false;
				if (GameManager.Instance.currentLevelPopUp != null)
				{
					return;
				}
				firstPersonController = FScriptsHandler.Instance.m_PlayerMain.firstPersonController;
				GameManager.TruncateContainer(closeChatMessageContainer.transform);
				chatInputField.enabled = true;
				chatInputField.placeholder.GetComponent<Text>().text = LanguageManager.Instance.GetText("CHAT_TYPE_EMESSAGE");
				GameManager.Instance.SetMouseCurrsor(val: true);
				firstPersonController.frezzeRotation = true;
				chatInputField.ActivateInputField();
				IsChatOpen = true;
				chatBg.SetActive(value: true);
				StartCoroutine(RefreshChat());
			}
			else if (chatInputField.text != "")
			{
				if (languageFiltr == LanguageFiltr.System || Time.time < writeTime + 1f)
				{
					return;
				}
				writeTime = Time.time;
				ChatBackendPUN.Instance.SendMessageChat(chatInputField.text, languageFiltr);
				chatInputField.text = "";
				chatInputField.ActivateInputField();
			}
			else
			{
				closeChatCointainer();
			}
		}
		if (Input.GetKeyDown(KeyCode.Escape) && IsChatOpen)
		{
			closeChatCointainer();
		}
		UpdatePlayersList();
	}

	public void AddChatMessage(ServerManager.Message messageData)
	{
		if (Time.timeScale != 0f)
		{
			CheckISPlayerInList(messageData.PLAYER_ID, messageData.PLAYER_NAME, messageData.COUNTRY);
			ReceiveMesage(messageData);
			Debug.Log("Add player message to chat");
		}
	}

	public void AddFishChatMessage(ServerManager.FishMessage fishMessageData)
	{
		if (Time.timeScale != 0f)
		{
			CheckISPlayerInList(fishMessageData.PLAYER_ID, fishMessageData.PLAYER_NAME, "");
			ReceiveFishMesage(fishMessageData);
			Debug.Log("Add fish message to chat");
		}
	}

	private void CheckISPlayerInList(string PLAYER_ID, string PLAYER_NAME, string COUNTRY)
	{
		if (Time.timeScale == 0f)
		{
			return;
		}
		Userchatslot[] componentsInChildren = userContainer.GetComponentsInChildren<Userchatslot>();
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			if (componentsInChildren[i].player_id == PLAYER_ID)
			{
				Debug.Log("Gracz istniej¹cy");
				return;
			}
		}
		Userchatslot component = UnityEngine.Object.Instantiate(userPrefab, userContainer.transform).GetComponent<Userchatslot>();
		component.player_id = PLAYER_ID;
		component.player_name = PLAYER_NAME;
		component.country = COUNTRY;
	}

	public IEnumerator UpdateContentHeight()
	{
		yield return null;
		Transform[] componentsInChildren = chatContainer.GetComponentsInChildren<Transform>();
		RectTransform component = chatContainer.GetComponent<RectTransform>();
		component.sizeDelta = new Vector2(component.sizeDelta.x, 0f);
		float num = 0f;
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			num += componentsInChildren[i].GetComponent<RectTransform>().sizeDelta.y + 10f;
		}
		component.sizeDelta = new Vector2(component.sizeDelta.x, num + 30f);
	}

	public void OnPointerEnter(PointerEventData eventData)
	{
		pointerOnChat = true;
	}

	public void OnPointerExit(PointerEventData eventData)
	{
		pointerOnChat = false;
	}

	private void OnDestroy()
	{
		if ((bool)ServerManager.Instance)
		{
			ServerManager.Instance.ChatDisconnect();
		}
	}

	private void ChatBackendPUN_On_MessageReceived(Message message, string messageStr, string playerID)
	{
		switch (message.messageType)
		{
		case Message.MessageType.Normal:
		{
			ServerManager.Message messageData = new ServerManager.Message
			{
				MESSAGE_TYPE = message.messageType.ToString(),
				PLAYER_ID = playerID,
				PLAYER_NAME = message.playerName,
				COUNTRY = message.countryCode,
				MESSAGE = messageStr
			};
			AddChatMessage(messageData);
			break;
		}
		case Message.MessageType.System:
			StartCoroutine(ShowSystemMessage(messageStr));
			break;
		case Message.MessageType.FishCatch:
		case Message.MessageType.JoinInfo:
		case Message.MessageType.LeaveInfo:
			break;
		}
	}

	private void ChatBackendPUN_On_MessageReceivedFishCatch(Message message, string messageStr, string playerID, int fishID, float fishWeight)
	{
		ServerManager.FishMessage fishMessageData = new ServerManager.FishMessage
		{
			PLAYER_ID = playerID,
			PLAYER_NAME = message.playerName,
			FISH_ID = fishID,
			FISH_WEIGHT = fishWeight
		};
		AddFishChatMessage(fishMessageData);
	}

	private void ChatBackendPUN_On_ReceivePreviousMessages(List<Message> previousMessages)
	{
		foreach (Message previousMessage in previousMessages)
		{
			if (previousMessage.messageType != Message.MessageType.System)
			{
				ServerManager.Message messageData = new ServerManager.Message
				{
					MESSAGE_TYPE = previousMessage.messageType.ToString(),
					PLAYER_ID = "",
					PLAYER_NAME = previousMessage.playerName,
					COUNTRY = previousMessage.countryCode,
					MESSAGE = previousMessage.chatmessage
				};
				Message.MessageType messageType = previousMessage.messageType;
				if (messageType == Message.MessageType.Normal || (uint)(messageType - 3) <= 1u)
				{
					ReceiveMesage(messageData);
				}
			}
		}
	}

	private void UpdatePlayersList()
	{
		if (!MultiplayerManager.InRoomLocationStatic)
		{
			return;
		}
		Userchatslot[] componentsInChildren = userContainer.GetComponentsInChildren<Userchatslot>();
		List<Userchatslot> list = new List<Userchatslot>();
		Userchatslot[] array = componentsInChildren;
		foreach (Userchatslot uiPlayer in array)
		{
			if (!MultiplayerManager.Instance.CurrentRoomPlayers.Exists((MultiplayerManager.FriendInfoData element) => element.userID == uiPlayer.player_id))
			{
				list.Add(uiPlayer);
			}
		}
		List<MultiplayerManager.FriendInfoData> list2 = new List<MultiplayerManager.FriendInfoData>();
		foreach (MultiplayerManager.FriendInfoData player in MultiplayerManager.Instance.CurrentRoomPlayers)
		{
			if (!componentsInChildren.Any((Userchatslot p) => p.player_id == player.userID))
			{
				list2.Add(player);
			}
		}
		foreach (Userchatslot item in list)
		{
			ServerManager.Message messageData = new ServerManager.Message
			{
				MESSAGE_TYPE = Message.MessageType.LeaveInfo.ToString(),
				PLAYER_ID = item.player_id,
				PLAYER_NAME = item.player_name,
				COUNTRY = "",
				MESSAGE = ""
			};
			ReceiveMesage(messageData);
		}
		foreach (MultiplayerManager.FriendInfoData item2 in list2)
		{
			ServerManager.Message messageData2 = new ServerManager.Message
			{
				MESSAGE_TYPE = Message.MessageType.JoinInfo.ToString(),
				PLAYER_ID = item2.userID,
				PLAYER_NAME = item2.name,
				COUNTRY = "",
				MESSAGE = ""
			};
			ReceiveMesage(messageData2);
		}
		foreach (Userchatslot item3 in list)
		{
			UnityEngine.Object.Destroy(item3.gameObject);
		}
		foreach (MultiplayerManager.FriendInfoData item4 in list2)
		{
			Userchatslot component = UnityEngine.Object.Instantiate(userPrefab, userContainer.transform).GetComponent<Userchatslot>();
			component.player_id = item4.userID;
			component.player_name = item4.name;
			component.country = "";
		}
	}
}