using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.Playables;

namespace UnityEngine.Timeline
{
	// Token: 0x0200000C RID: 12
	[Serializable]
	public class TimelineAsset : PlayableAsset, ISerializationCallbackReceiver, ITimelineClipAsset, IPropertyPreview
	{
		// Token: 0x17000014 RID: 20
		// (get) Token: 0x0600005E RID: 94 RVA: 0x00004618 File Offset: 0x00002818
		public TimelineAsset.EditorSettings editorSettings
		{
			get
			{
				return this.m_EditorSettings;
			}
		}

		// Token: 0x17000015 RID: 21
		// (get) Token: 0x0600005F RID: 95 RVA: 0x00004634 File Offset: 0x00002834
		public override double duration
		{
			get
			{
				double num;
				if (this.m_DurationMode == TimelineAsset.DurationMode.BasedOnClips)
				{
					num = this.CalculateDuration();
				}
				else
				{
					num = this.m_FixedDuration;
				}
				return num;
			}
		}

		// Token: 0x17000016 RID: 22
		// (get) Token: 0x06000060 RID: 96 RVA: 0x00004668 File Offset: 0x00002868
		// (set) Token: 0x06000061 RID: 97 RVA: 0x000046B5 File Offset: 0x000028B5
		public double fixedDuration
		{
			get
			{
				DiscreteTime discreteTime = (DiscreteTime)this.m_FixedDuration;
				double num;
				if (discreteTime <= 0)
				{
					num = 0.0;
				}
				else
				{
					num = (double)discreteTime.OneTickBefore();
				}
				return num;
			}
			set
			{
				this.m_FixedDuration = Math.Max(0.0, value);
			}
		}

		// Token: 0x17000017 RID: 23
		// (get) Token: 0x06000062 RID: 98 RVA: 0x000046D0 File Offset: 0x000028D0
		// (set) Token: 0x06000063 RID: 99 RVA: 0x000046EB File Offset: 0x000028EB
		public TimelineAsset.DurationMode durationMode
		{
			get
			{
				return this.m_DurationMode;
			}
			set
			{
				this.m_DurationMode = value;
			}
		}

		// Token: 0x17000018 RID: 24
		// (get) Token: 0x06000064 RID: 100 RVA: 0x000046F8 File Offset: 0x000028F8
		public override IEnumerable<PlayableBinding> outputs
		{
			get
			{
				return this.GetOutputTracks().SelectMany((TrackAsset x) => x.outputs).ToArray<PlayableBinding>();
			}
		}

		// Token: 0x17000019 RID: 25
		// (get) Token: 0x06000065 RID: 101 RVA: 0x0000473C File Offset: 0x0000293C
		public ClipCaps clipCaps
		{
			get
			{
				ClipCaps clipCaps = ClipCaps.All;
				foreach (TrackAsset trackAsset in this.m_Tracks)
				{
					foreach (TimelineClip timelineClip in trackAsset.clips)
					{
						clipCaps &= timelineClip.clipCaps;
					}
				}
				return clipCaps;
			}
		}

		// Token: 0x1700001A RID: 26
		// (get) Token: 0x06000066 RID: 102 RVA: 0x000047D4 File Offset: 0x000029D4
		public int outputTrackCount
		{
			get
			{
				this.GetOutputTracks();
				return this.m_CacheOutputTracks.Length;
			}
		}

		// Token: 0x1700001B RID: 27
		// (get) Token: 0x06000067 RID: 103 RVA: 0x000047F8 File Offset: 0x000029F8
		public int rootTrackCount
		{
			get
			{
				return this.m_Tracks.Count;
			}
		}

		// Token: 0x06000068 RID: 104 RVA: 0x00004818 File Offset: 0x00002A18
		public TrackAsset GetRootTrack(int index)
		{
			return this.m_Tracks[index];
		}

		// Token: 0x06000069 RID: 105 RVA: 0x0000483C File Offset: 0x00002A3C
		public IEnumerable<TrackAsset> GetRootTracks()
		{
			return this.m_Tracks;
		}

