using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RecordingArchiver.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.6.2.0")]
[assembly: AssemblyInformationalVersion("1.6.2")]
[assembly: AssemblyProduct("RecordingArchiver.Core")]
[assembly: AssemblyTitle("RecordingArchiver.Core")]
[assembly: AssemblyVersion("1.6.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RecordingArchiver.Core
{
	public sealed class ArchiveEngine : IDisposable
	{
		private sealed class SourceFile
		{
			public string Path = "";

			public string Relative = "";

			public string Root = "";

			public string RetentionId = "";

			public ArchiveContext? Context;

			public bool ProvenContext;
		}

		private sealed class Observation
		{
			public long Length;

			public long WriteTicks;

			public DateTime StableSince;

			public DateTime FirstSeen;

			public DateTime LastSnapshot;

			public DateTime RetryAfter;

			public int Failures;
		}

		private readonly ArchiveOptions options;

		private readonly Action<string> reportError;

		private readonly FileStream processLock;

		private readonly string statePath;

		private readonly string sessionId;

		private readonly Dictionary<string, Observation> observations = new Dictionary<string, Observation>(StringComparer.OrdinalIgnoreCase);

		private readonly HashSet<string> verified = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly HashSet<RecordingMetadata> changedRecordings = new HashSet<RecordingMetadata>();

		private readonly List<string> completedJournals = new List<string>();

		private readonly HashSet<string> persistedRecordings = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly HashSet<RecordingMetadata> unpersistedEvidence = new HashSet<RecordingMetadata>();

		private readonly Dictionary<string, RecordingMetadata> recordings;

		private readonly ArchiveState state;

		private bool dirty;

		private ArchiveContext? currentContext;

		private Dictionary<string, ArchiveContext> liveContexts = new Dictionary<string, ArchiveContext>();

		public ArchiveState State => state;

		public ArchiveEngine(ArchiveOptions options, Action<string> reportError)
		{
			this.options = options;
			this.reportError = reportError;
			options.SourceDirectory = ArchivePaths.NormalizeRoot(options.SourceDirectory);
			options.OutputDirectory = ArchivePaths.NormalizeRoot(options.OutputDirectory);
			options.RetentionDirectory = ArchivePaths.NormalizeRoot(string.IsNullOrEmpty(options.RetentionDirectory) ? (options.SourceDirectory + "_RA") : options.RetentionDirectory);
			new SourceRetention(options.SourceDirectory, options.RetentionDirectory);
			if (options.RetentionDirectory.Equals(options.OutputDirectory, StringComparison.OrdinalIgnoreCase) || ArchivePaths.Contains(options.RetentionDirectory, options.OutputDirectory) || ArchivePaths.Contains(options.OutputDirectory, options.RetentionDirectory))
			{
				throw new ArgumentException("Output and retention directories must not overlap.");
			}
			if (options.SourceDirectory.Equals(options.OutputDirectory, StringComparison.OrdinalIgnoreCase) || ArchivePaths.Contains(options.SourceDirectory, options.OutputDirectory) || ArchivePaths.Contains(options.OutputDirectory, options.SourceDirectory))
			{
				throw new ArgumentException("Source and output directories must not overlap.");
			}
			if (options.StabilityPeriod <= TimeSpan.Zero || options.SnapshotAfter < options.StabilityPeriod)
			{
				throw new ArgumentException("Invalid stabilization periods.");
			}
			ArchivePaths.RejectLinks(options.SourceDirectory, options.SourceDirectory);
			ArchivePaths.RejectLinks(options.OutputDirectory, options.OutputDirectory);
			Directory.CreateDirectory(options.OutputDirectory);
			processLock = new FileStream(ArchivePaths.Resolve(options.OutputDirectory, ".recordingarchiver.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
			try
			{
				statePath = ArchivePaths.Resolve(options.OutputDirectory, ".recordingarchiver-state.json");
				if (!File.Exists(statePath) && File.Exists(statePath + ".ra-tmp"))
				{
					JsonStore.Read<ArchiveState>(statePath + ".ra-tmp");
					File.Move(statePath + ".ra-tmp", statePath);
				}
				state = (File.Exists(statePath) ? JsonStore.Read<ArchiveState>(statePath) : new ArchiveState
				{
					SourceRoot = options.SourceDirectory
				});
				if ((state.SchemaVersion != 1 && state.SchemaVersion != 2) || state.Recordings == null || !string.Equals(state.SourceRoot, options.SourceDirectory, StringComparison.OrdinalIgnoreCase))
				{
					throw new InvalidDataException("State is incompatible with this source. Use a separate output directory.");
				}
				recordings = new Dictionary<string, RecordingMetadata>(StringComparer.OrdinalIgnoreCase);
				state.SchemaVersion = 2;
				foreach (RecordingMetadata recording in state.Recordings)
				{
					recording.Context?.Validate();
					if (string.IsNullOrEmpty(recording.Key))
					{
						recording.Key = recording.OriginalFolderId;
					}
					ArchivePaths.Resolve(options.OutputDirectory, recording.RelativeDirectory);
					if (recording.Files == null || recording.Clips == null)
					{
						throw new InvalidDataException("Invalid recording state.");
					}
					foreach (ArchivedFile file in recording.Files)
					{
						ArchivePaths.Resolve(options.OutputDirectory, file.Destination);
						ArchivePaths.Resolve(options.SourceDirectory, file.SourceRelativePath);
					}
					recordings.Add(recording.Key, recording);
					persistedRecordings.Add(recording.Key);
				}
				sessionId = DateTime.UtcNow.ToString("yyyy-MM-dd_HH-mm-ss") + "_" + Guid.NewGuid().ToString("N").Substring(0, 12);
				changedRecordings.UnionWith(state.Recordings);
				dirty = state.Recordings.Count > 0;
				RecoverCopies();
			}
			catch
			{
				processLock.Dispose();
				throw;
			}
		}

		public void Observe(ClipEvidence evidence)
		{
			if (!Guid.TryParse(evidence.VideoId, out var result) || result == Guid.Empty || !Guid.TryParse(evidence.ClipId, out var result2) || result2 == Guid.Empty || evidence.Order < 0)
			{
				throw new ArgumentException("Invalid recording evidence.");
			}
			evidence.VideoId = result.ToString();
			evidence.ClipId = result2.ToString();
			evidence.Context = evidence.Context ?? currentContext;
			RecordingMetadata recording = GetRecording(evidence.VideoId, evidence.Context);
			ClipEvidence clipEvidence = recording.Clips.FirstOrDefault((ClipEvidence c) => c.ClipId == evidence.ClipId);
			if (clipEvidence != null)
			{
				evidence.CameraOwner = evidence.CameraOwner ?? clipEvidence.CameraOwner;
				evidence.Holder = evidence.Holder ?? clipEvidence.Holder;
				evidence.Encoder = clipEvidence.Encoder ?? evidence.Encoder;
				if (evidence.CameraId.Length == 0)
				{
					evidence.CameraId = clipEvidence.CameraId;
				}
				if (SameEvidence(clipEvidence, evidence))
				{
					return;
				}
				recording.Clips.Remove(clipEvidence);
			}
			recording.Clips.Add(evidence);
			recording.Clips.Sort((ClipEvidence a, ClipEvidence b) => a.Order.CompareTo(b.Order));
			recording.OwnerConflict = (from c in recording.Clips
				where c.CameraOwner != null
				select c.CameraOwner.Id).Distinct().Skip(1).Any();
			dirty = true;
			changedRecordings.Add(recording);
			unpersistedEvidence.Add(recording);
		}

		private static bool SameEvidence(ClipEvidence a, ClipEvidence b)
		{
			if (a.Order == b.Order && a.CameraId == b.CameraId && a.IsRecording == b.IsRecording && a.IsEncoded == b.IsEncoded && a.IsReceived == b.IsReceived && a.IsValid == b.IsValid && SameIdentity(a.CameraOwner, b.CameraOwner) && SameIdentity(a.Holder, b.Holder))
			{
				return SameIdentity(a.Encoder, b.Encoder);
			}
			return false;
		}

		private static bool SameIdentity(PlayerIdentity? a, PlayerIdentity? b)
		{
			if (a?.Id == b?.Id && a?.Name == b?.Name)
			{
				return a?.Evidence == b?.Evidence;
			}
			return false;
		}

		public void SetContext(ArchiveContext? context)
		{
			context?.Validate();
			currentContext = context;
		}

		public void SetSourceContexts(Dictionary<string, ArchiveContext> contexts)
		{
			liveContexts = contexts;
		}

		public void Scan(DateTime utcNow, CancellationToken cancellation = default(CancellationToken))
		{
			HashSet<string> present = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (SourceFile item in EnumerateSources())
			{
				cancellation.ThrowIfCancellationRequested();
				string path = item.Path;
				string relative = item.Relative;
				string text = path;
				present.Add(text);
				try
				{
					ArchivePaths.RejectLinks(item.Root, path);
					ArchivePaths.Resolve(options.SourceDirectory, relative);
					FileInfo fileInfo = new FileInfo(path);
					long length = fileInfo.Length;
					long writeTicks = fileInfo.LastWriteTimeUtc.Ticks;
					if (!observations.TryGetValue(text, out Observation value))
					{
						value = new Observation
						{
							Length = length,
							WriteTicks = writeTicks,
							StableSince = utcNow,
							FirstSeen = utcNow
						};
						observations.Add(text, value);
					}
					if (value.Length != length || value.WriteTicks != writeTicks)
					{
						value.Length = length;
						value.WriteTicks = writeTicks;
						value.StableSince = utcNow;
						value.Failures = 0;
						value.RetryAfter = DateTime.MinValue;
					}
					if (utcNow < value.RetryAfter)
					{
						continue;
					}
					int num;
					if (utcNow - value.StableSince >= options.StabilityPeriod)
					{
						num = ((utcNow - fileInfo.LastWriteTimeUtc >= options.StabilityPeriod) ? 1 : 0);
						if (num != 0)
						{
							goto IL_01e6;
						}
					}
					else
					{
						num = 0;
					}
					if (!(utcNow - value.FirstSeen >= options.SnapshotAfter))
					{
						goto IL_01e6;
					}
					int num2 = ((utcNow - value.LastSnapshot >= options.SnapshotAfter) ? 1 : 0);
					goto IL_01e7;
					IL_01e6:
					num2 = 0;
					goto IL_01e7;
					IL_01e7:
					bool flag = (byte)num2 != 0;
					if (num == 0 && !flag)
					{
						continue;
					}
					string[] array = relative.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
					if (!((array.Length == 2 && array[1].Equals("fullRecording.webm", StringComparison.OrdinalIgnoreCase)) ? (!options.ArchiveFullRecordings) : (!options.ArchiveFragments)))
					{
						string folder = ((array.Length > 1) ? array[0] : "_unclassified");
						RecordingMetadata recordingMetadata = ResolveRecording(folder, array, relative, length, writeTicks, item);
						ArchivedFile archivedFile = recordingMetadata.Files.LastOrDefault((ArchivedFile f) => f.SourceRelativePath == relative && f.Length == length && f.SourceWriteTicks == writeTicks && f.Status == "byte-verified-media-unverified");
						if (archivedFile == null || !VerifyExisting(archivedFile))
						{
							Copy(path, relative, array, recordingMetadata, length, writeTicks, flag, utcNow, cancellation, item.RetentionId);
							value.LastSnapshot = utcNow;
							value.Failures = 0;
							value.RetryAfter = DateTime.MinValue;
						}
					}
				}
				catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException || ex is SecurityException)
				{
					if (observations.TryGetValue(text, out Observation value2))
					{
						value2.Failures++;
						value2.RetryAfter = utcNow.AddSeconds((value2.Failures <= 5) ? Math.Min(60.0, Math.Pow(2.0, value2.Failures)) : 300.0);
						int num3 = ex.HResult & 0xFFFF;
						string text2 = ((num3 == 112 || num3 == 39) ? "Destination disk is full; free space before retrying." : "Check destination permissions, free space and path length.");
						if (value2.Failures <= 5)
						{
							reportError($"Archive copy failed ({ex.GetType().Name}, code {num3}, retry {value2.Failures}/5; then 5-minute cooldown). {text2} Originals remain untouched.");
						}
					}
					else
					{
						reportError("Cannot inspect recording (" + ex.GetType().Name + "). Originals remain untouched.");
					}
				}
			}
			string[] array2 = observations.Keys.Where((string k) => !present.Contains(k)).ToArray();
			foreach (string key in array2)
			{
				observations.Remove(key);
			}
			if (dirty)
			{
				Persist();
			}
		}

		private RecordingMetadata ResolveRecording(string folder, string[] parts, string relative, long length, long ticks, SourceFile source)
		{
			bool provenContext = source.ProvenContext;
			RecordingMetadata recordingMetadata = state.Recordings.LastOrDefault((RecordingMetadata r) => (!provenContext || r.Context?.ScopeKey == source.Context.ScopeKey) && r.OriginalFolderId.Equals(folder, StringComparison.OrdinalIgnoreCase) && r.Files.Any((ArchivedFile f) => f.SourceRelativePath == relative && f.Length == length && f.SourceWriteTicks == ticks));
			if (source.RetentionId.Length > 0 && recordingMetadata != null)
			{
				return recordingMetadata;
			}
			if (parts.Length >= 3 && Guid.TryParse(parts[1], out var _))
			{
				List<RecordingMetadata> list = state.Recordings.Where((RecordingMetadata r) => (!provenContext || r.Context?.ScopeKey == source.Context.ScopeKey) && r.OriginalFolderId.Equals(folder, StringComparison.OrdinalIgnoreCase) && r.Clips.Any((ClipEvidence c) => c.ClipId.Equals(parts[1], StringComparison.OrdinalIgnoreCase))).ToList();
				RecordingMetadata recordingMetadata2 = list.LastOrDefault((RecordingMetadata r) => r.Context?.ScopeKey == source.Context?.ScopeKey);
				if (recordingMetadata2 != null)
				{
					return recordingMetadata2;
				}
				if (list.Count == 1)
				{
					return list[0];
				}
			}
			return recordingMetadata ?? GetRecording(folder, source.Context);
		}

		private IEnumerable<SourceFile> EnumerateSources()
		{
			foreach (string item in EnumerateFiles(options.SourceDirectory))
			{
				string relativePath = Path.GetRelativePath(options.SourceDirectory, item);
				ArchiveContext archiveContext = ContextForPath(liveContexts, relativePath);
				yield return new SourceFile
				{
					Path = item,
					Root = options.SourceDirectory,
					Relative = relativePath,
					Context = (archiveContext ?? currentContext),
					ProvenContext = (archiveContext != null)
				};
			}
			string[] array;
			try
			{
				ArchivePaths.RejectLinks(options.RetentionDirectory, options.RetentionDirectory);
				array = (Directory.Exists(options.RetentionDirectory) ? Directory.GetDirectories(options.RetentionDirectory) : Array.Empty<string>());
			}
			catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
			{
				reportError("Cannot scan retained sources; originals retained for retry (" + ex.GetType().Name + ").");
				yield break;
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				RetainedBatch manifest;
				string data;
				try
				{
					string path = ArchivePaths.Resolve(options.RetentionDirectory, Path.Combine(Path.GetFileName(text), "retention.json"));
					if (!File.Exists(path))
					{
						continue;
					}
					manifest = JsonStore.Read<RetainedBatch>(path);
					if (manifest.Id != Path.GetFileName(text) || !string.Equals(manifest.SourceRoot, options.SourceDirectory, StringComparison.OrdinalIgnoreCase))
					{
						throw new InvalidDataException("Invalid retention provenance.");
					}
					if (manifest.OriginalRelativePath != ".")
					{
						ArchivePaths.Resolve(options.SourceDirectory, manifest.OriginalRelativePath);
					}
					else if (manifest.IsFile)
					{
						throw new InvalidDataException("Invalid retained file path.");
					}
					manifest.Context?.Validate();
					data = ArchivePaths.Resolve(options.RetentionDirectory, Path.Combine(manifest.Id, "data"));
					goto IL_033e;
				}
				catch (Exception ex2) when (ex2 is IOException || ex2 is UnauthorizedAccessException || ex2 is SerializationException || ex2 is ArgumentException)
				{
					reportError("Cannot read a retention manifest; source left untouched (" + ex2.GetType().Name + ").");
				}
				continue;
				IL_033e:
				if (manifest.IsFile)
				{
					if (File.Exists(data))
					{
						ArchiveContext archiveContext2 = RetainedContext(manifest, manifest.OriginalRelativePath);
						yield return new SourceFile
						{
							Path = data,
							Root = text,
							Relative = manifest.OriginalRelativePath,
							Context = archiveContext2,
							ProvenContext = (archiveContext2 != null),
							RetentionId = manifest.Id
						};
					}
					continue;
				}
				foreach (string item2 in EnumerateFiles(data))
				{
					string relativePath2 = Path.GetRelativePath(data, item2);
					string relative = ((manifest.OriginalRelativePath == ".") ? relativePath2 : Path.Combine(manifest.OriginalRelativePath, relativePath2));
					ArchiveContext archiveContext3 = RetainedContext(manifest, relative);
					yield return new SourceFile
					{
						Path = item2,
						Root = data,
						Relative = relative,
						Context = archiveContext3,
						ProvenContext = (archiveContext3 != null),
						RetentionId = manifest.Id
					};
				}
			}
		}

		private static ArchiveContext? RetainedContext(RetainedBatch manifest, string relative)
		{
			return ContextForPath(manifest.FileContexts ?? new Dictionary<string, ArchiveContext>(), relative) ?? manifest.Context;
		}

		private static ArchiveContext? ContextForPath(Dictionary<string, ArchiveContext> contexts, string relative)
		{
			ArchiveContext result = null;
			int num = -1;
			foreach (KeyValuePair<string, ArchiveContext> context in contexts)
			{
				if (context.Key.Length > num && (relative.Equals(context.Key, StringComparison.OrdinalIgnoreCase) || relative.StartsWith(context.Key + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)))
				{
					context.Value.Validate();
					result = context.Value;
					num = context.Key.Length;
				}
			}
			return result;
		}

		private IEnumerable<string> EnumerateFiles(string root)
		{
			Stack<string> pending = new Stack<string>();
			pending.Push(root);
			while (pending.Count > 0)
			{
				string path = pending.Pop();
				string[] files;
				string[] directories;
				try
				{
					if (!Directory.Exists(path))
					{
						continue;
					}
					ArchivePaths.RejectLinks(root, path);
					files = Directory.GetFiles(path);
					directories = Directory.GetDirectories(path);
					goto IL_00cd;
				}
				catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
				{
					reportError("Cannot scan a recording directory (" + ex.GetType().Name + "). Will retry next scan.");
				}
				continue;
				IL_00cd:
				string[] array = directories;
				foreach (string item in array)
				{
					pending.Push(item);
				}
				string[] array2 = files;
				for (int j = 0; j < array2.Length; j++)
				{
					yield return array2[j];
				}
			}
		}

		private RecordingMetadata GetRecording(string folderId, ArchiveContext? context)
		{
			context?.Validate();
			string text = ((context == null) ? folderId : (context.ScopeKey + "/" + folderId));
			if (recordings.TryGetValue(text, out RecordingMetadata value))
			{
				return value;
			}
			string path = ((context != null) ? (options.GroupBySession ? ((string.IsNullOrEmpty(context.MatchDateLocal) ? "Undated" : context.MatchDateLocal) + "_M_" + ArchivePaths.HashText(context.MatchId).Substring(0, 12)) : "Matches_merged") : (options.GroupBySession ? sessionId : "Sessions_merged"));
			if (context != null && options.GroupBySession)
			{
				RecordingMetadata recordingMetadata = state.Recordings.FirstOrDefault((RecordingMetadata r) => r.Context?.MatchId == context.MatchId);
				if (recordingMetadata != null)
				{
					path = recordingMetadata.RelativeDirectory.Split(Path.DirectorySeparatorChar)[0];
				}
			}
			string text2 = ArchivePaths.HashText(text).Substring(0, 16);
			RecordingMetadata recordingMetadata2 = new RecordingMetadata
			{
				Key = text,
				Context = context,
				OriginalFolderId = folderId,
				RelativeDirectory = ((context == null) ? Path.Combine(path, "R_" + text2) : Path.Combine(path, "I_" + context.IncursionNumber.ToString("D3") + "_" + ArchivePaths.HashText(context.IncursionId).Substring(0, 8), "R_" + text2)),
				SessionId = (context?.MatchId ?? sessionId),
				PlayerDirectoryEvidence = "per-clip camera owner; full recording has no inferred single owner"
			};
			state.Recordings.Add(recordingMetadata2);
			recordings.Add(text, recordingMetadata2);
			dirty = true;
			changedRecordings.Add(recordingMetadata2);
			unpersistedEvidence.Add(recordingMetadata2);
			return recordingMetadata2;
		}

		private bool VerifyExisting(ArchivedFile file)
		{
			string text = ArchivePaths.Resolve(options.OutputDirectory, file.Destination);
			if (!File.Exists(text) || new FileInfo(text).Length != file.Length)
			{
				return false;
			}
			if (verified.Contains(file.Destination))
			{
				return true;
			}
			if (HashFile(text) != file.Sha256)
			{
				return false;
			}
			verified.Add(file.Destination);
			return true;
		}

		private void Copy(string source, string relative, string[] parts, RecordingMetadata recording, long length, long writeTicks, bool snapshot, DateTime utcNow, CancellationToken cancellation, string retentionId)
		{
			Guid result;
			string text = ((parts.Length == 2 && parts[1].Equals("fullRecording.webm", StringComparison.OrdinalIgnoreCase)) ? "full" : ((parts.Length >= 3 && Guid.TryParse(parts[1], out result)) ? "segment" : "unknown"));
			PlayerIdentity owner = ((!(text == "segment")) ? null : recording.Clips.FirstOrDefault((ClipEvidence c) => c.ClipId.Equals(parts[1], StringComparison.OrdinalIgnoreCase))?.CameraOwner);
			string path = (options.GroupByPlayer ? ArchivePaths.PlayerDirectory(owner, options.UseSteamId) : "AllPlayers");
			string path2 = ((text == "full") ? "original" : ((text == "segment") ? Path.Combine("segments", path, ArchivePaths.HashText(parts[1]).Substring(0, 16)) : "unknown"));
			string text2 = Path.Combine(recording.RelativeDirectory, path2);
			Directory.CreateDirectory(ArchivePaths.Resolve(options.OutputDirectory, text2));
			string text3 = ArchivePaths.Resolve(options.OutputDirectory, Path.Combine(text2, ".ra-" + Guid.NewGuid().ToString("N").Substring(0, 16) + ".partial"));
			if (!persistedRecordings.Contains(recording.Key) || unpersistedEvidence.Contains(recording))
			{
				Persist();
			}
			CopyJournal copyJournal = new CopyJournal
			{
				RecordingId = recording.Key,
				File = new ArchivedFile
				{
					SourceRelativePath = relative,
					RetentionId = retentionId,
					Length = length,
					SourceWriteTicks = writeTicks
				}
			};
			string text4 = text3 + ".ra-journal";
			JsonStore.Write(text4, copyJournal);
			string text5;
			using (FileStream fileStream = new FileStream(source, FileMode.Open, FileAccess.Read, (!snapshot) ? FileShare.Read : FileShare.ReadWrite, 131072, FileOptions.SequentialScan))
			{
				using FileStream fileStream2 = new FileStream(text3, FileMode.CreateNew, FileAccess.Write, FileShare.None, 131072, FileOptions.SequentialScan);
				using SHA256 sHA = SHA256.Create();
				byte[] array = new byte[131072];
				long num = length;
				while (num > 0)
				{
					cancellation.ThrowIfCancellationRequested();
					int num2 = fileStream.Read(array, 0, (int)Math.Min(array.Length, num));
					if (num2 == 0)
					{
						throw new IOException("Source shortened during copy.");
					}
					fileStream2.Write(array, 0, num2);
					sHA.TransformBlock(array, 0, num2, null, 0);
					num -= num2;
				}
				sHA.TransformFinalBlock(Array.Empty<byte>(), 0, 0);
				text5 = ArchivePaths.Hex(sHA.Hash);
				fileStream2.Flush(flushToDisk: true);
				FileInfo fileInfo = new FileInfo(source);
				if (!snapshot && (fileInfo.Length != length || fileInfo.LastWriteTimeUtc.Ticks != writeTicks))
				{
					throw new IOException("Source changed during copy.");
				}
			}
			if (new FileInfo(text3).Length != length || HashFile(text3) != text5)
			{
				throw new IOException("Archive verification failed.");
			}
			string path3 = parts[parts.Length - 1];
			string text6 = ArchivePaths.SafeName(Path.GetFileNameWithoutExtension(path3));
			if (text6.Length > 24)
			{
				text6 = text6.Substring(0, 24);
			}
			string text7 = ArchivePaths.SafeName(Path.GetExtension(path3));
			if (Path.GetExtension(path3).Length == 0)
			{
				text7 = "";
			}
			if (text7.Length > 12)
			{
				text7 = ".bin";
			}
			string text8 = text6 + "." + ArchivePaths.HashText(relative).Substring(0, 8) + "." + text5.Substring(0, 16) + (snapshot ? ".snapshot" : "") + text7;
			string destination = Path.Combine(text2, text8);
			string text9 = ArchivePaths.Resolve(options.OutputDirectory, destination);
			if (File.Exists(text9) && (new FileInfo(text9).Length != length || HashFile(text9) != text5))
			{
				destination = Path.Combine(text2, Guid.NewGuid().ToString("N") + "_" + text8);
				text9 = ArchivePaths.Resolve(options.OutputDirectory, destination);
			}
			ArchivedFile item = (copyJournal.File = new ArchivedFile
			{
				SourceRelativePath = relative,
				RetentionId = retentionId,
				Destination = destination,
				Sha256 = text5,
				Length = length,
				SourceWriteTicks = writeTicks,
				ArchivedUtc = utcNow.ToString("O"),
				Kind = text,
				Status = (snapshot ? "incomplete-snapshot-media-unverified" : "byte-verified-media-unverified")
			});
			copyJournal.ByteVerified = true;
			JsonStore.Write(text4, copyJournal);
			if (File.Exists(text9))
			{
				File.Delete(text3);
			}
			else
			{
				File.Move(text3, text9);
			}
			completedJournals.Add(text4);
			recording.Files.RemoveAll((ArchivedFile f) => f.SourceRelativePath == relative && f.Destination == destination);
			recording.Files.Add(item);
			if (text == "full")
			{
				recording.FullRecordingStatus = (snapshot ? "incomplete-snapshot" : "original-copied-media-unverified");
			}
			verified.Add(destination);
			dirty = true;
			changedRecordings.Add(recording);
		}

		private static string HashFile(string path)
		{
			using FileStream inputStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 131072, FileOptions.SequentialScan);
			using SHA256 sHA = SHA256.Create();
			return ArchivePaths.Hex(sHA.ComputeHash(inputStream));
		}

		private void RecoverCopies()
		{
			foreach (string item in from p in EnumerateFiles(options.OutputDirectory)
				where Path.GetFileName(p).StartsWith(".ra-", StringComparison.Ordinal) && p.EndsWith(".partial.ra-journal", StringComparison.Ordinal)
				select p)
			{
				ArchivePaths.RejectLinks(options.OutputDirectory, item);
				CopyJournal copyJournal = JsonStore.Read<CopyJournal>(item);
				if (!copyJournal.ByteVerified)
				{
					continue;
				}
				if (!recordings.TryGetValue(copyJournal.RecordingId, out RecordingMetadata value) || copyJournal.File == null)
				{
					throw new InvalidDataException("Copy journal has no known recording.");
				}
				ArchivedFile entry = copyJournal.File;
				string text = ArchivePaths.Resolve(options.OutputDirectory, entry.Destination);
				string root = ArchivePaths.Resolve(options.OutputDirectory, value.RelativeDirectory);
				ArchivePaths.Resolve(options.SourceDirectory, entry.SourceRelativePath);
				if (!ArchivePaths.Contains(root, text) || entry.Length < 0 || entry.Sha256.Length != 64)
				{
					throw new InvalidDataException("Invalid copy journal.");
				}
				string text2 = item.Substring(0, item.Length - ".ra-journal".Length);
				if (!File.Exists(text))
				{
					ArchivePaths.RejectLinks(options.OutputDirectory, text2);
					if (!File.Exists(text2) || new FileInfo(text2).Length != entry.Length || HashFile(text2) != entry.Sha256)
					{
						reportError("Interrupted copy could not be verified; partial and journal retained for recovery.");
						continue;
					}
					File.Move(text2, text);
				}
				if (new FileInfo(text).Length != entry.Length || HashFile(text) != entry.Sha256)
				{
					reportError("Interrupted copy destination differs; retained without overwriting.");
					continue;
				}
				value.Files.RemoveAll((ArchivedFile f) => f.SourceRelativePath == entry.SourceRelativePath && f.Destination == entry.Destination);
				value.Files.Add(entry);
				if (entry.Kind == "full")
				{
					value.FullRecordingStatus = (entry.Status.StartsWith("incomplete", StringComparison.Ordinal) ? "incomplete-snapshot" : "original-copied-media-unverified");
				}
				changedRecordings.Add(value);
				completedJournals.Add(item);
				dirty = true;
			}
		}

		private void Persist()
		{
			JsonStore.Write(statePath, state);
			foreach (RecordingMetadata recording in state.Recordings)
			{
				persistedRecordings.Add(recording.Key);
			}
			foreach (RecordingMetadata changedRecording in changedRecordings)
			{
				string path = ArchivePaths.Resolve(options.OutputDirectory, Path.Combine(changedRecording.RelativeDirectory, "metadata.json"));
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				JsonStore.Write(path, changedRecording);
				string path2 = changedRecording.RelativeDirectory.Split(Path.DirectorySeparatorChar)[0];
				string path3 = ArchivePaths.Resolve(options.OutputDirectory, Path.Combine(path2, "session_" + changedRecording.SessionId + ".json"));
				if (!File.Exists(path3))
				{
					JsonStore.Write(path3, new SessionMetadata
					{
						SessionId = changedRecording.SessionId,
						StartedUtc = (changedRecording.Context?.StartedUtc ?? DateTime.UtcNow.ToString("O")),
						SourceRoot = options.SourceDirectory,
						SessionMeaning = ((changedRecording.Context == null) ? "unassigned/legacy archiver process" : "room visit; incursion ordinals count locally observed underground arrivals")
					});
				}
			}
			changedRecordings.Clear();
			unpersistedEvidence.Clear();
			foreach (string completedJournal in completedJournals)
			{
				File.Delete(completedJournal);
			}
			completedJournals.Clear();
			dirty = false;
		}

		public void Dispose()
		{
			processLock.Dispose();
		}
	}
	public static class ArchivePaths
	{
		public static string NormalizeRoot(string path)
		{
			if (string.IsNullOrWhiteSpace(path) || !Path.IsPathRooted(path))
			{
				throw new ArgumentException("An absolute directory is required.", "path");
			}
			string fullPath = Path.GetFullPath(path);
			if (string.Equals(fullPath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), Path.GetPathRoot(fullPath)?.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException("A filesystem root is not an archive directory.", "path");
			}
			return fullPath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
		}

		public static bool Contains(string root, string path)
		{
			return Path.GetFullPath(path).StartsWith(root + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
		}

		public static string Resolve(string root, string relative)
		{
			if (string.IsNullOrWhiteSpace(relative) || Path.IsPathRooted(relative))
			{
				throw new InvalidDataException("Invalid relative archive path.");
			}
			string fullPath = Path.GetFullPath(Path.Combine(root, relative));
			if (!Contains(root, fullPath))
			{
				throw new InvalidDataException("Path escapes its root.");
			}
			RejectLinks(root, fullPath);
			return fullPath;
		}

		public static void RejectLinks(string root, string path)
		{
			for (string text = path; text != null; text = Path.GetDirectoryName(text))
			{
				if ((Directory.Exists(text) || File.Exists(text)) && (File.GetAttributes(text) & FileAttributes.ReparsePoint) != FileAttributes.None)
				{
					throw new IOException("Reparse points are not supported in archive paths.");
				}
			}
		}

		public static string SafeName(string name)
		{
			char[] invalid = Path.GetInvalidFileNameChars();
			string text = new string(name.Select((char c) => (!char.IsControl(c) && !invalid.Contains(c) && !"<>:\"/\\|?*".Contains(c)) ? c : '_').ToArray());
			text = text.Trim().TrimEnd('.', ' ');
			text = TruncateName(text, 48);
			if (text.Length == 0 || text == "." || text == "..")
			{
				text = "Unknown";
			}
			string value = text.Split('.')[0].TrimEnd(' ').ToUpperInvariant();
			if (new string[28]
			{
				"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6",
				"COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7",
				"LPT8", "LPT9", "COM¹", "COM²", "COM³", "LPT¹", "LPT²", "LPT³"
			}.Contains(value))
			{
				text = "_" + text;
			}
			return text;
		}

		private static string TruncateName(string name, int length)
		{
			int num = Math.Min(name.Length, length);
			if (num > 0 && char.IsHighSurrogate(name[num - 1]))
			{
				num--;
			}
			return name.Substring(0, num).TrimEnd('.', ' ');
		}

		public static string SafePlayerName(string name)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num;
			for (int i = 0; i < name.Length; i += num)
			{
				num = ((!char.IsHighSurrogate(name[i]) || i + 1 >= name.Length || !char.IsLowSurrogate(name[i + 1])) ? 1 : 2);
				int num2 = ((num == 2) ? char.ConvertToUtf32(name[i], name[i + 1]) : name[i]);
				UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(name, i);
				if (unicodeCategory == UnicodeCategory.OtherSymbol || unicodeCategory == UnicodeCategory.MathSymbol || unicodeCategory == UnicodeCategory.CurrencySymbol || unicodeCategory == UnicodeCategory.ModifierSymbol || unicodeCategory == UnicodeCategory.Control || unicodeCategory == UnicodeCategory.Format || unicodeCategory == UnicodeCategory.Surrogate || unicodeCategory == UnicodeCategory.EnclosingMark || (num2 >= 65024 && num2 <= 65039) || (num2 >= 917760 && num2 <= 917999))
				{
					if (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] != '_')
					{
						stringBuilder.Append('_');
					}
				}
				else
				{
					stringBuilder.Append(name, i, num);
				}
			}
			return SafeName(stringBuilder.ToString().Normalize(NormalizationForm.FormC).Trim('_', ' '));
		}

		public static string HashText(string text)
		{
			using SHA256 sHA = SHA256.Create();
			return Hex(sHA.ComputeHash(Encoding.UTF8.GetBytes(text)));
		}

		public static string Hex(byte[] bytes)
		{
			return BitConverter.ToString(bytes).Replace("-", "").ToLowerInvariant();
		}

		public static string PlayerDirectory(PlayerIdentity? owner, bool exposeId)
		{
			if (owner == null || string.IsNullOrWhiteSpace(owner.Id))
			{
				return "Unknown";
			}
			string text = (exposeId ? SafeName(owner.Id.StartsWith("steam:", StringComparison.Ordinal) ? owner.Id.Substring(6) : owner.Id) : HashText(owner.Id).Substring(0, 12));
			string text2 = TruncateName(SafePlayerName(owner.Name), 16);
			if (text2.Length == 0)
			{
				text2 = "Unknown";
			}
			return text2 + "_" + text;
		}
	}
	public static class IdentityResolver
	{
		public static bool IsNumericId(string? value)
		{
			if (ulong.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out var result))
			{
				return result != 0;
			}
			return false;
		}

		public static PlayerIdentity FromPhoton(string? userId, string? platform, string? steamId, string? nickname, int actor, string sessionScope)
		{
			string id;
			string evidence;
			if (IsNumericId(steamId))
			{
				id = "steam:" + steamId;
				evidence = "Photon.CustomProperties.SteamID";
			}
			else if (IsNumericId(userId) && !string.IsNullOrWhiteSpace(platform))
			{
				id = "platform:" + platform + ":" + userId;
				evidence = "Photon.CustomProperties.PlatformFamily+UserID";
			}
			else
			{
				id = "actor:" + sessionScope + ":" + actor.ToString(CultureInfo.InvariantCulture);
				evidence = "Photon.ActorNumber; session-scoped";
			}
			return new PlayerIdentity
			{
				Id = id,
				Name = (string.IsNullOrWhiteSpace(nickname) ? "Unknown" : nickname),
				Evidence = evidence
			};
		}

		public static PlayerIdentity? FromCameraOwner(string? steamId, string? name)
		{
			if (!IsNumericId(steamId))
			{
				return null;
			}
			return new PlayerIdentity
			{
				Id = "steam:" + steamId,
				Name = (string.IsNullOrWhiteSpace(name) ? "Unknown" : name),
				Evidence = "ContentPOVs.POVCamera.plrID"
			};
		}
	}
	public static class JsonStore
	{
		public static T Read<T>(string path) where T : class
		{
			using FileStream stream = File.OpenRead(path);
			return (T)(new DataContractJsonSerializer(typeof(T)).ReadObject(stream) ?? throw new InvalidDataException("Empty JSON document."));
		}

		public static void Write<T>(string path, T value)
		{
			string text = path + ".ra-tmp";
			ArchivePaths.RejectLinks(Path.GetDirectoryName(path), path);
			ArchivePaths.RejectLinks(Path.GetDirectoryName(path), text);
			using (FileStream fileStream = new FileStream(text, FileMode.Create, FileAccess.Write, FileShare.None))
			{
				new DataContractJsonSerializer(typeof(T)).WriteObject(fileStream, value);
				fileStream.Flush(flushToDisk: true);
			}
			if (File.Exists(path))
			{
				File.Replace(text, path, null);
			}
			else
			{
				File.Move(text, path);
			}
		}
	}
	public sealed class ArchiveOptions
	{
		public string SourceDirectory { get; set; } = "";

		public string OutputDirectory { get; set; } = "";

		public string RetentionDirectory { get; set; } = "";

		public bool ArchiveFragments { get; set; } = true;

		public bool ArchiveFullRecordings { get; set; } = true;

		public bool GroupBySession { get; set; } = true;

		public bool GroupByPlayer { get; set; } = true;

		public bool UseSteamId { get; set; } = true;

		public TimeSpan StabilityPeriod { get; set; } = TimeSpan.FromSeconds(5.0);

		public TimeSpan SnapshotAfter { get; set; } = TimeSpan.FromMinutes(2.0);
	}
	public sealed class PlayerIdentity
	{
		public string Id { get; set; } = "";

		public string Name { get; set; } = "Unknown";

		public string Evidence { get; set; } = "";
	}
	public sealed class ClipEvidence
	{
		public string VideoId { get; set; } = "";

		public string ClipId { get; set; } = "";

		public string CameraId { get; set; } = "";

		public int Order { get; set; }

		public ArchiveContext? Context { get; set; }

		public PlayerIdentity? CameraOwner { get; set; }

		public PlayerIdentity? Holder { get; set; }

		public PlayerIdentity? Encoder { get; set; }

		public bool IsRecording { get; set; }

		public bool IsEncoded { get; set; }

		public bool IsReceived { get; set; }

		public bool IsValid { get; set; }
	}
	public sealed class ArchivedFile
	{
		public string SourceRelativePath { get; set; } = "";

		public string RetentionId { get; set; } = "";

		public string Destination { get; set; } = "";

		public string Sha256 { get; set; } = "";

		public long Length { get; set; }

		public long SourceWriteTicks { get; set; }

		public string ArchivedUtc { get; set; } = "";

		public string Kind { get; set; } = "unknown";

		public string Status { get; set; } = "byte-verified-media-unverified";
	}
	public sealed class RecordingMetadata
	{
		public string Key { get; set; } = "";

		public ArchiveContext? Context { get; set; }

		public string OriginalFolderId { get; set; } = "";

		public string RelativeDirectory { get; set; } = "";

		public string SessionId { get; set; } = "";

		public string PlayerDirectoryEvidence { get; set; } = "Unknown";

		public bool OwnerConflict { get; set; }

		public string FullRecordingStatus { get; set; } = "not-observed";

		public List<ClipEvidence> Clips { get; set; } = new List<ClipEvidence>();

		public List<ArchivedFile> Files { get; set; } = new List<ArchivedFile>();

		public string FullRecordingScopeMeaning { get; set; } = "extraction context; may include clips from earlier incursions";
	}
	public sealed class ArchiveContext
	{
		public string MatchId { get; set; } = "";

		public string IncursionId { get; set; } = "";

		public int IncursionNumber { get; set; }

		public int GameDay { get; set; }

		public string SaveId { get; set; } = "";

		public string Evidence { get; set; } = "";

		public string StartedUtc { get; set; } = "";

		public string MatchDateLocal { get; set; } = "";

		public string ScopeKey => MatchId + "/" + IncursionId;

		public void Validate()
		{
			if (!Guid.TryParse(MatchId, out var result) || !Guid.TryParse(IncursionId, out result) || IncursionNumber < 0 || GameDay < 0)
			{
				throw new InvalidDataException("Invalid match/incursion context.");
			}
			if (!string.IsNullOrEmpty(MatchDateLocal) && !DateTime.TryParseExact(MatchDateLocal, "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var _))
			{
				throw new InvalidDataException("Invalid local match date.");
			}
		}
	}
	public sealed class RetainedBatch
	{
		public string Id { get; set; } = "";

		public string SourceRoot { get; set; } = "";

		public string OriginalRelativePath { get; set; } = "";

		public bool IsFile { get; set; }

		public ArchiveContext? Context { get; set; }

		public Dictionary<string, ArchiveContext> FileContexts { get; set; } = new Dictionary<string, ArchiveContext>();
	}
	public sealed class CopyJournal
	{
		public string RecordingId { get; set; } = "";

		public bool ByteVerified { get; set; }

		public ArchivedFile File { get; set; } = new ArchivedFile();
	}
	public sealed class ArchiveState
	{
		public int SchemaVersion { get; set; } = 1;

		public string SourceRoot { get; set; } = "";

		public List<RecordingMetadata> Recordings { get; set; } = new List<RecordingMetadata>();
	}
	public sealed class SessionMetadata
	{
		public string SessionId { get; set; } = "";

		public string StartedUtc { get; set; } = "";

		public string SourceRoot { get; set; } = "";

		public string SessionMeaning { get; set; } = "archiver-process; existing video IDs retain their previous session";
	}
	public static class PlaybackTimeline
	{
		public static float Rebase(float eventTime, float sourceOffset, float playbackOffset, float duration)
		{
			float[] array = new float[4] { eventTime, sourceOffset, playbackOffset, duration };
			foreach (float f in array)
			{
				if (float.IsNaN(f) || float.IsInfinity(f))
				{
					throw new InvalidDataException("Invalid recording timeline.");
				}
			}
			if (sourceOffset < 0f || playbackOffset < 0f || duration < 0f)
			{
				throw new InvalidDataException("Negative recording timeline.");
			}
			return playbackOffset + Math.Max(0f, Math.Min(duration, eventTime - sourceOffset));
		}
	}
	public sealed class PlaybackWorkspace
	{
		private const string Marker = "RecordingArchiver playback workspace v1\n";

		private readonly FileStream owner;

		private readonly Action<Exception> report;

		public string Root { get; }

		public PlaybackWorkspace(string parent, Action<Exception> report)
		{
			this.report = report;
			parent = ArchivePaths.NormalizeRoot(parent);
			ArchivePaths.RejectLinks(parent, parent);
			string text = Guid.NewGuid().ToString("N");
			Root = ArchivePaths.Resolve(parent, text);
			Directory.CreateDirectory(Root);
			owner = new FileStream(Path.Combine(Root, "owner.lock"), FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None);
			try
			{
				File.WriteAllText(Path.Combine(Root, "workspace.marker"), "RecordingArchiver playback workspace v1\n" + text);
			}
			catch
			{
				owner.Dispose();
				throw;
			}
		}

		public Task RemoveEpoch(string epoch, Task[] pending)
		{
			TerminalProtocol.RequireGuid(epoch);
			string path = ArchivePaths.Resolve(Root, Guid.Parse(epoch).ToString("N"));
			return After(pending, delegate
			{
				DeleteWithRetry(path);
			});
		}

		public Task Close(Task[] pending)
		{
			return After(pending, delegate
			{
				owner.Dispose();
				DeleteWithRetry(Root);
			});
		}

		private async Task After(Task[] pending, Action cleanup)
		{
			try
			{
				await Task.WhenAll(pending).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (OperationCanceledException)
			{
			}
			catch (Exception obj)
			{
				report(obj);
			}
			try
			{
				await Task.Run(cleanup).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (Exception obj2)
			{
				report(obj2);
			}
		}

		private static void DeleteWithRetry(string path)
		{
			int num = 0;
			while (true)
			{
				try
				{
					if (Directory.Exists(path))
					{
						ValidateTree(path);
						Directory.Delete(path, recursive: true);
					}
					break;
				}
				catch (IOException) when (num < 3)
				{
					Thread.Sleep(200 * (num + 1));
				}
				num++;
			}
		}

		private static void ValidateTree(string root)
		{
			Stack<string> stack = new Stack<string>();
			stack.Push(root);
			while (stack.Count > 0)
			{
				string path = stack.Pop();
				ArchivePaths.RejectLinks(root, path);
				string[] files = Directory.GetFiles(path);
				foreach (string path2 in files)
				{
					ArchivePaths.RejectLinks(root, path2);
				}
				files = Directory.GetDirectories(path);
				foreach (string item in files)
				{
					stack.Push(item);
				}
			}
		}

		public static void RecoverAbandoned(string parent, Action<Exception> report)
		{
			parent = ArchivePaths.NormalizeRoot(parent);
			try
			{
				ArchivePaths.RejectLinks(parent, parent);
				if (!Directory.Exists(parent))
				{
					return;
				}
				string[] directories = Directory.GetDirectories(parent);
				foreach (string path in directories)
				{
					string fileName = Path.GetFileName(path);
					if (!Guid.TryParseExact(fileName, "N", out var _))
					{
						continue;
					}
					try
					{
						string text = ArchivePaths.Resolve(parent, Path.Combine(fileName, "workspace.marker"));
						string path2 = ArchivePaths.Resolve(parent, Path.Combine(fileName, "owner.lock"));
						if (!File.Exists(text) || new FileInfo(text).Length > 128 || File.ReadAllText(text) != "RecordingArchiver playback workspace v1\n" + fileName || !File.Exists(path2))
						{
							continue;
						}
						try
						{
							using (File.Open(path2, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
							{
							}
						}
						catch (IOException)
						{
							goto end_IL_0048;
						}
						DeleteWithRetry(path);
						end_IL_0048:;
					}
					catch (Exception ex2) when (ex2 is IOException || ex2 is UnauthorizedAccessException)
					{
						report(ex2);
					}
				}
			}
			catch (Exception ex3) when (ex3 is IOException || ex3 is UnauthorizedAccessException)
			{
				report(ex3);
			}
		}
	}
	public enum RewardPhase
	{
		Quota = 1,
		Money
	}
	public sealed class RewardTicket
	{
		public string Epoch { get; set; } = "";

		public string SourceKey { get; set; } = "";

		public string Token { get; set; } = "";

		public bool PayPending { get; set; } = true;

		public bool AllowRepeat { get; set; }
	}
	public sealed class RewardLedgerState
	{
		public string Epoch { get; set; } = "";

		public List<string> Sources { get; set; } = new List<string>();

		public List<string> Repeats { get; set; } = new List<string>();
	}
	public sealed class RewardLedger
	{
		private readonly Dictionary<string, int> sources = new Dictionary<string, int>(StringComparer.Ordinal);

		private readonly Dictionary<string, int> repeats = new Dictionary<string, int>(StringComparer.Ordinal);

		public string Epoch { get; }

		public RewardLedger(string epoch)
		{
			TerminalProtocol.RequireGuid(epoch);
			Epoch = epoch;
		}

		public bool CanApply(RewardTicket ticket, RewardPhase phase)
		{
			ValidateTicket(ticket);
			if (!string.Equals(ticket.Epoch, Epoch, StringComparison.Ordinal))
			{
				return false;
			}
			if (!ticket.PayPending)
			{
				return false;
			}
			if (phase != RewardPhase.Quota && phase != RewardPhase.Money)
			{
				throw new ArgumentOutOfRangeException("phase");
			}
			if (ticket.AllowRepeat)
			{
				if (repeats.TryGetValue(ticket.Token + ":" + ticket.SourceKey, out var value))
				{
					return ((uint)value & (uint)phase) == 0;
				}
				return true;
			}
			if (sources.TryGetValue(ticket.SourceKey, out var value2))
			{
				return ((uint)value2 & (uint)phase) == 0;
			}
			return true;
		}

		public bool TryApply(RewardTicket ticket, RewardPhase phase)
		{
			if (!CanApply(ticket, phase))
			{
				return false;
			}
			if (!sources.ContainsKey(ticket.SourceKey) && sources.Count >= 4096)
			{
				throw new InvalidDataException("Reward ledger capacity reached.");
			}
			if (ticket.AllowRepeat)
			{
				string key = ticket.Token + ":" + ticket.SourceKey;
				if (!repeats.ContainsKey(key) && repeats.Count >= 32)
				{
					throw new InvalidDataException("Additional reward capacity reached.");
				}
				repeats.TryGetValue(key, out var value);
				repeats[key] = value | (int)phase;
			}
			sources.TryGetValue(ticket.SourceKey, out var value2);
			sources[ticket.SourceKey] = value2 | (int)phase;
			return true;
		}

		public int PaidPhases(string source)
		{
			if (!sources.TryGetValue(source, out var value))
			{
				return 0;
			}
			return value;
		}

		public RewardLedgerState Export()
		{
			return new RewardLedgerState
			{
				Epoch = Epoch,
				Sources = sources.Select<KeyValuePair<string, int>, string>((KeyValuePair<string, int> p) => p.Key + ":" + p.Value).ToList(),
				Repeats = repeats.Select<KeyValuePair<string, int>, string>((KeyValuePair<string, int> p) => p.Key + ":" + p.Value).ToList()
			};
		}

		public static RewardLedger Restore(RewardLedgerState state)
		{
			RewardLedger rewardLedger = new RewardLedger(state.Epoch);
			if (state.Sources == null || state.Repeats == null || state.Sources.Count > 4096 || state.Repeats.Count > 32)
			{
				throw new InvalidDataException("Invalid reward ledger.");
			}
			foreach (string source in state.Sources)
			{
				string[] array = (source ?? throw new InvalidDataException("Null reward receipt.")).Split(':');
				if (array.Length != 2 || !IsHash(array[0]) || !ValidMask(array[1], out var mask) || rewardLedger.sources.ContainsKey(array[0]))
				{
					throw new InvalidDataException("Invalid reward receipt.");
				}
				rewardLedger.sources.Add(array[0], mask);
			}
			foreach (string repeat in state.Repeats)
			{
				string[] array2 = (repeat ?? throw new InvalidDataException("Null repeated reward receipt.")).Split(':');
				if (array2.Length != 3 || array2[0].Length != 32 || !Guid.TryParseExact(array2[0], "N", out var _) || !IsHash(array2[1]) || !ValidMask(array2[2], out var mask2))
				{
					throw new InvalidDataException("Invalid repeated reward receipt.");
				}
				string key = array2[0] + ":" + array2[1];
				if (rewardLedger.repeats.ContainsKey(key))
				{
					throw new InvalidDataException("Duplicate reward receipt.");
				}
				rewardLedger.repeats.Add(key, mask2);
				if (!rewardLedger.sources.TryGetValue(array2[1], out var value) || (value & mask2) != mask2)
				{
					throw new InvalidDataException("Inconsistent repeated reward receipt.");
				}
			}
			return rewardLedger;
		}

		private static bool ValidMask(string text, out int mask)
		{
			if (int.TryParse(text, out mask) && mask >= 1)
			{
				return mask <= 3;
			}
			return false;
		}

		private static bool IsHash(string value)
		{
			if (value != null && value.Length == 64)
			{
				return value.All((char c) => (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'));
			}
			return false;
		}

		private static void ValidateTicket(RewardTicket ticket)
		{
			TerminalProtocol.RequireGuid(ticket.Epoch);
			if (!IsHash(ticket.SourceKey) || ticket.Token == null || ticket.Token.Length != 32 || !Guid.TryParseExact(ticket.Token, "N", out var result) || result == Guid.Empty || (ticket.AllowRepeat && !ticket.PayPending))
			{
				throw new InvalidDataException("Invalid reward ticket.");
			}
		}
	}
	public sealed class SessionTracker
	{
		private string lastUndergroundScene = "";

		private bool enteredUnderground;

		public ArchiveContext? Current { get; private set; }

		public ArchiveContext BeginMatch(string saveId, string evidence)
		{
			lastUndergroundScene = "";
			enteredUnderground = false;
			ArchiveContext obj = new ArchiveContext
			{
				MatchId = Guid.NewGuid().ToString("N")
			};
			Guid result = Guid.NewGuid();
			obj.IncursionId = result.ToString("N");
			obj.IncursionNumber = 1;
			obj.SaveId = (Guid.TryParse(saveId, out result) ? saveId : "");
			obj.Evidence = evidence + "; surface-before-first-observed-dive";
			obj.StartedUtc = DateTime.UtcNow.ToString("O");
			obj.MatchDateLocal = DateTime.Now.ToString("yyyyMMdd", CultureInfo.InvariantCulture);
			ArchiveContext result2 = obj;
			Current = obj;
			return result2;
		}

		public ArchiveContext EnterUnderground(string sceneToken, int day)
		{
			if (Current == null)
			{
				BeginMatch("", "late-observation");
			}
			if (enteredUnderground && lastUndergroundScene == sceneToken)
			{
				return Current;
			}
			bool flag = !enteredUnderground;
			enteredUnderground = true;
			lastUndergroundScene = sceneToken;
			return Current = new ArchiveContext
			{
				MatchId = Current.MatchId,
				IncursionId = (flag ? Current.IncursionId : Guid.NewGuid().ToString("N")),
				IncursionNumber = (flag ? Current.IncursionNumber : (Current.IncursionNumber + 1)),
				GameDay = Math.Max(0, day),
				SaveId = Current.SaveId,
				Evidence = "PhotonGameLobbyHandler.Awake; underground scene loaded; locally observed ordinal",
				StartedUtc = (flag ? Current.StartedUtc : DateTime.UtcNow.ToString("O")),
				MatchDateLocal = Current.MatchDateLocal
			};
		}
	}
	public sealed class SourceRetention
	{
		private readonly string sourceRoot;

		private readonly object gate = new object();

		private readonly Dictionary<string, ArchiveContext> origins = new Dictionary<string, ArchiveContext>(StringComparer.OrdinalIgnoreCase);

		public string Root { get; }

		public SourceRetention(string sourceRoot, string retentionRoot)
		{
			this.sourceRoot = ArchivePaths.NormalizeRoot(sourceRoot);
			Root = ArchivePaths.NormalizeRoot(retentionRoot);
			if (this.sourceRoot.Equals(Root, StringComparison.OrdinalIgnoreCase) || ArchivePaths.Contains(this.sourceRoot, Root) || ArchivePaths.Contains(Root, this.sourceRoot))
			{
				throw new ArgumentException("Retention must be outside the source tree.");
			}
			if (!string.Equals(Path.GetPathRoot(this.sourceRoot), Path.GetPathRoot(Root), StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException("Atomic retention requires the same volume.");
			}
		}

		public void Remember(string path, ArchiveContext? context)
		{
			if (context == null)
			{
				return;
			}
			context.Validate();
			string relativePath = Path.GetRelativePath(sourceRoot, path);
			ArchivePaths.Resolve(sourceRoot, relativePath);
			lock (gate)
			{
				origins[relativePath] = context;
			}
		}

		public Dictionary<string, ArchiveContext> SnapshotContexts()
		{
			lock (gate)
			{
				return new Dictionary<string, ArchiveContext>(origins, StringComparer.OrdinalIgnoreCase);
			}
		}

		public void Preserve(string path, bool isFile, ArchiveContext? context)
		{
			lock (gate)
			{
				string text = Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
				if (!text.Equals(sourceRoot, StringComparison.OrdinalIgnoreCase) && !ArchivePaths.Contains(sourceRoot, text))
				{
					throw new IOException("Refusing to retain a path outside Rec.");
				}
				ArchivePaths.RejectLinks(sourceRoot, text);
				ArchivePaths.RejectLinks(Root, Root);
				if (isFile ? (!File.Exists(text)) : (!Directory.Exists(text)))
				{
					return;
				}
				context?.Validate();
				string text2 = Guid.NewGuid().ToString("N").Substring(0, 16);
				string text3 = ArchivePaths.Resolve(Root, text2);
				Directory.CreateDirectory(text3);
				RetainedBatch retainedBatch = new RetainedBatch
				{
					Id = text2,
					SourceRoot = sourceRoot,
					OriginalRelativePath = Path.GetRelativePath(sourceRoot, text),
					IsFile = isFile,
					Context = context
				};
				string originalRelativePath = retainedBatch.OriginalRelativePath;
				foreach (KeyValuePair<string, ArchiveContext> origin in origins)
				{
					if (originalRelativePath == "." || origin.Key.Equals(originalRelativePath, StringComparison.OrdinalIgnoreCase) || origin.Key.StartsWith(originalRelativePath + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
					{
						retainedBatch.FileContexts.Add(origin.Key, origin.Value);
					}
				}
				JsonStore.Write(Path.Combine(text3, "retention.json"), retainedBatch);
				if (isFile)
				{
					File.Move(text, Path.Combine(text3, "data"));
				}
				else
				{
					Directory.Move(text, Path.Combine(text3, "data"));
				}
				foreach (string key in retainedBatch.FileContexts.Keys)
				{
					origins.Remove(key);
				}
			}
		}

		public void CopyPreserving(string source, string destination, ArchiveContext? context)
		{
			lock (gate)
			{
				Preserve(destination, isFile: true, null);
				File.Copy(source, destination, overwrite: false);
				Remember(destination, context);
			}
		}
	}
	public sealed class TerminalClipEntry
	{
		public string MatchId { get; set; } = "";

		public string VideoId { get; set; } = "";

		public string ClipId { get; set; } = "";

		public int Incursion { get; set; }

		public string PlayerId { get; set; } = "";

		public string PlayerName { get; set; } = "";

		public int Order { get; set; }
	}
	public sealed class TerminalSelection
	{
		public List<TerminalClipEntry> Clips { get; set; } = new List<TerminalClipEntry>();

		public bool IsSequence { get; set; }

		public int ClipNumber { get; set; }

		public string Key => TerminalProtocol.SourceKey(Clips[0].VideoId, Clips.Select((TerminalClipEntry c) => c.ClipId));
	}
	public sealed class TerminalLibrary
	{
		private readonly Dictionary<string, TerminalClipEntry> clips = new Dictionary<string, TerminalClipEntry>();

		public void Clear()
		{
			clips.Clear();
		}

		public bool Observe(TerminalClipEntry entry)
		{
			TerminalProtocol.RequireGuid(entry.VideoId);
			TerminalProtocol.RequireGuid(entry.ClipId);
			if (string.IsNullOrWhiteSpace(entry.MatchId) || string.IsNullOrWhiteSpace(entry.PlayerId) || entry.Incursion < 0 || entry.Order < 0)
			{
				throw new InvalidDataException("Missing clip scope or player identity.");
			}
			string key = TerminalProtocol.SourceKey(entry.VideoId, new string[1] { entry.ClipId });
			if (clips.TryGetValue(key, out TerminalClipEntry value) && (value.MatchId != entry.MatchId || value.Incursion != entry.Incursion))
			{
				return false;
			}
			if (!clips.ContainsKey(key) && clips.Count >= 4096)
			{
				throw new InvalidDataException("Terminal clip capacity reached.");
			}
			clips[key] = new TerminalClipEntry
			{
				MatchId = entry.MatchId,
				VideoId = Guid.Parse(entry.VideoId).ToString(),
				ClipId = Guid.Parse(entry.ClipId).ToString(),
				Incursion = entry.Incursion,
				PlayerId = entry.PlayerId,
				PlayerName = entry.PlayerName,
				Order = (value?.Order ?? entry.Order)
			};
			return true;
		}

		public IEnumerable<TerminalSelection> Selections(string match)
		{
			foreach (var item in (from c in clips.Values
				where c.MatchId == match
				group c by new { c.Incursion, c.PlayerId, c.VideoId } into g
				orderby g.Key.Incursion
				select g).ThenBy(g => g.First().PlayerName, StringComparer.CurrentCulture).ThenBy(g => g.Key.VideoId, StringComparer.Ordinal))
			{
				List<TerminalClipEntry> ordered = item.OrderBy((TerminalClipEntry c) => c.Order).ThenBy<TerminalClipEntry, string>((TerminalClipEntry c) => c.ClipId, StringComparer.Ordinal).ToList();
				if (ordered.Count <= 128)
				{
					yield return new TerminalSelection
					{
						Clips = ordered,
						IsSequence = true
					};
				}
				for (int i = 0; i < ordered.Count; i++)
				{
					yield return new TerminalSelection
					{
						Clips = new List<TerminalClipEntry> { ordered[i] },
						ClipNumber = i + 1
					};
				}
			}
		}

		public TerminalSelection? Resolve(string match, DiscDefinition disc)
		{
			disc.Validate();
			List<TerminalClipEntry> selected = new List<TerminalClipEntry>();
			foreach (string clipId in disc.ClipIds)
			{
				if (!clips.TryGetValue(TerminalProtocol.SourceKey(disc.SourceVideoId, new string[1] { clipId }), out TerminalClipEntry value) || value.MatchId != match)
				{
					return null;
				}
				selected.Add(value);
			}
			if (selected.Any((TerminalClipEntry c) => c.Incursion != selected[0].Incursion || c.PlayerId != selected[0].PlayerId))
			{
				return null;
			}
			if (!selected.Select((TerminalClipEntry c) => c.ClipId).SequenceEqual(from c in selected.OrderBy((TerminalClipEntry c) => c.Order).ThenBy<TerminalClipEntry, string>((TerminalClipEntry c) => c.ClipId, StringComparer.Ordinal)
				select c.ClipId))
			{
				return null;
			}
			return new TerminalSelection
			{
				Clips = selected,
				IsSequence = (selected.Count > 1)
			};
		}
	}
	public sealed class PlaybackFile
	{
		public string ClipId { get; set; } = "";

		public string SourceRelativePath { get; set; } = "";

		public long Length { get; set; }

		public long WriteTicks { get; set; }
	}
	public static class TerminalMedia
	{
		public static string Prepare(DiscDefinition disc, IReadOnlyList<PlaybackFile> files, string sourceRoot, string outputRoot, string playbackRoot, CancellationToken cancellation, PlaybackFile? fullRecording = null)
		{
			disc.Validate();
			sourceRoot = ArchivePaths.NormalizeRoot(sourceRoot);
			outputRoot = ArchivePaths.NormalizeRoot(outputRoot);
			playbackRoot = ArchivePaths.NormalizeRoot(playbackRoot);
			if (files.Count != disc.ClipIds.Count || files.Count == 0)
			{
				throw new InvalidDataException("Incomplete playback snapshot.");
			}
			if (playbackRoot.Equals(sourceRoot, StringComparison.OrdinalIgnoreCase) || ArchivePaths.Contains(sourceRoot, playbackRoot) || ArchivePaths.Contains(playbackRoot, sourceRoot) || playbackRoot.Equals(outputRoot, StringComparison.OrdinalIgnoreCase) || ArchivePaths.Contains(playbackRoot, outputRoot))
			{
				throw new InvalidDataException("Unsafe playback directory.");
			}
			string result = ArchivePaths.Resolve(playbackRoot, Guid.Parse(disc.AliasId).ToString("N"));
			ArchiveState archiveState = null;
			string path = ArchivePaths.Resolve(outputRoot, ".recordingarchiver-state.json");
			if (File.Exists(path))
			{
				archiveState = JsonStore.Read<ArchiveState>(path);
				if (!string.Equals(archiveState.SourceRoot, sourceRoot, StringComparison.OrdinalIgnoreCase) || archiveState.Recordings == null || archiveState.Recordings.Any((RecordingMetadata r) => r == null || r.Files == null))
				{
					throw new InvalidDataException("Archive index is invalid or belongs to another source.");
				}
			}
			for (int num = 0; num < files.Count; num++)
			{
				cancellation.ThrowIfCancellationRequested();
				PlaybackFile playbackFile = files[num];
				TerminalProtocol.RequireGuid(playbackFile.ClipId);
				string value = Path.Combine(Guid.Parse(disc.SourceVideoId).ToString(), Guid.Parse(playbackFile.ClipId).ToString(), "output.webm");
				if (!Guid.Parse(playbackFile.ClipId).Equals(Guid.Parse(disc.ClipIds[num])) || !playbackFile.SourceRelativePath.Equals(value, StringComparison.OrdinalIgnoreCase) || playbackFile.Length < 4 || playbackFile.WriteTicks <= 0)
				{
					throw new InvalidDataException("Invalid playback provenance.");
				}
				string source = FindSource(playbackFile, sourceRoot, outputRoot, archiveState);
				string text = ArchivePaths.Resolve(playbackRoot, Path.Combine(Guid.Parse(disc.AliasId).ToString("N"), Guid.Parse(playbackFile.ClipId).ToString(), "output.webm"));
				Directory.CreateDirectory(Path.GetDirectoryName(text));
				CopyVerified(source, text, playbackFile.Length, cancellation);
			}
			string target = ArchivePaths.Resolve(playbackRoot, Path.Combine(Guid.Parse(disc.AliasId).ToString("N"), "fullRecording.webm"));
			if (fullRecording != null)
			{
				string text2 = Path.Combine(Guid.Parse(disc.SourceVideoId).ToString(), "fullRecording.webm");
				if (fullRecording.SourceRelativePath != text2 || fullRecording.Length < 4 || fullRecording.WriteTicks <= 0)
				{
					throw new InvalidDataException("Invalid full recording provenance.");
				}
				CopyVerified(FindSource(fullRecording, sourceRoot, outputRoot, archiveState), target, fullRecording.Length, cancellation);
			}
			else if (files.Count == 1)
			{
				CopyVerified(ArchivePaths.Resolve(playbackRoot, Path.Combine(Guid.Parse(disc.AliasId).ToString("N"), Guid.Parse(files[0].ClipId).ToString(), "output.webm")), target, files[0].Length, cancellation);
			}
			return result;
		}

		private static string FindSource(PlaybackFile file, string sourceRoot, string outputRoot, ArchiveState? state)
		{
			string text = ArchivePaths.Resolve(sourceRoot, file.SourceRelativePath);
			if (Matches(text, file))
			{
				return text;
			}
			if (state != null)
			{
				foreach (ArchivedFile item in from f in state.Recordings.SelectMany((RecordingMetadata r) => r.Files ?? new List<ArchivedFile>())
					where f != null && string.Equals(f.SourceRelativePath, file.SourceRelativePath, StringComparison.OrdinalIgnoreCase) && f.Length == file.Length && f.SourceWriteTicks == file.WriteTicks && f.Status == "byte-verified-media-unverified"
					select f)
				{
					string text2 = ArchivePaths.Resolve(outputRoot, item.Destination);
					if (File.Exists(text2) && new FileInfo(text2).Length == file.Length && Hash(text2) == item.Sha256)
					{
						return text2;
					}
				}
			}
			string text3 = sourceRoot + "_RA";
			ArchivePaths.RejectLinks(text3, text3);
			if (Directory.Exists(text3))
			{
				string[] directories = Directory.GetDirectories(text3);
				foreach (string path in directories)
				{
					string path2 = ArchivePaths.Resolve(text3, Path.Combine(Path.GetFileName(path), "retention.json"));
					if (!File.Exists(path2))
					{
						continue;
					}
					RetainedBatch retainedBatch = JsonStore.Read<RetainedBatch>(path2);
					if (retainedBatch.Id != Path.GetFileName(path) || !string.Equals(retainedBatch.SourceRoot, sourceRoot, StringComparison.OrdinalIgnoreCase))
					{
						throw new InvalidDataException("Invalid retained playback provenance.");
					}
					string originalRelativePath = retainedBatch.OriginalRelativePath;
					if (originalRelativePath != ".")
					{
						ArchivePaths.Resolve(sourceRoot, originalRelativePath);
					}
					string relative;
					if (retainedBatch.IsFile)
					{
						if (!originalRelativePath.Equals(file.SourceRelativePath, StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						relative = Path.Combine(retainedBatch.Id, "data");
					}
					else
					{
						if (originalRelativePath != "." && !file.SourceRelativePath.StartsWith(originalRelativePath + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						relative = Path.Combine(retainedBatch.Id, "data", (originalRelativePath == ".") ? file.SourceRelativePath : file.SourceRelativePath.Substring(originalRelativePath.Length + 1));
					}
					string text4 = ArchivePaths.Resolve(text3, relative);
					if (Matches(text4, file))
					{
						return text4;
					}
				}
			}
			throw new FileNotFoundException("A clip is unavailable in live, archived and retained sources.");
		}

		private static bool Matches(string path, PlaybackFile file)
		{
			if (File.Exists(path) && new FileInfo(path).Length == file.Length)
			{
				return File.GetLastWriteTimeUtc(path).Ticks == file.WriteTicks;
			}
			return false;
		}

		private static void CopyVerified(string source, string target, long length, CancellationToken cancellation)
		{
			string text = Path.Combine(Path.GetDirectoryName(target), ".p" + Guid.NewGuid().ToString("N").Substring(0, 8));
			long ticks = File.GetLastWriteTimeUtc(source).Ticks;
			string text2;
			using (FileStream fileStream = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.Read, 131072, FileOptions.SequentialScan))
			{
				using FileStream fileStream2 = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None, 131072);
				using SHA256 sHA = SHA256.Create();
				byte[] array = new byte[131072];
				if (fileStream.Read(array, 0, 4) != 4 || array[0] != 26 || array[1] != 69 || array[2] != 223 || array[3] != 163)
				{
					throw new InvalidDataException("Clip has no WebM/EBML header.");
				}
				fileStream.Position = 0L;
				long num = 0L;
				int num2;
				while ((num2 = fileStream.Read(array, 0, array.Length)) > 0)
				{
					cancellation.ThrowIfCancellationRequested();
					if (num + num2 > length)
					{
						throw new IOException("Clip grew during preparation.");
					}
					fileStream2.Write(array, 0, num2);
					sHA.TransformBlock(array, 0, num2, null, 0);
					num += num2;
				}
				sHA.TransformFinalBlock(Array.Empty<byte>(), 0, 0);
				text2 = ArchivePaths.Hex(sHA.Hash);
				fileStream2.Flush(flushToDisk: true);
				if (num != length || File.GetLastWriteTimeUtc(source).Ticks != ticks)
				{
					throw new IOException("Clip changed during preparation.");
				}
			}
			if (Hash(text) != text2)
			{
				throw new IOException("Playback copy verification failed.");
			}
			if (File.Exists(target))
			{
				if (Hash(target) != text2)
				{
					throw new IOException("Playback target already exists with different bytes.");
				}
				File.Delete(text);
			}
			else
			{
				File.Move(text, target);
			}
		}

		private static string Hash(string path)
		{
			using FileStream inputStream = File.OpenRead(path);
			using SHA256 sHA = SHA256.Create();
			return ArchivePaths.Hex(sHA.ComputeHash(inputStream));
		}
	}
	public sealed class DiscDefinition
	{
		public string AliasId { get; set; } = "";

		public string SourceVideoId { get; set; } = "";

		public List<string> ClipIds { get; set; } = new List<string>();

		public bool PayPending { get; set; } = true;

		public bool AllowRepeat { get; set; }

		public string SourceKey => TerminalProtocol.SourceKey(SourceVideoId, ClipIds);

		public string PaymentKey => TerminalProtocol.PaymentKey(SourceVideoId);

		public void Validate()
		{
			TerminalProtocol.RequireGuid(AliasId);
			TerminalProtocol.RequireGuid(SourceVideoId);
			if (Guid.Parse(AliasId) == Guid.Parse(SourceVideoId) || ClipIds == null || ClipIds.Count == 0 || ClipIds.Count > 128 || (AllowRepeat && !PayPending))
			{
				throw new InvalidDataException("Invalid disc definition.");
			}
			foreach (string clipId in ClipIds)
			{
				TerminalProtocol.RequireGuid(clipId);
			}
			if (ClipIds.Select(Guid.Parse).Distinct().Count() != ClipIds.Count)
			{
				throw new InvalidDataException("Duplicate clip identity.");
			}
		}
	}
	public sealed class DiscRoomState
	{
		public int Version { get; set; } = 1;

		public string Epoch { get; set; } = "";

		public int AuthorActor { get; set; }

		public List<DiscDefinition> Discs { get; set; } = new List<DiscDefinition>();

		public void Validate()
		{
			TerminalProtocol.RequireGuid(Epoch);
			if (Version != 1 || AuthorActor <= 0 || Discs == null || Discs.Count > 32)
			{
				throw new InvalidDataException("Invalid terminal room state.");
			}
			foreach (DiscDefinition disc in Discs)
			{
				(disc ?? throw new InvalidDataException("Null disc definition.")).Validate();
			}
			if (Discs.Select((DiscDefinition d) => Guid.Parse(d.AliasId)).Distinct().Count() != Discs.Count)
			{
				throw new InvalidDataException("Duplicate disc identity.");
			}
		}
	}
	public static class TerminalProtocol
	{
		public const int MaxPayloadLength = 524288;

		public static void RequireGuid(string id)
		{
			if (id == null || id.Length > 36 || !Guid.TryParse(id, out var result) || result == Guid.Empty)
			{
				throw new InvalidDataException("Invalid video identifier.");
			}
		}

		public static string SourceKey(string video, IEnumerable<string> clips)
		{
			RequireGuid(video);
			string[] array = clips.Select(delegate(string id)
			{
				RequireGuid(id);
				return Guid.Parse(id).ToString("N");
			}).ToArray();
			if (array.Length > 128)
			{
				throw new InvalidDataException("Too many clips.");
			}
			return ArchivePaths.HashText(Guid.Parse(video).ToString("N") + "|" + string.Join("|", array));
		}

		public static string PaymentKey(string video)
		{
			RequireGuid(video);
			return ArchivePaths.HashText("native-video:" + Guid.Parse(video).ToString("N"));
		}

		public static string Encode<T>(T value)
		{
			using MemoryStream memoryStream = new MemoryStream();
			new DataContractJsonSerializer(typeof(T)).WriteObject(memoryStream, value);
			if (memoryStream.Length > 524288)
			{
				throw new InvalidDataException("Terminal metadata limit reached.");
			}
			return Encoding.UTF8.GetString(memoryStream.ToArray());
		}

		public static T Decode<T>(string text) where T : class
		{
			if (text == null || text.Length > 524288)
			{
				throw new InvalidDataException("Invalid terminal metadata size.");
			}
			byte[] bytes = Encoding.UTF8.GetBytes(text);
			if (bytes.Length > 524288)
			{
				throw new InvalidDataException("Invalid terminal metadata size.");
			}
			using MemoryStream stream = new MemoryStream(bytes);
			return (T)(new DataContractJsonSerializer(typeof(T)).ReadObject(stream) ?? throw new InvalidDataException("Empty terminal metadata."));
		}
	}
}