using System;
using KWS;
using QFSW.QC;
using UFS2.Gameplay;
using UnityEngine;
using UnityEngine.AzureSky;

public class KWS_SettingsController : MonoBehaviour
{
	private WaterSystem _WaterSystem;

	private AzureEffectsController _AzureFXController;

	private AzureWeatherController _AzureWeatherController;

	private bool _IsWeatherChanging;

	private bool _IsWaterVisible;

	private float _TransparentOriginal;

	[SerializeField]
	private ScriptableEnumWeatherType _WeatherType;

	[SerializeField]
	private float _TransparentUnderwater = 7f;

	[SerializeField]
	private Color _DyeColor_Underwater;

	[SerializeField]
	private Color _Turbidity_Underwater;

	private Color _DyeColor_Outwater;

	private Color _Turbidity_Outwater;

	private void Awake()
	{
		_WaterSystem = GetComponent<WaterSystem>();
		_AzureFXController = UnityEngine.Object.FindObjectOfType<AzureEffectsController>();
		_AzureWeatherController = UnityEngine.Object.FindObjectOfType<AzureWeatherController>();
	}

	private void Start()
	{
		WeatherTypeOnOnValueChanged(_WeatherType);
		SettingsManagerOnOnSettingApply();
		_TransparentOriginal = _WaterSystem.Settings.Transparent;
		_DyeColor_Outwater = _WaterSystem.Settings.DyeColor;
		_Turbidity_Outwater = _WaterSystem.Settings.TurbidityColor;
	}

	private void WeatherTypeOnOnValueChanged(Weather obj)
	{
		switch (obj)
		{
		case Weather.Rain:
			SetRainDrops(0.1f);
			break;
		case Weather.HeavyRain:
			SetRainDrops(0.5f);
			break;
		case Weather.Storm:
			SetRainDrops(1f);
			break;
		default:
			SetRainDrops(0f);
			break;
		}
	}

	private void OnEnable()
	{
		SettingsManager.OnSettingApply += SettingsManagerOnOnSettingApply;
		SettingsManager.OnSetReflection += SetPlanarReflection;
		FPlayer.OnPlayerFirstUpdate += LoadPlayerSettings;
		_WeatherType.OnValueChanged += WeatherTypeOnOnValueChanged;
		GameCameraController.OnEnterInToWater += GameCameraController_OnEnterInToWater;
		GameCameraController.OnExitFromWater += GameCameraController_OnExitFromWater;
		FreeCamera.OnEnterUnderwater += GameCameraController_OnEnterInToWater;
		FreeCamera.OnExitUnderwater += GameCameraController_OnExitFromWater;
	}

	private void OnDisable()
	{
		SettingsManager.OnSettingApply -= SettingsManagerOnOnSettingApply;
		SettingsManager.OnSetReflection -= SetPlanarReflection;
		FPlayer.OnPlayerFirstUpdate -= LoadPlayerSettings;
		_WeatherType.OnValueChanged -= WeatherTypeOnOnValueChanged;
		GameCameraController.OnEnterInToWater -= GameCameraController_OnEnterInToWater;
		GameCameraController.OnExitFromWater -= GameCameraController_OnExitFromWater;
		FreeCamera.OnEnterUnderwater -= GameCameraController_OnEnterInToWater;
		FreeCamera.OnExitUnderwater -= GameCameraController_OnExitFromWater;
	}

