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.2")]
    [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 fsmComponent in FSMComponent.workQueue.workList)
            {
                if (fsmComponent._baseEntity is ScientistNPC2)
                continue;
                FSMComponents.Add(fsmComponent);
            }
            foreach(var item in FSMComponents)
            {
                FSMComponent.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);
                    }
                }
            }
        }

        private void Unload()
        {
            _plugin = null;
        }

        [HarmonyPatch(typeof(BaseNpc), nameof(BaseNpc.TickAi)), AutoPatch]
        public static class TickAiPatch
        {
            [HarmonyPrefix]
            private static bool Prefix()
            {
                return false;
            }
        }

        [HarmonyPatch(typeof(LimitedTurnNavAgent), nameof(LimitedTurnNavAgent.TickSteering)), AutoPatch]
        public static class TickSteeringPatch
        {
            [HarmonyPrefix]
            private static bool Prefix(LimitedTurnNavAgent __instance)
            {
                for (int i = LimitedTurnNavAgent.steeringComponents.Count - 1; i >= 0; i--)
                {
                    LimitedTurnNavAgent item = LimitedTurnNavAgent.steeringComponents[i];
                    if (item.IsUnityNull<LimitedTurnNavAgent>() || !item.baseEntity.IsValid() || !(item.baseEntity is ScientistNPC2))
                    {
                        LimitedTurnNavAgent.steeringComponents.RemoveAt(i);
                    }
                    else
                    {
                        item.Tick();
                    }
                }
                return false;
            }
        }

        [HarmonyPatch(typeof(TickFSMWorkQueue), "RunJob"), AutoPatch]
        public static class RunJobPatch
        {
            [HarmonyPrefix]
            private static bool Prefix(FSMComponent component)
            {
                if (component == null)
                    return false;

                if(component._baseEntity is ScientistNPC2)
                    return true;

                if (!component.enabled)
                    return false;

                if (component._baseEntity?.Health() != 0)
                {
                    return false;
                }
                component.Tick();
                FSMComponent.workQueue.Remove(component);
                return false;
            }
        }

        [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;
            }
        }

    }
}