#include "sim/enemy.h"

#include "sim/element.h"
#include "sim/status.h"
#include "sim/trigger.h"

#include "sim/bullet.h"

namespace
{

// Ближайший ЖИВОЙ боец. Упавшего тварь не добивает: иначе отряд, потерявший
// одного, теряет всех подряд, пока игрок ничего не может сделать.
int NearestAgent(Vec2 from, const Agent* agents, int count, float maxDist, float* outDist)
{
    int best = -1;
    float bestD = maxDist;
    for (int i = 0; i < count; ++i)
    {
        if (!agents[i].alive) continue;
        const float d = Distance(from, agents[i].pos);
        if (d < bestD)
        {
            bestD = d;
            best = i;
        }
    }
    if (outDist) *outDist = bestD;
    return best;
}

// Расталкивание тварей между собой. Без него толпа сливается в одну точку и
// вместо десяти тел отряд видит одно — а бьют его при этом десятью ударами.
Vec2 CrowdPush(const Target& self, int selfIndex, const std::vector<Target>& all)
{
    Vec2 push{};
    for (int i = 0; i < int(all.size()); ++i)
    {
        if (i == selfIndex) continue;
        const Target& o = all[i];
        if (!o.alive || o.IsDummy() || o.IsProp()) continue;

        const Vec2 d = self.pos - o.pos;
        const float gap = self.radius + o.radius;
        const float len = Length(d);
        if (len >= gap || len < 1e-4f) continue;
        push += (d / len) * ((gap - len) / gap);
    }
    return push;
}

// Зазор, с которым плевок вылетает из пасти, а не из центра тела: стартуй
// снаряд внутри собственной капсулы — и он бы упирался в неё же. Это геометрия
// спавна, а не баланс, поэтому число живёт здесь, а не в каталоге видов.
constexpr float kSpitMuzzleGap = 0.12f;

// Урон бойцу от твари — в одном месте на все пять видов атак: множитель
// сложности, событие попадания и падение. Разложенное по веткам, это правило
// первым же дополнением разъехалось бы на пять слегка разных версий.
// attacker — индекс твари, которая ударила, или -1. Нужен ON_HURT: обжечь надо
// того, кто попал, а не «ближайшего».
//
// squadRage — таймер ярости отряда, общий на всех (sim/trigger.h). Указателем, а
// не возвратом: ударов за шаг бывает несколько, и каждый обязан уметь его
// поднять.
bool HurtAgent(Agent& a, int index, float damage, Vec2 dir, CombatEventLog* events,
               std::vector<Target>* targets = nullptr, int attacker = -1,
               float* squadRage = nullptr)
{
    // --- ПАРИРОВАНИЕ БЛИЖНЕГО БОЯ -------------------------------------------
    // Отбить можно, только если удары СОПРИКОСНУЛИСЬ: боец должен сам быть в
    // замахе или в ударе. Парирование «просто так» превратило бы клинок в щит,
    // который работает, пока стоишь.
    //
    // Удавшееся парирование: урона нет, тварь получает удар бойца, и боец бьёт
    // ЗАНОВО, не сбрасывая откат начальной атаки, — из чего и получается
    // размен «отбил и сразу ответил» (docs/11-melee.md).
    if (targets && attacker >= 0 && attacker < int(targets->size()) && a.IsMelee() &&
        a.melee.Committed() && a.melee.parry > 0.0f && a.trig.Chance(a.melee.parry))
    {
        Target& foe = (*targets)[size_t(attacker)];
        if (foe.alive && !foe.IsProp())
        {
            foe.hp -= ResolveDamage(a.melee.damage, a.melee.elem, foe.resist,
                                    ResistCutOf(foe.status) + a.pen) *
                      VulnerabilityOf(foe.status);
            foe.hurtTimer = g_tune.targetHurtTime;

            // Повторный удар: фаза начинается сначала, откат не трогается.
            a.melee.state = MeleeState::STRIKE;
            a.melee.phase = a.melee.strike;
            a.melee.hitMask = 0;   // тот же взмах бьёт заново, иначе цель уже «задета»

            if (events) events->Push(CombatEventKind::MELEE_HIT, index, a.pos, dir);
            return false;   // урона бойцу нет
        }
    }

    const bool down = DamageAgent(a, damage * g_tune.enemyDamageScale);

    // --- ON_HURT: обжечь того, кто ударил -----------------------------------
    // Триггер СНАЧАЛА, событие потом: журнал — канал эффектов, и правила боя
    // от него не зависят (sim/trigger.h).
    const float onHurt = a.mods.trigger[int(TriggerKind::ON_HURT)];
    if (targets && attacker >= 0 && attacker < int(targets->size()) &&
        TriggerReady(a.trig, TriggerKind::ON_HURT, onHurt) && a.trig.Chance(onHurt))
    {
        Target& t = (*targets)[size_t(attacker)];
        if (t.alive && !t.IsProp())
        {
            const StatusRule rule = StatusRuleOf(Element::INC);
            t.status.stacks[int(Element::INC)] =
                std::min(rule.maxStacks, t.status.stacks[int(Element::INC)] + 1);
            t.status.timer[int(Element::INC)] = rule.duration;
            TriggerFired(a.trig, TriggerKind::ON_HURT);
        }
    }

    // --- ON_DOWN: ярость отряда за павшего -----------------------------------
    if (down && squadRage)
    {
        const float onDown = a.mods.trigger[int(TriggerKind::ON_DOWN)];
        if (TriggerReady(a.trig, TriggerKind::ON_DOWN, onDown))
        {
            // Шанс тут не бросается: оперативник гибнет не каждую секунду, и
            // «сработало на 8%» означало бы, что эффект не видели ни разу.
            *squadRage = SQUAD_RAGE_TIME;
            TriggerFired(a.trig, TriggerKind::ON_DOWN);
        }
    }

    if (!events) return down;
    events->Push(CombatEventKind::ENEMY_HIT, index, a.pos, dir);
    if (down) events->Push(CombatEventKind::AGENT_DOWN, index, a.pos, dir);
    return down;
}

}   // namespace

