using System.Collections.Generic;
using UnityEngine;

namespace DarkTonic.MasterAudio
{
	[AudioScriptOrder(-35)]
	public class DynamicSoundGroupCreator : MonoBehaviour
	{
		public enum CreateItemsWhen
		{
			FirstEnableOnly = 0,
			EveryEnable = 1
		}

		public const int ExtraHardCodedBusOptions = 1;

		public SystemLanguage previewLanguage = SystemLanguage.English;

		public MasterAudio.DragGroupMode curDragGroupMode;

		public GameObject groupTemplate;

		public GameObject variationTemplate;

		public bool errorOnDuplicates;

		public bool createOnAwake = true;

		public bool soundGroupsAreExpanded = true;

		public bool removeGroupsOnSceneChange = true;

		public CreateItemsWhen reUseMode;

		public bool showCustomEvents = true;

		public MasterAudio.AudioLocation bulkVariationMode;

		public List<CustomEvent> customEventsToCreate = new List<CustomEvent>();

		public List<CustomEventCategory> customEventCategories = new List<CustomEventCategory>
		{
			new CustomEventCategory()
		};

		public string newEventName = "my event";

		public string newCustomEventCategoryName = "New Category";

		public string addToCustomEventCategoryName = "New Category";

		public bool showMusicDucking = true;

		public List<DuckGroupInfo> musicDuckingSounds = new List<DuckGroupInfo>();

		public List<GroupBus> groupBuses = new List<GroupBus>();

		public bool playListExpanded;

		public bool playlistEditorExp = true;

		public List<MasterAudio.Playlist> musicPlaylists = new List<MasterAudio.Playlist>();

		public List<GameObject> audioSourceTemplates = new List<GameObject>(10);

		public string audioSourceTemplateName = "Max Distance 500";

		public bool groupByBus;

		public bool showRTPC;

		public bool showParameterManagement = true;

		public List<RealTimeParameter> realTimeParameters = new List<RealTimeParameter>();

		public bool showParameterCommands;

		public bool showParameterCommandGizmo;

		public List<ParameterCommand> parameterCommands = new List<ParameterCommand>();

		public ParameterCommandElement parameterCommandToGizmo;

		public bool itemsCreatedEventExpanded;

		public string itemsCreatedCustomEvent = string.Empty;

		public bool showUnityMixerGroupAssignment = true;

		private bool _hasCreated;

		private readonly List<Transform> _groupsToRemove = new List<Transform>();

		private Transform _trans;

		private int _instanceId = -1;

		private readonly List<DynamicSoundGroup> _groupsToCreate = new List<DynamicSoundGroup>();

		public static int HardCodedBusOptions => 3;

		public List<DynamicSoundGroup> GroupsToCreate => _groupsToCreate;

		public int InstanceId
		{
			get
			{
				if (_instanceId < 0)
				{
					_instanceId = GetInstanceID();
				}
				return _instanceId;
			}
		}

		public bool ShouldShowUnityAudioMixerGroupAssignments => showUnityMixerGroupAssignment;

		private void Awake()
		{
			_trans = base.transform;
			_hasCreated = false;
			AudioSource component = GetComponent<AudioSource>();
			if (component != null)
			{
				Object.Destroy(component);
			}
		}

		private void OnEnable()
		{
			CreateItemsIfReady();
		}

		private void Start()
		{
			CreateItemsIfReady();
		}

		private void OnDisable()
		{
			if (!MasterAudio.AppIsShuttingDown && removeGroupsOnSceneChange && MasterAudio.SafeInstance != null)
			{
				RemoveItems();
			}
		}

		private void OnDrawGizmos()
		{
			if (!(MasterAudio.SafeInstance == null) && MasterAudio.Instance.showRangeSoundGizmos && showParameterCommandGizmo && parameterCommandToGizmo != null && parameterCommandToGizmo.ColliderMaxDistance != 0f)
			{
				Color color = Color.green;
				if (MasterAudio.SafeInstance != null)
				{
					color = MasterAudio.Instance.rangeGizmoColor;
				}
				Gizmos.color = color;
				Gizmos.DrawWireSphere(base.transform.position, parameterCommandToGizmo.ColliderMaxDistance);
			}
		}

