// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
using System;
using Mono.Cecil;
using Mono.Cecil.Cil;
 
namespace Mono.Linker
{
#pragma warning disable RS0030
	public sealed class LinkerILProcessor
	{
		readonly ILProcessor _ilProcessor;
 
		Collections.Generic.Collection<Instruction> Instructions => _ilProcessor.Body.Instructions;
 
		internal LinkerILProcessor (MethodBody body)
		{
			_ilProcessor = body.GetILProcessor ();
		}
 
		public void Emit (OpCode opcode) => Append (_ilProcessor.Create (opcode));
		public void Emit (OpCode opcode, TypeReference type) => Append (_ilProcessor.Create (opcode, type));
		public void Emit (OpCode opcode, MethodReference method) => Append (_ilProcessor.Create (opcode, method));
		public void Emit (OpCode opcode, VariableDefinition variable) => Append (_ilProcessor.Create (opcode, variable));
 
		public void Emit (OpCode opcode, string value) => Append (_ilProcessor.Create (opcode, value));
		public void InsertBefore (Instruction target, Instruction instruction)
		{
			// When inserting before, all pointers have to be updated to the new "before" instruction.
			RedirectScopeStart (target, instruction);
			ReplaceInstructionReference (target, instruction);
			_ilProcessor.InsertBefore (target, instruction);
		}
 
		// When inserting after, no redirection is necessary since it will naturally be "appended" to the same blocks
		// as the target instruction.
		public void InsertAfter (Instruction target, Instruction instruction)
		{
			RedirectScopeEnd (target, instruction);
			_ilProcessor.InsertAfter (target, instruction);
		}
 
		public void Append (Instruction instruction)
		{
			Instruction? lastInstruction = Instructions.Count == 0 ? null : Instructions[Instructions.Count - 1];
			RedirectScopeEnd (lastInstruction, instruction);
			_ilProcessor.Append (instruction);
		}
 
		public void Replace (Instruction target, Instruction instruction)
		{
			RedirectScopeStart (target, instruction);
			RedirectScopeEnd (target, instruction);
			ReplaceInstructionReference (target, instruction);
			_ilProcessor.Replace (target, instruction);
		}
 
		public void Replace (int index, Instruction instruction) => Replace (_ilProcessor.Body.Instructions[index], instruction);
 
		public void Remove (Instruction instruction)
		{
			int index = _ilProcessor.Body.Instructions.IndexOf (instruction);
			if (index == -1)
				throw new ArgumentOutOfRangeException (nameof (instruction));
 
			Instruction? nextInstruction = Instructions.Count == index + 1 ? null : Instructions[index + 1];
			Instruction? previousInstruction = index == 0 ? null : Instructions[index - 1];
 
			RedirectScopeStart (instruction, nextInstruction);
			RedirectScopeEnd (instruction, previousInstruction);
			ReplaceInstructionReference (instruction, nextInstruction);
			_ilProcessor.Remove (instruction);
		}
 
		public void RemoveAt (int index) => Remove (Instructions[index]);
 
		void RedirectScopeStart (Instruction oldTarget, Instruction? newTarget)
		{
			// In Cecil "start" pointers point to the first instruction in a given scope
			// and the "end" pointers point to the first instruction after the given block
			// so they need to effectively point to the start of the next scope.
			// That's why both start and end are handled in the RedirectScopeStart.
			foreach (var handler in _ilProcessor.Body.ExceptionHandlers) {
				if (handler.TryStart == oldTarget)
					handler.TryStart = newTarget;
				if (handler.TryEnd == oldTarget)
					handler.TryEnd = newTarget;
				if (handler.HandlerStart == oldTarget)
					handler.HandlerStart = newTarget;
				if (handler.HandlerEnd == oldTarget)
					handler.HandlerEnd = newTarget;
				if (handler.FilterStart == oldTarget)
					handler.FilterStart = newTarget;
			}
		}
 
#pragma warning disable IDE0060 // Remove unused parameter
		static void RedirectScopeEnd (Instruction? oldTarget, Instruction? newTarget)
#pragma warning restore IDE0060 // Remove unused parameter
		{
			// Currently Cecil treats all block boundaries as "starts"
			// so nothing to do here.
		}
 
		void ReplaceInstructionReference (Instruction oldTarget, Instruction? newTarget)
		{
			foreach (var instr in Instructions) {
				switch (instr.OpCode.FlowControl) {
				case FlowControl.Cond_Branch:
					if (instr.Operand is Instruction?[] instructions) {
						for (int i = 0; i < instructions.Length; ++i) {
							if (instructions[i] == oldTarget)
								instructions[i] = newTarget;
						}
 
						break;
					}
 
					goto case FlowControl.Branch;
 
				case FlowControl.Branch:
					if (instr.Operand == oldTarget)
						instr.Operand = newTarget;
					break;
				}
			}
		}
#pragma warning disable RS0030
	}
}