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

public static class BlinkController
{
    // Интервал мигания по умолчанию (в секундах)
    public static float DefaultInterval = 0.5f;

    // Внутренний раннер для запуска корутин (динамически создаётся при первом использовании)
    private class Runner : MonoBehaviour {
        // При выходе из приложения выключаем все подсветки
        private void OnApplicationQuit()
        {
            BlinkController.TurnAllOff();
        }
    }
    private static Runner _runner;

    // Хранилище запущенных корутин: ключ формируем как "A_1" (тип_игрок)
    private static readonly Dictionary<string, Coroutine> _coroutines = new Dictionary<string, Coroutine>();

    // Убедимся, что раннер существует и живёт на сцене
    private static void EnsureRunner()
    {
        if (_runner != null) return;
        var go = new GameObject("_BlinkControllerRunner");
        Object.DontDestroyOnLoad(go);
        _runner = go.AddComponent<Runner>();
        go.hideFlags = HideFlags.HideAndDontSave;
    }

    // ---- Адресные команды для подсветок A и B (по игроку) ----
    public static void LightAOn(int playerId)  => ComWrapper.Send("2171", playerId);
    public static void LightAOff(int playerId) => ComWrapper.Send("2170", playerId);

    public static void LightBOn(int playerId)  => ComWrapper.Send("2131", playerId);
    public static void LightBOff(int playerId) => ComWrapper.Send("2130", playerId);

    // ---- Глобальная подсветка C (broadcast) ----
    public static void LightCOn()  => ComWrapper.Send("401");
    public static void LightCOff() => ComWrapper.Send("400");

    // ---- Адресные LED диоды (команды 8xxx) ----
    // 81хх - канал 1, 82хх - канал 2, 83хх - канал 3, 84хх - канал 4
    // 80хх - все каналы сразу
    // Программы: 0-None, 1-Repeat, 2-Off, 3-Red, 4-Green, 5-Blue, 6-Gray, 7-White, 9-Rainbow, 10+-Custom
    
    /// <summary>Установить программу на канале LED (1-4) для конкретного игрока</summary>
    public static void SetLEDChannel(int channel, int program, int playerId)
    {
        if (channel < 1 || channel > 4) 
        {
            Debug.LogWarning($"BlinkController: Неверный канал LED {channel}. Допустимо 1-4");
            return;
        }
        if (program < 0 || program > 99)
        {
            Debug.LogWarning($"BlinkController: Неверная программа LED {program}. Допустимо 0-99");
            return;
        }
        string cmd = $"{80 + channel}{program:D2}";
        ComWrapper.Send(cmd, playerId);
        Debug.Log($"BlinkController: LED канал {channel} -> программа {program} для игрока {playerId} (cmd: {cmd})");
    }

    /// <summary>Установить программу на всех LED каналах для конкретного игрока</summary>
    public static void SetLEDAll(int program, int playerId)
    {
        if (program < 0 || program > 99)
        {
            Debug.LogWarning($"BlinkController: Неверная программа LED {program}. Допустимо 0-99");
            return;
        }
        string cmd = $"80{program:D2}";
        ComWrapper.Send(cmd, playerId);
        Debug.Log($"BlinkController: LED все каналы -> программа {program} для игрока {playerId} (cmd: {cmd})");
    }

    /// <summary>Установить программу на всех LED каналах глобально (broadcast)</summary>
    public static void SetLEDAllGlobal(int program)
    {
        if (program < 0 || program > 99)
        {
            Debug.LogWarning($"BlinkController: Неверная программа LED {program}. Допустимо 0-99");
            return;
        }
        string cmd = $"80{program:D2}";
        ComWrapper.Send(cmd);
        Debug.Log($"BlinkController: LED все каналы -> программа {program} глобально (cmd: {cmd})");
    }

    // Быстрые команды для LED (адресные для игрока)
    public static void LEDOff(int channel, int playerId) => SetLEDChannel(channel, 2, playerId);      // Погасить канал
    public static void LEDRed(int channel, int playerId) => SetLEDChannel(channel, 3, playerId);      // Красный
    public static void LEDGreen(int channel, int playerId) => SetLEDChannel(channel, 4, playerId);    // Зеленый
    public static void LEDBlue(int channel, int playerId) => SetLEDChannel(channel, 5, playerId);     // Синий
    public static void LEDWhite(int channel, int playerId) => SetLEDChannel(channel, 7, playerId);    // Белый
    public static void LEDRainbow(int channel, int playerId) => SetLEDChannel(channel, 9, playerId);  // Радуга
    
