using System.Collections.Generic;
using BeautifyEffect;
using DarkTonic.MasterAudio;
using OLDCODE;
using UltimateWater;
using UnityEngine;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.Serialization;

public class FScriptsHandler : MonoBehaviour
{
	private static FScriptsHandler instance;

	[HideInInspector]
	public Canvas m_Canvas;

	[HideInInspector]
	public InputManager m_InputManager;

	public FPlayer m_PlayerMain;

	[HideInInspector]
	public InteractionControl m_InteractionControl;

	[HideInInspector]
	public CanvasManager m_CanvasManager;

	[HideInInspector]
	public InventoryManager m_InventoryManager;

	[HideInInspector]
	public SceneSettings m_SceneSettings;

	[FormerlySerializedAs("m_WeatherController")]
	[HideInInspector]
	public GameWeatherManager mGameWeatherController;

	[HideInInspector]
	public HudManager m_HudManager;

	[HideInInspector]
	public PlayerManager playerManager;

	[HideInInspector]
	public QuickMenu m_QuickMenu;

	[HideInInspector]
	public ChatManager m_chatManager;

	private FFishSystem m_fishSystem;

	private List<AudioSource> allAudioSources = new List<AudioSource>();

	[Tooltip("Underwater camera prefab")]
	public GameObject underWaterCameraPrefab;

	[Tooltip("Postac z ryba na rekach prefab")]
	public GameObject[] fishAnglerViewPrefab;

	public GameObject ChwytakPrefab;

	public GameObject fishCatchPanel;

	public GameObject boatUIPanelPrefab;

	public GameObject[] waterFishSplash;

	public AudioClip[] fishBubbleSound;

	public GameObject debugText;

	public Transform PlayerTransformPoint;

	public GameObject nearThrowTargetPrefab;

	private Water water;

	private LayerMask WaterReflactionMask;

	private LayerMask WaterReflactionNothingMask;

	public GameObject FreeCameraPrefab;

	public GameObject lornetkaMaskPrefab;

	public float locationSpendTimer;

	public bool showLoadShadersMask = true;

	public RodActionCurve rodActionCurveSlow;

	public RodActionCurve rodActionCurveMedium;

	public RodActionCurve rodActionCurveFast;

	public RodActionCurve rodActionCurveExtraFast;

	public FishFightData fishFightData;

	private TournamentPlay currentTournamentPlay;

	public static FScriptsHandler Instance => instance;

	private void Awake()
	{
		if (instance == null)
		{
			instance = this;
		}
		AudioListener.volume = 0f;
		PutScripts();
	}

	private void PutScripts()
	{
		m_chatManager = Object.FindObjectOfType<ChatManager>();
		m_InputManager = Object.FindObjectOfType<InputManager>();
		if ((object)m_PlayerMain == null)
		{
			m_PlayerMain = Object.FindObjectOfType<FPlayer>();
		}
		m_Canvas = GameObject.Find("Canvas").GetComponent<Canvas>();
		m_CanvasManager = Object.FindObjectOfType<CanvasManager>();
		m_InventoryManager = Object.FindObjectOfType<InventoryManager>();
		m_SceneSettings = Object.FindObjectOfType<SceneSettings>();
		mGameWeatherController = Object.FindObjectOfType<GameWeatherManager>();
		m_HudManager = Object.FindObjectOfType<HudManager>();
		playerManager = Object.FindObjectOfType<PlayerManager>();
		m_QuickMenu = Object.FindObjectOfType<QuickMenu>();
		m_fishSystem = Object.FindObjectOfType<FFishSystem>();
		water = Object.FindObjectOfType<Water>();
		if ((bool)water)
		{
			WaterReflactionMask = water.PlanarReflection.ReflectionMask;
		}
		allAudioSources.AddRange(Object.FindObjectsOfType<AudioSource>());
		AffectSoundVolume();
	}

	private void Start()
	{
		showLoadShadersMask = true;
		_ = GameManager.Instance._playerData.currentPlayerProfileIndex;
		_ = -1;
		GameManager.Instance._playerData.eagleEyesCoolDown = 0f;
		Singleton<SaveDataManager>.Instance.ResetRodStatuses();
	}

	private void Update()
	{
		if (showLoadShadersMask)
		{
			ShowHideAddetiveEmptyScene();
			return;
		}
		if ((bool)m_PlayerMain && (bool)m_PlayerMain.m_Camera && m_PlayerMain.m_Camera.enabled)
		{
			PlayerTransformPoint.position = m_PlayerMain.transform.position;
		}
		else if ((bool)m_PlayerMain && m_PlayerMain.underWaterCamera != null)
		{
			PlayerTransformPoint.position = m_PlayerMain.underWaterCamera.transform.position;
		}
		locationSpendTimer += Time.unscaledDeltaTime;
	}

