// Reference: 0Harmony
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using HarmonyLib; // Update this to HarmonyLib for Harmony 2.x
using Oxide.Plugins.BulletsFixExt;

namespace Oxide.Plugins
{
    [Info("BulletsFix", "Unknown", "1.0.0")]
    [Description("Makes bullets and impact effects invisible for vanished players")]
    public class BulletsFix : RustPlugin
    {
        #region Fields

        private const string InstanceId = "com.unk.bulletsfix";
        private static Harmony _harmony; // Use Harmony instead of HarmonyInstance

        #endregion
        
        #region Hooks

        private void Loaded()
        {
            if (_harmony == null)
                _harmony = new Harmony(InstanceId); // Harmony 2.x syntax

            _harmony.Patch(AccessTools.Method(typeof(Effect.server), "ImpactEffect"),
                new HarmonyMethod(typeof(ImpactPatch), "Prefix"));

            _harmony.Patch(AccessTools.Method(typeof(BaseProjectile), "CLProject"),
                transpiler: new HarmonyMethod(typeof(ProjectilePatch), "Transpiler"));

            _harmony.Patch(AccessTools.Method(typeof(BasePlayer), "OnAttacked"),
                transpiler: new HarmonyMethod(typeof(HeadshotPatch), "Transpiler"));
        }

        private void Unload() => _harmony.UnpatchAll(InstanceId);

        #endregion

        #region Patch Utils

        private static Label GetLabel(CodeInstruction inst, ILGenerator generator = null)
        {
            Label lbl;
            if (inst.labels == null)
                inst.labels = new List<Label>();
            if (inst.labels.Count == 0 && generator != null)
                inst.labels.Add((lbl = generator.DefineLabel()));
            else
                lbl = inst.labels[0];
            return lbl;
        }
        
        private static Label CreateLabel(CodeInstruction inst, ILGenerator generator)
        {
            Label lbl;
            if (inst.labels == null)
                inst.labels = new List<Label>();
            inst.labels.Add((lbl = generator.DefineLabel()));
            return lbl;
        }

        private static int CountLabels(CodeInstruction inst) => inst.labels?.Count ?? 0;

        private static bool CheckLocal(ref int idx, Type type, MethodBase method, bool findFirst = false)
        {
            var body = method.GetMethodBody();
            if (body != null && (body.LocalVariables.Count <= idx || body.LocalVariables[idx].LocalType != type))
            {
                FileLog.Log($"[BulletsFix] WARN: Requested local variable of type {type.Name} at index {idx} is not found!");
                if (!findFirst)
                    return false;

                foreach (var locVar in body.LocalVariables)
                {
                    if (locVar.LocalType == type)
                    {
                        idx = locVar.LocalIndex;
                        FileLog.Log($"[BulletsFix] WARN: Replaced requested local variable of type {type.Name} with index {idx}.");
                        return true;
                    }
                }
            }
            return true;
        }

        #endregion

        #region Patches

        private static class ImpactPatch
        {
            internal static bool Prefix(HitInfo info) => !(info.InitiatorPlayer?._limitedNetworking ?? false);
        }
        
        private static class ProjectilePatch
        {
            internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
            {
                var lst = instructions.ToList();
                var jumpIndex = lst.FindLastIndex(i => i.opcode == OpCodes.Call && ((MethodBase) i.operand).Name == "CreateProjectileEffectClientside");
                if (jumpIndex == -1)
                {
                    FileLog.Log("[BulletsFix] Can't find jump index. ProjectilePatch skipped.");
                    return lst;
                }
                jumpIndex += 1;
                var injectIdx = lst.FindLastIndex(jumpIndex, i => i.opcode == OpCodes.Callvirt && ((MethodBase) i.operand).Name == "NoteFiredProjectile");
                if (injectIdx == -1)
                {
                    FileLog.Log("[BulletsFix] Can't find inject index. ProjectilePatch skipped.");
                    return lst;
                }
                injectIdx += 1;
                lst.InsertRange(injectIdx, new []
                {
                    new CodeInstruction(OpCodes.Ldloc_0), 
                    new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(BaseNetworkable), "_limitedNetworking")), 
                    new CodeInstruction(OpCodes.Brtrue_S, GetLabel(lst[jumpIndex], generator)), 
                });
                return lst;
            }
        }
        
        private static class HeadshotPatch
        {
            internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase original)
            {
                var lst = instructions.ToList();
                var playerLocIdx = 8;
                if (!CheckLocal(ref playerLocIdx, typeof(BasePlayer), original))
                {
                    FileLog.Log("[BulletsFix] Can't find local variable. HeadshotPatch skipped.");
                    return lst;
                }
                var injectIdx = lst.FindIndex(i => i.opcode == OpCodes.Ldstr && (string) i.operand == "assets/bundled/prefabs/fx/headshot.prefab");
                if (injectIdx == -1)
                {
                    FileLog.Log("[BulletsFix] Can't find inject index. Headshot skipped.");
                    return lst;
                }
                if (CountLabels(lst[injectIdx]) != 1)
                {
                    FileLog.Log("[BulletsFix] Inject point has invalid labels. Headshot skipped.");
                    return lst; 
                }
                var labelRelocate = lst[injectIdx].labels[0];
                lst[injectIdx].labels.Remove(labelRelocate);
                var jumpIndex = lst.FindIndex(injectIdx, i => i.opcode == OpCodes.Call && ((MethodBase) i.operand).Name == "Run");
                if (jumpIndex == -1)
                {
                    FileLog.Log("[BulletsFix] Can't find jump index. HeadshotPatch skipped.");
                    return lst;
                }
                jumpIndex += 1;
                var noInitiatorPlayerLabel = GetLabel(lst[injectIdx], generator);
                lst.InsertRange(injectIdx, new []
                {
                    new CodeInstruction(OpCodes.Ldloc_S, playerLocIdx).WithLabel(labelRelocate), 
                    new CodeInstruction(OpCodes.Brfalse_S, noInitiatorPlayerLabel), 
                    new CodeInstruction(OpCodes.Ldloc_S, playerLocIdx), 
                    new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(BaseNetworkable), "_limitedNetworking")),
                    new CodeInstruction(OpCodes.Brtrue, GetLabel(lst[jumpIndex], generator))
                });
                return lst;
            }
        }

        #endregion
    }
}

#region Extensions

namespace Oxide.Plugins.BulletsFixExt
{
    internal static class BulletFixExtensions
    {
        internal static CodeInstruction WithLabel(this CodeInstruction inst, Label label)
        {
            if(inst.labels == null)
                inst.labels = new List<Label>();
            inst.labels.Add(label);
            return inst;   
        }
    }
}

#endregion