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

/// <summary>
/// Точка маршрута для UI-элемента
/// </summary>
[Serializable]
public class UIPathPoint
{
    public Vector2 position;              
    public float duration = 1f;           
    public string animationStateName = ""; // Имя состояния анимации (walkk, stop, Idle, victory, defeat)
    [Range(0f, 5f)]
    public float delayAtPoint = 0f;
}

/// <summary>
/// Менеджер для управления движущимися UI-персонажами
/// Создаёт экземпляры и запускает их по маршрутам
/// </summary>
public class UIAnimatedMover : MonoBehaviour
{
    [Header("Конфигурации персонажей")]
    [SerializeField] private UICharacterPathConfig[] characterConfigs; // Массив конфигураций разных персонажей
    
    [Header("Настройки")]
    [SerializeField] private Transform spawnParent; // Родитель для создаваемых экземпляров
    
    private List<UICharacterInstance> activeInstances = new List<UICharacterInstance>();
    
    private void Awake()
    {
        if (spawnParent == null)
            spawnParent = transform;
    }
    
    /// <summary>
    /// Инициализировать и запустить персонажа по маршруту
    /// </summary>
    /// <param name="config">Конфигурация персонажа с маршрутами</param>
    /// <param name="pathType">Тип маршрута (Default по умолчанию)</param>
    /// <returns>Созданный экземпляр персонажа</returns>
    public UICharacterInstance InitializeCharacter(UICharacterPathConfig config, PathType pathType = PathType.Default)
    {
        if (config == null)
        {
            Debug.LogError("UIAnimatedMover: config is null!");
            return null;
        }
        
        if (config.characterPrefab == null)
        {
            Debug.LogError($"UIAnimatedMover: characterPrefab is null in config {config.name}!");
            return null;
        }
        
        // Получаем маршрут по ключу
        PathData pathData = config.GetPath(pathType);
        if (pathData == null || pathData.points.Count == 0)
        {
            Debug.LogError($"UIAnimatedMover: path not found for type {pathType} in config {config.name}!");
            return null;
        }
        
        // Создаём экземпляр персонажа
        GameObject instanceObj = Instantiate(config.characterPrefab, spawnParent);
        RectTransform rectTransform = instanceObj.GetComponent<RectTransform>();
        
        if (rectTransform == null)
        {
            Debug.LogError($"UIAnimatedMover: characterPrefab must have RectTransform!");
            Destroy(instanceObj);
            return null;
        }
        
        // Получаем или добавляем UIAnimationStateSwitcher
        UIAnimationStateSwitcher animationSwitcher = instanceObj.GetComponent<UIAnimationStateSwitcher>();
        if (animationSwitcher == null)
        {
            animationSwitcher = instanceObj.AddComponent<UIAnimationStateSwitcher>();
        }
        
        // Устанавливаем Override Controller
        if (config.overrideController != null)
        {
            animationSwitcher.SetOverrideController(config.overrideController);
        }
        
        // Устанавливаем в первую точку маршрута
        rectTransform.anchoredPosition = pathData.points[0].position;
        
        // Создаём экземпляр управления
        UICharacterInstance instance = new UICharacterInstance
        {
            gameObject = instanceObj,
            rectTransform = rectTransform,
            animationSwitcher = animationSwitcher,
            pathData = pathData,
            config = config
        };
        
        activeInstances.Add(instance);
        
        // Запускаем движение
        StartCoroutine(MoveAlongPath(instance));
        
        return instance;
    }
    
    /// <summary>
    /// Инициализировать персонажа по индексу из массива конфигураций
    /// </summary>
    /// <param name="configIndex">Индекс конфигурации в массиве (0, 1, 2...)</param>
    /// <param name="pathType">Тип маршрута (Default по умолчанию)</param>
    public UICharacterInstance InitializeByIndex(int configIndex, PathType pathType = PathType.Default)
    {
        if (characterConfigs == null || characterConfigs.Length == 0)
        {
            Debug.LogError("UIAnimatedMover: characterConfigs массив пуст!");
            return null;
        }
        
        if (configIndex < 0 || configIndex >= characterConfigs.Length)
        {
            Debug.LogError($"UIAnimatedMover: индекс {configIndex} вне диапазона массива (0-{characterConfigs.Length - 1})");
            return null;
        }
        
        return InitializeCharacter(characterConfigs[configIndex], pathType);
    }
    