		private void OnDrawGizmosSelected()
		{
			if (!(MasterAudio.SafeInstance == null) && MasterAudio.Instance.showRangeSoundGizmos && showParameterCommandGizmo && parameterCommandToGizmo != null && parameterCommandToGizmo.ColliderMaxDistance != 0f)
			{
				Color color = Color.green;
				if (MasterAudio.SafeInstance != null)
				{
					color = MasterAudio.Instance.selectedRangeGizmoColor;
				}
				Gizmos.color = color;
				Gizmos.DrawWireSphere(base.transform.position, parameterCommandToGizmo.ColliderMaxDistance);
			}
		}

		private void CreateItemsIfReady()
		{
			if (!(MasterAudio.SafeInstance == null) && createOnAwake && MasterAudio.SoundsReady && !_hasCreated)
			{
				CreateItems();
			}
		}

		public void RemoveItems()
		{
			for (int i = 0; i < groupBuses.Count; i++)
			{
				GroupBus groupBus = groupBuses[i];
				if (groupBus.isExisting)
				{
					continue;
				}
				GroupBus groupBus2 = MasterAudio.GrabBusByName(groupBus.busName);
				if (groupBus2 != null && !groupBus2.isTemporary)
				{
					continue;
				}
				if (groupBus2 != null)
				{
					groupBus2.RemoveActorInstanceId(InstanceId);
					if (groupBus2.HasLiveActors)
					{
						continue;
					}
				}
				MasterAudio.DeleteBusByName(groupBus.busName);
			}
			for (int j = 0; j < _groupsToRemove.Count; j++)
			{
				string sType = _groupsToRemove[j].name;
				MasterAudioGroup masterAudioGroup = MasterAudio.GrabGroup(sType, logIfMissing: false);
				if (!(masterAudioGroup == null))
				{
					masterAudioGroup.RemoveActorInstanceId(InstanceId);
					if (!masterAudioGroup.HasLiveActors && masterAudioGroup.isTemporary)
					{
						MasterAudio.RemoveSoundGroupFromDuckList(sType);
						MasterAudio.DeleteSoundGroup(sType);
					}
				}
			}
			_groupsToRemove.Clear();
			for (int k = 0; k < customEventsToCreate.Count; k++)
			{
				CustomEvent anEvent = customEventsToCreate[k];
				CustomEvent customEvent = MasterAudio.Instance.customEvents.Find((CustomEvent cEvent) => cEvent.EventName == anEvent.EventName && cEvent.isTemporary);
				if (customEvent != null)
				{
					customEvent.RemoveActorInstanceId(InstanceId);
					if (!customEvent.HasLiveActors)
					{
						MasterAudio.DeleteCustomEvent(anEvent.EventName);
					}
				}
			}
			for (int num = 0; num < customEventCategories.Count; num++)
			{
				CustomEventCategory aCat = customEventCategories[num];
				CustomEventCategory customEventCategory = MasterAudio.Instance.customEventCategories.Find((CustomEventCategory category) => category.CatName == aCat.CatName && category.IsTemporary);
				if (customEventCategory != null)
				{
					customEventCategory.RemoveActorInstanceId(InstanceId);
					if (!customEventCategory.HasLiveActors)
					{
						MasterAudio.Instance.customEventCategories.Remove(customEventCategory);
					}
				}
			}
			for (int num2 = 0; num2 < musicPlaylists.Count; num2++)
			{
				MasterAudio.Playlist playlist = musicPlaylists[num2];
				MasterAudio.Playlist playlist2 = MasterAudio.GrabPlaylist(playlist.playlistName, logErrorIfNotFound: false);
				if (playlist2 != null)
				{
					playlist2.RemoveActorInstanceId(InstanceId);
					if (!playlist2.HasLiveActors)
					{
						MasterAudio.DeletePlaylist(playlist.playlistName);
					}
				}
			}
			for (int num3 = 0; num3 < parameterCommands.Count; num3++)
			{
				ParameterCommand command = parameterCommands[num3];
				ParameterCommand parameterCommand = MasterAudio.Instance.parameterCommands.Find((ParameterCommand cmd) => cmd.ParameterName == command.ParameterName && cmd.IsTemporary);
				if (parameterCommand != null)
				{
					MasterAudio.StopParameterCommandsByCommandName(command.CommandName);
					MasterAudio.Instance.parameterCommands.Remove(parameterCommand);
				}
			}
			for (int num4 = 0; num4 < realTimeParameters.Count; num4++)
			{
				RealTimeParameter aParam = realTimeParameters[num4];
				RealTimeParameter realTimeParameter = MasterAudio.Instance.realTimeParameters.Find((RealTimeParameter parameter) => parameter.ParameterName == aParam.ParameterName && parameter.IsTemporary);
				if (realTimeParameter != null)
				{
					MasterAudio.Instance.realTimeParameters.Remove(realTimeParameter);
				}
			}
			if (reUseMode == CreateItemsWhen.EveryEnable)
			{
				_hasCreated = false;
			}
			MasterAudio.SilenceOrUnsilenceGroupsFromSoloChange();
		}