    public static void LEDWave(int channel, int playerId) => SetLEDChannel(channel, 11, playerId);  // волна
    
    public static void LEDOffAll(int playerId) => SetLEDAll(2, playerId);       // Погасить все для игрока
    public static void LEDRedAll(int playerId) => SetLEDAll(3, playerId);       // Красный на всех для игрока
    public static void LEDGreenAll(int playerId) => SetLEDAll(4, playerId);     // Зеленый на всех для игрока
    public static void LEDBlueAll(int playerId) => SetLEDAll(5, playerId);      // Синий на всех для игрока
    public static void LEDWhiteAll(int playerId) => SetLEDAll(7, playerId);     // Белый на всех для игрока
    public static void LEDRainbowAll(int playerId) => SetLEDAll(9, playerId);   // Радуга на всех для игрока
    
    // Глобальные команды (broadcast для всех игроков)
    public static void LEDOffAllGlobal() => SetLEDAllGlobal(2);       // Погасить все глобально
    public static void LEDRedAllGlobal() => SetLEDAllGlobal(3);       // Красный на всех глобально
    public static void LEDGreenAllGlobal() => SetLEDAllGlobal(4);     // Зеленый на всех глобально
    public static void LEDBlueAllGlobal() => SetLEDAllGlobal(5);      // Синий на всех глобально
    public static void LEDWhiteAllGlobal() => SetLEDAllGlobal(7);     // Белый на всех глобально
    public static void LEDRainbowAllGlobal() => SetLEDAllGlobal(9);   // Радуга на всех глобально

    // ---- Переключение цветового чередования (команды 89x) ----
    public enum ColorSequence
    {
        RGB = 0,  // 890 - Red, Green, Blue
        RBG = 1,  // 891 - Red, Blue, Green
        BRG = 2,  // 892 - Blue, Red, Green
        BGR = 3,  // 893 - Blue, Green, Red
        GRB = 4,  // 894 - Green, Red, Blue
        GBR = 5   // 895 - Green, Blue, Red
    }
    
    /// <summary>Установить цветовое чередование. Если playerId = 0 или не указан - отправка глобально</summary>
    public static void SetColorSequence(ColorSequence sequence, int playerId = 0)
    {
        string cmd = $"89{(int)sequence}";
        
        if (playerId > 0)
        {
            ComWrapper.Send(cmd, playerId);
            Debug.Log($"BlinkController: Цветовое чередование {sequence} для игрока {playerId} (cmd: {cmd})");
        }
        else
        {
            ComWrapper.Send(cmd);
            Debug.Log($"BlinkController: Цветовое чередование {sequence} глобально (cmd: {cmd})");
        }
    }

    // ---- Произвольный RGB цвет (команда 08RRRGGGBBB) ----
    
    /// <summary>Установить произвольный RGB цвет для LED. Если playerId = 0 - отправка глобально</summary>
    /// <param name="r">Красный канал (0-255)</param>
    /// <param name="g">Зеленый канал (0-255)</param>
    /// <param name="b">Синий канал (0-255)</param>
    /// <param name="playerId">ID игрока (0 = глобально)</param>
    /// <summary>Установить произвольный RGB цвет на конкретный канал (81-84)</summary>
    public static void SetLEDChannelCustomColor(int channel, int r, int g, int b, int playerId = 0)
    {
        // Ограничиваем значения
        channel = Mathf.Clamp(channel, 81, 84);
        r = Mathf.Clamp(r, 0, 255);
        g = Mathf.Clamp(g, 0, 255);
        b = Mathf.Clamp(b, 0, 255);
        
        // Формат: 8X (канал) + 08 (программа произвольный цвет) + RRRGGGBBB
        string cmd = $"{channel}08{r:D3}{g:D3}{b:D3}";
        
        if (playerId > 0)
        {
            ComWrapper.Send(cmd, playerId);
            Debug.Log($"BlinkController: LED канал {channel} произвольный цвет RGB({r},{g},{b}) для игрока {playerId} (cmd: {cmd})");
        }
        else
        {
            ComWrapper.Send(cmd);
            Debug.Log($"BlinkController: LED канал {channel} произвольный цвет RGB({r},{g},{b}) глобально (cmd: {cmd})");
        }
    }
    