		// Token: 0x0600006A RID: 106 RVA: 0x00004858 File Offset: 0x00002A58
		public TrackAsset GetOutputTrack(int index)
		{
			this.GetOutputTracks();
			return this.m_CacheOutputTracks[index];
		}

		// Token: 0x0600006B RID: 107 RVA: 0x0000487C File Offset: 0x00002A7C
		public IEnumerable<TrackAsset> GetOutputTracks()
		{
			if (this.m_CacheOutputTracks == null)
			{
				this.m_CacheOutputTracks = this.flattenedTracks.Where((TrackAsset t) => t != null && t.mediaType != TimelineAsset.MediaType.Group && !t.isSubTrack).ToArray<TrackAsset>();
			}
			return this.m_CacheOutputTracks;
		}

		// Token: 0x0600006C RID: 108 RVA: 0x000048D8 File Offset: 0x00002AD8
		public void OnEnable()
		{
			if (this.m_Tracks == null)
			{
				this.m_Tracks = new List<TrackAsset>();
			}
			this.m_Tracks.RemoveAll((TrackAsset t) => t == null);
		}

		// Token: 0x1700001C RID: 28
		// (get) Token: 0x0600006D RID: 109 RVA: 0x00004928 File Offset: 0x00002B28
		// (set) Token: 0x0600006E RID: 110 RVA: 0x00004943 File Offset: 0x00002B43
		internal int id
		{
			get
			{
				return this.m_Id;
			}
			set
			{
				this.m_Id = value;
			}
		}

		// Token: 0x1700001D RID: 29
		// (get) Token: 0x0600006F RID: 111 RVA: 0x00004950 File Offset: 0x00002B50
		internal IEnumerable<TrackAsset> flattenedTracks
		{
			get
			{
				if (this.m_CacheFlattenedTracks == null)
				{
					this.m_CacheFlattenedTracks = this.m_Tracks.ToList<TrackAsset>();
					foreach (TrackAsset trackAsset in this.m_Tracks)
					{
						TimelineAsset.AddSubTracksRecursive(trackAsset, ref this.m_CacheFlattenedTracks);
					}
				}
				return this.m_CacheFlattenedTracks;
			}
		}

		// Token: 0x1700001E RID: 30
		// (get) Token: 0x06000070 RID: 112 RVA: 0x000049E0 File Offset: 0x00002BE0
		internal List<TrackAsset> tracks
		{
			get
			{
				return this.m_Tracks;
			}
		}

		// Token: 0x06000071 RID: 113 RVA: 0x000049FB File Offset: 0x00002BFB
		internal void AddTrackInternal(TrackAsset track)
		{
			this.m_Tracks.Add(track);
			track.parent = this;
			this.Invalidate();
		}

		// Token: 0x06000072 RID: 114 RVA: 0x00004A18 File Offset: 0x00002C18
		internal void AddTrackBefore(TrackAsset track, TrackAsset before)
		{
			this.AddTrackInternal(track);
			this.MoveTracks(new List<TrackAsset> { track }, before, true);
		}

		// Token: 0x06000073 RID: 115 RVA: 0x00004A44 File Offset: 0x00002C44
		internal void AddTrackAfter(TrackAsset track, TrackAsset after)
		{
			this.AddTrackInternal(track);
			this.MoveTracks(new List<TrackAsset> { track }, after, false);
		}

		// Token: 0x06000074 RID: 116 RVA: 0x00004A70 File Offset: 0x00002C70
		internal void MoveTracks(List<TrackAsset> tracks, TrackAsset insertAfterAsset, bool up)
		{
			List<TrackAsset> list = new List<TrackAsset>(this.m_Tracks);
			for (int i = 0; i < tracks.Count; i++)
			{
				list.Remove(tracks[i]);
			}
			int num = list.IndexOf(insertAfterAsset);
			num = ((!up) ? (num + 1) : Math.Max(num - 1, 0));
			if (num < 0)
			{
				Debug.LogError("target track not found");
			}
			else
			{
				for (int j = 0; j < tracks.Count; j++)
				{
					num = ((!up) ? Math.Min(num, list.Count) : Math.Max(num, 0));
					list.Insert(num, tracks[j]);
				}
				this.m_Tracks = list;
			}
		}