		public void CreateItems()
		{
			if (_hasCreated)
			{
				Debug.LogWarning("DynamicSoundGroupCreator '" + base.transform.name + "' has already created its items. Cannot create again.");
			}
			else
			{
				if (MasterAudio.Instance == null)
				{
					return;
				}
				PopulateGroupData();
				for (int i = 0; i < groupBuses.Count; i++)
				{
					GroupBus groupBus = groupBuses[i];
					if (groupBus.isExisting)
					{
						if (MasterAudio.GrabBusByName(groupBus.busName) == null)
						{
							MasterAudio.LogWarning("Existing bus '" + groupBus.busName + "' was not found, specified in prefab '" + base.name + "'.");
						}
						continue;
					}
					GroupBus groupBus2 = MasterAudio.GrabBusByName(groupBus.busName);
					if (groupBus2 == null)
					{
						if (MasterAudio.CreateBus(groupBus.busName, InstanceId, errorOnDuplicates, isTemporary: true))
						{
							groupBus2 = MasterAudio.GrabBusByName(groupBus.busName);
						}
					}
					else
					{
						groupBus2.AddActorInstanceId(InstanceId);
					}
					if (groupBus2 != null)
					{
						if (!PersistentAudioSettings.GetBusVolume(groupBus.busName).HasValue)
						{
							groupBus2.volume = groupBus.volume;
							groupBus2.OriginalVolume = groupBus2.volume;
						}
						groupBus2.voiceLimit = groupBus.voiceLimit;
						groupBus2.busVoiceLimitExceededMode = groupBus.busVoiceLimitExceededMode;
						groupBus2.forceTo2D = groupBus.forceTo2D;
						groupBus2.bypassReverbZones = groupBus.bypassReverbZones;
						groupBus2.mixerChannel = groupBus.mixerChannel;
						groupBus2.busColor = groupBus.busColor;
						groupBus2.isUsingOcclusion = groupBus.isUsingOcclusion;
					}
				}
				for (int j = 0; j < _groupsToCreate.Count; j++)
				{
					DynamicSoundGroup dynamicSoundGroup = _groupsToCreate[j];
					string busName = string.Empty;
					int num = ((dynamicSoundGroup.busIndex != -1) ? dynamicSoundGroup.busIndex : 0);
					if (num >= HardCodedBusOptions)
					{
						busName = groupBuses[num - HardCodedBusOptions].busName;
					}
					dynamicSoundGroup.busName = busName;
					MasterAudioGroup masterAudioGroup = MasterAudio.GrabGroup(dynamicSoundGroup.name, logIfMissing: false);
					Transform transform;
					if (masterAudioGroup != null)
					{
						if (errorOnDuplicates)
						{
							Debug.LogError("Sound Group named '" + dynamicSoundGroup.name + "' already exists in MasterAudio game object. Skipping creation,");
						}
						masterAudioGroup.AddActorInstanceId(InstanceId);
						transform = masterAudioGroup.transform;
					}
					else
					{
						transform = MasterAudio.CreateSoundGroup(dynamicSoundGroup, InstanceId, errorOnDuplicates);
					}
					for (int k = 0; k < dynamicSoundGroup.groupVariations.Count; k++)
					{
						DynamicGroupVariation dynamicGroupVariation = dynamicSoundGroup.groupVariations[k];
						if (dynamicGroupVariation.LowPassFilter != null)
						{
							Object.Destroy(dynamicGroupVariation.LowPassFilter);
						}
						if (dynamicGroupVariation.HighPassFilter != null)
						{
							Object.Destroy(dynamicGroupVariation.HighPassFilter);
						}
						if (dynamicGroupVariation.DistortionFilter != null)
						{
							Object.Destroy(dynamicGroupVariation.DistortionFilter);
						}
						if (dynamicGroupVariation.ChorusFilter != null)
						{
							Object.Destroy(dynamicGroupVariation.ChorusFilter);
						}
						if (dynamicGroupVariation.EchoFilter != null)
						{
							Object.Destroy(dynamicGroupVariation.EchoFilter);
						}
						if (dynamicGroupVariation.ReverbFilter != null)
						{
							Object.Destroy(dynamicGroupVariation.ReverbFilter);
						}
					}
					if (!(transform == null))
					{
						_groupsToRemove.Add(transform);
					}
				}
				for (int l = 0; l < musicDuckingSounds.Count; l++)
				{
					DuckGroupInfo duckGroupInfo = musicDuckingSounds[l];
					if (!(duckGroupInfo.soundType == "[None]"))
					{
						MasterAudio.AddSoundGroupToDuckList(duckGroupInfo.soundType, duckGroupInfo.riseVolStart, duckGroupInfo.duckedVolumeCut, duckGroupInfo.unduckTime, duckGroupInfo.duckMode, duckGroupInfo.enableDistanceDuckRatio, isTemporary: true);
					}
				}
				for (int m = 0; m < customEventCategories.Count; m++)
				{
					MasterAudio.CreateCustomEventCategoryIfNotThere(customEventCategories[m].CatName, InstanceId, errorOnDuplicates, isTemporary: true);
				}
				for (int n = 0; n < customEventsToCreate.Count; n++)
				{
					CustomEvent customEvent = customEventsToCreate[n];
					MasterAudio.CreateCustomEvent(customEvent.EventName, customEvent.eventReceiveMode, customEvent.distanceThreshold, customEvent.eventRcvFilterMode, customEvent.filterModeQty, InstanceId, customEvent.categoryName, isTemporary: true, errorOnDuplicates);
				}
				for (int num2 = 0; num2 < musicPlaylists.Count; num2++)
				{
					MasterAudio.Playlist aPlaylist = musicPlaylists[num2];
					aPlaylist.isTemporary = true;
					MasterAudio.Playlist playlist = MasterAudio.Instance.musicPlaylists.Find((MasterAudio.Playlist playlist2) => playlist2.playlistName == aPlaylist.playlistName && aPlaylist.isTemporary);
					if (playlist != null)
					{
						playlist.AddActorInstanceId(InstanceId);
						continue;
					}
					MasterAudio.CreatePlaylist(aPlaylist, errorOnDuplicates);
					aPlaylist.AddActorInstanceId(InstanceId);
				}
				MasterAudio.SilenceOrUnsilenceGroupsFromSoloChange();
				for (int num3 = 0; num3 < realTimeParameters.Count; num3++)
				{
					RealTimeParameter realTimeParameter = realTimeParameters[num3];
					MasterAudio.CreateRealTimeParameter(realTimeParameter.ParameterName, 0f, realTimeParameter.IsExpanded, realTimeParameter.MinValue, realTimeParameter.MaxValue, isTemporary: true, errorOnDuplicates);
				}
				for (int num4 = 0; num4 < parameterCommands.Count; num4++)
				{
					ParameterCommand parameterCommand = parameterCommands[num4];
					ParameterCommand parameterCommand2 = MasterAudio.CreateRealTimeParameterCommand(parameterCommand.CommandName, parameterCommand.ParameterName, parameterCommand.IsExpanded, parameterCommand.MinDisplayCurveX, parameterCommand.MaxDisplayCurveX, isTemporary: true, errorOnDuplicates);
					if (parameterCommand2 != null)
					{
						for (int num5 = 0; num5 < parameterCommand.Elements.Count; num5++)
						{
							ParameterCommandElement parameterCommandElement = parameterCommand.Elements[num5];
							MasterAudio.CreateParameterCommandElement(parameterCommand2, parameterCommandElement.ElementName, parameterCommandElement.VariationName, parameterCommandElement.IsExpanded, parameterCommandElement.ShowAdvanced, parameterCommandElement.VariationMode, parameterCommandElement.SoundGroup, parameterCommandElement.Volume, parameterCommandElement.OverridePitch, parameterCommandElement.Pitch, parameterCommandElement.DelaySound, parameterCommandElement.FadeInRangeStart, parameterCommandElement.FadeInRangeEnd, parameterCommandElement.FadeOutRangeStart, parameterCommandElement.FadeOutRangeEnd, parameterCommandElement.SoundSpawnLocationMode, parameterCommandElement.ShowCurves, parameterCommandElement.AffectVolume, parameterCommandElement.VolumeAnimationCurve, parameterCommandElement.AffectPitch, parameterCommandElement.PitchAnimationCurve, parameterCommandElement.ShowFadeInOutFields, parameterCommandElement.AffectLowPassFilter, parameterCommandElement.LowPassAnimationCurve, parameterCommandElement.AffectHighPassFilter, parameterCommandElement.HighPassAnimationCurve, parameterCommandElement.MaxDisplayVolumeCurveY, errorOnDuplicates);
						}
					}
				}
				_hasCreated = true;
				if (itemsCreatedEventExpanded)
				{
					FireEvents();
				}
			}
		}