	private void SettingsManagerOnOnSettingApply()
	{
		int num = PlayerPrefs.GetInt("Settings_WaterPlanarMode");
		int num2 = PlayerPrefs.GetInt("Settings_WaterSSRMode");
		Array values = Enum.GetValues(typeof(WaterSystemScriptableData.PlanarReflectionResolutionQualityEnum));
		Array values2 = Enum.GetValues(typeof(WaterSystemScriptableData.ScreenSpaceReflectionResolutionQualityEnum));
		_WaterSystem.Settings.UsePlanarReflection = num >= 0;
		if (num >= 0)
		{
			_WaterSystem.Settings.PlanarReflectionResolutionQuality = (WaterSystemScriptableData.PlanarReflectionResolutionQualityEnum)values.GetValue(num);
		}
		_WaterSystem.Settings.UseScreenSpaceReflection = num2 >= 0;
		if (num2 >= 0)
		{
			_WaterSystem.Settings.ScreenSpaceReflectionResolutionQuality = (WaterSystemScriptableData.ScreenSpaceReflectionResolutionQualityEnum)values2.GetValue(num2);
		}
		_WaterSystem.ForceUpdateWaterSettings(WaterSystem.WaterTab.Reflection);
	}

	private void GameCameraControllerOnOnEnterInToWater()
	{
		_WaterSystem.Settings.UseDynamicWaves = false;
		_WaterSystem.ForceUpdateWaterSettings();
	}

	private void GameCameraControllerOnOnExitFromWater()
	{
		_WaterSystem.Settings.UseDynamicWaves = true;
		_WaterSystem.ForceUpdateWaterSettings();
	}

	private void Update()
	{
	}

	private void EnableVolumetricLight()
	{
		_WaterSystem.Settings.UseVolumetricLight = true;
		_WaterSystem.ForceUpdateWaterSettings();
	}

	private void DisableVolumetricLight()
	{
		_WaterSystem.Settings.UseVolumetricLight = false;
		_WaterSystem.ForceUpdateWaterSettings();
	}

	private void LoadPlayerSettings()
	{
		SettingsManagerOnOnSettingApply();
	}

	private void SetPlanarReflection(bool val)
	{
		_WaterSystem = GetComponent<WaterSystem>();
		_WaterSystem.Settings.UsePlanarReflection = val;
		_WaterSystem.ForceUpdateWaterSettings();
	}

	private void SetMeshDetail(int val)
	{
		switch (val)
		{
		case 0:
			_WaterSystem.Settings.WaterMeshQualityInfinite = WaterSystemScriptableData.WaterMeshQualityEnum.VeryLow;
			break;
		case 1:
			_WaterSystem.Settings.WaterMeshQualityInfinite = WaterSystemScriptableData.WaterMeshQualityEnum.Medium;
			break;
		case 2:
			_WaterSystem.Settings.WaterMeshQualityInfinite = WaterSystemScriptableData.WaterMeshQualityEnum.High;
			break;
		case 3:
			_WaterSystem.Settings.WaterMeshQualityInfinite = WaterSystemScriptableData.WaterMeshQualityEnum.Ultra;
			break;
		}
	}

	private void SetWavesDetail(int val)
	{
	}

	private void SetReflectionsDetail(int val)
	{
		switch (val)
		{
		case 0:
			_WaterSystem.Settings.PlanarReflectionResolutionQuality = WaterSystemScriptableData.PlanarReflectionResolutionQualityEnum.VeryLow;
			break;
		case 1:
			_WaterSystem.Settings.PlanarReflectionResolutionQuality = WaterSystemScriptableData.PlanarReflectionResolutionQualityEnum.Medium;
			break;
		case 2:
			_WaterSystem.Settings.PlanarReflectionResolutionQuality = WaterSystemScriptableData.PlanarReflectionResolutionQualityEnum.High;
			break;
		case 3:
			_WaterSystem.Settings.PlanarReflectionResolutionQuality = WaterSystemScriptableData.PlanarReflectionResolutionQualityEnum.Ultra;
			break;
		}
	}

	private void SetDynamicWavesDetail(int val)
	{
		switch (val)
		{
		case 0:
			_WaterSystem.Settings.DynamicWavesResolutionPerMeter = 5;
			break;
		case 1:
			_WaterSystem.Settings.DynamicWavesResolutionPerMeter = 15;
			break;
		case 2:
			_WaterSystem.Settings.DynamicWavesResolutionPerMeter = 35;
			break;
		case 3:
			_WaterSystem.Settings.DynamicWavesResolutionPerMeter = 50;
			break;
		}
	}

