using System.Collections;
using System.IO;
using GISTech.GISTerrainLoader;
using UnityEngine;
using UnityEngine.UI;

public class MainUI : MonoBehaviour
{
	public Button LoadTerrain;

	public Text TerrainPathText;

	public Scrollbar Terrain_Exaggeration;

	public Dropdown ProjectionMode_DropDown;

	public InputField EPSGCode_Input;

	public Dropdown ElevationMode;

	public Text Terrain_Exaggeration_value;

	public Dropdown DimensionMode;

	public InputField TerrainLenght;

	public InputField TerrainWidth;

	public Dropdown UnderWaterMode;

	public Dropdown AutoFixMode;

	public InputField MinElevation;

	public InputField MaxElevation;

	public InputField TerrainScale_x;

	public InputField TerrainScale_y;

	public InputField TerrainScale_z;

	public Dropdown HeightMapResolution;

	public Dropdown TexturingMode;

	public Dropdown ShaderType;

	public Dropdown VectorType;

	public Dropdown GenerateTrees;

	public Dropdown GenerateGrass;

	public Dropdown GenerateRoads;

	public Dropdown GenerateBuildings;

	public Button GenerateTerrainBtn;

	private RuntimeTerrainGenerator RuntimeGenerator;

	private GISTerrainLoaderPrefs Prefs;

	private GISTerrainLoaderRuntimePrefs RuntimePrefs;

	private Camera3D camera3d;

	public Scrollbar GenerationProgress;

	public Text Phasename;

	public Text progressValue;

	private void Start()
	{
		RuntimeTerrainGenerator.OnProgress += OnGeneratingTerrainProg;
		Debug.Log("Runtime File Browser Not Installed, to install it From the main menu click on Tools/GIS Tech/GIS Terrain Loader/Install Libs/FileBrowser/Import_FileBrowser");
		if ((bool)camera3d)
		{
			camera3d = Camera.main.GetComponent<Camera3D>();
			camera3d.enabled = false;
		}
		LoadTerrain.onClick.AddListener(OnLoadBtnClicked);
		GenerateTerrainBtn.onClick.AddListener(OnGenerateTerrainbtnClicked);
		RuntimePrefs = GISTerrainLoaderMonoSingleton<GISTerrainLoaderRuntimePrefs>.Get;
		Prefs = RuntimePrefs.Prefs;
		Prefs.LoadSettings();
		RuntimeGenerator = GISTerrainLoaderMonoSingleton<RuntimeTerrainGenerator>.Get;
		ProjectionMode_DropDown.onValueChanged.AddListener(OnProjectionModeChanged);
		ElevationMode.onValueChanged.AddListener(OnElevationModeChanged);
		DimensionMode.onValueChanged.AddListener(OnDimensionModeChanged);
		Terrain_Exaggeration.onValueChanged.AddListener(OnTerrainExaggerationChanged);
		AutoFixMode.onValueChanged.AddListener(OnFixModeChanged);
		TexturingMode.onValueChanged.AddListener(OnTexturingModeChanged);
		ShaderType.onValueChanged.AddListener(OnShaderTypeChanged);
		VectorType.onValueChanged.AddListener(OnVectorTypeChanged);
		GenerateTrees.onValueChanged.AddListener(OnGenerateTreesChanged);
		GenerateGrass.onValueChanged.AddListener(OnGenerateGrassChanged);
		GenerateRoads.onValueChanged.AddListener(OnGenerateRoadsChanged);
		GenerateBuildings.onValueChanged.AddListener(OnGenerateBuildingsChanged);
	}