    /// <summary>Установить произвольный RGB цвет на все каналы (80)</summary>
    public static void SetLEDCustomColor(int r, int g, int b, int playerId = 0)
    {
        // Ограничиваем значения 0-255
        r = Mathf.Clamp(r, 0, 255);
        g = Mathf.Clamp(g, 0, 255);
        b = Mathf.Clamp(b, 0, 255);
        
        // Формат: 80 (все каналы) + 08 (программа произвольный цвет) + RRRGGGBBB
        string cmd = $"8008{r:D3}{g:D3}{b:D3}";
        
        if (playerId > 0)
        {
            ComWrapper.Send(cmd, playerId);
            Debug.Log($"BlinkController: LED произвольный цвет RGB({r},{g},{b}) для игрока {playerId} (cmd: {cmd})");
        }
        else
        {
            ComWrapper.Send(cmd);
            Debug.Log($"BlinkController: LED произвольный цвет RGB({r},{g},{b}) глобально (cmd: {cmd})");
        }
    }
    
    // Предустановленные цвета
    public static void LEDGold(int playerId = 0) => SetLEDCustomColor(255, 215, 0, playerId);     // Золотой
    public static void LEDOrange(int playerId = 0) => SetLEDCustomColor(255, 165, 0, playerId);   // Оранжевый
    public static void LEDPurple(int playerId = 0) => SetLEDCustomColor(128, 0, 128, playerId);   // Фиолетовый
    public static void LEDPink(int playerId = 0) => SetLEDCustomColor(255, 192, 203, playerId);   // Розовый
    public static void LEDCyan(int playerId = 0) => SetLEDCustomColor(0, 255, 255, playerId);     // Голубой
    public static void LEDYellow(int playerId = 0) => SetLEDCustomColor(255, 255, 0, playerId);   // Желтый

    // ---- Мигание LED с возвратом к базовому цвету ----
    private static readonly Dictionary<int, int> _playerBaseLEDColor = new Dictionary<int, int>();
    
    // Храним кастомные RGB цвета для каждого игрока (если установлен)
    private static readonly Dictionary<int, Vector3Int> _playerCustomLEDColor = new Dictionary<int, Vector3Int>();

    /// <summary>Установить базовый цвет LED для игрока (к которому возвращаемся после мигания)</summary>
    public static void SetLEDBaseColor(int playerId, int program)
    {
        _playerBaseLEDColor[playerId] = program;
        _playerCustomLEDColor.Remove(playerId); // Убираем кастомный цвет
        SetLEDAll(program, playerId);
        Debug.Log($"BlinkController: Базовый LED цвет для игрока {playerId} установлен: {program}");
    }
    
    /// <summary>Установить базовый кастомный RGB цвет LED для игрока</summary>
    public static void SetLEDBaseCustomColor(int playerId, int r, int g, int b)
    {
        _playerBaseLEDColor[playerId] = -1; // Маркер кастомного цвета
        _playerCustomLEDColor[playerId] = new Vector3Int(r, g, b);
        SetLEDCustomColor(r, g, b, playerId);
        Debug.Log($"BlinkController: Базовый кастомный LED цвет для игрока {playerId} установлен: RGB({r},{g},{b})");
    }

    /// <summary>Получить базовый цвет LED для игрока</summary>
    public static int GetLEDBaseColor(int playerId)
    {
        return _playerBaseLEDColor.TryGetValue(playerId, out int color) ? color : 5; // По умолчанию синий (5)
    }
    
    /// <summary>Восстановить базовый цвет LED для игрока (включая кастомные RGB)</summary>
    public static void RestoreLEDBaseColor(int playerId)
    {
        if (_playerCustomLEDColor.TryGetValue(playerId, out Vector3Int rgb))
        {
            // Восстанавливаем кастомный цвет
            SetLEDCustomColor(rgb.x, rgb.y, rgb.z, playerId);
        }
        else
        {
            // Восстанавливаем обычный цвет по программе
            int baseColor = GetLEDBaseColor(playerId);
            SetLEDAll(baseColor, playerId);
        }
    }

    /// <summary>Мигание LED N раз цветом, затем возврат к базовому цвету</summary>
    public static void BlinkLED(int playerId, int colorProgram, int times, float interval = 0.3f)
    {
        EnsureRunner();
        _runner.StartCoroutine(BlinkLEDRoutine(playerId, colorProgram, times, interval));
    }