	private void SetVolumetricLightingDetail(int val)
	{
		switch (val)
		{
		case 0:
			_WaterSystem.Settings.VolumetricLightResolutionQuality = WaterSystemScriptableData.VolumetricLightResolutionQualityEnum.VeryLow;
			break;
		case 1:
			_WaterSystem.Settings.VolumetricLightResolutionQuality = WaterSystemScriptableData.VolumetricLightResolutionQualityEnum.Medium;
			break;
		case 2:
			_WaterSystem.Settings.VolumetricLightResolutionQuality = WaterSystemScriptableData.VolumetricLightResolutionQualityEnum.High;
			break;
		case 3:
			_WaterSystem.Settings.VolumetricLightResolutionQuality = WaterSystemScriptableData.VolumetricLightResolutionQualityEnum.Ultra;
			break;
		}
	}

	private void SetCausticDetail(int val)
	{
		switch (val)
		{
		case 0:
			_WaterSystem.Settings.GlobalCausticTextureResolutionQuality = WaterSystemScriptableData.CausticTextureResolutionQualityEnum.Low;
			break;
		case 1:
			_WaterSystem.Settings.GlobalCausticTextureResolutionQuality = WaterSystemScriptableData.CausticTextureResolutionQualityEnum.Medium;
			break;
		case 2:
			_WaterSystem.Settings.GlobalCausticTextureResolutionQuality = WaterSystemScriptableData.CausticTextureResolutionQualityEnum.High;
			break;
		case 3:
			_WaterSystem.Settings.GlobalCausticTextureResolutionQuality = WaterSystemScriptableData.CausticTextureResolutionQualityEnum.Ultra;
			break;
		}
	}

	[Command("hide-water", Platform.AllPlatforms, MonoTargetType.Single)]
	private void HideWater()
	{
		_WaterSystem.WaterRenderingActive = false;
		_WaterSystem.enabled = false;
	}

	[Command("show-water", Platform.AllPlatforms, MonoTargetType.Single)]
	private void ShowWater()
	{
		_WaterSystem.WaterRenderingActive = true;
		_WaterSystem.enabled = true;
	}

	private void SetRainDrops(float strength)
	{
		_WaterSystem.Settings.UseDynamicWavesRainEffect = strength > 0f;
		_WaterSystem.Settings.DynamicWavesRainStrength = Mathf.Clamp(strength, 0f, 1f);
	}

	private void GameCameraController_OnExitFromWater()
	{
		_WaterSystem.Settings.Transparent = _TransparentOriginal;
		_WaterSystem.Settings.DyeColor = _DyeColor_Outwater;
		_WaterSystem.Settings.TurbidityColor = _Turbidity_Outwater;
		_WaterSystem.WaterRenderingActive = true;
		_WaterSystem.ForceUpdateWaterSettings(WaterSystem.WaterTab.ColorSettings);
	}

	private void GameCameraController_OnEnterInToWater()
	{
		_WaterSystem.Settings.Transparent = _TransparentUnderwater;
		Color.RGBToHSV(_DyeColor_Underwater, out var H, out var S, out var _);
		Color dyeColor = Color.HSVToRGB(H, S, 1f);
		_WaterSystem.Settings.DyeColor = dyeColor;
		_WaterSystem.Settings.TurbidityColor = _Turbidity_Underwater;
		GameWaterSystem.FindWaterSystemAtLocation(Singleton<GameCameraController>.Instance.transform.position, out var waterSystem);
		_WaterSystem.WaterRenderingActive = waterSystem == _WaterSystem;
		_WaterSystem.ForceUpdateWaterSettings(WaterSystem.WaterTab.ColorSettings);
	}
}