		// Token: 0x06000075 RID: 117 RVA: 0x00004B38 File Offset: 0x00002D38
		internal void RemoveTrack(TrackAsset track)
		{
			this.m_Tracks.Remove(track);
			this.Invalidate();
			TrackAsset trackAsset = track.parent as TrackAsset;
			if (trackAsset != null)
			{
				trackAsset.RemoveSubTrack(track);
			}
		}

		// Token: 0x06000076 RID: 118 RVA: 0x00004B7C File Offset: 0x00002D7C
		internal int GenerateNewId()
		{
			this.m_NextId++;
			return base.GetInstanceID().GetHashCode().CombineHash(this.m_NextId.GetHashCode());
		}

		// Token: 0x06000077 RID: 119 RVA: 0x00004BCC File Offset: 0x00002DCC
		public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
		{
			bool flag = false;
			bool flag2 = graph.GetPlayableCount() == 0;
			ScriptPlayable<TimelinePlayable> scriptPlayable = TimelinePlayable.Create(graph, this.flattenedTracks.ToList<TrackAsset>(), go, flag, flag2);
			return (!scriptPlayable.IsValid<ScriptPlayable<TimelinePlayable>>()) ? Playable.Null : scriptPlayable;
		}

		// Token: 0x06000078 RID: 120 RVA: 0x00004C1E File Offset: 0x00002E1E
		void ISerializationCallbackReceiver.OnAfterDeserialize()
		{
			this.Invalidate();
		}

		// Token: 0x06000079 RID: 121 RVA: 0x00004C27 File Offset: 0x00002E27
		void ISerializationCallbackReceiver.OnBeforeSerialize()
		{
		}

		// Token: 0x0600007A RID: 122 RVA: 0x00004C2C File Offset: 0x00002E2C
		public void GatherProperties(PlayableDirector director, IPropertyCollector driver)
		{
			IEnumerable<TrackAsset> outputTracks = this.GetOutputTracks();
			foreach (TrackAsset trackAsset in outputTracks)
			{
				trackAsset.GatherProperties(director, driver);
			}
		}

		// Token: 0x0600007B RID: 123 RVA: 0x00004C8C File Offset: 0x00002E8C
		internal void Invalidate()
		{
			this.m_CacheOutputTracks = null;
			this.m_CacheFlattenedTracks = null;
		}

		// Token: 0x0600007C RID: 124 RVA: 0x00004CA0 File Offset: 0x00002EA0
		private double CalculateDuration()
		{
			IEnumerable<TrackAsset> flattenedTracks = this.flattenedTracks;
			double num;
			if (!flattenedTracks.Any<TrackAsset>())
			{
				num = 0.0;
			}
			else
			{
				DiscreteTime discreteTime = (DiscreteTime)flattenedTracks.Max((TrackAsset t) => t.end);
				if (discreteTime <= 0)
				{
					num = 0.0;
				}
				else
				{
					num = (double)discreteTime.OneTickBefore();
				}
			}
			return num;
		}

		// Token: 0x0600007D RID: 125 RVA: 0x00004D2C File Offset: 0x00002F2C
		private static void AddSubTracksRecursive(TrackAsset track, ref List<TrackAsset> allTracks)
		{
			if (!(track == null))
			{
				if (track.subTracks != null && track.subTracks.Count != 0)
				{
					allTracks.AddRange(track.subTracks);
					foreach (TrackAsset trackAsset in track.subTracks)
					{
						TimelineAsset.AddSubTracksRecursive(trackAsset, ref allTracks);
					}
				}
			}
		}