	private void FixedUpdate()
	{
		AddTimeToQuest();
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TimeBoostExp > 0f)
		{
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TimeBoostExp -= Time.deltaTime;
		}
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TimeBoostCash > 0f)
		{
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().TimeBoostCash -= Time.deltaTime;
		}
	}

	public void AffectSoundVolume()
	{
		if (m_SceneSettings.sceneID == 8)
		{
			return;
		}
		List<AudioSource> list = new List<AudioSource>();
		foreach (AudioSource allAudioSource in allAudioSources)
		{
			if (allAudioSource != null)
			{
				bool num = allAudioSource.outputAudioMixerGroup != null;
				bool flag = allAudioSource.GetComponentInParent<MasterAudio>() != null;
				if (!num && !flag)
				{
					list.Add(allAudioSource);
				}
			}
		}
		list.ForEach(delegate(AudioSource element)
		{
			element.volume = Singleton<SaveDataManager>.Instance.SettingsData.FXVolume * 0.1f;
		});
	}

	private void ShowHideAddetiveEmptyScene()
	{
		if ((bool)TournamentManager.Instance && GameManager.Instance.currentSceneLoadedType == GameManager.SceneLoadedType.Tournament && !currentTournamentPlay)
		{
			currentTournamentPlay = Object.Instantiate(TournamentManager.Instance.TournamentPlayPanelPrefab, m_Canvas.transform).GetComponent<TournamentPlay>();
		}
		if (GameManager.Instance.addectiveSceneLoaded != "WelcomeMap")
		{
			GameManager.Instance.LoadAddectiveScene("WelcomeMap");
			showLoadShadersMask = false;
		}
	}

	public void AffectControlsSetting()
	{
		m_PlayerMain.firstPersonController.m_MouseLook.XSensitivity = Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue;
		m_PlayerMain.firstPersonController.m_MouseLook.YSensitivity = Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue;
		m_PlayerMain.firstPersonController.m_MouseLook.invertMouseY = Singleton<SaveDataManager>.Instance.SettingsData.IsMouseYInverted;
		m_PlayerMain.firstPersonController.m_MouseLook.invertMouseX = Singleton<SaveDataManager>.Instance.SettingsData.IsMouseXInverted;
		m_PlayerMain.firstPersonController.m_MouseLook.ControllerHandMode = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].controllerSetup;
		m_PlayerMain.MouseSensitivityX = Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue;
		m_PlayerMain.MouseSensitivityY = Singleton<SaveDataManager>.Instance.SettingsData.MouseSensitivityValue;
	}

	public void AffectDisplaySetting()
	{
		m_PlayerMain.m_Camera.fieldOfView = Singleton<SaveDataManager>.Instance.SettingsData.FOVValue;
		m_PlayerMain.lastCameraFov = Singleton<SaveDataManager>.Instance.SettingsData.FOVValue;
		m_PlayerMain.m_Camera.GetComponent<Crepuscular>().enabled = Singleton<SaveDataManager>.Instance.SettingsData.IsLightShaftEnabled;
		EagleEyes eagleEyes = Object.FindObjectOfType<EagleEyes>();
		if ((bool)eagleEyes)
		{
			eagleEyes.startCameraFov = Singleton<SaveDataManager>.Instance.SettingsData.FOVValue;
		}
	}

	public void AffectGraphicsSetting()
	{
		QualitySettings.masterTextureLimit = Singleton<SaveDataManager>.Instance.SettingsData.TextureQualityModeIndex;
		QualitySettings.vSyncCount = (Singleton<SaveDataManager>.Instance.SettingsData.IsVSyncEnabled ? 1 : 0);
		QualitySettings.shadowDistance = Singleton<SaveDataManager>.Instance.SettingsData.ShadowDistanceValue;
		if ((bool)water)
		{
			if (!Singleton<SaveDataManager>.Instance.SettingsData.IsWaterReflectionEnabled)
			{
				water.PlanarReflection.ReflectionMask = WaterReflactionNothingMask;
				Debug.Log("Water reflaction Off");
			}
			else
			{
				water.PlanarReflection.ReflectionMask = WaterReflactionMask;
				Debug.Log("Water reflaction On");
			}
			water.PlanarReflection.RenderShadows = GameManager.Instance._playerData.Player[GameManager.Instance._playerData.currentPlayerProfileIndex].shadowOnWater;
		}
	}

	public void AffectPostProccesingFromSettings()
	{
		GameObject gameObject = GameObject.FindGameObjectWithTag("ScenePostProcessing");
		if (gameObject == null || !gameObject.TryGetComponent<PostProcessVolume>(out var component))
		{
			return;
		}
		if (component.profile.TryGetSettings<DepthOfField>(out var outSetting))
		{
			outSetting.active = Singleton<SaveDataManager>.Instance.SettingsData.IsBlurEnabled;
		}
		if (component.profile.TryGetSettings<Bloom>(out var outSetting2))
		{
			outSetting2.active = Singleton<SaveDataManager>.Instance.SettingsData.IsBloomEnabled;
		}
		if (component.profile.TryGetSettings<ChromaticAberration>(out var outSetting3))
		{
			outSetting3.active = Singleton<SaveDataManager>.Instance.SettingsData.IsChromaticAberrationEnabled;
		}
		if (component.profile.TryGetSettings<AmbientOcclusion>(out var outSetting4))
		{
			outSetting4.active = Singleton<SaveDataManager>.Instance.SettingsData.IsAmbientOcclusionEnabled;
		}
		PostProcessLayer component2 = m_PlayerMain.m_Camera.GetComponent<PostProcessLayer>();
		if ((bool)component2)
		{
			component2.antialiasingMode = (PostProcessLayer.Antialiasing)Singleton<SaveDataManager>.Instance.SettingsData.AntiAliasingModeIndex;
		}
		GameObject gameObject2 = null;
		if (gameObject.transform.parent != null)
		{
			foreach (Transform item in gameObject.transform.parent)
			{
				if (item != gameObject.transform)
				{
					gameObject2 = item.gameObject;
				}
			}
		}
		if ((bool)gameObject2 && gameObject2.TryGetComponent<PostProcessVolume>(out component) && component.profile.TryGetSettings<DepthOfField>(out outSetting))
		{
			outSetting.active = false;
		}
		Beautify beautify = Beautify.instance;
		beautify.depthOfFieldAutofocus = false;
		beautify.depthOfFieldFocusSpeed = 1f;
		beautify.depthOfFieldFocalLength = 0.05f;
		beautify.depthOfFieldAperture = Mathf.Lerp(0f, 10f, Singleton<SaveDataManager>.Instance.SettingsData.BlurUnderwaterSetting);
		beautify.depthOfFieldForegroundBlur = true;
		beautify.depthOfFieldForegroundDistance = 1f;
		beautify.depthOfFieldBokeh = false;
		beautify.depthOfFieldDownsampling = 1;
		beautify.depthOfFieldMaxSamples = 5;
		Debug.Log("Apply postprocesing settings");
	}

	public void AddTimeToQuest()
	{
		for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerQuest.Count; i++)
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerQuest[i].gameQuest.questObjectiveType == GameManager.GameQuest.QuestObjectiveType.Spend_time)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerQuest[i].gameQuest.objectiveValue * 60f > Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerQuest[i].curentObjectiveProgress)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerQuest[i].curentObjectiveProgress += Time.deltaTime / 60f;
				}
				else
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerQuest[i].curentObjectiveProgress = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerQuest[i].gameQuest.objectiveValue;
				}
			}
		}
		for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest.Count; j++)
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest[j].gameQuest.questObjectiveType == GameManager.GameQuest.QuestObjectiveType.Spend_time && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest[j].isShowed)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest[j].gameQuest.objectiveValue * 60f > Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest[j].curentObjectiveProgress)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest[j].curentObjectiveProgress += Time.deltaTime / 60f;
				}
				else
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest[j].curentObjectiveProgress = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeeklyQuest[j].gameQuest.objectiveValue;
				}
			}
		}
		for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest.Count; k++)
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest[k].gameQuest.questObjectiveType == GameManager.GameQuest.QuestObjectiveType.Spend_time && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest[k].isShowed)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest[k].gameQuest.objectiveValue * 60f > Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest[k].curentObjectiveProgress)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest[k].curentObjectiveProgress += Time.deltaTime / 60f;
				}
				else
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest[k].curentObjectiveProgress = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerMonthlyQuest[k].gameQuest.objectiveValue;
				}
			}
		}
	}

	public AnimationCurve GetRodActionCurve(GameManager.GameRods.Action action)
	{
		AnimationCurve result = new AnimationCurve();
		switch (action)
		{
		case GameManager.GameRods.Action.Slow:
			result = rodActionCurveSlow.curve;
			break;
		case GameManager.GameRods.Action.Medium:
			result = rodActionCurveMedium.curve;
			break;
		case GameManager.GameRods.Action.Fast:
			result = rodActionCurveFast.curve;
			break;
		case GameManager.GameRods.Action.ExtraFast:
			result = rodActionCurveExtraFast.curve;
			break;
		}
		return result;
	}

	private void OnDestroy()
	{
		Singleton<SaveDataManager>.Instance.ResetRodStatuses();
	}
}