using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using Vanguard.Api;
using Vanguard.Api.Contracts;
using Vanguard.Auth;
using Vanguard.Battle;
using Vanguard.Meta;

namespace Vanguard.UI
{
    /// <summary>
    /// Декбилдер: слева коллекция с мультифильтрами, справа панель, которая
    /// показывает либо список колод, либо карты открытой колоды.
    /// </summary>
    public sealed class DeckBuilderView
    {
        private const float PanelWidth = 420f;
        private const float RowHeight = 92f;

        private static readonly Color TextPrimary = new Color(0.88f, 0.93f, 1f);
        private static readonly Color TextMuted = new Color(0.62f, 0.70f, 0.84f);
        private static readonly Color TextDim = new Color(0.50f, 0.58f, 0.72f);
        private static readonly Color Accent = new Color(0.30f, 0.65f, 1f);
        private static readonly Color PanelFill = new Color(0.06f, 0.08f, 0.14f, 0.96f);
        private static readonly Color RowFill = new Color(0.08f, 0.11f, 0.18f, 1f);
        private static readonly Color ChipOn = new Color(0.16f, 0.40f, 0.80f, 0.95f);
        private static readonly Color ChipOff = new Color(0.05f, 0.10f, 0.22f, 0.9f);

        private readonly MetaService _meta;
        private readonly AuthService _auth;
        private readonly Action<DeckDto> _onPlay;
        private readonly Action<MatchConnectionInfo> _onPracticeStarted;

        private readonly RectTransform _root;
        private RectTransform _collectionContent;
        private RectTransform _deckListPanel;
        private RectTransform _deckPanel;
        private RectTransform _deckListContent;
        private RectTransform _deckCardContent;
        private InputField _nameInput;
        private Text _status;
        private Text _filterSummary;
        private Text _stats;
        private Text _deckCount;
        private Button _saveButton;
        private Button _botButton;
        private Button _duelButton;
        private Button _deleteButton;
        private RectTransform _deckMenuOverlay;
        private Text _deckMenuTitle;
        private DeckDto _deckMenuDeck;

        private RectTransform _filterOverlay;
        private RectTransform _rarityChips;
        private RectTransform _gradeChips;
        private RectTransform _triggerChips;
        private RectTransform _clanChips;
        private RectTransform _confirmOverlay;
        private InputField _searchInput;
        private Text _confirmText;
        private DeckDto _pendingDelete;

        private RectTransform _cardOverlay;
        private Image _cardArt;
        private Text _cardArtName;
        private Text _cardTitle;
        private Text _cardSubtitle;
        private Text _cardStats;
        private Text _cardAbilities;
        private Text _cardOwned;
        private Text _cardStatus;
        private Button _dismantleButton;
        private Button _craftButton;
        private CollectionItemDto _selectedItem;
        private CardCatalogItemDto _selectedMeta;

        private readonly List<DeckDto> _decks = new List<DeckDto>();
        private readonly List<CollectionItemDto> _collection = new List<CollectionItemDto>();
        private readonly Dictionary<string, CardCatalogItemDto> _catalog =
            new Dictionary<string, CardCatalogItemDto>(StringComparer.Ordinal);
        private readonly List<string> _cards = new List<string>();
        private readonly Dictionary<string, Text> _countTexts =
            new Dictionary<string, Text>(StringComparer.Ordinal);

        private readonly DeckFilter _filter = new DeckFilter();
        private readonly DeckFilter _draftFilter = new DeckFilter();

        private DeckDto _editing;
        private int _dust;
        private bool _dirty;
        private bool _deckOpen;
        private bool _loading;
        private bool _busy;

        public DeckBuilderView(
            Transform parent,
            MetaService meta,
            AuthService auth,
            Action onBack,
            Action<DeckDto> onPlay,
            Action<MatchConnectionInfo> onPracticeStarted)
        {
            _meta = meta;
            _auth = auth;
            _onPlay = onPlay;
            _onPracticeStarted = onPracticeStarted;

            _root = UiKit.CreatePanel(parent, "DeckBuilderScreen", new Color(0.018f, 0.03f, 0.06f, 0.97f));
            BuildBody();
            _filterOverlay = BuildFilterOverlay();
            _confirmOverlay = BuildDeleteConfirm();
            _deckMenuOverlay = BuildDeckMenu();
            _cardOverlay = BuildCardOverlay();

            _filterOverlay.gameObject.SetActive(false);
            _confirmOverlay.gameObject.SetActive(false);
            _deckMenuOverlay.gameObject.SetActive(false);
            _cardOverlay.gameObject.SetActive(false);
            _root.gameObject.SetActive(false);
        }

        public RectTransform Root => _root;

        /// <summary>Esc: закрывает верхний оверлей, если он открыт.</summary>
        public void CloseTopmost()
        {
            if (_cardOverlay.gameObject.activeSelf)
            {
                CloseCardOverlay();
                return;
            }

            if (_confirmOverlay.gameObject.activeSelf)
            {
                CancelDelete();
                return;
            }

            if (_deckMenuOverlay.gameObject.activeSelf)
            {
                CloseDeckMenu();
                return;
            }

            if (_filterOverlay.gameObject.activeSelf)
                CloseFilters();
        }

        public void Show()
        {
            UiKit.SetActive(_root, true);
            ShowDeckList();
            _ = LoadAsync();
        }

        public void Hide()
        {
            _filterOverlay.gameObject.SetActive(false);
            _confirmOverlay.gameObject.SetActive(false);
            _deckMenuOverlay.gameObject.SetActive(false);
            _cardOverlay.gameObject.SetActive(false);
            _root.gameObject.SetActive(false);
        }

        // ------------------------------------------------------------ каркас

        private void BuildBody()
        {
            var body = UiKit.CreatePanel(_root, "Body", new Color(0f, 0f, 0f, 0f));
            body.anchorMin = Vector2.zero;
            body.anchorMax = Vector2.one;
            body.offsetMin = new Vector2(34f, 24f);
            body.offsetMax = new Vector2(-34f, -120f);
            UiKit.AddHorizontalLayout(body, 0, 14);
            var bodyLayout = body.GetComponent<HorizontalLayoutGroup>();
            if (bodyLayout != null)
                bodyLayout.childForceExpandWidth = false;

            var collectionArea = UiKit.CreatePanel(
                body, "CollectionArea", new Color(0.04f, 0.06f, 0.10f, 0.55f));
            var collectionElement = collectionArea.gameObject.AddComponent<LayoutElement>();
            collectionElement.flexibleWidth = 1f;
            collectionElement.flexibleHeight = 1f;
            collectionElement.minHeight = 300f;
            UiKit.AddVerticalLayout(collectionArea, 8, 6);

            var filterBar = UiKit.CreatePanel(collectionArea, "FilterBar", new Color(0f, 0f, 0f, 0f));
            UiKit.SetPreferredHeight(filterBar, 44f);
            UiKit.AddHorizontalLayout(filterBar, 0, 8);

            _filterSummary = UiKit.CreateText(
                filterBar, "FilterSummary", "Все карты", 15, TextMuted, TextAnchor.MiddleLeft);
            _filterSummary.horizontalOverflow = HorizontalWrapMode.Wrap;
            SetFlexible(_filterSummary, 1f, 44f);

            var filters = UiKit.CreateButton(filterBar, "Filters", "Фильтры", OpenFilters, 16);
            SetFixedSize(filters, 110f, 38f);

            var reset = UiKit.CreateButton(filterBar, "ResetFilters", "Сброс", ResetFilters, 16);
            SetFixedSize(reset, 90f, 38f);

            var scroll = UiKit.CreateGridScrollView(
                collectionArea,
                "CollectionGrid",
                new Vector2(270f, 440f),
                new Vector2(14f, 14f),
                out _collectionContent);
            var scrollElement = scroll.gameObject.AddComponent<LayoutElement>();
            scrollElement.flexibleHeight = 1f;
            scrollElement.minHeight = 220f;

            var grid = _collectionContent.GetComponent<GridLayoutGroup>();
            if (grid != null)
                grid.childAlignment = TextAnchor.UpperLeft;

            _status = UiKit.CreateText(
                collectionArea, "Status", string.Empty, 15,
                TextMuted, TextAnchor.MiddleLeft);
            _status.horizontalOverflow = HorizontalWrapMode.Wrap;
            UiKit.SetPreferredHeight(_status, 30f);

            var right = UiKit.CreatePanel(
                body, "RightPanel", new Color(0.04f, 0.06f, 0.10f, 0.85f));
            var rightElement = right.gameObject.AddComponent<LayoutElement>();
            rightElement.preferredWidth = PanelWidth;
            rightElement.minWidth = PanelWidth;
            rightElement.flexibleWidth = 0f;
            rightElement.flexibleHeight = 1f;
            rightElement.minHeight = 300f;

            _deckListPanel = BuildDeckListPanel(right);
            _deckPanel = BuildDeckPanel(right);
            _deckListPanel.gameObject.SetActive(true);
            _deckPanel.gameObject.SetActive(false);
        }

