using Facepunch;
using HarmonyLib;
using Oxide.Core.Plugins;
using Rust.Ai.Gen2;
using System.Collections.Generic;
using static Rust.Ai.Gen2.FSMComponent;

namespace Oxide.Plugins
{
    [Info("Remove Animals AI", "Whipers88 @CobaltStudios", "1.1.6")]
    [Description("Removing AI only for animals (not for bots)")]
    public class RemoveAnimalsAI : RustPlugin
    {
        static RemoveAnimalsAI _plugin;
        private void Init()
        {
            _plugin = this;
            //FSMComponent.workQueue.Clear();
            List<FSMComponent> FSMComponents = Pool.Get<List<FSMComponent>>();
            foreach (var queue in new[] { FSMComponent.defaultWorkQueue, CritterAnimalFSM.critterWorkQueue })
            {
                foreach (var fsmComponent in queue.workList)
                {
                    if (fsmComponent._baseEntity is ScientistNPC2)
                        continue;
                    FSMComponents.Add(fsmComponent);
                }
            }
            foreach (var item in FSMComponents)
            {
                item.workQueue.Remove(item);
            }

            foreach (var entity in BaseNetworkable.serverEntities)
            {
                if (entity is BaseNPC2 && !(entity is ScientistNPC2))
                {
                    entity.Kill();
                }
                if (entity is BaseAnimalNPC baseAnimalNPC)
                {
                    if (baseAnimalNPC.HasBrain && baseAnimalNPC.TryGetComponent<BaseAIBrain>(out BaseAIBrain baseAIBrain))
                    {
                        UnityEngine.Object.Destroy(baseAIBrain);
                    }
                }
                if (entity is BaseNpc npc)
                {
                    npc.CancelInvoke(npc.TickAi);
                }
            }
        }

        private void Unload()
        {
            _plugin = null;
        }

        [HarmonyPatch(typeof(BaseNpc), nameof(BaseNpc.ServerInit)), AutoPatch]
        public static class ServerInitPatch
        {
            [HarmonyPostfix]
            private static void Postfix(BaseNpc __instance)
            {
                __instance.CancelInvoke(__instance.TickAi);
            }
        }

        [HarmonyPatch(typeof(FSMComponent), nameof(FSMComponent.SetFsmActive)), AutoPatch]
        public static class SetFsmActivePatch
        {
            [HarmonyPrefix]
            private static bool Prefix(FSMComponent __instance, bool newActive)
            {
                if (__instance._baseEntity is ScientistNPC2)
                    return true;
                return !newActive;
            }
        }

        [HarmonyPatch(typeof(AIThinkManager), nameof(AIThinkManager.ProcessQueue)), AutoPatch]
        public static class ProcessQueuePatch
        {
            [HarmonyPrefix]
            private static bool Prefix(AIThinkManager.QueueType queueType)
            {
                if (queueType == AIThinkManager.QueueType.Animal)
                {
                    return false;
                }
                return true;
            }
        }

        [HarmonyPatch(typeof(AnimalBrain), nameof(AnimalBrain.InitializeAI)), AutoPatch]
        public static class InitializeAIPatch
        {
            [HarmonyPrefix]
            private static bool Prefix(BaseAIBrain __instance)
            {
                return false;
            }
        }

        [HarmonyPatch(typeof(BaseCombatEntity), nameof(BaseCombatEntity.OnDied)), AutoPatch]
        public static class OnDiedRequeueFSMPatch
        {
            [HarmonyPrefix]
            private static void Prefix(BaseCombatEntity __instance)
            {
                if (__instance is BaseNPC2 npc && !(npc is ScientistNPC2) && !__instance.IsDestroyed && npc.TryGetComponent<FSMComponent>(out var fsm) && !fsm.workQueue.Contains(fsm))
                {
                    fsm.isRunning = true;
                    fsm.workQueue.Add(fsm);
                }
            }
        }

    }
}