		// Token: 0x0600007E RID: 126 RVA: 0x00004DCC File Offset: 0x00002FCC
		public TrackAsset CreateTrack(Type type, TrackAsset parent, string name)
		{
			if (parent != null && parent.timelineAsset != this)
			{
				throw new InvalidOperationException("Addtrack cannot parent to a track not in the Timeline");
			}
			if (!typeof(TrackAsset).IsAssignableFrom(type))
			{
				throw new InvalidOperationException("Supplied type must be a track asset");
			}
			if (parent != null)
			{
				if (!TimelineCreateUtilities.ValidateParentTrack(parent, type))
				{
					throw new InvalidOperationException("Cannot assign a child of type " + type.Name + "to a parent of type " + parent.GetType().Name);
				}
			}
			PlayableAsset playableAsset = ((!(parent != null)) ? this : parent);
			string text = name;
			if (string.IsNullOrEmpty(text))
			{
				text = type.Name;
			}
			string text2 = TimelineCreateUtilities.GenerateUniqueActorName(this, text);
			TrackAsset trackAsset = this.AllocateTrack(parent, text2, type);
			if (trackAsset != null)
			{
				trackAsset.name = text2;
				TimelineCreateUtilities.SaveAssetIntoObject(trackAsset, playableAsset);
			}
			return trackAsset;
		}

		// Token: 0x0600007F RID: 127 RVA: 0x00004EC4 File Offset: 0x000030C4
		public T CreateTrack<T>(TrackAsset parent, string name) where T : TrackAsset, new()
		{
			return (T)((object)this.CreateTrack(typeof(T), parent, name));
		}