        private RectTransform BuildDeckListPanel(RectTransform parent)
        {
            var panel = UiKit.CreatePanel(parent, "DeckListPanel", new Color(0f, 0f, 0f, 0f));
            UiKit.Stretch(panel);
            UiKit.AddVerticalLayout(panel, 10, 8);

            var create = UiKit.CreateButton(panel, "Create", "+ Новый набор", NewDeck, 17);
            UiKit.SetPreferredHeight(create, 52f);
            SetButtonColor(create, new Color(0.10f, 0.28f, 0.58f, 0.95f));

            var scroll = UiKit.CreateScrollView(panel, "DeckListScroll", out _deckListContent, 8f);
            var scrollElement = scroll.gameObject.AddComponent<LayoutElement>();
            scrollElement.flexibleHeight = 1f;
            scrollElement.minHeight = 200f;

            var hint = UiKit.CreateText(
                panel, "Hint", "Нажмите на колоду,\nчтобы открыть редактор.", 13,
                TextDim, TextAnchor.MiddleLeft);
            hint.horizontalOverflow = HorizontalWrapMode.Wrap;
            UiKit.SetPreferredHeight(hint, 42f);

            return panel;
        }

        private RectTransform BuildDeckPanel(RectTransform parent)
        {
            var panel = UiKit.CreatePanel(parent, "DeckPanel", new Color(0f, 0f, 0f, 0f));
            UiKit.Stretch(panel);
            UiKit.AddVerticalLayout(panel, 10, 6);

            var header = UiKit.CreatePanel(panel, "Header", new Color(0f, 0f, 0f, 0f));
            UiKit.SetPreferredHeight(header, 36f);
            UiKit.AddHorizontalLayout(header, 0, 8);

            var back = UiKit.CreateButton(header, "BackToList", "← К списку колод", BackToDeckList, 14);
            SetFixedSize(back, 180f, 34f);

            _deckCount = UiKit.CreateText(
                header, "DeckCount", "0/50", 16, TextPrimary, TextAnchor.MiddleRight);
            _deckCount.fontStyle = FontStyle.Bold;
            SetFlexible(_deckCount, 1f, 34f);

            _nameInput = UiKit.CreateInput(panel, "Name", "Название колоды");
            UiKit.SetPreferredHeight(_nameInput, 44f);
            _nameInput.onValueChanged.AddListener(_ =>
            {
                _dirty = true;
                UpdateStats();
            });

            _stats = UiKit.CreateText(
                panel, "Stats", string.Empty, 13, TextMuted, TextAnchor.UpperLeft);
            _stats.horizontalOverflow = HorizontalWrapMode.Wrap;
            UiKit.SetPreferredHeight(_stats, 44f);

            var scroll = UiKit.CreateScrollView(panel, "DeckCardScroll", out _deckCardContent, 6f);
            var scrollElement = scroll.gameObject.AddComponent<LayoutElement>();
            scrollElement.flexibleHeight = 1f;
            scrollElement.minHeight = 200f;

            _saveButton = UiKit.CreateButton(panel, "Save", "Сохранить", SaveDeck, 16);
            UiKit.SetPreferredHeight(_saveButton, 42f);

            var row = UiKit.CreatePanel(panel, "Actions", new Color(0f, 0f, 0f, 0f));
            UiKit.SetPreferredHeight(row, 40f);
            UiKit.AddHorizontalLayout(row, 0, 8);

            _botButton = UiKit.CreateButton(row, "Bot", "С ботом", PlayBot, 15);
            _duelButton = UiKit.CreateButton(row, "Duel", "В бой", PlayDeck, 15);
            SetFlexible(_botButton, 1f, 38f);
            SetFlexible(_duelButton, 1f, 38f);

            _deleteButton = UiKit.CreateButton(panel, "Delete", "Удалить колоду", RequestDeleteCurrent, 14);
            UiKit.SetPreferredHeight(_deleteButton, 34f);
            SetButtonColor(_deleteButton, new Color(0.30f, 0.08f, 0.11f, 0.95f));

            var hint = UiKit.CreateText(
                panel, "Hint", "ЛКМ — убрать копию,\nПКМ — посмотреть карту.", 13,
                TextDim, TextAnchor.MiddleLeft);
            hint.horizontalOverflow = HorizontalWrapMode.Wrap;
            UiKit.SetPreferredHeight(hint, 36f);

            return panel;
        }

        // ------------------------------------------------------------ оверлеи

        private RectTransform BuildFilterOverlay()
        {
            var overlay = UiKit.CreatePanel(_root, "FilterOverlay", new Color(0f, 0f, 0f, 0.78f));

            var card = UiKit.CreateCenteredCard(
                overlay, "FilterCard", new Vector2(900f, 940f), PanelFill);
            UiKit.AddVerticalLayout(card, 24, 10);

            var title = UiKit.CreateText(card, "Title", "Фильтры коллекции", 28, TextPrimary);
            title.fontStyle = FontStyle.Bold;
            UiKit.SetPreferredHeight(title, 40f);

            _searchInput = UiKit.CreateInput(card, "Search", "Поиск по названию");
            UiKit.SetPreferredHeight(_searchInput, 44f);
            _searchInput.onValueChanged.AddListener(value => _draftFilter.Search = value);

            _rarityChips = BuildFilterSection(card, "Редкость", 44f);
            _gradeChips = BuildFilterSection(card, "Ранг", 44f);
            _triggerChips = BuildFilterSection(card, "Триггер", 44f);
            _clanChips = BuildFilterSection(card, "Клан", 260f, flexible: true);

            var footer = UiKit.CreatePanel(card, "Footer", new Color(0f, 0f, 0f, 0f));
            UiKit.SetPreferredHeight(footer, 48f);
            UiKit.AddHorizontalLayout(footer, 0, 8);

            var reset = UiKit.CreateButton(footer, "Reset", "Сбросить", ResetDraftFilters, 16);
            SetFixedSize(reset, 200f, 44f);

            var cancel = UiKit.CreateButton(footer, "Cancel", "Отмена", CloseFilters, 16);
            SetFixedSize(cancel, 180f, 44f);

            var apply = UiKit.CreateButton(footer, "Apply", "Применить", ApplyFilters, 16);
            SetFixedSize(apply, 220f, 44f);

            return overlay;
        }

