using HarmonyLib;
using KFCommonUtilityLib.Scripts.StaticManagers;
using KFCommonUtilityLib.Scripts.Utilities;
using System;
using System.Collections.Generic;
using UniLinq;
using System.Reflection;
using System.Reflection.Emit;
using System.Xml.Linq;
using UnityEngine;
using KFCommonUtilityLib.Scripts.NetPackages;
using KFCommonUtilityLib;
using static ItemActionRanged;

[HarmonyPatch]
public static class CommonUtilityPatch
{
    //fix reloading issue and onSelfRangedBurstShot timing
    public static void FakeReload(EntityAlive holdingEntity, ItemActionRanged.ItemActionDataRanged _actionData)
    {
        if (!holdingEntity)
            return;
        _actionData.isReloading = true;
        _actionData.isWeaponReloading = true;
        holdingEntity.MinEventContext.ItemActionData = _actionData;
        holdingEntity.FireEvent(MinEventTypes.onReloadStart, true);
        _actionData.isReloading = false;
        _actionData.isWeaponReloading = false;
        _actionData.isReloadCancelled = false;
        _actionData.isWeaponReloadCancelled = false;
        holdingEntity.FireEvent(MinEventTypes.onReloadStop);

        AnimationAmmoUpdateState.SetAmmoCountForEntity(holdingEntity, holdingEntity.inventory.holdingItemIdx);
    }

    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.SwapAmmoType))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_SwapAmmoType_ItemActionRanged(IEnumerable<CodeInstruction> instructions)
    {
        var codes = new List<CodeInstruction>(instructions);

        for (int i = 0; i < codes.Count; ++i)
        {
            if (codes[i].opcode == OpCodes.Ret)
            {
                codes.InsertRange(i, new CodeInstruction[]
                {
                    new CodeInstruction(OpCodes.Ldarg_1),
                    new CodeInstruction(OpCodes.Ldloc_0),
                    CodeInstruction.Call(typeof(CommonUtilityPatch), nameof(FakeReload))
                });
                break;
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.ExecuteAction))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_ExecuteAction_ItemActionRanged(IEnumerable<CodeInstruction> instructions)
    {
        var codes = new List<CodeInstruction>(instructions);
        var mtd_fire_event = AccessTools.Method(typeof(EntityAlive), nameof(EntityAlive.FireEvent));
        var mtd_get_model_layer = AccessTools.Method(typeof(EntityAlive), nameof(EntityAlive.GetModelLayer));
        var mtd_get_perc_left = AccessTools.PropertyGetter(typeof(ItemValue), nameof(ItemValue.PercentUsesLeft));
        var mtd_check_ammo = AccessTools.Method(typeof(ItemActionRanged), nameof(ItemActionRanged.checkAmmo));

        int take = -1, insert = -1;
        for (int i = 0; i < codes.Count; ++i)
        {
            if (codes[i].opcode == OpCodes.Ldc_I4_S && codes[i].OperandIs((int)MinEventTypes.onSelfRangedBurstShotEnd) && codes[i + 2].Calls(mtd_fire_event))
                take = i - 3;
            else if (codes[i].Calls(mtd_get_model_layer))
                insert = i + 2;
        }

        if (take < insert)
        {
            var list = codes.GetRange(take, 6);
            codes.InsertRange(insert, list);
            codes.RemoveRange(take, 6);
        }

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Calls(mtd_check_ammo))
            {
                codes.InsertRange(i + 2, new[]
                {
                    new CodeInstruction(OpCodes.Ldloc_0),
                    new CodeInstruction(OpCodes.Ldc_I4_0),
                    CodeInstruction.StoreField(typeof(ItemActionDataRanged), nameof(ItemActionDataRanged.state))
                });
                break;
            }
        }

        return codes;
    }
    //fix recoil animation does not match weapon RPM
    private static int weaponFireHash = Animator.StringToHash("WeaponFire");
    private static int aimHash = Animator.StringToHash("IsAiming");
    private static HashSet<int> hash_shot_state = new HashSet<int>();
    private static HashSet<int> hash_aimshot_state = new HashSet<int>();

    public static void InitShotStates()
    {
        string[] weapons =
        {
            "fpvAK47",
            "fpvMagnum",
            "fpvRocketLauncher",
            "fpvSawedOffShotgun",
            "fpvBlunderbuss",
            "fpvCrossbow",
            "fpvPistol",
            "fpvHuntingRifle",
            "fpvSMG",
            "fpvSniperRifle",
            "M60",
            "fpvDoubleBarrelShotgun",
            //"fpvJunkTurret",
            "fpvTacticalAssaultRifle",
            "fpvDesertEagle",
            "fpvAutoShotgun",
            "fpvSharpShooterRifle",
            "fpvPipeMachineGun",
            "fpvPipeRifle",
            "fpvPipeRevolver",
            "fpvPipeShotgun",
            "fpvLeverActionRifle",
        };
        foreach (string weapon in weapons)
        {
            hash_shot_state.Add(Animator.StringToHash(weapon + "Fire"));
            hash_aimshot_state.Add(Animator.StringToHash(weapon + "AimFire"));
        }
    }

    [HarmonyPatch(typeof(EntityPlayerLocal), nameof(EntityPlayerLocal.OnFired))]
    [HarmonyPostfix]
    private static void Postfix_OnFired_EntityPlayerLocal(EntityPlayerLocal __instance)
    {
        if (!__instance.bFirstPersonView)
            return;

        ItemActionRanged.ItemActionDataRanged _rangedData;
        if ((_rangedData = __instance.inventory.holdingItemData.actionData[0] as ItemActionRanged.ItemActionDataRanged) == null && (_rangedData = __instance.inventory.holdingItemData.actionData[1] as ItemActionRanged.ItemActionDataRanged) == null)
            return;

        if (_rangedData.invData.model.TryGetComponent<AnimationTargetsAbs>(out var targets) && targets.ItemFpv)
            return;

        var anim = (__instance.emodel.avatarController as AvatarLocalPlayerController).FPSArms.Animator;
        if (anim.IsInTransition(0))
            return;

        var curState = anim.GetCurrentAnimatorStateInfo(0);
        if (curState.length > _rangedData.Delay)
        {
            bool aimState = anim.GetBool(aimHash);
            short shotState = 0;
            if (hash_shot_state.Contains(curState.shortNameHash))
                shotState = 1;
            else if (hash_aimshot_state.Contains(curState.shortNameHash))
                shotState = 2;
            if (shotState == 0 || (shotState == 1 && aimState) || (shotState == 2 && !aimState))
            {
                if (shotState > 0)
                    anim.ResetTrigger(weaponFireHash);
                return;
            }

            //current state, layer 0, offset 0
            anim.PlayInFixedTime(0, 0, 0);
            anim.ResetTrigger(weaponFireHash);
            if (_rangedData.invData.itemValue.Meta == 0)
            {
                __instance.emodel.avatarController.CancelEvent(weaponFireHash);
                Log.Out("Cancel fire event because meta is 0");
            }
        }
    }

    //[HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.ItemActionEffects))]
    //[HarmonyPostfix]
    //private static void Postfix_ItemActionEffects_ItemActionRanged(ItemActionData _actionData, int _firingState)
    //{
    //    if (_firingState == 0 && _actionData.invData.holdingEntity is EntityPlayerLocal && !(_actionData.invData.itemValue.ItemClass.Actions[0] is ItemActionCatapult))
    //    {
    //        _actionData.invData.holdingEntity?.emodel.avatarController.CancelEvent(weaponFireHash);
    //        //Log.Out("Cancel fire event because firing state is 0\n" + StackTraceUtility.ExtractStackTrace());
    //    }
    //}

    //[HarmonyPatch(typeof(GameManager), "gmUpdate")]
    //[HarmonyTranspiler]
    //private static IEnumerable<CodeInstruction> Transpiler_gmUpdate_GameManager(IEnumerable<CodeInstruction> instructions)
    //{
    //    var codes = new List<CodeInstruction>(instructions);
    //    var mtd_unload = AccessTools.Method(typeof(Resources), nameof(Resources.UnloadUnusedAssets));
    //    var fld_duration = AccessTools.Field(typeof(GameManager), "unloadAssetsDuration");

    //    for (int i = 0; i < codes.Count; ++i)
    //    {
    //        if (codes[i].opcode == OpCodes.Call && codes[i].Calls(mtd_unload))
    //        {
    //            for (int j = i; j >= 0; --j)
    //            {
    //                if (codes[j].opcode == OpCodes.Ldfld && codes[j].LoadsField(fld_duration) && codes[j + 1].opcode == OpCodes.Ldc_R4)
    //                    codes[j + 1].operand = (float)codes[j + 1].operand / 2;
    //            }
    //            break;
    //        }
    //    }

    //    return codes;
    //}

    //internal static void ForceUpdateGC()
    //{
    //    if (GameManager.IsDedicatedServer)
    //        return;
    //    if (GameManager.frameCount % 18000 == 0)
    //    {
    //        long rss = GetRSS.GetCurrentRSS();
    //        if (rss / 1024 / 1024 > 6144)
    //        {
    //            Log.Out("Memory usage exceeds threshold, now performing garbage collection...");
    //            GC.Collect();
    //        }
    //    }
    //}

    //altmode workarounds
    //deprecated by action module
    private static void ParseAltRequirements(XElement _node)
    {
        string itemName = _node.GetAttribute("name");
        if (string.IsNullOrEmpty(itemName))
        {
            return;
        }
        ItemClass item = ItemClass.GetItemClass(itemName);
        for (int i = 0; i < item.Actions.Length; i++)
        {
            if (item.Actions[i] is ItemActionAltMode _alt)
                _alt.ParseAltRequirements(_node, i);
        }
    }

    [HarmonyPatch(typeof(ItemClassesFromXml), nameof(ItemClassesFromXml.parseItem))]
    [HarmonyPostfix]
    private static void Postfix_parseItem_ItemClassesFromXml(XElement _node)
    {
        ParseAltRequirements(_node);
    }

    [HarmonyPatch(typeof(ItemClass), nameof(ItemClass.ExecuteAction))]
    [HarmonyPrefix]
    private static bool Prefix_ExecuteAction_ItemClass(ItemClass __instance, int _actionIdx, ItemInventoryData _data, bool _bReleased)
    {
        if (!_bReleased && __instance.Actions[_actionIdx] is ItemActionAltMode _alt)
            _alt.SetAltRequirement(_data.actionData[_actionIdx]);

        return true;
    }

    [HarmonyPatch(typeof(DynamicProperties), nameof(DynamicProperties.Parse))]
    [HarmonyPrefix]
    private static bool Prefix_Parse_DynamicProperties(XElement elementProperty)
    {
        if (elementProperty.Name.LocalName != "property")
            return false;
        return true;
    }

    //MinEventParams workarounds
    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.fireShot))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_fireShot_ItemActionRanged(IEnumerable<CodeInstruction> instructions)
    {
        var codes = new List<CodeInstruction>(instructions);

        var fld_ranged_tag = AccessTools.Field(typeof(ItemActionAttack), nameof(ItemActionAttack.RangedTag));
        var fld_params = AccessTools.Field(typeof(EntityAlive), nameof(EntityAlive.MinEventContext));

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].LoadsField(fld_ranged_tag))
            {
                if (!codes[i + 3].LoadsField(fld_params))
                {
                    codes.InsertRange(i + 2, new CodeInstruction[]
                    {
                        new CodeInstruction(OpCodes.Ldloc_1),
                        CodeInstruction.LoadField(typeof(EntityAlive), nameof(EntityAlive.MinEventContext)),
                        new CodeInstruction(OpCodes.Dup),
                        new CodeInstruction(OpCodes.Ldloc, 10),
                        CodeInstruction.LoadField(typeof(WorldRayHitInfo), nameof(WorldRayHitInfo.hit)),
                        CodeInstruction.LoadField(typeof(HitInfoDetails), nameof(HitInfoDetails.pos)),
                        CodeInstruction.StoreField(typeof(MinEventParams), nameof(MinEventParams.Position)),
                        new CodeInstruction(OpCodes.Ldloc_1),
                        CodeInstruction.Call(typeof(EntityAlive), nameof(EntityAlive.GetPosition)),
                        CodeInstruction.StoreField(typeof(MinEventParams), nameof(MinEventParams.StartPosition))
                    });
                }
                break;
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.OnHoldingUpdate))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_OnHoldingUpdate_ItemActionRanged(IEnumerable<CodeInstruction> instructions)
    {
        var mtd_release = AccessTools.Method(typeof(ItemActionRanged), nameof(ItemActionRanged.triggerReleased));
        var codes = instructions.ToList();

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Calls(mtd_release))
            {
                codes[i + 1].labels.Clear();
                codes[i + 1].MoveLabelsFrom(codes[i - 20]);
                codes.RemoveRange(i - 20, 21);
                break;
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.OnHoldingUpdate))]
    [HarmonyPostfix]
    private static void Postfix_OnHoldingUpdate_ItemActionRanged(ItemActionRanged __instance, ItemActionData _actionData)
    {
        ItemActionDataRanged itemActionDataRanged = (ItemActionDataRanged)_actionData;

        if (itemActionDataRanged.state != 0 && itemActionDataRanged.m_LastShotTime > 0f && Time.time > itemActionDataRanged.m_LastShotTime + itemActionDataRanged.Delay * 2f)
        {
            itemActionDataRanged.invData.gameManager.ItemActionEffectsServer(itemActionDataRanged.invData.holdingEntity.entityId, itemActionDataRanged.invData.slotIdx, itemActionDataRanged.indexInEntityOfAction, 0, Vector3.zero, Vector3.zero);
            itemActionDataRanged.state = ItemActionFiringState.Off;
        }
    }

    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.triggerReleased))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_triggerReleased_ItemActionRanged(IEnumerable<CodeInstruction> instructions)
    {
        var mtd_effect = AccessTools.Method(typeof(IGameManager), nameof(IGameManager.ItemActionEffectsServer));
        var mtd_data = AccessTools.Method(typeof(ItemActionRanged), nameof(ItemActionRanged.getUserData));
        var codes = instructions.ToList();

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Calls(mtd_effect))
            {
                codes.InsertRange(i, new CodeInstruction[]
                {
                    new CodeInstruction(OpCodes.Ldarg_0),
                    new CodeInstruction(OpCodes.Ldarg_1),
                    new CodeInstruction(OpCodes.Callvirt, mtd_data)
                });
                codes.RemoveAt(i - 1);
                break;
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(GameManager), nameof(GameManager.StartGame))]
    [HarmonyPrefix]
    private static bool Prefix_StartGame_GameManager()
    {
        CustomEffectEnumManager.InitFinal();
        return true;
    }

    [HarmonyPatch(typeof(PassiveEffect), nameof(PassiveEffect.ParsePassiveEffect))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_ParsePassiveEffect_PassiveEffect(IEnumerable<CodeInstruction> instructions)
    {
        return instructions.MethodReplacer(AccessTools.Method(typeof(EnumUtils), nameof(EnumUtils.Parse), new[] { typeof(string), typeof(bool) }, new[] { typeof(PassiveEffects) }),
                                           AccessTools.Method(typeof(CustomEffectEnumManager), nameof(CustomEffectEnumManager.RegisterOrGetEnum), new[] { typeof(string), typeof(bool) }, new[] { typeof(PassiveEffects) }));

    }

    [HarmonyPatch(typeof(MinEventActionBase), nameof(MinEventActionBase.ParseXmlAttribute))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_ParseXmlAttribute_MinEventActionBase(IEnumerable<CodeInstruction> instructions)
    {
        return instructions.MethodReplacer(AccessTools.Method(typeof(EnumUtils), nameof(EnumUtils.Parse), new[] { typeof(string), typeof(bool) }, new[] { typeof(MinEventTypes) }),
                                           AccessTools.Method(typeof(CustomEffectEnumManager), nameof(CustomEffectEnumManager.RegisterOrGetEnum), new[] { typeof(string), typeof(bool) }, new[] { typeof(MinEventTypes) }));
    }

    //todo: patch Quartz
    [HarmonyPatch(typeof(UIDisplayInfoFromXml), nameof(UIDisplayInfoFromXml.ParseDisplayInfoEntry))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_ParseDisplayInfoEntry_UIDisplayInfoFromXml(IEnumerable<CodeInstruction> instructions)
    {
        return instructions.MethodReplacer(AccessTools.Method(typeof(EnumUtils), nameof(EnumUtils.Parse), new[] { typeof(string), typeof(bool) }, new[] { typeof(PassiveEffects) }), 
                                           AccessTools.Method(typeof(CustomEffectEnumManager), nameof(CustomEffectEnumManager.GetEnumOrThrow), new[] { typeof(string), typeof(bool) }, new[] { typeof(PassiveEffects) }));
    }

    [HarmonyPatch(typeof(ItemActionDynamicMelee), nameof(ItemActionDynamicMelee.OnHoldingUpdate))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_OnHoldingUpdate_ItemActionDynamicMelee(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();
        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Is(OpCodes.Ldc_R4, 0.1f))
            {
                codes.RemoveRange(i, 2);
                break;
            }
        }
        return codes;
    }

    [HarmonyPatch(typeof(ItemActionDynamicMelee), nameof(ItemActionDynamicMelee.canStartAttack))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_canStartAttack_ItemActionDynamicMelee(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();
        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Is(OpCodes.Ldc_R4, 0.1f))
            {
                codes.RemoveRange(i, 2);
                break;
            }
        }
        return codes;
    }

    /// <summary>
    /// projectile direct hit damage percent
    /// removed due to new explosion damage passives
    /// </summary>
    /// <param name="instructions"></param>
    /// <returns></returns>
    //[HarmonyPatch(typeof(ProjectileMoveScript), nameof(ProjectileMoveScript.checkCollision))]
    //[HarmonyTranspiler]
    //private static IEnumerable<CodeInstruction> Transpiler_checkCollision_ProjectileMoveScript(IEnumerable<CodeInstruction> instructions)
    //{
    //    var codes = instructions.ToList();
    //    var fld_strain = AccessTools.Field(typeof(ItemActionLauncher.ItemActionDataLauncher), nameof(ItemActionLauncher.ItemActionDataLauncher.strainPercent));
    //    var mtd_block = AccessTools.Method(typeof(ItemActionAttack), nameof(ItemActionAttack.GetDamageBlock));

    //    for (int i = 0; i < codes.Count; i++)
    //    {
    //        if (codes[i].LoadsField(fld_strain))
    //        {
    //            codes.InsertRange(i + 1, new CodeInstruction[]
    //            {
    //                new CodeInstruction(OpCodes.Ldarg_0),
    //                CodeInstruction.LoadField(typeof(ProjectileMoveScript), nameof(ProjectileMoveScript.itemValueProjectile)),
    //                new CodeInstruction(OpCodes.Ldloc_S, 4),
    //                CodeInstruction.Call(typeof(CommonUtilityPatch), codes[i - 3].Calls(mtd_block) ? nameof(GetProjectileBlockDamagePerc) : nameof(GetProjectileEntityDamagePerc)),
    //                new CodeInstruction(OpCodes.Mul)
    //            });
    //        }
    //    }

    //    return codes;
    //}

    //public static float GetProjectileBlockDamagePerc(ItemValue _itemValue, EntityAlive _holdingEntity)
    //{
    //    return EffectManager.GetValue(CustomEnums.ProjectileImpactDamagePercentBlock, _itemValue, 1, _holdingEntity, null);
    //}

    //public static float GetProjectileEntityDamagePerc(ItemValue _itemValue, EntityAlive _holdingEntity)
    //{
    //    return EffectManager.GetValue(CustomEnums.ProjectileImpactDamagePercentEntity, _itemValue, 1, _holdingEntity, null);
    //}

    /// <summary>
    /// force tpv crosshair
    /// </summary>
    /// <param name="instructions"></param>
    /// <returns></returns>
    [HarmonyPatch(typeof(EntityPlayerLocal), nameof(EntityPlayerLocal.guiDrawCrosshair))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_guiDrawCrosshair_EntityPlayerLocal(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        FieldInfo fld_debug = AccessTools.Field(typeof(ItemAction), nameof(ItemAction.ShowDistanceDebugInfo));

        for ( int i = 0; i < codes.Count; i++ )
        {
            if (codes[i].LoadsField(fld_debug))
            {
                var label = codes[i - 1].operand;
                codes.InsertRange(i, new[]
                {
                    new CodeInstruction(OpCodes.Ldarg_0),
                    CodeInstruction.LoadField(typeof(EntityPlayerLocal), nameof(EntityPlayerLocal.bFirstPersonView)),
                    new CodeInstruction(OpCodes.Brfalse_S, label)
                });
                break;
            }
        }

        return codes;
    }

    /// <summary>
    /// correctly apply muzzle flash silence with modifications
    /// </summary>
    /// <param name="_data"></param>
    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.OnModificationsChanged))]
    [HarmonyPostfix]
    private static void Postfix_OnModificationsChanged_ItemActionRanged(ItemActionData _data)
    {
        ItemActionRanged.ItemActionDataRanged itemActionDataRanged = _data as ItemActionRanged.ItemActionDataRanged;
        if (itemActionDataRanged.SoundStart.Contains("silenced"))
        {
            itemActionDataRanged.IsFlashSuppressed = true;
        }

        //should fix stuck on switching item?
        itemActionDataRanged.isReloadCancelled = false;
        itemActionDataRanged.isWeaponReloadCancelled = false;
        itemActionDataRanged.isReloading = false;
        itemActionDataRanged.isWeaponReloading = false;
        itemActionDataRanged.isChangingAmmoType = false;
    }

    #region item tags modifier

    /// <summary>
    /// should handle swapping mod
    /// first check if the mod to install can be installed after current mod is removed
    /// then check if any other mod requires or conflicts current mod
    /// </summary>
    /// <param name="instructions"></param>
    /// <param name="generator"></param>
    /// <returns></returns>
    [HarmonyPatch(typeof(XUiC_ItemPartStack), nameof(XUiC_ItemPartStack.CanSwap))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_CanSwap_XUiC_ItemPartStack(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
    {
        var codes = instructions.ToList();

        LocalBuilder lbd_tags_if_remove_prev = generator.DeclareLocal(typeof(FastTags<TagGroup.Global>));
        LocalBuilder lbd_tags_if_install_new = generator.DeclareLocal(typeof(FastTags<TagGroup.Global>));
        MethodInfo mtd_get_item_class = AccessTools.PropertyGetter(typeof(ItemValue), nameof(ItemValue.ItemClass));
        MethodInfo mtd_has_any_tags = AccessTools.Method(typeof(ItemClass), nameof(ItemClass.HasAnyTags));
        MethodInfo mtd_test_any_set = AccessTools.Method(typeof(FastTags<TagGroup.Global>), nameof(FastTags<TagGroup.Global>.Test_AnySet));
        FieldInfo fld_mod = AccessTools.Field(typeof(ItemValue), nameof(ItemValue.Modifications));
        FieldInfo fld_installable_tags = AccessTools.Field(typeof(ItemClassModifier), nameof(ItemClassModifier.InstallableTags));

        for (int i = 3; i < codes.Count; i++)
        {
            //get current tags
            if (codes[i].opcode == OpCodes.Stloc_2)
            {
                codes.InsertRange(i + 1, new[]
                {
                    new CodeInstruction(OpCodes.Ldloc_1),
                    new CodeInstruction(OpCodes.Ldarg_0),
                    CodeInstruction.LoadField(typeof(XUiC_ItemPartStack), "itemValue"),
                    CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.GetTagsAsIfNotInstalled)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_tags_if_remove_prev),
                    new CodeInstruction(OpCodes.Ldloc_1),
                    new CodeInstruction(OpCodes.Ldloc_0),
                    CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.GetTagsAsIfInstalled)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_tags_if_install_new)
                });
                i += 10;
                Log.Out("mod 1!!!");
            }
            //replace checking tags
            else if (codes[i].Calls(mtd_has_any_tags) && codes[i - 3].opcode == OpCodes.Ldloc_2)
            {
                if (codes[i - 1].LoadsField(fld_installable_tags) && (codes[i + 1].opcode == OpCodes.Brtrue || codes[i + 1].opcode == OpCodes.Brtrue_S))
                {
                    var lbl_prev = codes[i + 4].ExtractLabels();
                    var lbl_jump = generator.DefineLabel();
                    codes[i + 4].WithLabels(lbl_jump);
                    codes.InsertRange(i + 4, new[]
                    {
                        new CodeInstruction(OpCodes.Ldloc_1).WithLabels(lbl_prev),
                        new CodeInstruction(OpCodes.Ldarg_0),
                        CodeInstruction.LoadField(typeof(XUiC_ItemPartStack), "itemValue"),
                        new CodeInstruction(OpCodes.Ldloc_0),
                        CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.CanSwapMod)),
                        new CodeInstruction(OpCodes.Brtrue, lbl_jump),
                        new CodeInstruction(OpCodes.Ldc_I4_0),
                        new CodeInstruction(OpCodes.Ret)
                    });
                }
                codes[i - 3].opcode = OpCodes.Ldloca_S;
                codes[i - 3].operand = lbd_tags_if_remove_prev;
                codes[i].opcode = OpCodes.Call;
                codes[i].operand = mtd_test_any_set;
                Log.Out("mod 2!!!");
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(XUiC_ItemCosmeticStack), nameof(XUiC_ItemCosmeticStack.CanSwap))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_CanSwap_XUiC_ItemCosmeticStack(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
    {
        var codes = instructions.ToList();

        LocalBuilder lbd_tags_if_remove_prev = generator.DeclareLocal(typeof(FastTags<TagGroup.Global>));
        LocalBuilder lbd_tags_if_install_new = generator.DeclareLocal(typeof(FastTags<TagGroup.Global>));
        LocalBuilder lbd_item_being_assembled = generator.DeclareLocal(typeof(ItemValue));
        MethodInfo mtd_get_item_class = AccessTools.PropertyGetter(typeof(ItemValue), nameof(ItemValue.ItemClass));
        MethodInfo mtd_has_any_tags = AccessTools.Method(typeof(ItemClass), nameof(ItemClass.HasAnyTags));
        MethodInfo mtd_test_any_set = AccessTools.Method(typeof(FastTags<TagGroup.Global>), nameof(FastTags<TagGroup.Global>.Test_AnySet));
        MethodInfo mtd_get_xui = AccessTools.PropertyGetter(typeof(XUiController), nameof(XUiController.xui));
        MethodInfo mtd_get_cur_item = AccessTools.PropertyGetter(typeof(XUiM_AssembleItem), nameof(XUiM_AssembleItem.CurrentItem));
        FieldInfo fld_cos = AccessTools.Field(typeof(ItemValue), nameof(ItemValue.CosmeticMods));
        FieldInfo fld_installable_tags = AccessTools.Field(typeof(ItemClassModifier), nameof(ItemClassModifier.InstallableTags));

        for (int i = 3; i < codes.Count; i++)
        {
            //get current tags
            if ((codes[i].opcode == OpCodes.Brtrue || codes[i].opcode == OpCodes.Brtrue_S) && codes[i - 1].opcode == OpCodes.Ldloc_0)
            {
                codes.InsertRange(i + 3, new[]
                {
                    new CodeInstruction(OpCodes.Ldarg_0).MoveLabelsFrom(codes[i + 3]),
                    new CodeInstruction(OpCodes.Call, mtd_get_xui),
                    CodeInstruction.LoadField(typeof(XUi), nameof(XUi.AssembleItem)),
                    new CodeInstruction(OpCodes.Callvirt, mtd_get_cur_item),
                    CodeInstruction.LoadField(typeof(ItemStack), nameof(ItemStack.itemValue)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_item_being_assembled),
                    new CodeInstruction(OpCodes.Ldloc_S, lbd_item_being_assembled),
                    new CodeInstruction(OpCodes.Ldarg_0),
                    CodeInstruction.LoadField(typeof(XUiC_ItemCosmeticStack), "itemValue"),
                    CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.GetTagsAsIfNotInstalled)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_tags_if_remove_prev),
                    new CodeInstruction(OpCodes.Ldloc_S, lbd_item_being_assembled),
                    new CodeInstruction(OpCodes.Ldloc_0),
                    CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.GetTagsAsIfInstalled)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_tags_if_install_new)
                });
                i += 18;
                Log.Out("cos 1!!!");
            }
            //replace checking tags
            else if (codes[i].Calls(mtd_has_any_tags) && codes[i - 3].Calls(mtd_get_item_class))
            {
                if (codes[i - 1].LoadsField(fld_installable_tags) && (codes[i + 1].opcode == OpCodes.Brtrue || codes[i + 1].opcode == OpCodes.Brtrue_S))
                {
                    var lbl_prev = codes[i + 4].ExtractLabels();
                    var lbl_jump = generator.DefineLabel();
                    codes[i + 4].WithLabels(lbl_jump);
                    codes.InsertRange(i + 4, new[]
                    {
                        new CodeInstruction(OpCodes.Ldloc_S, lbd_item_being_assembled).WithLabels(lbl_prev),
                        new CodeInstruction(OpCodes.Ldarg_0),
                        CodeInstruction.LoadField(typeof(XUiC_ItemPartStack), "itemValue"),
                        new CodeInstruction(OpCodes.Ldloc_0),
                        CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.CanSwapMod)),
                        new CodeInstruction(OpCodes.Brtrue, lbl_jump),
                        new CodeInstruction(OpCodes.Ldc_I4_0),
                        new CodeInstruction(OpCodes.Ret)
                    });
                }
                codes[i - 8].MoveLabelsTo(codes[i - 3]);
                codes[i - 3].opcode = OpCodes.Ldloca_S;
                codes[i - 3].operand = lbd_tags_if_remove_prev;
                codes[i].opcode = OpCodes.Call;
                codes[i].operand = mtd_test_any_set;
                codes.RemoveRange(i - 8, 5);
                i -= 5;
                Log.Out("cos 2!!!");
            }
        }

        return codes;
    }

    /// <summary>
    /// check if other mods relies on this one
    /// </summary>
    /// <param name="__result"></param>
    /// <param name="__instance"></param>
    /// <param name="___itemValue"></param>
    [HarmonyPatch(typeof(XUiC_ItemPartStack), "CanRemove")]
    [HarmonyPostfix]
    private static void Postfix_CanRemove_XUiC_ItemPartStack(ref bool __result, XUiC_ItemPartStack __instance)
    {
        if (__result && __instance.xui?.AssembleItem?.CurrentItem?.itemValue is ItemValue itemValue)
        {
            ItemClass itemClass = itemValue.ItemClass;
            FastTags<TagGroup.Global> tagsAfterRemove = LocalItemTagsManager.GetTagsAsIfNotInstalled(itemValue, __instance.itemValue);
            if (tagsAfterRemove.IsEmpty)
            {
                __result = false;
                return;
            }

            foreach (var mod in itemValue.Modifications)
            {
                if (mod.IsEmpty())
                    continue;
                ItemClassModifier modClass = mod.ItemClass as ItemClassModifier;
                if (modClass == null || !tagsAfterRemove.Test_AnySet(modClass.InstallableTags) || tagsAfterRemove.Test_AnySet(modClass.DisallowedTags))
                {
                    __result = false;
                    return;
                }
            }
        }
    }

    [HarmonyPatch(typeof(XUiC_ItemCosmeticStack), "CanRemove")]
    [HarmonyPostfix]
    private static void Postfix_CanRemove_XUiC_ItemCosmeticStack(ref bool __result, XUiC_ItemCosmeticStack __instance)
    {
        if (__result && __instance.xui?.AssembleItem?.CurrentItem?.itemValue is ItemValue itemValue)
        {
            ItemClass itemClass = itemValue.ItemClass;
            FastTags<TagGroup.Global> tagsAfterRemove = LocalItemTagsManager.GetTagsAsIfNotInstalled(itemValue, __instance.itemValue);
            if (tagsAfterRemove.IsEmpty)
            {
                __result = false;
                return;
            }

            foreach (var mod in itemValue.CosmeticMods)
            {
                if (mod.IsEmpty())
                    continue;
                ItemClassModifier modClass = mod.ItemClass as ItemClassModifier;
                if (modClass == null || !tagsAfterRemove.Test_AnySet(modClass.InstallableTags) || tagsAfterRemove.Test_AnySet(modClass.DisallowedTags))
                {
                    __result = false;
                    return;
                }
            }
        }
    }

    /// <summary>
    /// should update the gear icon?
    /// </summary>
    /// <param name="instructions"></param>
    /// <param name="generator"></param>
    /// <returns></returns>
    [HarmonyPatch(typeof(XUiC_ItemStack), nameof(XUiC_ItemStack.updateLockTypeIcon))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_updateLockTypeIcon_XUiC_ItemStack(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
    {
        var codes = instructions.ToList();

        LocalBuilder lbd_tags = generator.DeclareLocal(typeof(FastTags<TagGroup.Global>));
        MethodInfo mtd_has_any_tags = AccessTools.Method(typeof(ItemClass), nameof(ItemClass.HasAnyTags));
        MethodInfo mtd_test_any_set = AccessTools.Method(typeof(FastTags<TagGroup.Global>), nameof(FastTags<TagGroup.Global>.Test_AnySet));
        MethodInfo mtd_get_item_class = AccessTools.PropertyGetter(typeof(ItemValue), nameof(ItemValue.ItemClass));
        MethodInfo mtd_get_cur_item = AccessTools.PropertyGetter(typeof(XUiM_AssembleItem), nameof(XUiM_AssembleItem.CurrentItem));
        MethodInfo mtd_get_xui = AccessTools.PropertyGetter(typeof(XUiController), nameof(XUiController.xui));

        for (int i = 3; i < codes.Count; i++)
        {
            //get current tags
            if ((codes[i].opcode == OpCodes.Brfalse_S || codes[i].opcode == OpCodes.Brfalse) && codes[i - 1].Calls(mtd_get_cur_item))
            {
                codes.InsertRange(i + 1, new[]
                {
                    new CodeInstruction(OpCodes.Ldarg_0),
                    new CodeInstruction(OpCodes.Call, mtd_get_xui),
                    CodeInstruction.LoadField(typeof(XUi), nameof(XUi.AssembleItem)),
                    new CodeInstruction(OpCodes.Callvirt, mtd_get_cur_item),
                    CodeInstruction.LoadField(typeof(ItemStack), nameof(ItemStack.itemValue)),
                    CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.GetTags)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_tags)
                });
                i += 7;
            }
            //do not touch check on the modification item
            else if (codes[i].Calls(mtd_has_any_tags) && codes[i - 3].Calls(mtd_get_item_class))
            {
                codes[i].opcode = OpCodes.Call;
                codes[i].operand = mtd_test_any_set;
                var insert = new CodeInstruction(OpCodes.Ldloca_S, lbd_tags);
                codes[i - 8].MoveLabelsTo(insert);
                codes.RemoveRange(i - 8, 6);
                codes.Insert(i - 8, insert);
                i -= 5;
            }
        }

        return codes;
    }

    /// <summary>
    /// when installing new mod, use modified tags to check for compatibility
    /// </summary>
    /// <param name="instructions"></param>
    /// <param name="generator"></param>
    /// <returns></returns>
    [HarmonyPatch(typeof(XUiM_AssembleItem), nameof(XUiM_AssembleItem.AddPartToItem))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_AddPartToItem_XUiM_AssembleItem(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
    {
        var codes = instructions.ToList();

        LocalBuilder lbd_tags_cur = generator.DeclareLocal(typeof(FastTags<TagGroup.Global>));
        LocalBuilder lbd_tags_after_install = generator.DeclareLocal(typeof(FastTags<TagGroup.Global>));
        MethodInfo mtd_has_any_tags = AccessTools.Method(typeof(ItemClass), nameof(ItemClass.HasAnyTags));
        MethodInfo mtd_test_any_set = AccessTools.Method(typeof(FastTags<TagGroup.Global>), nameof(FastTags<TagGroup.Global>.Test_AnySet));
        MethodInfo mtd_get_item_class = AccessTools.PropertyGetter(typeof(ItemValue), nameof(ItemValue.ItemClass));
        MethodInfo mtd_get_cur_item = AccessTools.PropertyGetter(typeof(XUiM_AssembleItem), nameof(XUiM_AssembleItem.CurrentItem));
        MethodInfo mtd_is_empty = AccessTools.Method(typeof(ItemValue), nameof(ItemValue.IsEmpty));
        FieldInfo fld_cos = AccessTools.Field(typeof(ItemValue), nameof(ItemValue.CosmeticMods));
        FieldInfo fld_mod = AccessTools.Field(typeof(ItemValue), nameof(ItemValue.Modifications));
        FieldInfo fld_installable_tags = AccessTools.Field(typeof(ItemClassModifier), nameof(ItemClassModifier.InstallableTags));
        
        for (int i = 3; i < codes.Count; i++)
        {
            //get current tags
            if (codes[i].opcode == OpCodes.Stloc_0)
            {
                codes.InsertRange(i + 1, new[]
                {
                    new CodeInstruction(OpCodes.Ldarg_0),
                    new CodeInstruction(OpCodes.Call, mtd_get_cur_item),
                    CodeInstruction.LoadField(typeof(ItemStack), nameof(ItemStack.itemValue)),
                    new CodeInstruction(OpCodes.Dup),
                    CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.GetTags)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_tags_cur),
                    new CodeInstruction(OpCodes.Ldloc_0),
                    CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.GetTagsAsIfInstalled)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_tags_after_install)
                });
                i += 9;
            }
            //do not touch check on the modification item, check if current mod can be installed
            else if (codes[i].Calls(mtd_has_any_tags) && codes[i - 3].Calls(mtd_get_item_class))
            {
                if (codes[i - 1].LoadsField(fld_installable_tags))
                {
                    codes.InsertRange(i + 2, new[]
                    {
                        new CodeInstruction(OpCodes.Ldarg_0),
                        new CodeInstruction(OpCodes.Call, mtd_get_cur_item),
                        CodeInstruction.LoadField(typeof(ItemStack), nameof(ItemStack.itemValue)),
                        new CodeInstruction(OpCodes.Ldloc_0),
                        CodeInstruction.Call(typeof(LocalItemTagsManager), nameof(LocalItemTagsManager.CanInstallMod)),
                        new CodeInstruction(OpCodes.Brfalse, codes[i + 1].operand)
                    });
                }
                codes[i].opcode = OpCodes.Call;
                codes[i].operand = mtd_test_any_set;
                var insert = new CodeInstruction(OpCodes.Ldloca_S, lbd_tags_cur);
                codes[i - 6].MoveLabelsTo(insert);
                codes.RemoveRange(i - 6, 4);
                codes.Insert(i - 6, insert);
                i -= 3;
            }
        }

        return codes;
    }

    #endregion

    //change when aiming events are fired
    [HarmonyPatch(typeof(EntityPlayerLocal), nameof(EntityPlayerLocal.SetMoveState))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_SetMoveState_EntityPlayerLocal(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        FieldInfo fld_msa = AccessTools.Field(typeof(EntityPlayerLocal), nameof(EntityPlayerLocal.moveStateAiming));

        for (int i = 0; i < codes.Count - 2; i++)
        {
            if (codes[i].LoadsField(fld_msa) && codes[i + 2].opcode == OpCodes.Ldloc_1)
            {
                codes[i - 2].MoveLabelsTo(codes[i + 13]);
                codes.RemoveRange(i - 2, 15);
                break;
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(EntityAlive), nameof(EntityAlive.AimingGun), MethodType.Setter)]
    [HarmonyPrefix]
    private static bool Prefix_AimingGun_EntityAlive(bool value, EntityAlive __instance)
    {
        if (__instance is EntityPlayerLocal && __instance.inventory != null)
        {
            bool isAimingGun = __instance.AimingGun;
            if (value != isAimingGun)
            {
                __instance.FireEvent(value ? MinEventTypes.onSelfAimingGunStart : MinEventTypes.onSelfAimingGunStop, true);
#if DEBUG
                Log.Out(value ? "START AIMING GUN FIRED" : "STOP AIMING GUN FIRED");
#endif
            }
        }
        return true;
    }

    [HarmonyPatch(typeof(ItemActionAttack), nameof(ItemActionAttack.HasRadial))]
    [HarmonyPostfix]
    private static void Postfix_HasRadial_ItemActionAttack(ref bool __result)
    {
        EntityPlayerLocal player = GameManager.Instance.World?.GetPrimaryPlayer();
        int index = MultiActionManager.GetActionIndexForEntity(player);
        List<ItemActionData> actionDatas = player.inventory?.holdingItemData?.actionData;
        if (actionDatas != null && actionDatas.Count > index && actionDatas[index] is ItemActionRanged.ItemActionDataRanged rangedData && (rangedData.isReloading || rangedData.isWeaponReloading))
        {
            __result = false;
        }
    }

    [HarmonyPatch(typeof(ItemActionAttack), nameof(ItemActionAttack.SetupRadial))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_SetupRadial_ItemActionAttack(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
    {
        var codes = instructions.ToList();

        var fld_usable = AccessTools.Field(typeof(ItemClass), nameof(ItemClass.UsableUnderwater));

        var lbd_states = generator.DeclareLocal(typeof(bool[]));

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].opcode == OpCodes.Stloc_0)
            {
                codes.InsertRange(i + 1, new[]
                {
                    new CodeInstruction(OpCodes.Ldloc_0),
                    new CodeInstruction(OpCodes.Ldarg_2),
                    new CodeInstruction(OpCodes.Ldc_I4_M1),
                    CodeInstruction.Call(typeof(CommonUtilityPatch), nameof(CommonUtilityPatch.GetUnusableItemEntries)),
                    new CodeInstruction(OpCodes.Stloc_S, lbd_states)
                });
                i += 4;
            }
            else if (codes[i].LoadsField(fld_usable))
            {
                codes.InsertRange(i + 2, new[]
                {
                    new CodeInstruction(OpCodes.Ldloc_S, lbd_states).WithLabels(codes[i + 2].ExtractLabels()),
                    new CodeInstruction(OpCodes.Ldloc_2),
                    CodeInstruction.Call(typeof(CommonUtilityPatch), nameof(CommonUtilityPatch.IsAmmoDisabled)),
                    new CodeInstruction(OpCodes.Brtrue_S, codes[i + 1].operand)
                });
                break;
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(ItemAction), nameof(ItemAction.StartHolding))]
    [HarmonyPostfix]
    private static void Postfix_StartHolding_ItemAction(ItemActionData _data, ItemAction __instance)
    {
        if (__instance is ItemActionAttack itemActionAttack && _data.invData.holdingEntity is EntityPlayerLocal player)
        {
            var arr_disabled_ammo = GetUnusableItemEntries(itemActionAttack.MagazineItemNames, player, _data.indexInEntityOfAction);
            if (arr_disabled_ammo == null)
            {
                return;
            }
            var itemValue = _data.invData.itemValue;
            int cur_index = itemValue.GetSelectedAmmoIndexByActionIndex(_data.indexInEntityOfAction);
            if (arr_disabled_ammo[cur_index])
            {
                int first_enabled_index = Mathf.Max(Array.IndexOf(arr_disabled_ammo, false), 0);

                var mapping = MultiActionManager.GetMappingForEntity(player.entityId);
                if (mapping != null)
                {
                    if (_data.indexInEntityOfAction == mapping.CurMetaIndex)
                    {
                        itemValue.SelectedAmmoTypeIndex = (byte)first_enabled_index;
                    }
                    else
                    {
                        itemValue.SetMetadata(MultiActionUtils.ActionSelectedAmmoNames[mapping.indices.GetMetaIndexForActionIndex(_data.indexInEntityOfAction)], first_enabled_index, TypedMetadataValue.TypeTag.Integer);
                    }
                    _data.invData.holdingEntity.inventory.CallOnToolbeltChangedInternal();
                }
                else
                {
                    itemValue.SelectedAmmoTypeIndex = (byte)(first_enabled_index);
                }
            }
        }
    }

    public static bool[] GetUnusableItemEntries(string[] ammoNames, EntityPlayerLocal player, int actionIndex = -1)
    {
        if (ammoNames == null)
        {
            return null;
        }
        if (actionIndex < 0)
        {
            actionIndex = MultiActionManager.GetActionIndexForEntity(player);
        }
        string str_disabled_ammo_names = player.inventory.holdingItemItemValue.GetPropertyOverrideForAction("DisableAmmo", "", actionIndex);
        //Log.Out($"checking disabled ammo: {str_disabled_ammo_names}\n{StackTraceUtility.ExtractStackTrace()}");
        bool[] arr_disable_states = new bool[ammoNames.Length];
        if(!string.IsNullOrEmpty(str_disabled_ammo_names))
        {
            string[] arr_disabled_ammo_names = str_disabled_ammo_names.Split(',', StringSplitOptions.RemoveEmptyEntries);
            foreach (var name in arr_disabled_ammo_names)
            {
                int index = Array.IndexOf(ammoNames, name.Trim());
                if (index >= 0)
                {
                    arr_disable_states[index] = true;
                    if (ConsoleCmdReloadLog.LogInfo)
                        Log.Out($"ammo {ammoNames[index]} is disabled");
                }
            }
        }
        return arr_disable_states;
    }

    private static bool IsAmmoDisabled(bool[] ammoStates, int index)
    {
        if (ammoStates == null || ammoStates.Length <= index)
        {
            return false;
        }
        return ammoStates[index];
    }

    //dont spread onSelfItemActivate/onSelfItemDeactivate to attachments
    //handle start holding
    [HarmonyPatch(typeof(Inventory), nameof(Inventory.syncHeldItem))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_syncHeldItem_Inventory(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        var prop_itemvalue = AccessTools.PropertyGetter(typeof(Inventory), nameof(Inventory.holdingItemItemValue));
        var mtd_fireevent = AccessTools.Method(typeof(ItemValue), nameof(ItemValue.FireEvent));

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Calls(mtd_fireevent) && codes[i - 5].Calls(prop_itemvalue))
            {
                codes[i] = CodeInstruction.Call(typeof(MinEffectController), nameof(MinEffectController.FireEvent));
                codes.InsertRange(i - 4, new[]
                {
                    CodeInstruction.Call(typeof(ItemValue), "get_ItemClass"),
                    CodeInstruction.LoadField(typeof(ItemClass), nameof(ItemClass.Effects))
                });
                i += 2;
            }
        }

        return codes;
    }

    //handle radial activation
    [HarmonyPatch(typeof(XUiC_Radial), nameof(XUiC_Radial.handleActivatableItemCommand))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_handleActivatableItemCommand_XUiC_Radial(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        var mtd_fireevent = AccessTools.Method(typeof(ItemValue), nameof(ItemValue.FireEvent));
        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Calls(mtd_fireevent))
            {
                codes[i] = CodeInstruction.Call(typeof(MinEffectController), nameof(MinEffectController.FireEvent));
                codes.InsertRange(i - 2, new[]
                {
                    CodeInstruction.Call(typeof(ItemValue), "get_ItemClass"),
                    CodeInstruction.LoadField(typeof(ItemClass), nameof(ItemClass.Effects))
                });
                i += 2;
            }
        }
        return codes;
    }

    //handle equipments
    [HarmonyPatch(typeof(Equipment), nameof(Equipment.SetSlotItem))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_SetSlotItem_Equipment(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        var mtd_fireevent = AccessTools.Method(typeof(ItemValue), nameof(ItemValue.FireEvent));
        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].Calls(mtd_fireevent) && codes[i - 5].opcode == OpCodes.Ldloc_0 && codes[i - 4].OperandIs((int)MinEventTypes.onSelfItemDeactivate))
            {
                codes[i] = CodeInstruction.Call(typeof(MinEffectController), nameof(MinEffectController.FireEvent));
                codes.InsertRange(i - 4, new[]
                {
                    CodeInstruction.Call(typeof(ItemValue), "get_ItemClass"),
                    CodeInstruction.LoadField(typeof(ItemClass), nameof(ItemClass.Effects))
                });
                i += 2;
            }
        }
        return codes;
    }

    [HarmonyPatch(typeof(GameManager), nameof(GameManager.DropContentOfLootContainerServer))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_DropContentOfLootContainerServer_GameManager(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        var setter_localscale = AccessTools.PropertySetter(typeof(Transform), nameof(Transform.localScale));

        for (var i = 0; i < codes.Count; i++)
        {
            if (codes[i].Calls(setter_localscale))
            {
                codes.RemoveRange(i - 6, 7);
                break;
            }
        }

        return codes;
    }

    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.onHoldingEntityFired))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_onHoldingEntityFired_ItemActionRanged(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].opcode == OpCodes.Ldc_R4 && codes[i].operand is 5f)
            {
                codes.RemoveAt(i);
                codes.InsertRange(i, new[]
                {
                    new CodeInstruction(OpCodes.Ldarg_1),
                    CodeInstruction.Call(typeof(CommonUtilityPatch), nameof(CommonUtilityPatch.GetMaxSpread))
                });
                break;
            }
        }
        return codes;
    }

    private static float GetMaxSpread(ItemActionData _data)
    {
        return EffectManager.GetValue(CustomEnums.MaxWeaponSpread, _data.invData.itemValue, 5f, _data.invData.holdingEntity);
    }

    [HarmonyPatch(typeof(NetEntityDistributionEntry), nameof(NetEntityDistributionEntry.getSpawnPacket))]
    [HarmonyPrefix]
    private static bool Prefix_getSpawnPacket_NetEntityDistributionEntry(NetEntityDistributionEntry __instance, ref NetPackage __result)
    {
        if (__instance.trackedEntity is EntityAlive ea)
        { 
            __result = NetPackageManager.GetPackage<NetPackageEntitySpawnWithCVar>().Setup(new EntityCreationData(__instance.trackedEntity, true), (EntityAlive)__instance.trackedEntity);
            return false;
        }
        return true;
    }

    [HarmonyPatch(typeof(World), nameof(World.SpawnEntityInWorld))]
    [HarmonyPostfix]
    private static void Postfix_SpawnEntityInWorld_World(Entity _entity)
    {
        if (_entity is EntityAlive ea && !ea.isEntityRemote)
        {
            ea.FireEvent(CustomEnums.onSelfFirstCVarSync);
        }
    }

    [HarmonyPatch(typeof(ItemActionRanged), nameof(ItemActionRanged.ItemActionEffects))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_ItemActionEffects_ItemActionRanged(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        for (int i = 0; i < codes.Count - 2; i++)
        {
            if (codes[i].opcode == OpCodes.Ldloc_S && ((LocalBuilder)codes[i].operand).LocalIndex == 9 && codes[i + 2].Branches(out _))
            {
                codes.InsertRange(i + 3, new[]
                {
                    new CodeInstruction(OpCodes.Ldloc_S, codes[i].operand).WithLabels(codes[i + 3].ExtractLabels()),
                    CodeInstruction.Call(typeof(CommonUtilityPatch), nameof(AddTmpMuzzleFlash)),
                });
                i += 5;
            }
            else if (codes[i].opcode == OpCodes.Ldloc_S && ((LocalBuilder)codes[i].operand).LocalIndex == 12 && codes[i + 2].Branches(out _))
            {
                codes.InsertRange(i + 3, new[]
                {
                    new CodeInstruction(OpCodes.Ldloc_S, codes[i].operand).WithLabels(codes[i + 3].ExtractLabels()),
                    CodeInstruction.Call(typeof(CommonUtilityPatch), nameof(AddTmpMuzzleFlash)),
                });
                i += 5;
            }
        }
        return codes;
    }

    private static void AddTmpMuzzleFlash(Transform trans)
    {
        if (trans.TryGetComponent<TemporaryObject>(out var tmp))
        {
            tmp.StopAllCoroutines();
            Component.Destroy(tmp);
        }
        tmp = trans.AddMissingComponent<TemporaryMuzzleFlash>();
        tmp.life = 5f;
    }

    [HarmonyPatch(typeof(vp_FPCamera), nameof(vp_FPCamera.UpdateShakes))]
    [HarmonyTranspiler]
    private static IEnumerable<CodeInstruction> Transpiler_UpdateShakes_vp_FPCamera(IEnumerable<CodeInstruction> instructions)
    {
        var codes = instructions.ToList();

        var fld_shake = AccessTools.Field(typeof(vp_FPCamera), nameof(vp_FPCamera.m_Shake));

        for (int i = 0; i < codes.Count; i++)
        {
            if (codes[i].StoresField(fld_shake))
            {
                codes.InsertRange(i + 1, new[]
                {
                    new CodeInstruction(OpCodes.Ldarg_0),
                    CodeInstruction.Call(typeof(CommonUtilityPatch), nameof(CheckShakeNaN))
                });
                break;
            }
        }
        return codes;
    }

    private static void CheckShakeNaN(vp_FPCamera fpcamera)
    {
        if (float.IsNaN(fpcamera.m_Shake.x) || float.IsNaN(fpcamera.m_Shake.y) || float.IsNaN(fpcamera.m_Shake.z))
        {
            Log.Warning("Shake1 NaN {0}, time {1}, speed {2}, amp {3}", new object[]
            {
                fpcamera.m_Shake,
                Time.time,
                fpcamera.ShakeSpeed,
                fpcamera.ShakeAmplitude
            });
            fpcamera.ShakeSpeed = 0f;
            fpcamera.m_Shake = Vector3.zero;
            fpcamera.m_Pitch += -1f;
        }
    }

    //[HarmonyPatch(typeof(EntityBuffs), nameof(EntityBuffs.AddBuff), typeof(string), typeof(Vector3i), typeof(int), typeof(bool), typeof(bool), typeof(float))]
    //[HarmonyPostfix]
    //private static void Postfix_AddBuff_EntityBuffs(string _name, EntityBuffs __instance, EntityBuffs.BuffStatus __result, bool _netSync)
    //{
    //    if (_name.StartsWith("eftZombieRandomArmor") || _name.StartsWith("eftZombieArmor"))
    //        Log.Out($"AddBuff [{_name}] on entity {__instance.parent.GetDebugName()} should sync {_netSync} result {__result.ToStringCached()}\n{StackTraceUtility.ExtractStackTrace()}");
    //}

    //[HarmonyPatch(typeof(EntityBuffs), nameof(EntityBuffs.RemoveBuff))]
    //[HarmonyPostfix]
    //private static void Postfix_RemoveBuff_EntityBuffs(string _name, EntityBuffs __instance, bool _netSync)
    //{
    //    if (_name.StartsWith("eftZombieRandomArmor") || _name.StartsWith("eftZombieArmor"))
    //        Log.Out($"RemoveBuff [{_name}] on entity {__instance.parent.GetDebugName()} should sync {_netSync}\n{StackTraceUtility.ExtractStackTrace()}");
    //}

    //[HarmonyPatch(typeof(Inventory), nameof(Inventory.Execute))]
    //[HarmonyPrefix]
    //private static void Prefix_Execute_Inventory(Inventory __instance, int _actionIdx, bool _bReleased, PlayerActionsLocal _playerActions = null)
    //{
    //    Log.Out($"Execute Inventory holding item {__instance.holdingItem.Name} slot {__instance.holdingItemIdx} action index {_actionIdx} released {_bReleased} is holster delay {__instance.IsHolsterDelayActive()} is unholster delay {__instance.IsUnholsterDelayActive()}");
    //}

    //[HarmonyPatch(typeof(Inventory), nameof(Inventory.updateHoldingItem))]
    //[HarmonyTranspiler]
    //private static IEnumerable<CodeInstruction> Transpiler_updateHoldingItem_Inventory(IEnumerable<CodeInstruction> instructions)
    //{
    //    var codes = instructions.ToList();

    //    var mtd_setholdingtrans = AccessTools.Method(typeof(Inventory), nameof(Inventory.setHoldingItemTransfrom));
    //    var mtd_showrighthand = AccessTools.Method(typeof(Inventory), nameof(Inventory.ShowRightHand));
    //    int insert = -1, take = -1;

    //    for (int i = 0; i < codes.Count; i++)
    //    {
    //        if (codes[i].Calls(mtd_showrighthand))
    //        {
    //            insert = i + 1;
    //        }
    //        else if (codes[i].Calls(mtd_setholdingtrans))
    //        {
    //            take = i - 6;
    //        }
    //    }

    //    if (take > insert)
    //    {
    //        var list_take = codes.GetRange(take, 7);
    //        codes.RemoveRange(take, 7);
    //        codes.InsertRange(insert, list_take);
    //    }

    //    return codes;
    //}
    //private static bool exported = false;
    //[HarmonyPatch(typeof(EModelSDCS), nameof(EModelSDCS.createModel))]
    //[HarmonyPostfix]
    //private static void Postfix_test(EModelSDCS __instance)
    //{
    //    if (!exported)
    //    {
    //        exported = true;
    //        var objects = new[] { __instance.entity.RootTransform.gameObject.GetComponentsInChildren<Animator>()[1] };
    //        Log.Out($"exporting objs: {objects.Length} avatar {objects[0].avatar.name} is human {objects[0].avatar.isHuman}");
    //        FbxExporter07.OnExport(objects, @"E:\Unity Projects\AnimationPlayground\Assets\ExportedProject\example_skinned_mesh_with_bones.fbx");
    //        Application.Quit();
    //    }
    //}
}