lsh4/Assets/Scripts/Monsters/MonsterFormationGroup.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class MonsterFormationGroup : MonoBehaviour
{
    public MonsterData monsterData;
    public Vector3 anchorPosition;
    public float spacing = 1.5f;
    public float frontRowOffset = 2f;
    public float cellSize = 5f;
    public float attackRange = 6f;
    public float moveDelay = 1f;
    public float stopAfterDistance = 5f;
    public float stopDuration = 2f;
    public float attackInterval = 1.5f;
    public float attackRepeatDelay = 3f;
    
    // Attack range consistency
    private const float ATTACK_RANGE_BUFFER = 0.5f;
    private float effectiveAttackRange => attackRange + ATTACK_RANGE_BUFFER;

    public List<MonsterController> frontRow = new();
    public List<MonsterController> backRow = new();
    public List<Vector3> frontRowPositions = new();

    private Transform player;
    public bool isChasing = false;
    public bool hasDetectedPlayer = false; // Track if player has been detected
    private float distanceTravelled = 0f;
    private Coroutine attackLoopCoroutine;
    private TeamCohesionManager cohesionManager;

    private void Start()
    {
        StartCoroutine(DelayedStart());
    }

private IEnumerator DelayedStart()
{
    while (UIUpdater.Instance == null)
        yield return null; // attend que UIUpdater existe

    player = GameObject.FindWithTag("Player")?.transform;
    cohesionManager = FindFirstObjectByType<TeamCohesionManager>();

    if (GetComponent<Collider>() == null)
    {
        SphereCollider trigger = gameObject.AddComponent<SphereCollider>();
        trigger.isTrigger = true;
        trigger.radius = 20f;
    }
}


    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            hasDetectedPlayer = true;
            Debug.Log("[MonsterGroup] Player entered detection zone");
            
            // Only start chase if not already chasing or attacking
            if (!isChasing && attackLoopCoroutine == null)
            {
                StartChase();
            }
        }
    }
    
    private void OnTriggerExit(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            hasDetectedPlayer = false;
            Debug.Log("[MonsterGroup] Player exited detection zone");
            
            // Stop attack loop if player leaves
            if (attackLoopCoroutine != null)
            {
                StopCoroutine(attackLoopCoroutine);
                attackLoopCoroutine = null;
            }
            
            // Reset chase state
            isChasing = false;
        }
    }
    
    private void OnTriggerStay(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            hasDetectedPlayer = true;
        }
    }

    public void Spawn()
    {
        int total = monsterData.monstersPerGroup;

        for (int i = 0; i < total; i++)
        {
            int row = i < 3 ? 0 : 1;
            int indexInRow = row == 0 ? i : i - 3;

            float xOffset = 0f;
            if (row == 0)
            {
                xOffset = (indexInRow - 1) * spacing;
            }
            else
            {
                if (monsterData.monstersPerGroup == 5 && indexInRow < 2)
                    xOffset = (indexInRow - 0.5f) * spacing;
                else
                    xOffset = (indexInRow - 1.5f) * spacing;
            }

            float zOffset = -row * spacing + (row == 0 ? frontRowOffset : 0);
            Vector3 offset = new Vector3(xOffset, 0, zOffset);
            Vector3 rotatedOffset = RotateOffset(offset, monsterData.defaultOrientation);
            Vector3 spawnPos = anchorPosition + rotatedOffset;

            Quaternion rotation = GetRotationFromOrientation(monsterData.defaultOrientation);
            GameObject m = Instantiate(monsterData.prefab, spawnPos, rotation, transform);
            MonsterController ctrl = m.GetComponent<MonsterController>();
            ctrl.data = monsterData;
            ctrl.formationGroup = this;

            if (row == 0)
            {
                frontRow.Add(ctrl);
                frontRowPositions.Add(spawnPos);
            }
            else
            {
                backRow.Add(ctrl);
            }
        }
    }

    public void NotifyMonsterDeath(MonsterController dead)
    {
        Debug.Log("Boucle NotifyMonster");

        Vector3 deadPosition = dead.transform.position;

        if (frontRow.Contains(dead))
        {
            Debug.Log("FrontRow ...");
            int index = frontRow.IndexOf(dead);
            frontRow.RemoveAt(index);

            if (backRow.Count > 0)
            {
                Debug.Log("BackRow");
                MonsterController replacement = GetClosestBacklinerTo(deadPosition);
                backRow.Remove(replacement);
                frontRow.Insert(index, replacement);

                StartCoroutine(MoveReplacementWithDelay(replacement, deadPosition, 2f)); // 👈 délai de 2s
            }
        }
        else
        {
            Debug.Log("BackRow Dead");
            backRow.Remove(dead);
        }
    }

    IEnumerator MoveReplacementWithDelay(MonsterController replacement, Vector3 destination, float delay)
    {
        yield return new WaitForSeconds(delay);
        replacement.MoveTo(destination);
        replacement.FaceTarget(player.position);
    }

    public void StartChase()
    {
        if (!isChasing)
        {
            // Ajout de vérification avant de démarrer le combat
            if (UIUpdater.Instance == null || UIUpdater.Instance.IsReady == false)
            {
                Debug.Log("[MonsterGroup] UI pas encore prête, attente du setup...");
                StartCoroutine(WaitForUIThenChase());
                return;
            }

            Debug.Log("[MonsterGroup] StartChase() appelé");
            StartCoroutine(ChaseRoutine());
        }
    }

    IEnumerator WaitForUIThenChase()
    {
        // Attend que UIUpdater soit prêt
        while (UIUpdater.Instance == null || UIUpdater.Instance.IsReady == false)
        {
            yield return null;
        }

        Debug.Log("[MonsterGroup] UI prête, démarrage de la chasse !");
        StartCoroutine(ChaseRoutine());
    }


    IEnumerator ChaseRoutine()
    {
        isChasing = true;
        distanceTravelled = 0f;
        
        Debug.Log("[MonsterGroup] Chase routine started");

        while (isChasing && hasDetectedPlayer)
        {
            // Check if player left detection zone
            if (!hasDetectedPlayer)
            {
                Debug.Log("[MonsterGroup] Player left detection zone during chase");
                isChasing = false;
                yield break;
            }
            
            float distanceToPlayer = Vector3.Distance(transform.position, player.position);

            // Reached attack range
            if (distanceToPlayer <= attackRange || IsAdjacentToPlayer())
            {
                Debug.Log("[MonsterGroup] Reached attack range, starting combat");
                isChasing = false;
                attackLoopCoroutine = StartCoroutine(LoopAttack());
                yield break;
            }

            // Continue chasing
            Vector3 dirToPlayer = (player.position - transform.position).normalized;
            Vector3 step = new Vector3(Mathf.Round(dirToPlayer.x), 0, Mathf.Round(dirToPlayer.z)) * cellSize;

            MoveGroupBy(step);
            distanceTravelled += cellSize + 1f;

            // Tactical pause every 5 meters
            if (distanceTravelled >= stopAfterDistance)
            {
                Debug.Log("[MonsterGroup] Tactical pause after moving 5m");
                yield return new WaitForSeconds(stopDuration);
                distanceTravelled = 0f;
            }
            else
            {
                yield return new WaitForSeconds(moveDelay);
            }
        }
        
        Debug.Log("[MonsterGroup] Chase routine ended");
        isChasing = false;
    }

    void MoveGroupBy(Vector3 step)
    {
        foreach (var monster in frontRow.Concat(backRow))
        {
            Vector3 targetPos = monster.transform.position + step;
            monster.MoveTo(targetPos);
            monster.FaceTarget(player.position);
        }
    }

    private void Update()
    {
        // Only act if player is in detection zone
        if (!hasDetectedPlayer) return;
        
        // If player not assigned yet, wait
        if (player == null) return;
        
        // Prevent interference with active states
        if (isChasing || attackLoopCoroutine != null) return;
        
        // If not currently doing anything and player is detected
        if (!isChasing && attackLoopCoroutine == null)
        {
            // Check if any front row monster is in attack range
            bool anyMonsterInAttackRange = false;
            float closestMonsterDistance = float.MaxValue;
            
            if (frontRow.Count > 0)
            {
                foreach (var monster in frontRow)
                {
                    if (monster != null)
                    {
                        float monsterToPlayerDist = Vector3.Distance(monster.transform.position, player.position);
                        
                        if (monsterToPlayerDist < closestMonsterDistance)
                        {
                            closestMonsterDistance = monsterToPlayerDist;
                        }
                        
                        if (monsterToPlayerDist <= effectiveAttackRange)
                        {
                            anyMonsterInAttackRange = true;
                        }
                    }
                }
            }
            else
            {
                Debug.LogWarning("[MonsterGroup] Update: No front row monsters available!");
                return;
            }
            
            if (anyMonsterInAttackRange)
            {
                // Monsters are close enough to attack
                Debug.Log($"[MonsterGroup] Update: Monsters in attack range (closest: {closestMonsterDistance:F1}m), starting attack loop");
                attackLoopCoroutine = StartCoroutine(LoopAttack());
            }
            else
            {
                // No monsters in attack range, should chase player
                Debug.Log($"[MonsterGroup] Update: Monsters out of attack range (closest: {closestMonsterDistance:F1}m), starting chase");
                StartChase();
            }
        }
    }

    bool IsPlayerInRange()
    {
        return Vector3.Distance(transform.position, player.position) <= attackRange;
    }

    IEnumerator LoopAttack()
    {
        Debug.Log("[MonsterGroup] Attack loop started");
        
        while (true)
        {
            // Check if game manager says player is dead (prevents attacks during death sequence)
            if (GameManager.Instance != null && GameManager.Instance.IsPlayerDead())
            {
                Debug.Log("[MonsterGroup] Player is dead, stopping attack");
                attackLoopCoroutine = null;
                yield break;
            }
            
            // Check if player left detection zone completely
            if (!hasDetectedPlayer)
            {
                Debug.Log("[MonsterGroup] Player left detection zone, stopping attack");
                attackLoopCoroutine = null;
                yield break;
            }
            
            // Check if any party members are still alive
            if (cohesionManager == null || cohesionManager.groupMembers.Count == 0)
            {
                Debug.Log("[MonsterGroup] No party members alive, stopping attack");
                attackLoopCoroutine = null;
                yield break;
            }
            
            // Check if any monsters are still alive
            if (frontRow.Count == 0 && backRow.Count == 0)
            {
                Debug.Log("[MonsterGroup] All monsters dead, stopping attack");
                attackLoopCoroutine = null;
                yield break;
            }
            
            // Check if any monster is in attack range
            bool anyInRange = frontRow.Any(monster =>
                monster != null && Vector3.Distance(monster.transform.position, player.position) <= effectiveAttackRange);

            if (!anyInRange)
            {
                Debug.Log("[MonsterGroup] Player moved out of attack range - stopping attack loop");
                attackLoopCoroutine = null;
                
                // Log state for debugging
                Debug.Log($"[MonsterGroup] State after attack stop: hasDetectedPlayer={hasDetectedPlayer}, isChasing={isChasing}, attackLoopCoroutine={attackLoopCoroutine}");
                
                if (hasDetectedPlayer)
                {
                    Debug.Log("[MonsterGroup] Player still detected - Update() will handle re-engagement");
                }
                else
                {
                    Debug.Log("[MonsterGroup] Player no longer detected - will wait for re-entry");
                }
                
                yield break;
            }

            // Attack with each front row monster
            foreach (var monster in frontRow.ToList()) // ToList to avoid modification during iteration
            {
                if (monster == null) continue;
                
                if (monsterData.attackType == MonsterData.AttackType.Melee)
                {
                    float distanceToPlayer = Vector3.Distance(monster.transform.position, player.position);
                    if (distanceToPlayer > effectiveAttackRange)
                    {
                        continue;
                    }
                    
                    monster.StopMove();
                    monster.FaceTarget(player.position, instant: true);
                    
                    // Verify monster is facing player (required for melee)
                    if (!monster.IsFacingTarget(player.position, 45f))
                    {
                        Debug.Log($"[Combat] {monster.name} not facing player, skipping");
                        continue;
                    }
                    
                    monster.Attack();

                    // Find the closest character on the party grid
                    var closest = cohesionManager.groupMembers
                        .OrderBy(charac => Vector3.Distance(monster.transform.position, new Vector3(charac.gridX, 0, charac.gridY)))
                        .FirstOrDefault();

                    if (closest == null)
                    {
                        Debug.LogWarning("[Combat] No valid target found!");
                        continue;
                    }
                    
                    Debug.Log($"[Combat] Target: {closest.characterName}");

                    // Apply damage to the character
                    var uiController = UIUpdater.Instance?.GetUIForCharacterByName(closest.characterName);
                    if (uiController != null)
                    {
                        int damage = monster.data.attackDamage;
                        closest.currentHP -= damage;
                        closest.currentHP = Mathf.Max(0, closest.currentHP);

                        uiController.UpdateHPBar();
                        uiController.ShowDamageOnCard(damage);
                        Debug.Log($"[Combat] {monster.name} dealt {damage} damage to {closest.characterName} ({closest.currentHP}/{closest.maxHP} HP remaining)");
                        
                        // Check if character died
                        if (closest.currentHP <= 0)
                        {
                            Debug.Log($"[Combat] {closest.characterName} has been defeated!");
                            uiController.HandleCharacterDeath();
                        }
                    }
                    else
                    {
                        Debug.LogWarning($"[Combat] UI not found for {closest.characterName}");
                    }

                    yield return new WaitForSeconds(attackInterval);
                }
            }

            yield return new WaitForSeconds(attackRepeatDelay);
            Debug.Log("[MonsterGroup] Starting next attack round...");
        }
    }

    MonsterController GetClosestBacklinerTo(Vector3 position)
    {
        MonsterController closest = null;
        float minDist = float.MaxValue;

        foreach (var b in backRow)
        {
            float d = Vector3.Distance(b.transform.position, position);
            if (d < minDist)
            {
                minDist = d;
                closest = b;
            }
        }

        return closest;
    }

    bool IsAdjacentToPlayer()
    {
        foreach (var monster in frontRow.Concat(backRow))
        {
            if (Vector3.Distance(monster.transform.position, player.position) <= cellSize + 0.5f)
                return true;
        }
        return false;
    }

    Vector3 RotateOffset(Vector3 offset, MonsterData.Orientation direction)
    {
        switch (direction)
        {
            case MonsterData.Orientation.North: return offset;
            case MonsterData.Orientation.South: return new Vector3(-offset.x, 0, -offset.z);
            case MonsterData.Orientation.East:  return new Vector3(offset.z, 0, -offset.x);
            case MonsterData.Orientation.West:  return new Vector3(-offset.z, 0, offset.x);
            default: return offset;
        }
    }

    Quaternion GetRotationFromOrientation(MonsterData.Orientation orientation)
    {
        switch (orientation)
        {
            case MonsterData.Orientation.North: return Quaternion.Euler(0, 0, 0);
            case MonsterData.Orientation.South: return Quaternion.Euler(0, 180, 0);
            case MonsterData.Orientation.East:  return Quaternion.Euler(0, 90, 0);
            case MonsterData.Orientation.West:  return Quaternion.Euler(0, 270, 0);
            default: return Quaternion.identity;
        }
    }
}