        private static RectTransform BuildFilterSection(
            RectTransform parent,
            string title,
            float height,
            bool flexible = false)
        {
            var caption = UiKit.CreateText(
                parent, "Caption_" + title, title, 17, TextMuted, TextAnchor.MiddleLeft);
            UiKit.SetPreferredHeight(caption, 24f);

            var container = UiKit.CreatePanel(parent, "Chips_" + title, new Color(0f, 0f, 0f, 0f));
            var element = container.gameObject.AddComponent<LayoutElement>();
            element.preferredHeight = height;
            if (flexible)
            {
                element.flexibleHeight = 1f;
                element.minHeight = 140f;
            }
            else
            {
                element.flexibleHeight = 0f;
            }

            if (flexible)
            {
                var scroll = UiKit.CreateScrollView(container, "Scroll", out var content, 4f);
                UiKit.Stretch(scroll);
                return content;
            }

            UiKit.AddHorizontalLayout(container, 0, 6);
            return container;
        }

        private RectTransform BuildDeckMenu()
        {
            var overlay = UiKit.CreatePanel(_root, "DeckMenuOverlay", new Color(0f, 0f, 0f, 0.78f));

            var card = UiKit.CreateCenteredCard(
                overlay, "MenuCard", new Vector2(520f, 320f), PanelFill);
            UiKit.AddVerticalLayout(card, 28, 10);

            _deckMenuTitle = UiKit.CreateText(
                card, "Title", string.Empty, 24, TextPrimary);
            _deckMenuTitle.fontStyle = FontStyle.Bold;
            UiKit.MakeLiteral(_deckMenuTitle);
            UiKit.SetPreferredHeight(_deckMenuTitle, 40f);

            var open = UiKit.CreateButton(card, "Open", "Открыть", OpenDeckFromMenu, 17);
            UiKit.SetPreferredHeight(open, 48f);

            var delete = UiKit.CreateButton(card, "Delete", "Удалить", DeleteDeckFromMenu, 17);
            UiKit.SetPreferredHeight(delete, 48f);
            SetButtonColor(delete, new Color(0.30f, 0.08f, 0.11f, 0.95f));

            var cancel = UiKit.CreateButton(card, "Cancel", "Отмена", CloseDeckMenu, 17);
            UiKit.SetPreferredHeight(cancel, 48f);

            return overlay;
        }

        private RectTransform BuildDeleteConfirm()
        {
            var overlay = UiKit.CreatePanel(
                _root, "DeleteDeckConfirm", new Color(0f, 0f, 0f, 0.78f));

            var card = UiKit.CreateCenteredCard(
                overlay, "ConfirmCard", new Vector2(640f, 300f), PanelFill);
            UiKit.AddVerticalLayout(card, 30, 12);

            var title = UiKit.CreateText(card, "Title", "Удалить колоду?", 28, TextPrimary);
            title.fontStyle = FontStyle.Bold;
            UiKit.SetPreferredHeight(title, 42f);

            _confirmText = UiKit.CreateText(
                card, "Text", string.Empty, 19, TextMuted);
            UiKit.SetPreferredHeight(_confirmText, 70f);

            var yes = UiKit.CreateButton(card, "Yes", "Удалить", ConfirmDelete, 20);
            UiKit.SetPreferredHeight(yes, 48f);

            var no = UiKit.CreateButton(card, "No", "Отмена", CancelDelete, 20);
            UiKit.SetPreferredHeight(no, 44f);

            return overlay;
        }

        private RectTransform BuildCardOverlay()
        {
            var overlay = UiKit.CreatePanel(_root, "CardOverlay", new Color(0f, 0f, 0f, 0.82f));
            var card = UiKit.CreateCenteredCard(
                overlay, "CardView", new Vector2(1040f, 660f), new Color(0.05f, 0.07f, 0.11f, 1f));

            var body = UiKit.CreatePanel(card, "Body", new Color(0f, 0f, 0f, 0f));
            body.anchorMin = Vector2.zero;
            body.anchorMax = Vector2.one;
            body.offsetMin = new Vector2(26f, 26f);
            body.offsetMax = new Vector2(-26f, -26f);
            UiKit.AddHorizontalLayout(body, 0, 22);

            var art = UiKit.CreatePanel(body, "Art", new Color(0.2f, 0.3f, 0.5f, 1f));
            SetFixedSize(art, 360f, 540f);
            _cardArt = art.GetComponent<Image>();

            _cardArtName = UiKit.CreateText(
                art, "ArtName", string.Empty, 18,
                new Color(1f, 1f, 1f, 0.92f), TextAnchor.MiddleCenter);
            UiKit.MakeLiteral(_cardArtName);
            UiKit.Stretch(_cardArtName.rectTransform);
            _cardArtName.rectTransform.offsetMin = new Vector2(14f, 16f);
            _cardArtName.rectTransform.offsetMax = new Vector2(-14f, -16f);
            _cardArtName.horizontalOverflow = HorizontalWrapMode.Wrap;

            var info = UiKit.CreatePanel(body, "Info", new Color(0f, 0f, 0f, 0f));
            var infoElement = info.gameObject.AddComponent<LayoutElement>();
            infoElement.flexibleWidth = 1f;
            infoElement.flexibleHeight = 1f;
            UiKit.AddVerticalLayout(info, 4, 6);

            _cardTitle = UiKit.CreateText(
                info, "Title", string.Empty, 30, Color.white, TextAnchor.MiddleLeft);
            UiKit.MakeLiteral(_cardTitle);
            _cardTitle.fontStyle = FontStyle.Bold;
            _cardTitle.horizontalOverflow = HorizontalWrapMode.Wrap;
            UiKit.SetPreferredHeight(_cardTitle, 44f);

            _cardSubtitle = UiKit.CreateText(
                info, "Subtitle", string.Empty, 16, TextMuted, TextAnchor.MiddleLeft);
            UiKit.MakeLiteral(_cardSubtitle);
            UiKit.SetPreferredHeight(_cardSubtitle, 26f);

            _cardStats = UiKit.CreateText(
                info, "Stats", string.Empty, 15,
                new Color(0.72f, 0.78f, 0.92f), TextAnchor.UpperLeft);
            _cardStats.horizontalOverflow = HorizontalWrapMode.Wrap;
            UiKit.SetPreferredHeight(_cardStats, 88f);

            var abilitiesCaption = UiKit.CreateText(
                info, "AbilitiesCaption", "Способности", 16, TextMuted, TextAnchor.MiddleLeft);
            UiKit.SetPreferredHeight(abilitiesCaption, 24f);

            _cardAbilities = UiKit.CreateText(
                info, "Abilities", string.Empty, 15,
                new Color(0.82f, 0.86f, 0.96f), TextAnchor.UpperLeft);
            UiKit.MakeLiteral(_cardAbilities);
            _cardAbilities.horizontalOverflow = HorizontalWrapMode.Wrap;
            var abilitiesElement = _cardAbilities.gameObject.AddComponent<LayoutElement>();
            abilitiesElement.flexibleHeight = 1f;
            abilitiesElement.minHeight = 100f;

            _cardOwned = UiKit.CreateText(
                info, "Owned", string.Empty, 15,
                new Color(0.98f, 0.82f, 0.42f), TextAnchor.MiddleLeft);
            UiKit.SetPreferredHeight(_cardOwned, 24f);

            _cardStatus = UiKit.CreateText(
                info, "Status", string.Empty, 14, TextDim, TextAnchor.UpperLeft);
            _cardStatus.horizontalOverflow = HorizontalWrapMode.Wrap;
            UiKit.SetPreferredHeight(_cardStatus, 38f);

            var actions = UiKit.CreatePanel(info, "Actions", new Color(0f, 0f, 0f, 0f));
            UiKit.SetPreferredHeight(actions, 50f);
            UiKit.AddHorizontalLayout(actions, 0, 8);

            _dismantleButton = UiKit.CreateButton(
                actions, "Dismantle", "Разобрать", DismantleSelected, 16);
            SetFixedSize(_dismantleButton, 225f, 46f);

            _craftButton = UiKit.CreateButton(
                actions, "Craft", "Скрафтить", CraftSelected, 16);
            SetFixedSize(_craftButton, 225f, 46f);

            var close = UiKit.CreateButton(actions, "Close", "Закрыть", CloseCardOverlay, 16);
            SetFixedSize(close, 110f, 46f);

            return overlay;
        }