	private void OnGenerateTerrainbtnClicked()
	{
		if ((bool)camera3d)
		{
			camera3d.enabled = false;
		}
		RuntimeGenerator.enabled = true;
		string text = TerrainPathText.text;
		if (!string.IsNullOrEmpty(text) && File.Exists(text))
		{
			Prefs.TerrainFilePath = text;
			if (Prefs.projectionMode == ProjectionMode.Custom_EPSG)
			{
				if (!string.IsNullOrEmpty(EPSGCode_Input.text))
				{
					int ePSGCode = int.Parse(EPSGCode_Input.text);
					Prefs.EPSGCode = ePSGCode;
				}
				else
				{
					Prefs.projectionMode = ProjectionMode.Geographic;
					Prefs.EPSGCode = 0;
					Debug.LogError("EPSG Not Correct...");
				}
			}
			Prefs.TerrainElevation = (TerrainElevation)ElevationMode.value;
			Prefs.TerrainExaggeration = Terrain_Exaggeration.value;
			Prefs.terrainDimensionMode = (TerrainDimensionsMode)DimensionMode.value;
			Prefs.UnderWater = (OptionEnabDisab)UnderWaterMode.value;
			Prefs.TerrainFixOption = (FixOption)AutoFixMode.value;
			if (Prefs.TerrainFixOption == FixOption.ManualFix)
			{
				float x = float.Parse(MinElevation.text.Replace(".", ","));
				float y = float.Parse(MinElevation.text.Replace(".", ","));
				Prefs.TerrainMaxMinElevation = new Vector2(x, y);
			}
			float x2 = float.Parse(TerrainScale_x.text.Replace(".", ","));
			float y2 = float.Parse(TerrainScale_y.text.Replace(".", ","));
			float z = float.Parse(TerrainScale_z.text.Replace(".", ","));
			Prefs.terrainScale = new Vector3(x2, y2, z);
			Prefs.heightmapResolution_index = HeightMapResolution.value;
			Prefs.heightmapResolution = Prefs.heightmapResolutions[Prefs.heightmapResolution_index];
			Prefs.RemovePrvTerrain = OptionEnabDisab.Enable;
			if (!Prefs.Settings_SO.IsGeoFile(Path.GetExtension(text)) || Prefs.terrainDimensionMode == TerrainDimensionsMode.Manual)
			{
				if (string.IsNullOrEmpty(TerrainLenght.text) || string.IsNullOrEmpty(TerrainWidth.text))
				{
					Debug.LogError("Reset terrain Dimensions...");
					return;
				}
				float num = float.Parse(TerrainLenght.text.Replace(".", ","));
				float num2 = float.Parse(TerrainWidth.text.Replace(".", ","));
				Prefs.TerrainDimensions = new DVector2(num, num2);
			}
			StartCoroutine(RuntimeGenerator.StartGenerating(Prefs));
		}
		else
		{
			Debug.LogError("Terrain file null or not supported.. Try againe");
		}
	}

	private void OnTerrainExaggerationChanged(float value)
	{
		Terrain_Exaggeration_value.text = value.ToString();
	}

	private void OnProjectionModeChanged(int value)
	{
		Transform parent = EPSGCode_Input.transform.parent.parent.parent;
		switch (value)
		{
		case 0:
			parent.gameObject.SetActive(value: false);
			Prefs.projectionMode = ProjectionMode.Geographic;
			Prefs.EPSGCode = 0;
			break;
		case 1:
			parent.gameObject.SetActive(value: false);
			Prefs.projectionMode = ProjectionMode.AutoDetection;
			break;
		case 2:
			parent.gameObject.SetActive(value: true);
			Prefs.projectionMode = ProjectionMode.Custom_EPSG;
			break;
		}
	}

	private void OnElevationModeChanged(int value)
	{
		switch (value)
		{
		case 0:
			Terrain_Exaggeration.transform.parent.parent.gameObject.SetActive(value: false);
			Terrain_Exaggeration.transform.parent.parent.GetComponent<Element>().ShowElement = false;
			break;
		case 1:
			Terrain_Exaggeration.transform.parent.parent.gameObject.SetActive(value: true);
			Terrain_Exaggeration.transform.parent.parent.GetComponent<Element>().ShowElement = true;
			break;
		}
	}

