Neutral

using System;

using AnimalSimulator.Animals.Behaviours.States;
using AnimalSimulator.Animals.Mods.EventsObservers;
using AnimalSimulator.Infrastructure.TickableStateMachineWithTransitions;
using UnityEngine;

namespace AnimalSimulator.Animals.Behaviours
{
    public class Neutral : IBehaviour, IAnimalDamagedListener, IAttackModeEndListener, IDamageModeEndListener
    {
        private readonly StateMachine _stateMachine;
        private readonly Patrol _patrol;
        private readonly Chase _chase;
        private readonly Search _search;
        private readonly CombatDecide _decide;
        private readonly Attack _attack;
        private readonly Triggers _triggers;
        private readonly TargetOwner _targetOwner;
        private readonly Toggle _toggle = new();

        public Neutral
        (
            StateMachine stateMachine,
            Patrol patrol,
            Search search,
            CombatDecide decide,
            Chase chase,
            Attack attack,
            Triggers triggers,
            TargetOwner targetOwner
        )
        {
            _stateMachine = stateMachine;
            _patrol = patrol;
            _chase = chase;
            _search = search;
            _decide = decide;
            _attack = attack;
            _triggers = triggers;
            _targetOwner = targetOwner;
        }

        public void Enable()
        {
            _toggle.Enable();

            DoTransition(_search, _decide, HasTarget);
            DoTransition(_decide, _attack, _triggers.CanAttack);
            DoTransition(_decide, _chase, _triggers.NeedChase);
            DoTransition(_attack, _decide, _triggers.AttackEnd);
            DoTransition(_chase, _decide, _triggers.TargetArrived);
            DoTransition(_patrol, _decide, _triggers.PatrolTargetArrived);
            DoTransition(_decide, _search, _triggers.LostTarget);
            DoTransition(_search, _patrol, _triggers.NoFoundTarget);

            DoTransitionFromAnyState(_search, _triggers.Damaged);

            _stateMachine.SetState(_patrol);
        }

        private bool HasTarget() =>
            _targetOwner.Target != null;

        private void DoTransitionFromAnyState(IState to, Func<bool> when)
        {
            var transition = new Transition(to, when);
            _stateMachine.AddAnyTransition(transition);
        }

        private void DoTransition(IState @from, IState to, Func<bool> @when) =>
            _stateMachine.AddTransition(@from, new Transition(to, when));

        public void Tick() =>
            _stateMachine.Tick();

        public void Disable() =>
            _toggle.Disable();

        public void OnAnimalDamaged(DamageContext context)
        {
            if (_toggle.Disabled)
                return;

            GameObject owner = context.Owner;

            if (owner == null)
                return;

            var animalReferences = owner.GetComponent<AnimalReferences>();

            Animal animal = animalReferences.Animal;
            _targetOwner.Target = animal;
        }

        public void OnDamageModeEnded(int ability)
        {
            if (_toggle.Enabled)
                _triggers.Damaged.Set();
        }

        public void OnAttackModeEnded(int ability)
        {
            if (_toggle.Enabled)
                _triggers.AttackEnd.Set();
        }
    }
}