        // ------------------------------------------------------------ загрузка

        private async Task LoadAsync()
        {
            if (_loading)
                return;

            _loading = true;
            SetStatus("Загружаем коллекцию и колоды…", false);
            ClearChildren(_deckListContent);

            try
            {
                await _auth.EnsureAccessAsync();
                var collection = await _meta.GetCollectionAsync();
                var catalog = await _meta.GetCatalogAsync();
                var decks = await _meta.GetDecksAsync();
                if (!_root.gameObject.activeSelf)
                    return;

                _collection.Clear();
                _collection.AddRange(collection.Items ?? new List<CollectionItemDto>());
                _dust = collection.Balances != null ? collection.Balances.Dust : 0;
                _catalog.Clear();
                foreach (var item in catalog)
                    _catalog[item.PrintingId] = item;

                _decks.Clear();
                _decks.AddRange(decks);
                BuildDeckList();
                RebuildCollection();
                SetStatus(
                    _decks.Count == 0
                        ? "Колод пока нет. Пыль: " + _dust + ". ПКМ по карте — подробности."
                        : "Карт в коллекции: " + _collection.Count + " · пыль " + _dust
                          + " · ПКМ по карте — подробности.",
                    false);
            }
            catch (ApiException exception)
            {
                SetStatus(exception.Message, true);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
                SetStatus("Не удалось загрузить декбилдер.", true);
            }
            finally
            {
                _loading = false;
            }
        }

        // ------------------------------------------------------------ список колод

        private void BuildDeckList()
        {
            ClearChildren(_deckListContent);

            if (_decks.Count == 0)
            {
                var empty = UiKit.CreateText(
                    _deckListContent, "Empty", "Нет колод", 15, TextDim);
                UiKit.SetPreferredHeight(empty, 90f);
                return;
            }

            foreach (var deck in _decks)
            {
                var row = UiKit.CreatePanel(
                    _deckListContent, "DeckRow_" + deck.Id, RowFill);
                var rowElement = row.gameObject.AddComponent<LayoutElement>();
                rowElement.preferredHeight = RowHeight;

                var button = row.gameObject.AddComponent<Button>();
                button.targetGraphic = row.GetComponent<Image>();
                button.onClick.AddListener(() => OpenDeck(deck));

                var isOpen = _editing != null && _editing.Id == deck.Id;
                row.GetComponent<Image>().color = isOpen
                    ? new Color(0.10f, 0.18f, 0.32f, 1f)
                    : RowFill;
                UiKit.AddHorizontalLayout(row, 8, 8);

                var emblem = UiKit.CreatePanel(row, "Emblem", new Color(0f, 0f, 0f, 0f));
                SetFixedSize(emblem, 48f, 48f);
                var clan = DeckClan(deck);
                var color = CardArt.ClanColor(clan ?? "None");
                NeonUi.AddImage(
                    emblem,
                    "Crest",
                    NeonUi.BodySliced(
                        12,
                        new Color(color.r, color.g, color.b, 0.35f),
                        new Color(color.r, color.g, color.b, 0.95f),
                        2),
                    new Vector2(48f, 48f),
                    Vector2.zero,
                    true);
                var gem = NeonUi.AddImage(
                    emblem,
                    "Gem",
                    NeonUi.Body(20, 20, 4, color, Color.white, 1),
                    new Vector2(20f, 20f),
                    Vector2.zero);
                gem.rectTransform.localRotation = Quaternion.Euler(0f, 0f, 45f);

                var content = UiKit.CreatePanel(row, "Content", new Color(0f, 0f, 0f, 0f));
                var contentElement = content.gameObject.AddComponent<LayoutElement>();
                contentElement.flexibleWidth = 1f;
                contentElement.preferredHeight = 64f;
                UiKit.AddVerticalLayout(content, 0, 2);

                var name = UiKit.CreateText(
                    content, "Name", deck.Name, 16, TextPrimary, TextAnchor.MiddleLeft);
                UiKit.MakeLiteral(name);
                name.fontStyle = FontStyle.Bold;
                name.horizontalOverflow = HorizontalWrapMode.Wrap;
                UiKit.SetPreferredHeight(name, 24f);

                var validation = DeckListModel.Validate(deck.Cards, _catalog);
                var info = UiKit.CreateText(
                    content,
                    "Info",
                    deck.Cards.Count + "/50 · T " + validation.Triggers + "/16",
                    12,
                    validation.IsValid
                        ? new Color(0.55f, 0.9f, 0.62f)
                        : new Color(1f, 0.66f, 0.5f),
                    TextAnchor.MiddleLeft);
                UiKit.MakeLiteral(info);
                UiKit.SetPreferredHeight(info, 18f);

                var kebab = UiKit.CreateButton(row, "Menu", string.Empty, () => OpenDeckMenu(deck), 14);
                SetFixedSize(kebab, 34f, 34f);
                SetButtonColor(kebab, new Color(0.06f, 0.11f, 0.22f, 0.9f));
                for (var i = -1; i <= 1; i++)
                {
                    NeonUi.AddImage(
                        kebab.transform,
                        "Dot" + i,
                        NeonUi.Circle(4, TextMuted),
                        new Vector2(4f, 4f),
                        new Vector2(0f, i * 7f));
                }
            }
        }

        private void OpenDeckMenu(DeckDto deck)
        {
            _deckMenuDeck = deck;
            _deckMenuTitle.text = deck.Name;
            _deckMenuOverlay.SetAsLastSibling();
            _deckMenuOverlay.gameObject.SetActive(true);
        }

        private void CloseDeckMenu()
        {
            _deckMenuDeck = null;
            _deckMenuOverlay.gameObject.SetActive(false);
        }

        private void OpenDeckFromMenu()
        {
            var deck = _deckMenuDeck;
            CloseDeckMenu();
            if (deck != null)
                OpenDeck(deck);
        }

        private void DeleteDeckFromMenu()
        {
            var deck = _deckMenuDeck;
            CloseDeckMenu();
            if (deck != null)
                RequestDelete(deck);
        }

        private string DeckClan(DeckDto deck)
        {
            if (deck == null || deck.Cards == null)
                return null;

            foreach (var printingId in deck.Cards)
            {
                if (_catalog.TryGetValue(printingId, out var meta)
                    && !string.IsNullOrEmpty(meta.Clan))
                {
                    return meta.Clan;
                }
            }

            return null;
        }