		private void FireEvents()
		{
			MasterAudio.FireCustomEventNextFrame(itemsCreatedCustomEvent, _trans);
		}

		public void PopulateGroupData()
		{
			if (_trans == null)
			{
				_trans = base.transform;
			}
			_groupsToCreate.Clear();
			for (int i = 0; i < _trans.childCount; i++)
			{
				DynamicSoundGroup component = _trans.GetChild(i).GetComponent<DynamicSoundGroup>();
				if (component == null)
				{
					continue;
				}
				component.groupVariations.Clear();
				for (int j = 0; j < component.transform.childCount; j++)
				{
					DynamicGroupVariation component2 = component.transform.GetChild(j).GetComponent<DynamicGroupVariation>();
					if (!(component2 == null))
					{
						component.groupVariations.Add(component2);
					}
				}
				_groupsToCreate.Add(component);
			}
		}

		public AudioSource GetNamedOrFirstAudioSource(ParameterCommandElement parameterCommandElement)
		{
			if (string.IsNullOrEmpty(parameterCommandElement.SoundGroup))
			{
				parameterCommandElement.ColliderMaxDistance = 0f;
				return null;
			}
			Transform transform = base.transform.Find(parameterCommandElement.SoundGroup);
			if (transform == null)
			{
				parameterCommandElement.ColliderMaxDistance = 0f;
				return null;
			}
			Transform transform2 = null;
			switch (parameterCommandElement.VariationMode)
			{
			case EventSounds.VariationType.PlayRandom:
				transform2 = transform.GetChild(0);
				break;
			case EventSounds.VariationType.PlaySpecific:
				transform2 = transform.transform.Find(parameterCommandElement.VariationName);
				break;
			}
			if (transform2 == null)
			{
				parameterCommandElement.ColliderMaxDistance = 0f;
				return null;
			}
			return transform2.GetComponent<AudioSource>();
		}

		public List<AudioSource> GetAllVariationAudioSources(ParameterCommandElement element)
		{
			if (string.IsNullOrEmpty(element.SoundGroup))
			{
				element.ColliderMaxDistance = 0f;
				return null;
			}
			Transform transform = base.transform.Find(element.SoundGroup);
			if (transform == null)
			{
				element.ColliderMaxDistance = 0f;
				return null;
			}
			List<AudioSource> list = new List<AudioSource>(transform.childCount);
			for (int i = 0; i < transform.childCount; i++)
			{
				AudioSource component = transform.GetChild(i).GetComponent<AudioSource>();
				list.Add(component);
			}
			return list;
		}

		public void CalculateRadius(ParameterCommandElement element)
		{
			AudioSource namedOrFirstAudioSource = GetNamedOrFirstAudioSource(element);
			if (namedOrFirstAudioSource == null)
			{
				element.ColliderMaxDistance = 0f;
			}
			else
			{
				element.ColliderMaxDistance = namedOrFirstAudioSource.maxDistance;
			}
		}
	}
}