using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RepoStarterMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("RepoStarterMod")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("97d352f5-4c2d-4aec-a09b-d82de3937eea")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("com.yourname.headcamreplay", "Headcam Replay", "1.1.3")]
public sealed class HeadcamReplay : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass34_0
	{
		public Texture2D screenshot;

		public HeadcamReplay <>4__this;

		internal void <CaptureCurrentScreenFrame>b__0()
		{
			byte[] item = ImageConversion.EncodeToPNG(screenshot);
			Object.Destroy((Object)(object)screenshot);
			int num = Mathf.RoundToInt(<>4__this.cfgReplaySeconds.Value * (float)<>4__this.cfgBufferFPS.Value);
			if (<>4__this.frameBuffer.Count >= num)
			{
				<>4__this.frameBuffer.Dequeue();
			}
			<>4__this.frameBuffer.Enqueue(item);
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass39_0
	{
		public string execPath;

		public HeadcamReplay <>4__this;
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass39_1
	{
		public string args;

		public bool finished;

		public <>c__DisplayClass39_0 CS$<>8__locals1;

		internal void <FinalizeExportCoroutine>b__0()
		{
			try
			{
				ProcessStartInfo startInfo = new ProcessStartInfo
				{
					FileName = CS$<>8__locals1.execPath,
					Arguments = args,
					UseShellExecute = false,
					CreateNoWindow = true
				};
				Process process = new Process
				{
					StartInfo = startInfo
				};
				process.Start();
				process.WaitForExit();
				finished = true;
			}
			catch (Exception ex)
			{
				CS$<>8__locals1.<>4__this.PublicLogger.LogError((object)("Failed to run FFmpeg: ApplicationName='" + CS$<>8__locals1.execPath + "', Arguments='" + args + "', Error= " + ex.Message));
				finished = true;
			}
		}
	}

	[CompilerGenerated]
	private sealed class <CaptureCurrentScreenFrame>d__34 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public HeadcamReplay <>4__this;

		private <>c__DisplayClass34_0 <>8__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <CaptureCurrentScreenFrame>d__34(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>8__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass34_0();
				<>8__1.<>4__this = <>4__this;
				if (<>4__this.isCapturingFrame)
				{
					return false;
				}
				<>4__this.isCapturingFrame = true;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>8__1.screenshot = ScreenCapture.CaptureScreenshotAsTexture();
				<>2__current = Task.Run(delegate
				{
					byte[] item = ImageConversion.EncodeToPNG(<>8__1.screenshot);
					Object.Destroy((Object)(object)<>8__1.screenshot);
					int num = Mathf.RoundToInt(<>8__1.<>4__this.cfgReplaySeconds.Value * (float)<>8__1.<>4__this.cfgBufferFPS.Value);
					if (<>8__1.<>4__this.frameBuffer.Count >= num)
					{
						<>8__1.<>4__this.frameBuffer.Dequeue();
					}
					<>8__1.<>4__this.frameBuffer.Enqueue(item);
				});
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.isCapturingFrame = false;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <ExportCoroutine>d__36 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public HeadcamReplay <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ExportCoroutine>d__36(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.PrepareExport();
				<>2__current = <>4__this.FinalizeExportCoroutine();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.PublicLogger.LogInfo((object)"Pre-death footage export complete.");
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <FinalizeExportCoroutine>d__39 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public HeadcamReplay <>4__this;

		private <>c__DisplayClass39_0 <>8__1;

		private bool <useSystemPath>5__2;

		private int <i>5__3;

		private string <path>5__4;

		private <>c__DisplayClass39_1 <>8__5;

		private float <playbackFPS>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <FinalizeExportCoroutine>d__39(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>8__1 = null;
			<path>5__4 = null;
			<>8__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			int num = <>1__state;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass39_0();
				<>8__1.<>4__this = <>4__this;
				<i>5__3 = 0;
				while (<i>5__3 < <>4__this.framePngsToExport.Count)
				{
					<path>5__4 = Path.Combine(<>4__this.tempPngFolder, $"{<i>5__3:D6}.png");
					File.WriteAllBytes(<path>5__4, <>4__this.framePngsToExport[<i>5__3]);
					<path>5__4 = null;
					<i>5__3++;
				}
				<>4__this.framePngsToExport.Clear();
				<useSystemPath>5__2 = <>4__this.ffmpegPath == "ffmpeg";
				<>8__1.execPath = <>4__this.ffmpegPath;
				if (!<useSystemPath>5__2 && !File.Exists(<>8__1.execPath))
				{
					<>4__this.PublicLogger.LogError((object)("FFmpeg not found at the expected path: " + <>4__this.ffmpegPath + ". Export skipped."));
					goto IL_02db;
				}
				<>8__5 = new <>c__DisplayClass39_1();
				<>8__5.CS$<>8__locals1 = <>8__1;
				if (!<useSystemPath>5__2)
				{
					<>8__5.CS$<>8__locals1.execPath = "\"" + <>8__5.CS$<>8__locals1.execPath + "\"";
				}
				<playbackFPS>5__6 = (float)<>4__this.cfgBufferFPS.Value * <>4__this.cfgPlaybackSpeed.Value;
				if (<playbackFPS>5__6 < 1f)
				{
					<playbackFPS>5__6 = 1f;
				}
				<>8__5.args = $"-framerate {<playbackFPS>5__6} -i \"{<>4__this.tempPngFolder}/%06d.png\" -c:v libx264 -pix_fmt yuv420p -y \"{<>4__this.exportFilePath}\"";
				<>4__this.PublicLogger.LogInfo((object)$"Starting FFmpeg process. Playback FPS: {<playbackFPS>5__6}, Arguments: {<>8__5.args}");
				<>8__5.finished = false;
				Task.Run(delegate
				{
					try
					{
						ProcessStartInfo startInfo = new ProcessStartInfo
						{
							FileName = <>8__5.CS$<>8__locals1.execPath,
							Arguments = <>8__5.args,
							UseShellExecute = false,
							CreateNoWindow = true
						};
						Process process = new Process
						{
							StartInfo = startInfo
						};
						process.Start();
						process.WaitForExit();
						<>8__5.finished = true;
					}
					catch (Exception ex)
					{
						<>8__5.CS$<>8__locals1.<>4__this.PublicLogger.LogError((object)("Failed to run FFmpeg: ApplicationName='" + <>8__5.CS$<>8__locals1.execPath + "', Arguments='" + <>8__5.args + "', Error= " + ex.Message));
						<>8__5.finished = true;
					}
				});
			}
			if (!<>8__5.finished)
			{
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			<>4__this.PublicLogger.LogInfo((object)"FFmpeg finished. Cleaning up.");
			<>8__5 = null;
			goto IL_02db;
			IL_02db:
			try
			{
				Directory.Delete(<>4__this.tempPngFolder, recursive: true);
			}
			catch
			{
			}
			<>4__this.PublicLogger.LogInfo((object)("Pre-death footage export complete. Saved to: " + <>4__this.exportFilePath));
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public const string PLUGIN_GUID = "com.yourname.headcamreplay";

	public const string PLUGIN_NAME = "Headcam Replay";

	public const string PLUGIN_VERSION = "1.1.3";

	private ConfigEntry<float> cfgReplaySeconds;

	private ConfigEntry<int> cfgBufferFPS;

	private ConfigEntry<string> cfgExportFolder;

	private ConfigEntry<float> cfgPlaybackSpeed;

	private Queue<byte[]> frameBuffer;

	internal float timeOfDeath = 0f;

	private const float POST_DEATH_DELAY = 2f;

	private List<byte[]> framePngsToExport;

	private string exportFilePath;

	private string tempPngFolder;

	private string ffmpegPath;

	private bool isCapturingFrame = false;

	internal static HeadcamReplay Instance { get; private set; }

	internal static Camera StaticPlayerCam { get; set; }

	internal static CameraNoise StaticCameraNoise { get; set; }

	public ManualLogSource PublicLogger => ((BaseUnityPlugin)this).Logger;

	private Camera PlayerCam => StaticPlayerCam;

	private void Awake()
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Expected O, but got Unknown
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Expected O, but got Unknown
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Expected O, but got Unknown
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		Instance = this;
		frameBuffer = new Queue<byte[]>();
		framePngsToExport = new List<byte[]>();
		cfgReplaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("General", "ReplaySeconds", 10f, new ConfigDescription("Seconds of pre-death footage", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 30f), Array.Empty<object>()));
		cfgBufferFPS = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "BufferFPS", 30, new ConfigDescription("Recording FPS", (AcceptableValueBase)(object)new AcceptableValueRange<int>(24, 60), Array.Empty<object>()));
		string text = Path.Combine(Application.dataPath, "..", "DeathVids");
		cfgExportFolder = ((BaseUnityPlugin)this).Config.Bind<string>("Export", "ExportFolder", text, "Folder for MP4s (full path or relative to game dir)");
		cfgPlaybackSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Export", "PlaybackSpeedMultiplier", 1f, new ConfigDescription("Playback speed multiplier (1.0 = normal, 0.5 = half speed/slow motion)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 4f), Array.Empty<object>()));
		Directory.CreateDirectory(cfgExportFolder.Value);
		new Harmony("com.yourname.headcamreplay").PatchAll();
		PublicLogger.LogInfo((object)"Headcam Replay v1.1.3 loaded. Delayed full screen capture enabled.");
	}

	private void Update()
	{
		if ((Object)(object)PlayerCam == (Object)null)
		{
			TryFindPlayerComponentsFallback();
		}
		if ((Object)(object)PlayerCam != (Object)null && !isCapturingFrame && Time.frameCount % (60 / cfgBufferFPS.Value) == 0)
		{
			((MonoBehaviour)this).StartCoroutine(CaptureCurrentScreenFrame());
		}
		if (timeOfDeath > 0f && Time.time >= timeOfDeath + 2f)
		{
			StartExport();
			timeOfDeath = 0f;
		}
	}

	private void TryFindPlayerComponentsFallback()
	{
		if ((Object)(object)StaticCameraNoise == (Object)null)
		{
			StaticCameraNoise = Object.FindObjectOfType<CameraNoise>();
		}
		if ((Object)(object)StaticCameraNoise != (Object)null && (Object)(object)StaticPlayerCam == (Object)null)
		{
			StaticPlayerCam = ((Component)StaticCameraNoise).GetComponentInChildren<Camera>(true);
		}
	}

	[IteratorStateMachine(typeof(<CaptureCurrentScreenFrame>d__34))]
	private IEnumerator CaptureCurrentScreenFrame()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <CaptureCurrentScreenFrame>d__34(0)
		{
			<>4__this = this
		};
	}

	internal void StartExport()
	{
		if ((Object)(object)PlayerCam == (Object)null)
		{
			TryFindPlayerComponentsFallback();
			if ((Object)(object)PlayerCam == (Object)null)
			{
				PublicLogger.LogError((object)"Cannot start export: Player Camera is null. Export aborted.");
				return;
			}
		}
		framePngsToExport.Clear();
		foreach (byte[] item in frameBuffer)
		{
			framePngsToExport.Add(item);
		}
		frameBuffer.Clear();
		((MonoBehaviour)this).StartCoroutine(ExportCoroutine());
		PublicLogger.LogInfo((object)$"Pre-death footage export initiated. Capturing {framePngsToExport.Count} frames.");
	}

	[IteratorStateMachine(typeof(<ExportCoroutine>d__36))]
	private IEnumerator ExportCoroutine()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ExportCoroutine>d__36(0)
		{
			<>4__this = this
		};
	}

	private void PrepareExport()
	{
		string text = "Player";
		if ((Object)(object)StaticCameraNoise != (Object)null)
		{
			text = ((Object)((Component)StaticCameraNoise).gameObject.transform.root).name.Replace("(Clone)", "").Trim();
		}
		string text2 = DateTime.Now.ToString("yyyyMMdd_HHmmss");
		string path = text + "_" + text2 + ".mp4";
		exportFilePath = Path.Combine(cfgExportFolder.Value, path);
		tempPngFolder = Path.Combine(Path.GetTempPath(), "HeadcamReplay_" + Guid.NewGuid().ToString("N").Substring(0, 8));
		Directory.CreateDirectory(tempPngFolder);
		DownloadFFmpeg();
	}

	private void DownloadFFmpeg()
	{
		string directoryName = Path.GetDirectoryName(typeof(HeadcamReplay).Assembly.Location);
		ffmpegPath = Path.Combine(directoryName, "ffmpeg.exe");
		if (File.Exists(ffmpegPath))
		{
			PublicLogger.LogInfo((object)("FFmpeg found locally: " + ffmpegPath));
			return;
		}
		PublicLogger.LogWarning((object)"FFmpeg not found next to mod DLL. Attempting to use system PATH (command: 'ffmpeg').");
		ffmpegPath = "ffmpeg";
	}

	[IteratorStateMachine(typeof(<FinalizeExportCoroutine>d__39))]
	private IEnumerator FinalizeExportCoroutine()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <FinalizeExportCoroutine>d__39(0)
		{
			<>4__this = this
		};
	}
}
[HarmonyPatch(typeof(PlayerLocalCamera), "Update")]
public static class CameraReferencePatch
{
	private static readonly FieldInfo PhotonViewField = AccessTools.Field(typeof(PlayerLocalCamera), "photonView");