        // ------------------------------------------------------------ редактор колоды

        private void RebuildDeckCards()
        {
            ClearChildren(_deckCardContent);

            var groups = DeckListModel.GroupDeck(_cards, _catalog);
            if (groups.Count == 0)
            {
                var empty = UiKit.CreateText(
                    _deckCardContent, "Empty", "Колода пуста", 15, TextDim);
                UiKit.SetPreferredHeight(empty, 90f);
                return;
            }

            foreach (var group in groups)
            {
                var row = UiKit.CreatePanel(
                    _deckCardContent, "DeckCard_" + group.NameId, RowFill);
                var rowElement = row.gameObject.AddComponent<LayoutElement>();
                rowElement.preferredHeight = 84f;
                UiKit.AddHorizontalLayout(row, 6, 8);

                var button = row.gameObject.AddComponent<Button>();
                button.targetGraphic = row.GetComponent<Image>();
                var printingId = group.PrintingIds[group.PrintingIds.Count - 1];
                button.onClick.AddListener(() => RemoveCard(printingId));
                if (group.Meta != null)
                    AddRightClick(row.gameObject, printingId, group.Meta);

                var art = UiKit.CreatePanel(row, "Art", new Color(0.1f, 0.2f, 0.4f, 1f));
                SetFixedSize(art, 64f, 54f);
                CardImageService.ApplyIllustration(
                    art.GetComponent<Image>(),
                    group.Meta != null ? group.Meta.ImageKey : null,
                    CardArt.ForCard(
                        group.Meta != null ? group.Meta.NameId : group.NameId,
                        group.Meta != null ? group.Meta.Clan : "None"));

                var texts = UiKit.CreatePanel(row, "Texts", new Color(0f, 0f, 0f, 0f));
                var textsElement = texts.gameObject.AddComponent<LayoutElement>();
                textsElement.flexibleWidth = 1f;
                textsElement.preferredHeight = 66f;
                UiKit.AddVerticalLayout(texts, 2, 0);

                var name = UiKit.CreateText(
                    texts, "Name", group.Name, 14, TextPrimary, TextAnchor.UpperLeft);
                UiKit.MakeLiteral(name);
                name.fontStyle = FontStyle.Bold;
                name.horizontalOverflow = HorizontalWrapMode.Wrap;
                UiKit.SetPreferredHeight(name, 34f);

                var metaLine = "G" + (group.Grade == int.MaxValue ? "?" : group.Grade.ToString())
                    + " · ×" + group.Count
                    + (group.Meta != null
                        ? " · " + TriggerShort(group.Meta.Trigger) + " · " + group.Meta.Clan
                        : string.Empty);
                var info = UiKit.CreateText(
                    texts, "Info", metaLine, 11, TextMuted, TextAnchor.MiddleLeft);
                UiKit.MakeLiteral(info);
                UiKit.SetPreferredHeight(info, 18f);
            }
        }

        private void ShowDeckList()
        {
            _deckOpen = false;
            _deckListPanel.gameObject.SetActive(true);
            _deckPanel.gameObject.SetActive(false);
            _filterOverlay.gameObject.SetActive(false);
            _cardOverlay.gameObject.SetActive(false);
            _deckMenuOverlay.gameObject.SetActive(false);
        }

        private void ShowDeckPanel()
        {
            _deckOpen = true;
            _deckListPanel.gameObject.SetActive(false);
            _deckPanel.gameObject.SetActive(true);
            _filterOverlay.gameObject.SetActive(false);
            _cardOverlay.gameObject.SetActive(false);
            _deckMenuOverlay.gameObject.SetActive(false);
            RebuildDeckPanel();
            RebuildCollection();
        }

        private void BackToDeckList()
        {
            _dirty = false;
            _editing = null;
            _cards.Clear();
            _deckListPanel.gameObject.SetActive(true);
            _deckPanel.gameObject.SetActive(false);
            BuildDeckList();
            RebuildCollection();
            ShowDeckList();
        }

        private void NewDeck()
        {
            _editing = null;
            _cards.Clear();
            _dirty = true;
            _nameInput.SetTextWithoutNotify("Новая колода");
            ShowDeckPanel();
        }

        private void OpenDeck(DeckDto deck)
        {
            _editing = deck;
            _cards.Clear();
            _cards.AddRange(deck.Cards);
            _nameInput.SetTextWithoutNotify(deck.Name);
            _dirty = false;
            ShowDeckPanel();
        }

        private void RebuildDeckPanel()
        {
            UpdateStats();
            RebuildDeckCards();
            RefreshCounts();
        }

        private void RefreshAfterDeckChange()
        {
            UpdateStats();
            RebuildDeckCards();
            RefreshCounts();
        }

        // ------------------------------------------------------------ коллекция

        private void RebuildCollection()
        {
            ClearChildren(_collectionContent);
            _countTexts.Clear();

            var items = _collection
                .Select(item => new { Item = item, Meta = MetaOf(item) })
                .Where(pair => pair.Meta != null && _filter.Matches(pair.Meta))
                .OrderBy(pair => pair.Meta.Clan, StringComparer.Ordinal)
                .ThenBy(pair => pair.Meta.Grade)
                .ThenBy(pair => Loc.CardName(pair.Meta), StringComparer.Ordinal);

            foreach (var pair in items)
                AddCollectionCell(pair.Item, pair.Meta);
        }

        private void AddCollectionCell(CollectionItemDto item, CardCatalogItemDto meta)
        {
            var cell = UiKit.CreatePanel(
                _collectionContent, "Owned_" + item.PrintingId, RowFill);
            UiKit.AddVerticalLayout(cell, 0, 0);
            AddRightClick(cell.gameObject, item.PrintingId, meta);

            var frame = cell.gameObject.AddComponent<Outline>();
            frame.effectColor = CardArt.ClanColor(meta.Clan);
            frame.effectDistance = new Vector2(2f, -2f);

            if (_deckOpen)
            {
                var button = cell.gameObject.AddComponent<Button>();
                button.targetGraphic = cell.GetComponent<Image>();
                button.onClick.AddListener(() => AddCard(item));
            }

            var art = UiKit.CreatePanel(cell, "Art", Color.white);
            UiKit.SetPreferredHeight(art, 394f);
            var artImage = art.GetComponent<Image>();
            CardImageService.Apply(
                artImage,
                meta.ImageKey,
                CardArt.ForCard(meta.NameId, meta.Clan));
            artImage.preserveAspect = true;

            var qty = UiKit.CreatePanel(cell, "Qty", new Color(0.02f, 0.05f, 0.12f, 0.95f));
            UiKit.SetPreferredHeight(qty, 46f);

            var counts = UiKit.CreateText(
                qty,
                "Counts",
                CountText(item),
                14,
                new Color(0.90f, 0.86f, 0.70f),
                TextAnchor.MiddleCenter);
            UiKit.Stretch(counts.rectTransform);
            counts.rectTransform.offsetMin = new Vector2(8f, 0f);
            counts.rectTransform.offsetMax = new Vector2(-8f, 0f);
            _countTexts[item.PrintingId] = counts;
        }