		// Token: 0x06000080 RID: 128 RVA: 0x00004EF0 File Offset: 0x000030F0
		public bool DeleteClip(TimelineClip clip)
		{
			bool flag;
			if (clip == null || clip.parentTrack == null)
			{
				flag = false;
			}
			else if (this != clip.parentTrack.timelineAsset)
			{
				Debug.LogError("Cannot delete a clip from this timeline");
				flag = false;
			}
			else
			{
				if (clip.curves != null)
				{
					TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.curves, "Delete Curves");
				}
				if (clip.asset != null)
				{
					this.DeleteRecordedAnimation(clip);
					TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.asset, "Delete Clip Asset");
				}
				TrackAsset parentTrack = clip.parentTrack;
				parentTrack.RemoveClip(clip);
				parentTrack.CalculateExtrapolationTimes();
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000081 RID: 129 RVA: 0x00004FC0 File Offset: 0x000031C0
		public bool DeleteTrack(TrackAsset track)
		{
			bool flag;
			if (track.timelineAsset != this)
			{
				flag = false;
			}
			else
			{
				TrackAsset trackAsset = track.parent as TrackAsset;
				if (trackAsset != null)
				{
				}
				if (track.subTracks != null)
				{
					IEnumerable<TrackAsset> childTracks = track.GetChildTracks();
					foreach (TrackAsset trackAsset2 in childTracks)
					{
						this.DeleteTrack(trackAsset2);
					}
				}
				this.DeleteRecordingClip(track);
				List<TimelineClip> list = new List<TimelineClip>(track.clips);
				foreach (TimelineClip timelineClip in list)
				{
					this.DeleteClip(timelineClip);
				}
				this.RemoveTrack(track);
				TimelineUndo.PushDestroyUndo(this, this, track, "Delete Track");
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000082 RID: 130 RVA: 0x000050E0 File Offset: 0x000032E0
		internal TrackAsset AllocateTrack(TrackAsset parent, string name, Type trackType)
		{
			if (parent != null && parent.timelineAsset != this)
			{
				throw new InvalidOperationException("Addtrack cannot parent to a track not in the Timeline");
			}
			if (!typeof(TrackAsset).IsAssignableFrom(trackType))
			{
				throw new InvalidOperationException("Supplied type must be a track asset");
			}
			TrackAsset trackAsset = ScriptableObject.CreateInstance(trackType) as TrackAsset;
			if (parent != null)
			{
				trackAsset.parent = parent;
			}
			else
			{
				trackAsset.parent = this;
			}
			trackAsset.name = name;
			if (parent != null)
			{
				parent.subTracks.Add(trackAsset);
			}
			else
			{
				this.AddTrackInternal(trackAsset);
			}
			this.Invalidate();
			return trackAsset;
		}

		// Token: 0x06000083 RID: 131 RVA: 0x000051A4 File Offset: 0x000033A4
		private void DeleteRecordingClip(TrackAsset track)
		{
			AnimationTrack animationTrack = track as AnimationTrack;
			if (!(animationTrack == null) && !(animationTrack.animClip == null))
			{
				TimelineUndo.PushDestroyUndo(this, track, animationTrack.animClip, "Delete Track");
			}
		}

		// Token: 0x06000084 RID: 132 RVA: 0x000051F0 File Offset: 0x000033F0
		private void DeleteRecordedAnimation(TimelineClip clip)
		{
			if (clip != null)
			{
				if (clip.curves != null)
				{
					TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.curves, "Delete Parameters");
				}
				if (clip.recordable)
				{
					AnimationPlayableAsset animationPlayableAsset = clip.asset as AnimationPlayableAsset;
					if (!(animationPlayableAsset == null) && !(animationPlayableAsset.clip == null))
					{
						TimelineUndo.PushDestroyUndo(this, animationPlayableAsset, animationPlayableAsset.clip, "Delete Recording");
					}
				}
			}
		}

		// Token: 0x0400001E RID: 30
		[HideInInspector]
		[SerializeField]
		private int m_Id;

		// Token: 0x0400001F RID: 31
		[HideInInspector]
		[SerializeField]
		private int m_NextId;

		// Token: 0x04000020 RID: 32
		[HideInInspector]
		[SerializeField]
		private List<TrackAsset> m_Tracks;

		// Token: 0x04000021 RID: 33
		[HideInInspector]
		[SerializeField]
		private double m_FixedDuration;

		// Token: 0x04000022 RID: 34
		[HideInInspector]
		[NonSerialized]
		private TrackAsset[] m_CacheOutputTracks;

		// Token: 0x04000023 RID: 35
		[HideInInspector]
		[NonSerialized]
		private List<TrackAsset> m_CacheFlattenedTracks;

		// Token: 0x04000024 RID: 36
		[HideInInspector]
		[SerializeField]
		private TimelineAsset.EditorSettings m_EditorSettings = new TimelineAsset.EditorSettings();

		// Token: 0x04000025 RID: 37
		[SerializeField]
		public TimelineAsset.SequenceUpdateMode m_UpdateMode = TimelineAsset.SequenceUpdateMode.TimeBased;

		// Token: 0x04000026 RID: 38
		[SerializeField]
		public string m_ParameterName = "";

		// Token: 0x04000027 RID: 39
		[SerializeField]
		public TimelineAsset.DurationMode m_DurationMode;

		// Token: 0x0200000D RID: 13
		public enum SequenceUpdateMode
		{
			// Token: 0x0400002D RID: 45
			TimeBased,
			// Token: 0x0400002E RID: 46
			ParameterBased,
			// Token: 0x0400002F RID: 47
			ParentSequence
		}

		// Token: 0x0200000E RID: 14
		public enum MediaType
		{
			// Token: 0x04000031 RID: 49
			Animation,
			// Token: 0x04000032 RID: 50
			Audio,
			// Token: 0x04000033 RID: 51
			Video,
			// Token: 0x04000034 RID: 52
			Script,
			// Token: 0x04000035 RID: 53
			Hybrid,
			// Token: 0x04000036 RID: 54
			Group
		}

		// Token: 0x0200000F RID: 15
		public enum DurationMode
		{
			// Token: 0x04000038 RID: 56
			BasedOnClips,
			// Token: 0x04000039 RID: 57
			FixedLength
		}

		// Token: 0x02000010 RID: 16
		[Serializable]
		public class EditorSettings
		{
			// Token: 0x0400003A RID: 58
			internal static readonly float kDefaultFPS = 60f;

			// Token: 0x0400003B RID: 59
			[HideInInspector]
			[SerializeField]
			public float fps = TimelineAsset.EditorSettings.kDefaultFPS;
		}
	}
}