    private static IEnumerator BlinkLEDRoutine(int playerId, int colorProgram, int times, float interval)
    {
        for (int i = 0; i < times; i++)
        {
            // Включить цвет
            SetLEDAll(colorProgram, playerId);
            yield return new WaitForSeconds(interval);
            
            // Вернуть базовый цвет (включая кастомные RGB)
            RestoreLEDBaseColor(playerId);
            
            // Пауза между миганиями (кроме последнего)
            if (i < times - 1)
                yield return new WaitForSeconds(interval);
        }
    }

    // Быстрые команды мигания
    public static void BlinkLEDRed(int playerId, int times = 1, float interval = 0.3f) 
        => BlinkLED(playerId, 3, times, interval);
    
    public static void BlinkLEDGreen(int playerId, int times = 1, float interval = 0.3f) 
        => BlinkLED(playerId, 4, times, interval);
    
    public static void BlinkLEDBlue(int playerId, int times = 1, float interval = 0.3f) 
        => BlinkLED(playerId, 5, times, interval);

    // ---- Start/Stop мигания ----
    public static void StartBlinkA(int playerId, float interval = -1f)
    {
        // Оставляем обратную совместимость: бесконечное мигание
        StartBlinkATimes(playerId, -1, interval);
    }

    // Мигание N раз (N <= 0 = бесконечно)
    public static void StartBlinkATimes(int playerId, int times, float interval = -1f)
    {
        StopBlinkA(playerId);
        EnsureRunner();
        string key = KeyFor("A", playerId);
        var coro = _runner.StartCoroutine(BlinkRoutinePlayer(key, playerId, "2170", "2171", interval > 0 ? interval : DefaultInterval, times));
        _coroutines[key] = coro;
    }

    public static void StopBlinkA(int playerId)
    {
        string key = KeyFor("A", playerId);
        StopAndRemove(key);
        LightAOff(playerId);
    }

    public static void StartBlinkB(int playerId, float interval = -1f)
    {
        // Оставляем обратную совместимость: бесконечное мигание
        StartBlinkBTimes(playerId, -1, interval);
    }

    // Мигание N раз (N <= 0 = бесконечно)
    public static void StartBlinkBTimes(int playerId, int times, float interval = -1f)
    {
        StopBlinkB(playerId);
        EnsureRunner();
        string key = KeyFor("B", playerId);
        var coro = _runner.StartCoroutine(BlinkRoutinePlayer(key, playerId, "2130", "2131", interval > 0 ? interval : DefaultInterval, times));
        _coroutines[key] = coro;
    }

    public static void StopBlinkB(int playerId)
    {
        string key = KeyFor("B", playerId);
        StopAndRemove(key);
        LightBOff(playerId);
    }

    // Глобальная C
    public static void StartBlinkC(float interval = -1f)
    {
        // Оставляем обратную совместимость: бесконечное мигание
        StartBlinkCTimes(-1, interval);
    }

    // Мигание N раз глобально (N <= 0 = бесконечно)
    public static void StartBlinkCTimes(int times, float interval = -1f)
    {
        StopBlinkC();
        EnsureRunner();
        string key = KeyFor("C", 0);
        var coro = _runner.StartCoroutine(BlinkRoutineGlobal(key, "400", "401", interval > 0 ? interval : DefaultInterval, times));
        _coroutines[key] = coro;
    }

    public static void StopBlinkC()
    {
        string key = KeyFor("C", 0);
        StopAndRemove(key);
        LightCOff();
    }

    private static void StopAndRemove(string key)
    {
        if (_coroutines.TryGetValue(key, out Coroutine c))
        {
            if (_runner != null && c != null) _runner.StopCoroutine(c);
            _coroutines.Remove(key);
        }
    }

    private static string KeyFor(string type, int playerId) => $"{type}_{playerId}";