	public static void Postfix(PlayerLocalCamera __instance)
	{
		if ((Object)(object)HeadcamReplay.Instance == (Object)null || (Object)(object)HeadcamReplay.StaticPlayerCam != (Object)null)
		{
			return;
		}
		ManualLogSource publicLogger = HeadcamReplay.Instance.PublicLogger;
		object? obj = PhotonViewField?.GetValue(__instance);
		PhotonView val = (PhotonView)((obj is PhotonView) ? obj : null);
		if (!((Object)(object)val == (Object)null) && val.IsMine && (Object)(object)CameraNoise.Instance != (Object)null)
		{
			HeadcamReplay.StaticCameraNoise = CameraNoise.Instance;
			HeadcamReplay.StaticPlayerCam = ((Component)CameraNoise.Instance).GetComponentInChildren<Camera>(true);
			if ((Object)(object)HeadcamReplay.StaticPlayerCam == (Object)null)
			{
				publicLogger.LogError((object)"Camera component not found on CameraNoise children.");
			}
			else
			{
				publicLogger.LogInfo((object)"Successfully cached Camera references using CameraNoise.");
			}
		}
	}
}
[HarmonyPatch(typeof(PlayerHealth), "Death")]
public static class PlayerDeathPatch
{
	public static void Postfix()
	{
		if ((Object)(object)HeadcamReplay.Instance != (Object)null && HeadcamReplay.Instance.timeOfDeath == 0f)
		{
			HeadcamReplay.Instance.timeOfDeath = Time.time;
			HeadcamReplay.Instance.PublicLogger.LogInfo((object)"Death detected. Recording will continue for 2 seconds.");
		}
	}
}