	private void OnDimensionModeChanged(int value)
	{
		Transform parent = TerrainLenght.transform.parent.parent.parent.parent.parent.parent;
		switch (value)
		{
		case 0:
			parent.gameObject.SetActive(value: false);
			parent.GetComponent<Element>().ShowElement = false;
			break;
		case 1:
			parent.gameObject.SetActive(value: true);
			parent.GetComponent<Element>().ShowElement = true;
			break;
		}
	}

	private void OnFixModeChanged(int value)
	{
		Transform parent = MinElevation.transform.parent.parent.parent.parent.parent.parent;
		if (value == 2)
		{
			parent.gameObject.SetActive(value: true);
			parent.GetComponent<Element>().ShowElement = true;
		}
		else
		{
			parent.gameObject.SetActive(value: false);
			parent.GetComponent<Element>().ShowElement = false;
		}
	}

	private void OnTexturingModeChanged(int value)
	{
		Transform parent = ShaderType.transform.parent.parent.parent;
		Prefs.textureMode = (TextureMode)value;
		if (value == 5)
		{
			parent.gameObject.SetActive(value: true);
			parent.GetComponent<Element>().ShowElement = true;
		}
		else
		{
			parent.gameObject.SetActive(value: false);
			parent.GetComponent<Element>().ShowElement = false;
		}
	}

	private void OnVectorTypeChanged(int value)
	{
		Prefs.vectorType = (VectorType)value;
	}

	private void OnShaderTypeChanged(int value)
	{
		Prefs.TerrainShaderType = (ShaderType)value;
	}

	private void OnGenerateTreesChanged(int value)
	{
		if (value == 0)
		{
			Prefs.EnableTreeGeneration = OptionEnabDisab.Disable;
		}
		else
		{
			Prefs.EnableTreeGeneration = OptionEnabDisab.Enable;
		}
	}

	private void OnGenerateGrassChanged(int value)
	{
		if (value == 0)
		{
			Prefs.EnableGrassGeneration = OptionEnabDisab.Disable;
		}
		else
		{
			Prefs.EnableGrassGeneration = OptionEnabDisab.Enable;
		}
	}

	private void OnGenerateRoadsChanged(int value)
	{
		if (value == 0)
		{
			Prefs.EnableRoadGeneration = OptionEnabDisab.Disable;
		}
		else
		{
			Prefs.EnableRoadGeneration = OptionEnabDisab.Enable;
		}
	}

	private void OnGenerateBuildingsChanged(int value)
	{
		if (value == 0)
		{
			Prefs.EnableBuildingGeneration = OptionEnabDisab.Disable;
		}
		else
		{
			Prefs.EnableBuildingGeneration = OptionEnabDisab.Enable;
		}
	}

	private void OnLoadBtnClicked()
	{
		StartCoroutine(ShowLoadDialogCoroutine());
	}

	private IEnumerator ShowLoadDialogCoroutine()
	{
		yield return null;
		OnTerrainFileChanged(TerrainPathText.text);
	}

	private void OnGeneratingTerrainProg(string phase, float progress)
	{
		if (!phase.Equals("Finalization"))
		{
			GenerationProgress.transform.parent.gameObject.SetActive(value: true);
			Phasename.text = phase.ToString();
			GenerationProgress.value = progress / 100f;
			progressValue.text = progress + "%";
		}
		else
		{
			if ((bool)camera3d)
			{
				camera3d.enabled = true;
			}
			GenerationProgress.transform.parent.gameObject.SetActive(value: false);
		}
	}

	private void OnTerrainFileChanged(string TerrainFilePath)
	{
		Prefs.TerrainHasDimensions = Prefs.Settings_SO.IsGeoFile(Path.GetExtension(TerrainFilePath));
		Transform parent = TerrainLenght.transform.parent.parent.parent.parent.parent.parent;
		if (!Prefs.TerrainHasDimensions)
		{
			parent.gameObject.SetActive(value: true);
			parent.gameObject.SetActive(value: true);
		}
		else
		{
			parent.gameObject.SetActive(value: false);
			parent.gameObject.SetActive(value: false);
		}
	}
}