        private void RefreshCounts()
        {
            var triggerCap = TriggerCount() >= 16;
            foreach (var pair in _countTexts)
            {
                var item = _collection.Find(candidate => candidate.PrintingId == pair.Key);
                if (item == null)
                    continue;

                var meta = MetaOf(item);
                var used = UsedByName(item.NameId);
                var atCap = _deckOpen
                    && (used >= 4 || (meta != null && IsTrigger(meta.Trigger) && triggerCap));
                pair.Value.text = CountText(item);
                pair.Value.color = atCap
                    ? new Color(1f, 0.55f, 0.45f)
                    : new Color(0.90f, 0.86f, 0.70f);
            }
        }

        private string CountText(CollectionItemDto item) =>
            _deckOpen
                ? "в колоде ×" + UsedByName(item.NameId) + " · есть ×" + item.Count
                : "есть ×" + item.Count;

        private void AddCard(CollectionItemDto item)
        {
            if (!_catalog.TryGetValue(item.PrintingId, out var itemMeta))
                return;

            if (_cards.Count >= 50)
            {
                SetStatus("В колоде уже 50 карт.", true);
                return;
            }

            if (UsedByName(item.NameId) >= 4)
            {
                SetStatus("Не больше 4 копий одной карты.", true);
                return;
            }

            if (IsTrigger(itemMeta.Trigger) && TriggerCount() >= 16)
            {
                SetStatus("В колоде уже 16 триггеров.", true);
                return;
            }

            if (_cards.Count(card => card == item.PrintingId) >= item.Count)
            {
                SetStatus("В коллекции больше нет свободных копий.", true);
                return;
            }

            _cards.Add(item.PrintingId);
            _dirty = true;
            SetStatus(string.Empty, false);
            RefreshAfterDeckChange();
        }

        private void RemoveCard(string printingId)
        {
            var index = _cards.LastIndexOf(printingId);
            if (index >= 0)
            {
                _cards.RemoveAt(index);
                _dirty = true;
            }

            RefreshAfterDeckChange();
        }

        // ------------------------------------------------------------ фильтры

        private void OpenFilters()
        {
            _draftFilter.CopyFrom(_filter);
            _searchInput.SetTextWithoutNotify(_draftFilter.Search ?? string.Empty);
            RebuildFilterChips();
            _filterOverlay.SetAsLastSibling();
            _filterOverlay.gameObject.SetActive(true);
        }

        private void CloseFilters()
        {
            _filterOverlay.gameObject.SetActive(false);
        }

        private void ApplyFilters()
        {
            _filter.CopyFrom(_draftFilter);
            UpdateFilterSummary();
            RebuildCollection();
            CloseFilters();
        }

        private void ResetDraftFilters()
        {
            _draftFilter.Clear();
            _searchInput.SetTextWithoutNotify(string.Empty);
            RebuildFilterChips();
        }

        private void ResetFilters()
        {
            _filter.Clear();
            UpdateFilterSummary();
            RebuildCollection();
        }

        private void RebuildFilterChips()
        {
            ClearChildren(_rarityChips);
            foreach (var rarity in new[] { "C", "R", "RR", "RRR", "SP" })
            {
                var value = rarity;
                Chip(
                    _rarityChips,
                    value,
                    _draftFilter.Rarities.Contains(value),
                    () => ToggleRarity(value),
                    120f);
            }

            ClearChildren(_gradeChips);
            for (var grade = 0; grade <= 3; grade++)
            {
                var value = grade;
                Chip(
                    _gradeChips,
                    "G" + value,
                    _draftFilter.Grades.Contains(value),
                    () => ToggleGrade(value),
                    92f);
            }

            ClearChildren(_triggerChips);
            foreach (var trigger in new[] { "None", "Critical", "Draw", "Stand", "Heal" })
            {
                var value = trigger;
                Chip(
                    _triggerChips,
                    TriggerLabel(value),
                    _draftFilter.Triggers.Contains(value),
                    () => ToggleTrigger(value),
                    150f);
            }

            ClearChildren(_clanChips);
            foreach (var clan in _catalog.Values
                         .Select(item => item.Clan)
                         .Distinct()
                         .OrderBy(item => item, StringComparer.Ordinal))
            {
                var value = clan;
                Chip(
                    _clanChips,
                    value,
                    _draftFilter.Clans.Contains(value),
                    () => ToggleClan(value),
                    0f,
                    fullWidth: true);
            }

            if (_clanChips.childCount == 0)
            {
                var empty = UiKit.CreateText(
                    _clanChips, "Empty", "Кланы появятся после загрузки коллекции.",
                    14, TextDim);
                UiKit.SetPreferredHeight(empty, 40f);
            }
        }

        private void ToggleGrade(int grade)
        {
            if (!_draftFilter.Grades.Add(grade))
                _draftFilter.Grades.Remove(grade);
            RebuildFilterChips();
        }

        private void ToggleTrigger(string trigger)
        {
            if (!_draftFilter.Triggers.Add(trigger))
                _draftFilter.Triggers.Remove(trigger);
            RebuildFilterChips();
        }

        private void ToggleClan(string clan)
        {
            if (!_draftFilter.Clans.Add(clan))
                _draftFilter.Clans.Remove(clan);
            RebuildFilterChips();
        }

        private void ToggleRarity(string rarity)
        {
            if (!_draftFilter.Rarities.Add(rarity))
                _draftFilter.Rarities.Remove(rarity);
            RebuildFilterChips();
        }

        private static Button Chip(
            Transform parent,
            string label,
            bool active,
            Action onClick,
            float width,
            bool fullWidth = false)
        {
            var button = UiKit.CreateButton(
                parent, "Chip_" + label, label, () => onClick(), 14);
            if (fullWidth)
            {
                UiKit.SetPreferredHeight(button, 34f);
                var element = button.gameObject.GetComponent<LayoutElement>();
                element.flexibleWidth = 1f;
            }
            else
            {
                SetFixedSize(button, width, 38f);
            }

            SetButtonColor(button, active ? ChipOn : ChipOff);
            return button;
        }

        private void UpdateFilterSummary()
        {
            if (_filter.IsEmpty)
            {
                _filterSummary.text = "Все карты";
                return;
            }

            var parts = new List<string>();
            if (_filter.Rarities.Count > 0)
                parts.Add("Редкость: " + string.Join(", ", _filter.Rarities.OrderBy(item => item, StringComparer.Ordinal)));
            if (_filter.Clans.Count > 0)
                parts.Add("Клан: " + string.Join(", ", _filter.Clans.OrderBy(item => item, StringComparer.Ordinal)));
            if (_filter.Grades.Count > 0)
                parts.Add("Ранг: " + string.Join(", ", _filter.Grades.OrderBy(item => item)));
            if (_filter.Triggers.Count > 0)
                parts.Add("Триггер: " + string.Join(", ", _filter.Triggers.OrderBy(item => item, StringComparer.Ordinal)));
            if (!string.IsNullOrWhiteSpace(_filter.Search))
                parts.Add("Поиск: " + _filter.Search.Trim());

            _filterSummary.text = string.Join(" · ", parts);
        }

        private static string TriggerLabel(string trigger) => trigger switch
        {
            "None" => "Без триггера",
            "Critical" => "Критический",
            "Draw" => "Добор",
            "Stand" => "Стойка",
            "Heal" => "Лечение",
            _ => trigger,
        };

        // ------------------------------------------------------------ статистика и валидация