    /// <summary>
    /// Инициализировать первого персонажа из массива (индекс 0)
    /// </summary>
    public UICharacterInstance InitializeDefault()
    {
        return InitializeByIndex(0, PathType.Default);
    }
    
    /// <summary>
    /// Получить конфигурацию персонажа по индексу
    /// </summary>
    public UICharacterPathConfig GetConfig(int index)
    {
        if (characterConfigs == null || index < 0 || index >= characterConfigs.Length)
            return null;
        
        return characterConfigs[index];
    }
    
    /// <summary>
    /// Количество доступных конфигураций персонажей
    /// </summary>
    public int GetConfigCount()
    {
        return characterConfigs != null ? characterConfigs.Length : 0;
    }
    
    /// <summary>
    /// Остановить и удалить экземпляр персонажа
    /// </summary>
    public void RemoveCharacter(UICharacterInstance instance)
    {
        if (instance == null) return;
        
        if (instance.moveCoroutine != null)
        {
            StopCoroutine(instance.moveCoroutine);
        }
        
        activeInstances.Remove(instance);
        
        if (instance.gameObject != null)
        {
            Destroy(instance.gameObject);
        }
    }
    
    /// <summary>
    /// Удалить все активные экземпляры
    /// </summary>
    public void RemoveAllCharacters()
    {
        for (int i = activeInstances.Count - 1; i >= 0; i--)
        {
            RemoveCharacter(activeInstances[i]);
        }
        
        activeInstances.Clear();
    }
    
    private IEnumerator MoveAlongPath(UICharacterInstance instance)
    {
        instance.isMoving = true;
        PathData pathData = instance.pathData;
        
        do
        {
            for (int i = 0; i < pathData.points.Count; i++)
            {
                UIPathPoint point = pathData.points[i];
                
                // Переключаем анимацию если указана
                if (!string.IsNullOrEmpty(point.animationStateName) && instance.animationSwitcher != null)
                {
                    instance.animationSwitcher.SetState(point.animationStateName);
                }
                
                // Движение к точке (пропускаем первую точку если это начало)
                if (i > 0 || instance.hasStartedMoving)
                {
                    yield return MoveToTargetPoint(instance, point);
                }
                else
                {
                    instance.hasStartedMoving = true;
                }
                
                // Достигли точки
                instance.InvokeReachPoint(i);
                
                // Задержка в точке
                if (point.delayAtPoint > 0)
                    yield return new WaitForSeconds(point.delayAtPoint);
            }
            
        } while (pathData.loop && instance.gameObject != null);
        
        instance.isMoving = false;
        instance.InvokePathComplete();
    }
    
    private IEnumerator MoveToTargetPoint(UICharacterInstance instance, UIPathPoint point)
    {
        Vector2 startPos = instance.rectTransform.anchoredPosition;
        Vector2 targetPos = point.position;
        float elapsed = 0f;
        
        while (elapsed < point.duration)
        {
            if (instance.gameObject == null) yield break;
            
            float t = elapsed / point.duration;
            instance.rectTransform.anchoredPosition = Vector2.Lerp(startPos, targetPos, t);
            
            elapsed += Time.deltaTime;
            yield return null;
        }
        
        // Финальная позиция
        if (instance.rectTransform != null)
        {
            instance.rectTransform.anchoredPosition = targetPos;
        }
    }
    
    private void OnDestroy()
    {
        RemoveAllCharacters();
    }
}

/// <summary>
/// Экземпляр движущегося персонажа
/// </summary>
public class UICharacterInstance
{
    public GameObject gameObject;
    public RectTransform rectTransform;
    public UIAnimationStateSwitcher animationSwitcher;
    public PathData pathData;
    public UICharacterPathConfig config;
    
    public bool isMoving;
    public bool hasStartedMoving;
    public Coroutine moveCoroutine;
    
    // События
    public event Action OnPathComplete;
    public event Action<int> OnReachPoint;
    
    // Внутренние методы для вызова событий
    internal void InvokePathComplete() => OnPathComplete?.Invoke();
    internal void InvokeReachPoint(int pointIndex) => OnReachPoint?.Invoke(pointIndex);
}