    private static IEnumerator BlinkRoutinePlayer(string key, int playerId, string onCmd, string offCmd, float interval, int repeatCount)
    {
        // repeatCount <= 0 => бесконечно
        if (repeatCount <= 0)
        {
            while (true)
            {
                ComWrapper.Send(onCmd, playerId);
                yield return new WaitForSeconds(interval);
                ComWrapper.Send(offCmd, playerId);
                yield return new WaitForSeconds(interval);
            }
        }

        // Повторяем заданное количество раз
        for (int i = 0; i < repeatCount; i++)
        {
            ComWrapper.Send(onCmd, playerId);
            yield return new WaitForSeconds(interval);
            ComWrapper.Send(offCmd, playerId);
            // Между итерациями делаем паузу, как в обычном мигании, кроме последней
            if (i < repeatCount - 1) yield return new WaitForSeconds(interval);
        }

        // Гарантируем, что команда выключения послана
        ComWrapper.Send(offCmd, playerId);

        // Удаляем запись о корутине
        try { _coroutines.Remove(key); } catch { }
    }

    private static IEnumerator BlinkRoutineGlobal(string key, string onCmd, string offCmd, float interval, int repeatCount)
    {
        if (repeatCount <= 0)
        {
            while (true)
            {
                ComWrapper.Send(onCmd);
                yield return new WaitForSeconds(interval);
                ComWrapper.Send(offCmd);
                yield return new WaitForSeconds(interval);
            }
        }

        for (int i = 0; i < repeatCount; i++)
        {
            ComWrapper.Send(onCmd);
            yield return new WaitForSeconds(interval);
            ComWrapper.Send(offCmd);
            if (i < repeatCount - 1) yield return new WaitForSeconds(interval);
        }

        ComWrapper.Send(offCmd);
        try { _coroutines.Remove(key); } catch { }
    }

    // Вспомогательные: мгновенный вкл/выкл всех
    public static void StopAll()
    {
        var keys = new List<string>(_coroutines.Keys);
        foreach (var k in keys) StopAndRemove(k);
    }

    // Включить все подсветки (A и B — для обоих игроков, C — глобально)
    public static void TurnAllOn()
    {
        Debug.Log("BlinkController: TurnAllOn");
        // A и B адресные — для игроков 1 и 2
        LightAOn(1);
        LightAOn(2);
        LightBOn(1);
        LightBOn(2);
        // C — глобально
        LightCOn();
        
        // LED - при старте: канал 1 волна, канал 2 радуга для обоих игроков
        LEDWave(1, 1);      // Игрок 1: канал 1 -> волна
        LEDRainbow(2, 1);   // Игрок 1: канал 2 -> радуга
        LEDWave(1, 2);      // Игрок 2: канал 1 -> волна
        LEDRainbow(2, 2);   // Игрок 2: канал 2 -> радуга
        
        // Устанавливаем базовый цвет - радуга (для мигания будет возврат к ней)
        _playerBaseLEDColor[1] = 9;
        _playerBaseLEDColor[2] = 9;
    }

    // Выключить все подсветки (и остановить корутины)
    public static void TurnAllOff()
    {
        Debug.Log("BlinkController: TurnAllOff");
        // Остановим все мигания
        StopAll();

        // Отправим команды выключения адресно для игроков 1 и 2
        try
        {
            LightAOff(1);
            LightAOff(2);
            LightBOff(1);
            LightBOff(2);
            // C — глобально
            LightCOff();
            // LED - выключить все каналы глобально
            LEDOffAllGlobal();
        }
        catch (System.Exception e)
        {
            Debug.LogWarning($"BlinkController: ошибка при TurnAllOff: {e.Message}");
        }
    }

    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
    private static void OnRuntimeInitialized()
    {
        // Подписываемся на событие инициализации ComWrapper — включим подсветки, когда COM будет готов
        try
        {
            ComWrapper.OnInitialize += TurnAllOn;
            // Подписываемся, чтобы выключить подсветки ДО закрытия портов
            ComWrapper.OnBeforeClose += TurnAllOff;
        }
        catch
        {
            // Если ComWrapper ещё не существует или не определён, проигнорируем — вызов произойдёт при инициализации
        }

        // Создаём раннер заранее, чтобы он был доступен и гарантированно существовал
        EnsureRunner();

        // Подпишемся на событие выхода приложения — гарантированно выключит подсветки и почистит подписки
        Application.quitting += OnApplicationQuitting;
    }

    // Обработчик выхода приложения: отписываемся от событий ComWrapper
    private static void OnApplicationQuitting()
    {
        try { ComWrapper.OnInitialize -= TurnAllOn; } catch { }
        try { ComWrapper.OnBeforeClose -= TurnAllOff; } catch { }
        try { TurnAllOff(); } catch { }
        if (_runner != null)
        {
            Object.Destroy(_runner.gameObject);
            _runner = null;
        }
    }
}