        private void UpdateStats()
        {
            var grades = new int[4];
            foreach (var printingId in _cards)
            {
                if (_catalog.TryGetValue(printingId, out var meta)
                    && meta.Grade >= 0 && meta.Grade < grades.Length)
                {
                    grades[meta.Grade]++;
                }
            }

            var validation = DeckListModel.Validate(_cards, _catalog);
            _deckCount.text = _cards.Count + "/50 · T " + validation.Triggers + "/16";
            _deckCount.color = validation.IsValid
                ? new Color(0.55f, 0.9f, 0.62f)
                : new Color(1f, 0.72f, 0.5f);

            _stats.text = "Всего: " + _cards.Count + "/50   G0 " + grades[0]
                + " · G1 " + grades[1] + " · G2 " + grades[2] + " · G3 " + grades[3]
                + " · T " + validation.Triggers + "/16"
                + (_dirty ? " · не сохранено" : string.Empty);
            _stats.color = validation.IsValid ? TextMuted : new Color(1f, 0.68f, 0.45f);

            var canSave = validation.IsValid && !_busy;
            var canPlay = validation.IsValid && !_busy && !_dirty && _editing != null;
            _saveButton.interactable = canSave;
            _duelButton.interactable = canPlay;
            _botButton.interactable = canPlay;
            _deleteButton.interactable = _editing != null && !_busy;
        }

        private string GradeLine(IEnumerable<string> cards)
        {
            var grades = new int[4];
            foreach (var printingId in cards)
            {
                if (_catalog.TryGetValue(printingId, out var meta)
                    && meta.Grade >= 0 && meta.Grade < grades.Length)
                {
                    grades[meta.Grade]++;
                }
            }

            return "G0 " + grades[0] + " · G1 " + grades[1]
                + " · G2 " + grades[2] + " · G3 " + grades[3];
        }

        private static string FormatName(string format) =>
            string.Equals(format, "classic", StringComparison.OrdinalIgnoreCase)
                ? "Classic"
                : format;

        private int UsedByName(string nameId) =>
            _cards.Count(printingId =>
                _catalog.TryGetValue(printingId, out var meta) && meta.NameId == nameId);

        private int TriggerCount() =>
            _cards.Count(printingId =>
                _catalog.TryGetValue(printingId, out var meta) && IsTrigger(meta.Trigger));

        private static bool IsTrigger(string trigger) => DeckListModel.IsTrigger(trigger);

        private static string TriggerShort(string trigger) => trigger switch
        {
            "Critical" => "K",
            "Draw" => "D",
            "Stand" => "S",
            "Heal" => "H",
            _ => "—",
        };

        // ------------------------------------------------------------ сохранение и бой

        private async void SaveDeck()
        {
            if (_busy)
                return;

            var validation = DeckListModel.Validate(_cards, _catalog);
            if (!validation.IsValid)
            {
                SetStatus("Нужно ровно 50 карт, 16 триггеров и не больше 4 копий.", true);
                return;
            }

            _busy = true;
            UpdateStats();
            SetStatus("Сохраняем…", false);
            try
            {
                await _auth.EnsureAccessAsync();
                var name = string.IsNullOrWhiteSpace(_nameInput.text)
                    ? "Новая колода"
                    : _nameInput.text.Trim();

                var result = _editing == null
                    ? await _meta.CreateDeckAsync(name, new List<string>(_cards))
                    : await _meta.UpdateDeckAsync(_editing.Id, name, new List<string>(_cards));

                _editing = result;
                _cards.Clear();
                _cards.AddRange(result.Cards);
                _nameInput.SetTextWithoutNotify(result.Name);
                _dirty = false;
                UpsertDeck(result);
                BuildDeckList();
                RebuildDeckPanel();
                SetStatus("Сохранено: " + result.Cards.Count + " карт.", false);
            }
            catch (ApiException exception)
            {
                var details = exception.Violations.Count > 0
                    ? "\n" + string.Join("\n", exception.Violations.Take(3).Select(v => v.Message))
                    : string.Empty;
                SetStatus(exception.Message + details, true);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
                SetStatus("Не удалось сохранить колоду.", true);
            }
            finally
            {
                _busy = false;
                UpdateStats();
            }
        }

        private void PlayDeck()
        {
            if (_editing == null || _dirty)
            {
                SetStatus("Сначала сохраните колоду.", true);
                return;
            }

            _onPlay(_editing);
        }

        private async void PlayBot()
        {
            if (_busy)
                return;

            if (_editing == null || _dirty)
            {
                SetStatus("Сначала сохраните колоду.", true);
                return;
            }

            _busy = true;
            UpdateStats();
            SetStatus("Готовим тренировочный матч…", false);
            try
            {
                await _auth.EnsureAccessAsync();
                var response = await _meta.StartPracticeAsync(_editing.Id);
                _onPracticeStarted(new MatchConnectionInfo
                {
                    MatchId = response.MatchId,
                    Seat = response.Seat,
                    Ticket = response.Ticket,
                    WsUrl = response.WsUrl,
                    DeckName = _editing.Name,
                });
            }
            catch (ApiException exception)
            {
                SetStatus(exception.Message, true);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
                SetStatus("Не удалось начать матч с ботом.", true);
            }
            finally
            {
                _busy = false;
                UpdateStats();
            }
        }

        // ------------------------------------------------------------ удаление

        private void RequestDeleteCurrent()
        {
            if (_editing == null)
            {
                SetStatus("Сначала сохраните колоду.", true);
                return;
            }

            RequestDelete(_editing);
        }

        private async void DeleteDeck(DeckDto deck)
        {
            if (_busy)
                return;

            _busy = true;
            try
            {
                await _meta.DeleteDeckAsync(deck.Id);
                _decks.RemoveAll(item => item.Id == deck.Id);
                if (_editing != null && _editing.Id == deck.Id)
                    _editing = null;
                BuildDeckList();
                if (_deckPanel.gameObject.activeSelf)
                    BackToDeckList();
                SetStatus("Колода удалена.", false);
            }
            catch (ApiException exception)
            {
                SetStatus(exception.Message, true);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
                SetStatus("Не удалось удалить колоду.", true);
            }
            finally
            {
                _busy = false;
            }
        }

        private void RequestDelete(DeckDto deck)
        {
            _pendingDelete = deck;
            _confirmText.text = deck.Name + "\nКолода будет удалена без восстановления.";
            _confirmOverlay.SetAsLastSibling();
            _confirmOverlay.gameObject.SetActive(true);
        }

        private void CancelDelete()
        {
            _pendingDelete = null;
            _confirmOverlay.gameObject.SetActive(false);
        }

        private void ConfirmDelete()
        {
            var deck = _pendingDelete;
            _confirmOverlay.gameObject.SetActive(false);
            _pendingDelete = null;
            if (deck != null)
                DeleteDeck(deck);
        }

        // ------------------------------------------------------------ карточка

        private void AddRightClick(GameObject target, string printingId, CardCatalogItemDto meta)
        {
            var trigger = target.GetComponent<EventTrigger>()
                ?? target.AddComponent<EventTrigger>();
            var entry = new EventTrigger.Entry { eventID = EventTriggerType.PointerClick };
            entry.callback.AddListener(data =>
            {
                if (data is PointerEventData pointer
                    && pointer.button == PointerEventData.InputButton.Right)
                {
                    ShowCardOverlay(printingId, meta);
                }
            });
            trigger.triggers.Add(entry);
        }

        private void ShowCardOverlay(string printingId, CardCatalogItemDto meta)
        {
            if (meta == null)
                return;

            _selectedMeta = meta;
            _selectedItem = _collection.Find(item => item.PrintingId == printingId);
            _cardStatus.text = string.Empty;
            UpdateCardOverlay();
            _cardOverlay.SetAsLastSibling();
            _cardOverlay.gameObject.SetActive(true);
        }