bool HurtAgentForTest(Agent& a, int index, Target& attacker, int attackerIndex,
                      std::vector<Target>& targets, float damage)
{
    (void)attacker;
    return HurtAgent(a, index, damage, FromAngle(a.facing), nullptr, &targets, attackerIndex,
                     nullptr);
}

void UpdateEnemies(ecs::World& world, const Tilemap& map, Agent* agents, int agentCount,
                   std::vector<Target>& targets, float dt, CombatEventLog* events,
                   float aggroMul, float* squadRage)
{
    // Захват гаснет САМ, а держащая тварь его продлевает. Так освобождение
    // бойца не требует, чтобы про захват знали пуля, клинок и респавн: убили
    // хвата — продлевать стало некому, и через enemyGrabHold боец свободен.
    // В песочнице приёмки этот цикл ничего не делает: там никого не хватают.
    for (int i = 0; i < agentCount; ++i)
        agents[i].grabbedTimer = std::max(0.0f, agents[i].grabbedTimer - dt);

    for (int ti = 0; ti < int(targets.size()); ++ti)
    {
        Target& t = targets[ti];
        // Мишень приёмки не шевелится по определению, обстановка — тем более:
        // у ящика нет ни скорости, ни агро, ни удара. Отсекаем их здесь, а не
        // полагаемся на нули в каталоге.
        if (t.IsDummy() || t.IsProp() || !t.alive) continue;

        t.attackTimer = std::max(0.0f, t.attackTimer - dt);

        // --- захват уже держит (GRAB) -----------------------------------------
        // Пока держит — не ходит, не выбирает цель заново и не замахивается.
        // Всё, что у неё есть, уже вцепилось в бойца.
        if (t.grabbed >= 0)
        {
            Agent& held = agents[t.grabbed];
            t.grabTimer -= dt;
            t.facing = AngleOf(Normalized(held.pos - t.pos, FromAngle(t.facing)));

            // Время вышло или боец упал: упавшего твари не добивают, держать
            // его тем более незачем.
            if (!held.alive || t.grabTimer <= 0.0f)
            {
                if (events) events->Push(CombatEventKind::ENEMY_RELEASE, t.grabbed, held.pos,
                                         FromAngle(t.facing));
                t.grabbed = -1;
                t.grabTimer = 0.0f;
                t.attackTimer = t.interval;
                continue;
            }

            held.grabbedTimer = std::max(held.grabbedTimer, g_tune.enemyGrabHold);

            t.grabTickTimer -= dt;
            if (t.grabTickTimer <= 0.0f)
            {
                t.grabTickTimer += std::max(0.05f, t.grabTick);
                HurtAgent(held, t.grabbed, t.damage, FromAngle(t.facing), events, &targets, ti, squadRage);
            }
            continue;
        }

        // --- рывок в полёте (LUNGE) -------------------------------------------
        // Именно движение по времени, а не телепорт: бросок обязан быть виден,
        // иначе непонятно, чем именно снесло бойца.
        if (t.lungeTimer > 0.0f)
        {
            t.lungeTimer -= dt;

            const Vec2 from = t.pos;
            const float speed = t.lungeDist / std::max(0.02f, t.lungeTime);
            t.pos += t.lungeDir * (speed * dt);
            map.ResolveCircle(t.pos, t.radius);   // сквозь стены не рвётся никто

            // Урон всем, кого зацепило ПО ПУТИ, а не одной жертве: рывок —
            // это отрезок, и стоять на нём не должно быть безопасно никому.
            // Маска считается по индексам бойцов, поэтому и ограничена 32.
            for (int i = 0; i < agentCount && i < 32; ++i)
            {
                if (!agents[i].alive) continue;
                if (t.lungeMask & (1u << i)) continue;   // каждого — один раз за рывок
                if (DistancePointToSegment(agents[i].pos, from, t.pos) >
                    t.radius + agents[i].bodyRadius)
                    continue;
                t.lungeMask |= (1u << i);
                HurtAgent(agents[i], i, t.damage, t.lungeDir, events, &targets, ti, squadRage);
            }

            if (t.lungeTimer <= 0.0f)
            {
                t.lungeTimer = 0.0f;
                t.attackTimer = t.interval;   // откат считается от КОНЦА рывка
            }
            continue;
        }

        // --- кого преследуем --------------------------------------------------
        float dist = 0.0f;
        const int victim = NearestAgent(t.pos, agents, agentCount, t.aggroRadius * aggroMul, &dist);
        if (victim >= 0) t.aggro = true;   // заметил — уже не забудет
        t.victim = victim;

        if (victim < 0)
        {
            // Никого в радиусе: замах в пустоту не доводится.
            t.windupTimer = 0.0f;
            continue;
        }

        const Vec2 toVictim = agents[victim].pos - t.pos;
        t.facing = AngleOf(Normalized(toVictim, FromAngle(t.facing)));

        // --- замах доведён: бьём ----------------------------------------------
        // Ось удара НЕ доводится: замахнулся — бьёт туда, куда замахнулся.
        // Ровно это даёт игроку возможность увести бойца из-под удара.
        if (t.Telegraphing())
        {
            t.windupTimer -= dt;
            if (t.windupTimer > 0.0f) continue;   // на замахе тварь стоит

            t.windupTimer = 0.0f;
            const Vec2 axis = FromAngle(t.facing);

            switch (t.attack)
            {
                // Плевок: единственная атака, которую перекрывает стена, —
                // снаряд летит и во что-нибудь упирается.
                case AttackKind::SPIT:
                    SpawnHostileBullet(world, t.pos + axis * (t.radius + kSpitMuzzleGap), axis,
                                       t.projectileSpeed, t.damage * g_tune.enemyDamageScale,
                                       std::max(t.spitRange, t.attackRange));
                    if (events) events->Push(CombatEventKind::ENEMY_SPIT, ti, t.pos, axis);
                    t.attackTimer = t.interval;
                    break;

                // Рывок: с этого шага тварь едет по прямой и откат ей встанет
                // только в конце броска.
                case AttackKind::LUNGE:
                    t.lungeDir = axis;
                    t.lungeTimer = t.lungeTime;
                    t.lungeMask = 0;
                    if (events) events->Push(CombatEventKind::ENEMY_LUNGE, ti, t.pos, axis);
                    break;

                // Удар оземь: КРУГ вокруг себя. Под него попадает и тот, кто
                // просто стоял рядом с жертвой, — разбирать громилу вдвоём
                // теперь стоит здоровья обоим.
                case AttackKind::SLAM:
                {
                    if (events) events->Push(CombatEventKind::ENEMY_SLAM, ti, t.pos, axis);
                    for (int i = 0; i < agentCount; ++i)
                    {
                        if (!agents[i].alive) continue;
                        const Vec2 d = agents[i].pos - t.pos;
                        if (Length(d) > t.slamRadius + agents[i].bodyRadius) continue;
                        HurtAgent(agents[i], i, t.damage, Normalized(d, axis), events, &targets, ti, squadRage);
                    }
                    t.attackTimer = t.interval;
                    break;
                }

                // Захват: промахнуться им можно — ушёл из вытянутых лап за время
                // замаха, и хват остался ни с чем на целый интервал.
                case AttackKind::GRAB:
                {
                    if (dist <= t.attackRange + agents[victim].bodyRadius)
                    {
                        t.grabbed = victim;
                        t.grabTimer = t.grabTime;
                        t.grabTickTimer = 0.0f;   // первый тик сразу: хватку видно
                        agents[victim].grabbedTimer =
                            std::max(agents[victim].grabbedTimer, g_tune.enemyGrabHold);
                        if (events) events->Push(CombatEventKind::ENEMY_GRAB, victim,
                                                 agents[victim].pos, axis);
                    }
                    else
                    {
                        t.attackTimer = t.interval;
                    }
                    break;
                }

                // Взмах: сектор перед собой. Достаёт всех, кто в него влез, —
                // от такого удара уходят вбок, а не назад.
                case AttackKind::SWIPE:
                default:
                {
                    const float half = t.swipeArcDeg * 0.5f * DEG2RAD_F;
                    for (int i = 0; i < agentCount; ++i)
                    {
                        if (!agents[i].alive) continue;
                        const Vec2 d = agents[i].pos - t.pos;
                        if (Length(d) > t.attackRange + agents[i].bodyRadius) continue;
                        if (std::fabs(AngleDiff(t.facing, AngleOf(d))) > half) continue;
                        HurtAgent(agents[i], i, t.damage, Normalized(d, axis), events, &targets, ti, squadRage);
                    }
                    t.attackTimer = t.interval;
                    break;
                }
            }
            continue;
        }

        // --- начать замах -----------------------------------------------------
        // Телеграф обязателен для КАЖДОЙ атаки, но дистанция начала у них разная:
        // рывок затевается ИЗДАЛЕКА (он для того и нужен, чтобы закрыть разрыв),
        // остальные — по своей досягаемости.
        const float reach = t.attackRange + agents[victim].bodyRadius;
        const float trigger = (t.attack == AttackKind::LUNGE) ? std::max(reach, t.lungeDist)
                                                              : reach;
        if (dist <= trigger && t.attackTimer <= 0.0f)
        {
            t.windupTimer = t.windup * std::max(0.05f, g_tune.enemyWindupScale);
            if (events) events->Push(CombatEventKind::ENEMY_WINDUP, ti, t.pos,
                                     FromAngle(t.facing));
            continue;
        }

        // --- ход --------------------------------------------------------------
        // Стрелок держит дистанцию: подходить вплотную ему незачем, а отряду
        // нужен противник, до которого ещё надо дойти.
        Vec2 dir{};
        if (t.ranged && dist < t.attackRange * 0.55f) dir = Normalized(-toVictim);
        else if (dist > reach * 0.9f)                 dir = Normalized(toVictim);

        Vec2 move = dir * t.speed;
        move += CrowdPush(t, ti, targets) * t.speed;

        t.pos += move * dt;
        map.ResolveCircle(t.pos, t.radius);
    }
}

int CountAggroEnemies(const std::vector<Target>& targets)
{
    int n = 0;
    for (const Target& t : targets)
        if (t.alive && !t.IsDummy() && t.victim >= 0) ++n;
    return n;
}