#ifndef CREATURELIB_ATTACKTURNCHOICE_HPP
#define CREATURELIB_ATTACKTURNCHOICE_HPP

#include "../Models/Battle.hpp"
#include "../Models/CreatureIndex.hpp"
#include "../Models/LearnedAttack.hpp"
#include "../ScriptHandling/ScriptCategory.hpp"
#include "../ScriptHandling/ScriptMacros.hpp"
#include "BaseTurnChoice.hpp"

namespace CreatureLib::Battling {
    class AttackTurnChoice : public BaseTurnChoice {
        ArbUt::BorrowedPtr<LearnedAttack> _attack;
        CreatureIndex _target;
        std::unique_ptr<BattleScript> _attackScript = nullptr;
        i8 _priority = 0;
        bool _hasFailed = false;

        void ResolveScript(ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData> attack) {
            if (_attackScript != nullptr)
                return;
            auto user = GetUser();
            auto battle = user->GetBattle();
            if (battle.HasValue()) {
                if (attack->HasSecondaryEffect()) {
                    auto library = battle.GetValue()->GetLibrary();
                    auto& effect = attack->GetSecondaryEffect();
                    _attackScript = std::unique_ptr<BattleScript>(
                        library->LoadScript(this, ScriptCategory::Attack, effect->GetEffectName()));
                    if (_attackScript != nullptr) {
                        _attackScript->OnInitialize(battle.GetValue()->GetLibrary().GetRaw(), effect->GetParameters());
                    }
                }
            }
        }

    public:
        AttackTurnChoice(Creature* user, const ArbUt::BorrowedPtr<LearnedAttack>& attack, const CreatureIndex& target)
            : BaseTurnChoice(user), _attack(attack), _target(target) {
            EnsureNotNull(user)
            ResolveScript(attack->GetAttack());
            _priority = _attack->GetAttack()->GetPriority();
        }
        AttackTurnChoice(Creature* user, const ArbUt::BorrowedPtr<LearnedAttack>& attack, const CreatureIndex& target,
                         BattleScript* script)
            : BaseTurnChoice(user), _attack(attack), _target(target), _attackScript(script) {
            _priority = _attack->GetAttack()->GetPriority();
        }

        ~AttackTurnChoice() = default;

        inline const ArbUt::BorrowedPtr<LearnedAttack>& GetAttack() const noexcept { return _attack; }

        void ChangeAttackScript(ArbUt::BorrowedPtr<const CreatureLib::Library::AttackData> attack) {
            _attackScript = nullptr;
            ResolveScript(attack);
            ResetActiveScripts();
        }

        TurnChoiceKind GetKind() const noexcept override { return TurnChoiceKind ::Attack; }

        inline i8 GetPriority() const noexcept { return _priority; }
        inline void SetPriority(i8 priority) noexcept { _priority = priority; }

        const CreatureIndex& GetTarget() const noexcept { return _target; }

        const std::unique_ptr<BattleScript>& GetAttackScript() const noexcept { return _attackScript; }
        size_t ScriptCount() const override { return 1 + GetUser()->ScriptCount(); }

        void GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) override {
            GetOwnScripts(scripts);
            GetUser()->GetActiveScripts(scripts);
        }
        void GetOwnScripts(ArbUt::List<ScriptWrapper>& scripts) override {
            scripts.Append(ScriptWrapper::FromScript(&_attackScript));
        }

        inline bool HasFailed() const noexcept { return _hasFailed; }
        inline void Fail() noexcept { _hasFailed = true; }
    };
}

#endif // CREATURELIB_ATTACKTURNCHOICE_HPP