        private void UpdateCardOverlay()
        {
            if (_selectedMeta == null)
                return;

            var meta = _selectedMeta;
            CardImageService.Apply(
                _cardArt,
                meta.ImageKey,
                CardArt.ForCard(meta.NameId, meta.Clan));
            var otherName = Loc.OtherCardName(meta);
            _cardArtName.text = Loc.CardName(meta);
            _cardTitle.text = Loc.CardName(meta);
            _cardSubtitle.text = (string.IsNullOrEmpty(otherName) ? string.Empty : otherName + " · ")
                + meta.Clan + " · G" + meta.Grade;
            _cardStats.text = "Тип: " + meta.Type + " · Редкость: " + meta.Rarity + "\n"
                + "Power " + meta.Power + " · Shield " + meta.Shield + " · Critical " + meta.Critical + "\n"
                + "Триггер: " + meta.Trigger
                + " · Sentinel: " + (meta.IsSentinel ? "да" : "нет")
                + " · Boost: " + (meta.HasBoost ? "да" : "нет")
                + " · Intercept: " + (meta.HasIntercept ? "да" : "нет") + "\n"
                + "Принт: " + meta.PrintingId;
            var abilityText = Loc.CardText(meta);
            _cardAbilities.text = string.IsNullOrWhiteSpace(abilityText)
                ? Loc.Translate("Текст способности отсутствует.")
                : abilityText;
            _cardOwned.text = "В коллекции: ×" + (_selectedItem != null ? _selectedItem.Count : 0)
                + " · в колоде: " + UsedByName(meta.NameId)
                + " · пыль: " + _dust;

            var canChange = CanChange(meta.Rarity);
            var craftCost = CraftCostFor(meta.Rarity);
            _dismantleButton.interactable = canChange && !_busy
                && _selectedItem != null && _selectedItem.Count > 0;
            _craftButton.interactable = canChange && !_busy && _dust >= craftCost;
            SetButtonLabel(
                _dismantleButton,
                canChange ? "Разобрать (+" + DustFor(meta.Rarity) + " пыли)" : "Нельзя разобрать");
            SetButtonLabel(
                _craftButton,
                canChange
                    ? "Скрафтить (−" + craftCost + " пыли)"
                    : "Нельзя скрафтить");
        }

        private static bool CanChange(string rarity) =>
            rarity == "C" || rarity == "R" || rarity == "RR" || rarity == "RRR";

        private async void DismantleSelected()
        {
            if (_busy || _selectedItem == null || _selectedItem.Count <= 0
                || _selectedMeta == null || !CanChange(_selectedMeta.Rarity))
                return;

            var printingId = _selectedItem.PrintingId;
            _busy = true;
            UpdateCardOverlay();
            _cardStatus.text = "Разбираем…";
            _cardStatus.color = TextMuted;
            try
            {
                await _auth.EnsureAccessAsync();
                await _meta.DismantleAsync(printingId, 1);
                await ReloadCollectionAsync(printingId);
                SetCardStatus("Карта разобрана.", false);
            }
            catch (ApiException exception)
            {
                SetCardStatus(exception.Message, true);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
                SetCardStatus("Не удалось разобрать карту.", true);
            }
            finally
            {
                _busy = false;
                UpdateCardOverlay();
            }
        }

        private async void CraftSelected()
        {
            if (_busy || _selectedMeta == null || !CanChange(_selectedMeta.Rarity))
                return;

            var printingId = _selectedMeta.PrintingId;
            _busy = true;
            UpdateCardOverlay();
            _cardStatus.text = "Крафтим…";
            _cardStatus.color = TextMuted;
            try
            {
                await _auth.EnsureAccessAsync();
                await _meta.CraftAsync(printingId);
                await ReloadCollectionAsync(printingId);
                SetCardStatus("Карта скрафчена.", false);
            }
            catch (ApiException exception)
            {
                SetCardStatus(exception.Message, true);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
                SetCardStatus("Не удалось скрафтить карту.", true);
            }
            finally
            {
                _busy = false;
                UpdateCardOverlay();
            }
        }

        private async Task ReloadCollectionAsync(string printingId)
        {
            var collection = await _meta.GetCollectionAsync();
            _collection.Clear();
            _collection.AddRange(collection.Items ?? new List<CollectionItemDto>());
            _dust = collection.Balances != null ? collection.Balances.Dust : 0;
            RebuildCollection();
            RefreshCounts();
            _selectedItem = _collection.Find(item => item.PrintingId == printingId);
            if (_selectedItem == null)
            {
                _cardOverlay.gameObject.SetActive(false);
                SetStatus("Карт в коллекции: " + _collection.Count + ".", false);
            }
            else
            {
                UpdateCardOverlay();
            }
        }

        private void SetCardStatus(string text, bool error)
        {
            _cardStatus.text = text;
            _cardStatus.color = error
                ? new Color(1f, 0.55f, 0.45f)
                : new Color(0.45f, 0.85f, 0.55f);
        }

        private void CloseCardOverlay()
        {
            _selectedItem = null;
            _selectedMeta = null;
            _cardOverlay.gameObject.SetActive(false);
        }

        // ------------------------------------------------------------ утилиты

        private void SetStatus(string text, bool error)
        {
            if (_status == null)
                return;

            _status.text = text ?? string.Empty;
            _status.color = error
                ? new Color(1f, 0.55f, 0.45f)
                : TextMuted;
        }

        private void UpsertDeck(DeckDto deck)
        {
            var index = _decks.FindIndex(item => item.Id == deck.Id);
            if (index >= 0)
                _decks[index] = deck;
            else
                _decks.Add(deck);
        }

        private CardCatalogItemDto MetaOf(CollectionItemDto item) =>
            _catalog.TryGetValue(item.PrintingId, out var meta) ? meta : null;

        private static int DustFor(string rarity) => rarity switch
        {
            "C" => 5,
            "R" => 10,
            "RR" => 25,
            "RRR" => 100,
            _ => 0,
        };

        private static int CraftCostFor(string rarity) => rarity switch
        {
            "C" => 20,
            "R" => 40,
            "RR" => 100,
            "RRR" => 400,
            _ => 0,
        };

        private static void SetButtonLabel(Button button, string label)
        {
            var text = button.GetComponentInChildren<Text>();
            if (text != null)
                text.text = label;
        }

        private static void SetButtonColor(Button button, Color color)
        {
            var image = button.GetComponent<Image>();
            if (image != null)
                image.color = color;
        }

        private static void SetFixedSize(Component component, float width, float height)
        {
            var element = component.gameObject.GetComponent<LayoutElement>()
                ?? component.gameObject.AddComponent<LayoutElement>();
            element.preferredWidth = width;
            element.preferredHeight = height;
            element.flexibleWidth = 0f;
            element.flexibleHeight = 0f;
        }

        private static void SetFlexible(Component component, float widthWeight, float height)
        {
            var element = component.gameObject.GetComponent<LayoutElement>()
                ?? component.gameObject.AddComponent<LayoutElement>();
            element.preferredHeight = height;
            element.flexibleWidth = widthWeight;
            element.flexibleHeight = 0f;
        }

        private static void ClearChildren(Transform parent)
        {
            for (var i = parent.childCount - 1; i >= 0; i--)
            {
                var child = parent.GetChild(i).gameObject;
                if (Application.isPlaying)
                    UnityEngine.Object.Destroy(child);
                else
                    UnityEngine.Object.DestroyImmediate(child);
            }
        }
    }
}