using System;
using System.Collections.Generic;
using System.Linq;
using Logic.CrashSight;
using Logic.Multilingual;
using TH1_Core.Events;
using TH1_Logic.Oss;
using TH1_Logic.Questionnaire;
using TH1Resource;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
#if STEAM_CHANNEL || STEAMWORKS_NET
using Steamworks;
#endif

namespace TH1_UI.View.Outside
{
    public class UIOutsideQuestionnaireView : Base.View
    {
        private const string DataAssetPath = "Export/QuestionnaireDataAssets";
        private const string QuestionPrefabPath = "Prefab/UI/Outside/UIOutsideQuestionnaireQuestion";
        private const string OptionPrefabPath = "Prefab/UI/Outside/UIOutsideQuestionnaireOption";
        private const uint BodyFontGroupId = 1;
        private const uint TitleFontGroupId = 2;
        private const uint TextQuestionnaireCenter = 30978;
        private const uint TextCurrentQuestionnaire = 30979;
        private const uint TextLatestSubmission = 30984;
        private const uint TextReturn = 1048;
        private const uint TextView = 19671;
        private const uint TextNoAvailableQuestionnaires = 31171;
        private const uint TextNoCurrentQuestionnaire = 31172;
        private const uint TextLongTermQuestionnaire = 31173;
        private const uint TextNoLongTermQuestionnaires = 31174;
        private const uint TextPastQuestionnaires = 31175;
        private const uint TextNoPastQuestionnaires = 31176;
        private const uint TextNoQuestionnairesToDisplay = 31177;
        private const uint TextPastQuestionnairesCollapsed = 31178;
        private const uint TextViewRecordsCount = 31179;
        private const uint TextFillQuestionnaire = 31180;
        private const uint TextFormSubmitHint = 31181;
        private const uint TextClear = 31182;
        private const uint TextResponseRecords = 31183;
        private const uint TextNoResponseRecords = 31184;
        private const uint TextReadOnlyRecord = 31185;
        private const uint TextBackToRecords = 31186;
        private const uint TextRecordIndex = 31187;
        private const uint TextQuestionnaireMissing = 31188;
        private const uint TextQuestionnaireEnded = 31189;
        private const uint TextQuestionnaireUnavailable = 31190;
        private const uint TextQuestionnaireAlreadySubmitted = 31191;
        private const uint TextQuestionnaireSubmissionLimit = 31192;
        private const uint TextQuestionnaireInterval = 31193;
        private const uint TextListMetaNotFilled = 31194;
        private const uint TextListMetaSubmitted = 31195;
        private const uint TextStatusCurrent = 30981;
        private const uint TextStatusLongTerm = 31198;
        private const uint TextStatusPast = 31199;
        private const uint TextStatusHidden = 31200;
        private const uint TextUnknownTime = 31201;
        private const uint TextUploaded = 31202;
        private const uint TextLocalOnly = 31203;
        private const uint TextWaitingUploadResult = 31204;

        public static readonly Color InkColor = new Color(0.25490198f, 0.23137257f, 0.41960788f, 1f);
        public static readonly Color InkMutedColor = new Color(0.53f, 0.53f, 0.53f, 1f);
        public static readonly Color InkLightColor = new Color(0.96f, 0.96f, 0.92f, 1f);
        public static readonly Color GoldColor = new Color(0.91372555f, 0.7176471f, 0.3647059f, 1f);
        public static readonly Color PanelTint = Color.white;
        public static readonly Color TransparentPanelTint = new Color(1f, 1f, 1f, 0f);
        public const float ItemButtonPixelsPerUnitMultiplier = 1f;

        private const float SidebarWidth = 440f;
        private const float LibraryFrameHorizontalPadding = 86f;
        private const float LibraryFrameTopPadding = 42f;
        private const float LibraryFrameBottomPadding = 58f;
        private const float LibraryTopBarHeight = 203.6337f;
        private const float TitleAreaHeight = 82f;
        private const float ContentAreaSpacing = 18f;
        private const int DetailPanelHorizontalPadding = 42;
        private const int DetailPanelTopPadding = 34;
        private const int DetailPanelBottomPadding = 30;
        private const float DetailPanelSpacing = 22f;
        private const float DetailContentSpacing = 18f;
        private const float DetailHeaderSpacing = 6f;
        private const float PrimaryButtonPixelsPerUnitMultiplier = 1f;
        private const float SecondaryButtonPixelsPerUnitMultiplier = 1f;
        private const string SpriteFullscreenBackdrop = "TH1UI/Common/CommonBG/CommonVerticleStripeTileBG";
        private const string SpriteLibraryTopBar = "TH1UI/TechTree/TechTreeTopBar";
        private const string SpriteCommonWindow = "TH1UI/Common/CommonBG/CommonWindowBG";
        private const string SpriteCommonPanel = "ArtResources/TH1UI/Common/CommonPanelBG";
        private const string SpriteCommonLabel = "TH1UI/Common/CommonBG/CommonLabelBG";
        private const string SpriteCommonSelectLabel = "TH1UI/Common/CommonBG/CommonSelectLabelBG";
        private const string SpriteButtonPrimary = "TH1UI/Common/CommonButton/CheckButton1";
        private const string SpriteButtonSecondary = "TH1UI/Common/CommonButton/CheckButton2";
        private const string SpriteButtonDisabled = "TH1UI/Common/CommonButton/CheckButton_Gray";
        private const string SpriteReturnButton = "TH1UI/Common/CommonButton/CommonReturnButton";
        private const string SpriteItemButton = "TH1UI/Common/CommonButton/ItemButtonBG";
        private const string SpriteItemButtonSelected = "TH1UI/Common/CommonButton/ItemButtonSelectedBG";
        private const string SpriteDivider = "TH1UI/Common/CommonDeco/DecoDashedHoriLine";

        public Button CloseButton;
        public Button SubmitButton;
        public Button RefillButton;
        public TextMeshProUGUI TitleText;
        public TextMeshProUGUI DescriptionText;
        public TextMeshProUGUI StatusText;
        public TextMeshProUGUI SubmitButtonText;
        public TextMeshProUGUI RefillButtonText;
        public TextMeshProUGUI CloseButtonText;
        public Transform QuestionListContent;
        public GameObject QuestionPrefab;
        public GameObject OptionPrefab;
        public GameObject QuestionnaireItemTemplate;
        public GameObject SectionHeaderTemplate;
        public GameObject DividerTemplate;
        public GameObject InfoStripTemplate;
        public GameObject LatestRecordPreviewTemplate;
        public GameObject RecordRowTemplate;
        public GameObject PrimaryButtonTemplate;
        public GameObject SecondaryButtonTemplate;

        public ViDelegateAssisstant.Dele OnBtnCloseClick;

        private readonly List<UIOutsideQuestionnaireQuestionMono> _questionItems = new List<UIOutsideQuestionnaireQuestionMono>();
        private readonly List<QuestionnaireListItem> _listItems = new List<QuestionnaireListItem>();

        private QuestionnaireDataAssets _dataAssets;
        private QuestionnaireInfo _questionnaireInfo;
        private QuestionnaireAnswerSheet _currentSheet;
        private bool _isUploading;
        private bool _layoutBuilt;
        private bool _showExpired;
        private bool _templatesExtracted;
        private Transform _runtimeTemplateRoot;

        private Transform _sidebarContent;
        private Transform _rightBody;
        private Transform _rightFooter;
        private TextMeshProUGUI _expiredToggleText;
        private Transform _rightHeaderRoot;
        private TextMeshProUGUI _rightHeaderTitle;
        private TextMeshProUGUI _rightHeaderSubtitle;
        private Button _recordsButton;
        private Button _startButton;
        private TextMeshProUGUI _recordsButtonText;
        private TextMeshProUGUI _startButtonText;
        private static readonly Dictionary<string, Sprite> SpriteCache = new Dictionary<string, Sprite>();

        protected override void OnInit()
        {
            base.OnInit();
            EnsureLayout();
        }

#if UNITY_EDITOR
        [ContextMenu("Questionnaire/Rebuild Design Templates")]
        public void RebuildDesignTemplatesContext()
        {
            if (!CanEditDesignTemplateHierarchy())
            {
                Debug.LogWarning(
                    "[UIOutsideQuestionnaireView] Open the questionnaire prefab in Prefab Mode before rebuilding design templates.");
                return;
            }

            EnsureDesignTemplates(true);
            UnityEditor.EditorUtility.SetDirty(this);
        }

        private bool CanEditDesignTemplateHierarchy()
        {
            if (this == null || gameObject == null) return false;

            var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage();
            if (prefabStage != null && prefabStage.prefabContentsRoot != null &&
                transform.root == prefabStage.prefabContentsRoot.transform)
            {
                return true;
            }

            return gameObject.scene.IsValid() && gameObject.scene.isLoaded &&
                   !UnityEditor.EditorUtility.IsPersistent(gameObject);
        }
#endif

        public void SetContent(ShowUIOutsideQuestionnaire evt)
        {
            EnsureLayout();
            if (Application.isPlaying)
            {
                ExtractPrefabTemplates();
            }

            LoadAssetsIfNeeded();

            CloseButton.onClick.RemoveAllListeners();
            CloseButton.onClick.AddListener(OnCloseClicked);
            SetUploading(false);

            var selected = ResolveInitialQuestionnaire(evt);
            if (selected != null && selected.GetEffectiveStatus(DateTime.UtcNow) == QuestionnaireStatus.Expired)
            {
                _showExpired = true;
            }

            BuildQuestionnaireList();

            if (selected == null)
            {
                ShowEmptyState(L(TextNoAvailableQuestionnaires));
                return;
            }

            SelectQuestionnaire(selected);
        }

        public void OnCloseView()
        {
        }

        public static string ResolveText(string raw)
        {
            if (string.IsNullOrEmpty(raw)) return string.Empty;
            if (uint.TryParse(raw, out var id))
            {
                return MultilingualManager.Instance.GetMultilingualText(id);
            }

            return raw;
        }

        private static string L(uint id)
        {
            return MultilingualManager.Instance.GetMultilingualText(id);
        }

        private static string L(uint id, params object[] values)
        {
            var text = L(id);
            if (string.IsNullOrEmpty(text) || values == null || values.Length == 0) return text;

            foreach (var value in values)
            {
                var index = text.IndexOf("{param}", StringComparison.Ordinal);
                if (index < 0) break;
                text = text.Remove(index, 7).Insert(index, value?.ToString() ?? string.Empty);
            }

            return text;
        }

        public static TextMeshProUGUI CreateText(Transform parent, string objectName, string text, float fontSize,
            Color color, TextAlignmentOptions alignment)
        {
            var go = new GameObject(objectName, typeof(RectTransform), typeof(TextMeshProUGUI));
            go.transform.SetParent(parent, false);
            var label = go.GetComponent<TextMeshProUGUI>();
            label.text = text;
            label.fontSize = fontSize;
            label.color = color;
            label.alignment = alignment;
            label.enableWordWrapping = false;
            label.raycastTarget = false;
            ApplyFontGroup(label, BodyFontGroupId);
            return label;
        }

        public static void ApplyTitleFont(TextMeshProUGUI label)
        {
            if (label == null) return;
            ApplyFontGroup(label, TitleFontGroupId);
        }

        private static void ApplyFontGroup(TextMeshProUGUI label, uint fontGroupId)
        {
            if (label == null) return;
            label.fontStyle = FontStyles.Normal;
            label.fontWeight = FontWeight.Regular;
            var font = MultilingualManager.Instance.GetMultilingualFont(fontGroupId);
            if (font != null) label.font = font;
        }

        public static Sprite LoadUiSprite(string path)
        {
            if (string.IsNullOrEmpty(path)) return null;
            if (SpriteCache.TryGetValue(path, out var cached)) return cached;

#if UNITY_EDITOR
            if (!Application.isPlaying)
            {
                var editorPath = $"Assets/BundleResources/{path}.png";
                var editorSprite = UnityEditor.AssetDatabase.LoadAssetAtPath<Sprite>(editorPath);
                if (editorSprite != null)
                {
                    SpriteCache[path] = editorSprite;
                    return editorSprite;
                }
            }
#endif

            var sprite = ResourceLoader.Load<Sprite>(path);
            SpriteCache[path] = sprite;
            return sprite;
        }

        public static void ApplySprite(Image image, string path, Color tint, bool preserveAspect = false,
            float pixelsPerUnitMultiplier = 1f)
        {
            if (image == null) return;
            image.sprite = LoadUiSprite(path);
            image.color = tint;
            image.preserveAspect = preserveAspect;
            image.pixelsPerUnitMultiplier = pixelsPerUnitMultiplier;
            image.type = image.sprite != null && image.sprite.border != Vector4.zero
                ? Image.Type.Sliced
                : Image.Type.Simple;
        }

        private void LoadAssetsIfNeeded()
        {
            if (_dataAssets == null)
            {
                _dataAssets = ResourceLoader.Load<QuestionnaireDataAssets>(DataAssetPath);
            }

            if (QuestionPrefab == null)
            {
                QuestionPrefab = ResourceLoader.Load<GameObject>(QuestionPrefabPath);
            }

            if (OptionPrefab == null)
            {
                OptionPrefab = ResourceLoader.Load<GameObject>(OptionPrefabPath);
            }
        }

        private QuestionnaireInfo ResolveInitialQuestionnaire(ShowUIOutsideQuestionnaire evt)
        {
            if (_dataAssets == null)
            {
                Debug.LogError("[UIOutsideQuestionnaireView] QuestionnaireDataAssets is missing.");
                return null;
            }

            QuestionnaireInfo selected = null;
            if (!string.IsNullOrEmpty(evt.QuestionnaireId))
            {
                _dataAssets.GetQuestionnaireInfo(evt.QuestionnaireId, out selected);
            }

            selected ??= _dataAssets.GetDefaultQuestionnaire();
            if (selected != null && selected.IsVisibleAt(DateTime.UtcNow)) return selected;

            return GetVisibleQuestionnaires().FirstOrDefault();
        }

        private List<QuestionnaireInfo> GetVisibleQuestionnaires()
        {
            return _dataAssets != null
                ? _dataAssets.GetVisibleQuestionnaires(DateTime.UtcNow)
                : new List<QuestionnaireInfo>();
        }

        private void SelectQuestionnaire(QuestionnaireInfo info)
        {
            if (info == null)
            {
                ShowEmptyState(L(TextNoAvailableQuestionnaires));
                return;
            }

            _questionnaireInfo = info;
            _currentSheet = QuestionnaireAnswerStore.Instance.GetLatestAnswerSheet(info.QuestionnaireId);
            if (info.GetEffectiveStatus(DateTime.UtcNow) == QuestionnaireStatus.Expired && !_showExpired)
            {
                _showExpired = true;
                BuildQuestionnaireList();
            }

            UpdateListSelection();
            ShowDetail();
        }

        private void BuildQuestionnaireList()
        {
            if (_sidebarContent == null) return;

            DestroyChildren(_sidebarContent);
            _listItems.Clear();

            var items = GetVisibleQuestionnaires();
            var featured = items.Where(item => item.GetEffectiveStatus(DateTime.UtcNow) == QuestionnaireStatus.Featured).ToList();
            var longTerm = items.Where(item => item.GetEffectiveStatus(DateTime.UtcNow) == QuestionnaireStatus.LongTerm).ToList();
            var expired = items.Where(item => item.GetEffectiveStatus(DateTime.UtcNow) == QuestionnaireStatus.Expired).ToList();

            CreateSectionHeader(_sidebarContent, L(TextCurrentQuestionnaire));
            CreateQuestionnaireListItems(featured, L(TextNoCurrentQuestionnaire));
            CreateDivider(_sidebarContent);

            CreateSectionHeader(_sidebarContent, L(TextLongTermQuestionnaire));
            CreateQuestionnaireListItems(longTerm, L(TextNoLongTermQuestionnaires));
            CreateDivider(_sidebarContent);

            CreateExpiredHeader(expired.Count);
            if (_showExpired)
            {
                CreateQuestionnaireListItems(expired, L(TextNoPastQuestionnaires));
            }
            else if (expired.Count > 0)
            {
                var hint = CreateText(_sidebarContent, "ExpiredHiddenHint",
                    L(TextPastQuestionnairesCollapsed, expired.Count), 20f,
                    InkMutedColor, TextAlignmentOptions.Left);
                hint.enableWordWrapping = true;
            }

            if (items.Count == 0)
            {
                var empty = CreateText(_sidebarContent, "EmptyList", L(TextNoQuestionnairesToDisplay), 20f,
                    InkMutedColor, TextAlignmentOptions.Left);
                empty.enableWordWrapping = true;
            }
        }

        private void CreateQuestionnaireListItems(List<QuestionnaireInfo> infos, string emptyText)
        {
            if (infos == null || infos.Count == 0)
            {
                var empty = CreateText(_sidebarContent, "Empty", emptyText, 20f,
                    InkMutedColor, TextAlignmentOptions.Left);
                empty.enableWordWrapping = true;
                return;
            }

            foreach (var info in infos)
            {
                CreateQuestionnaireListItem(info);
            }
        }

        private void CreateQuestionnaireListItem(QuestionnaireInfo info)
        {
            var row = InstantiateTemplate(QuestionnaireItemTemplate, _sidebarContent, "QuestionnaireItem");
            if (row == null)
            {
                row = new GameObject("QuestionnaireItem", typeof(RectTransform), typeof(Image), typeof(Button),
                    typeof(VerticalLayoutGroup), typeof(LayoutElement));
                row.transform.SetParent(_sidebarContent, false);
            }

            var image = EnsureImage(row.transform, PanelTint, true);
            ApplySprite(image, SpriteItemButton, PanelTint, false, ItemButtonPixelsPerUnitMultiplier);

            var layout = row.GetComponent<VerticalLayoutGroup>();
            if (layout == null)
            {
                layout = row.AddComponent<VerticalLayoutGroup>();
            }

            layout.padding = new RectOffset(26, 26, 16, 16);
            layout.spacing = 5f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;

            var layoutElement = row.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = row.AddComponent<LayoutElement>();
            }

            layoutElement.minHeight = 98f;
            layoutElement.preferredHeight = 102f;

            var button = row.GetComponent<Button>();
            if (button == null)
            {
                button = row.AddComponent<Button>();
            }

            button.targetGraphic = image;
            button.transition = Selectable.Transition.ColorTint;
            button.onClick.RemoveAllListeners();
            button.onClick.AddListener(() => SelectQuestionnaire(info));

            var header = row.transform.Find("Header");
            if (header == null)
            {
                var headerGo = new GameObject("Header", typeof(RectTransform), typeof(HorizontalLayoutGroup));
                headerGo.transform.SetParent(row.transform, false);
                header = headerGo.transform;
            }

            var headerLayout = header.GetComponent<HorizontalLayoutGroup>();
            if (headerLayout == null)
            {
                headerLayout = header.gameObject.AddComponent<HorizontalLayoutGroup>();
            }

            headerLayout.spacing = 8f;
            headerLayout.childControlWidth = true;
            headerLayout.childControlHeight = true;
            headerLayout.childForceExpandWidth = false;
            headerLayout.childForceExpandHeight = false;
            headerLayout.childAlignment = TextAnchor.MiddleLeft;

            var title = EnsureText(header.transform, "Title", ResolveText(info.Title), 24f,
                InkColor, TextAlignmentOptions.Left);
            title.enableWordWrapping = true;
            title.enableAutoSizing = false;
            ApplyTitleFont(title);
            var titleLayout = title.GetComponent<LayoutElement>();
            if (titleLayout == null)
            {
                titleLayout = title.gameObject.AddComponent<LayoutElement>();
            }

            titleLayout.flexibleWidth = 1f;

            var meta = EnsureText(row.transform, "Meta", BuildListMetaText(info), 20f,
                InkMutedColor, TextAlignmentOptions.Left);
            meta.enableWordWrapping = true;
            meta.enableAutoSizing = false;

            _listItems.Add(new QuestionnaireListItem
            {
                Info = info,
                Background = image,
                TitleText = title,
                MetaText = meta
            });
        }

        private void ShowDetail()
        {
            if (_questionnaireInfo == null)
            {
                ShowEmptyState(L(TextNoAvailableQuestionnaires));
                return;
            }

            ClearRight();
            var sheets = QuestionnaireAnswerStore.Instance.GetAnswerSheets(_questionnaireInfo.QuestionnaireId);
            _currentSheet = sheets.FirstOrDefault();

            SetRightHeader(string.Empty, string.Empty);

            TitleText = CreateText(_rightBody, "DetailTitle", ResolveText(_questionnaireInfo.Title), 38f,
                InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(TitleText);
            TitleText.enableWordWrapping = true;

            DescriptionText = CreateText(_rightBody, "Description", ResolveText(_questionnaireInfo.Description), 24f,
                InkColor, TextAlignmentOptions.Left);
            DescriptionText.enableWordWrapping = true;

            var latestMessage = ResolveSubmittedMessage(_currentSheet);
            if (!string.IsNullOrEmpty(latestMessage))
            {
                StatusText = CreateText(_rightBody, "LatestStatus", latestMessage, 20f,
                    GoldColor, TextAlignmentOptions.Left);
                StatusText.enableWordWrapping = true;
            }

            if (_currentSheet != null)
            {
                CreateLatestRecordPreview(_currentSheet);
            }

            var canStart = CanStartNewSubmission(_questionnaireInfo, sheets, out var blockReason);
            if (!canStart && !string.IsNullOrEmpty(blockReason))
            {
                CreateInfoStrip(_rightBody, blockReason, GoldColor);
            }

            if (sheets.Count > 0 && _questionnaireInfo.CanViewHistory)
            {
                _recordsButton = CreateButton(_rightFooter, "RecordsButton",
                    L(TextViewRecordsCount, sheets.Count), false,
                    out _recordsButtonText, 170f);
                _recordsButton.onClick.AddListener(ShowRecords);
            }

            var startText = sheets.Count > 0
                ? ResolveText(_questionnaireInfo.ResubmitButtonText)
                : ResolveText(_questionnaireInfo.StartButtonText);
            if (string.IsNullOrEmpty(startText))
            {
                startText = ResolveText(_questionnaireInfo.StartButtonText);
            }

            _startButton = CreateDetailStartButton(startText, canStart);
            _startButton.interactable = canStart;
            ApplyQuestionnaireButtonState(_startButton, true);
            _startButton.onClick.AddListener(ShowForm);
        }

        private void ShowForm()
        {
            if (_questionnaireInfo == null) return;

            var sheets = QuestionnaireAnswerStore.Instance.GetAnswerSheets(_questionnaireInfo.QuestionnaireId);
            if (!CanStartNewSubmission(_questionnaireInfo, sheets, out var blockReason))
            {
                ShowDetail();
                SetStatus(blockReason);
                return;
            }

            ClearRight();
            SetRightHeader(L(TextFillQuestionnaire), ResolveText(_questionnaireInfo.Title));

            TitleText = CreateText(_rightBody, "FormTitle", ResolveText(_questionnaireInfo.Title), 30f,
                InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(TitleText);
            TitleText.enableWordWrapping = true;

            var hint = CreateText(_rightBody, "FormHint", L(TextFormSubmitHint), 18f,
                InkMutedColor, TextAlignmentOptions.Left);
            hint.enableWordWrapping = true;

            CreateQuestionListRoot();
            BuildQuestions(_questionnaireInfo.Questions, false, null);

            StatusText = CreateText(_rightFooter, "Status", "", 17f,
                GoldColor, TextAlignmentOptions.Left);
            StatusText.enableWordWrapping = true;
            StatusText.gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;

            ConfigureFormFooter(_rightFooter);

            var backButton = CreateButton(_rightFooter, "BackButton", L(TextReturn), false, out var backButtonText, 150f);
            ConfigureFormFooterButton(backButton, backButtonText, 150f);
            backButton.onClick.AddListener(ShowDetail);

            RefillButton = CreateButton(_rightFooter, "RefillButton", L(TextClear), false, out RefillButtonText, 150f);
            ConfigureFormFooterButton(RefillButton, RefillButtonText, 150f);
            RefillButton.onClick.AddListener(OnRefillClicked);

            var submitText = ResolveText(_questionnaireInfo.SubmitButtonText);
            if (string.IsNullOrEmpty(submitText)) submitText = ResolveText("20099");
            SubmitButton = CreateButton(_rightFooter, "SubmitButton", submitText, true, out SubmitButtonText, 168f);
            ConfigureFormFooterButton(SubmitButton, SubmitButtonText, 168f);
            SubmitButton.onClick.AddListener(OnSubmitClicked);
            SetUploading(false);
            SetStatus(string.Empty);
        }

        private void ShowRecords()
        {
            if (_questionnaireInfo == null) return;

            ClearRight();
            SetRightHeader(L(TextResponseRecords), ResolveText(_questionnaireInfo.Title));

            var sheets = QuestionnaireAnswerStore.Instance.GetAnswerSheets(_questionnaireInfo.QuestionnaireId);
            TitleText = CreateText(_rightBody, "RecordsTitle", L(TextResponseRecords), 31f,
                InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(TitleText);

            if (sheets.Count == 0)
            {
                var empty = CreateText(_rightBody, "EmptyRecords", L(TextNoResponseRecords), 20f,
                    InkMutedColor, TextAlignmentOptions.Left);
                empty.enableWordWrapping = true;
            }
            else
            {
                for (var i = 0; i < sheets.Count; i++)
                {
                    CreateRecordRow(sheets[i], i + 1);
                }
            }

            var backButton = CreateButton(_rightFooter, "BackButton", L(TextReturn), false, out _, 120f);
            backButton.onClick.AddListener(ShowDetail);
        }

        private void ShowReadonlyRecord(QuestionnaireAnswerSheet sheet)
        {
            if (sheet == null) return;

            ClearRight();
            SetRightHeader(L(TextView), ResolveText(_questionnaireInfo?.Title));

            var snapshotTitle = sheet.DefinitionSnapshot != null && !string.IsNullOrEmpty(sheet.DefinitionSnapshot.Title)
                ? sheet.DefinitionSnapshot.Title
                : ResolveText(_questionnaireInfo?.Title);

            TitleText = CreateText(_rightBody, "RecordTitle", snapshotTitle, 30f,
                InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(TitleText);
            TitleText.enableWordWrapping = true;

            CreateInfoStrip(_rightBody, $"{FormatSubmittedAt(sheet)}  ·  {GetUploadStateText(sheet)}  ·  {L(TextReadOnlyRecord)}");

            CreateQuestionListRoot();
            var questions = BuildQuestionsFromSnapshot(sheet.DefinitionSnapshot);
            if (questions == null || questions.Count == 0)
            {
                questions = _questionnaireInfo?.Questions;
            }

            BuildQuestions(questions, true, sheet);

            var backButton = CreateButton(_rightFooter, "BackButton", L(TextBackToRecords), false, out _, 140f);
            backButton.onClick.AddListener(ShowRecords);
        }

        private void CreateLatestRecordPreview(QuestionnaireAnswerSheet sheet)
        {
            var preview = InstantiateTemplate(LatestRecordPreviewTemplate, _rightBody, "LatestRecordPreview") ??
                          CreatePanel(_rightBody, "LatestRecordPreview", PanelTint);
            var image = EnsureImage(preview.transform, PanelTint, true);
            ApplySprite(image, SpriteCommonPanel, PanelTint);

            var layout = preview.GetComponent<VerticalLayoutGroup>();
            if (layout == null)
            {
                layout = preview.AddComponent<VerticalLayoutGroup>();
            }

            layout.padding = new RectOffset(16, 16, 14, 14);
            layout.spacing = 6f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;

            var title = EnsureText(preview.transform, "Title", L(TextLatestSubmission), 20f,
                InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(title);

            var meta = EnsureText(preview.transform, "Meta", $"{FormatSubmittedAt(sheet)}  ·  {GetUploadStateText(sheet)}", 17f,
                InkMutedColor, TextAlignmentOptions.Left);
            meta.enableWordWrapping = true;
        }

        private void CreateRecordRow(QuestionnaireAnswerSheet sheet, int index)
        {
            var row = InstantiateTemplate(RecordRowTemplate, _rightBody, "RecordRow");
            if (row == null)
            {
                row = new GameObject("RecordRow", typeof(RectTransform), typeof(Image), typeof(HorizontalLayoutGroup),
                    typeof(LayoutElement));
                row.transform.SetParent(_rightBody, false);
            }

            var image = EnsureImage(row.transform, PanelTint, true);
            ApplySprite(image, SpriteCommonLabel, PanelTint);

            var layout = row.GetComponent<HorizontalLayoutGroup>();
            if (layout == null)
            {
                layout = row.AddComponent<HorizontalLayoutGroup>();
            }

            layout.padding = new RectOffset(16, 14, 12, 12);
            layout.spacing = 14f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = false;
            layout.childForceExpandHeight = false;
            layout.childAlignment = TextAnchor.MiddleLeft;

            var layoutElement = row.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = row.AddComponent<LayoutElement>();
            }

            layoutElement.minHeight = 76f;

            var textRoot = row.transform.Find("TextRoot");
            if (textRoot == null)
            {
                var textRootGo = new GameObject("TextRoot", typeof(RectTransform), typeof(VerticalLayoutGroup),
                    typeof(LayoutElement));
                textRootGo.transform.SetParent(row.transform, false);
                textRoot = textRootGo.transform;
            }

            var textRootLayoutElement = textRoot.GetComponent<LayoutElement>();
            if (textRootLayoutElement == null)
            {
                textRootLayoutElement = textRoot.gameObject.AddComponent<LayoutElement>();
            }

            textRootLayoutElement.flexibleWidth = 1f;
            var textLayout = textRoot.GetComponent<VerticalLayoutGroup>();
            if (textLayout == null)
            {
                textLayout = textRoot.gameObject.AddComponent<VerticalLayoutGroup>();
            }

            textLayout.spacing = 3f;
            textLayout.childControlWidth = true;
            textLayout.childControlHeight = true;
            textLayout.childForceExpandWidth = true;
            textLayout.childForceExpandHeight = false;

            var title = EnsureText(textRoot.transform, "Title", L(TextRecordIndex, index), 20f,
                InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(title);

            var meta = EnsureText(textRoot.transform, "Meta", $"{FormatSubmittedAt(sheet)}  ·  {GetUploadStateText(sheet)}", 17f,
                InkMutedColor, TextAlignmentOptions.Left);
            meta.enableWordWrapping = true;

            var viewButtonTransform = row.transform.Find("ViewButton");
            var viewButton = viewButtonTransform != null
                ? ConfigureButton(viewButtonTransform.gameObject, L(TextView), false, out _, 104f)
                : CreateButton(row.transform, "ViewButton", L(TextView), false, out _, 104f);
            viewButton.onClick.AddListener(() => ShowReadonlyRecord(sheet));
        }

        private void BuildQuestions(IList<QuestionnaireQuestionInfo> questions, bool readOnly, QuestionnaireAnswerSheet sheet)
        {
            if (QuestionListContent == null) return;

            DestroyChildren(QuestionListContent);
            _questionItems.Clear();
            if (questions == null) return;

            Dictionary<string, QuestionnaireAnswer> answerDict = null;
            if (sheet?.Answers != null)
            {
                answerDict = sheet.Answers
                    .Where(answer => answer != null && !string.IsNullOrEmpty(answer.QuestionId))
                    .GroupBy(answer => answer.QuestionId)
                    .ToDictionary(group => group.Key, group => group.First());
            }

            for (var i = 0; i < questions.Count; i++)
            {
                var question = questions[i];
                if (question == null) continue;

                var item = CreateQuestionItem();
                item.SetContent(i + 1, question, OptionPrefab, readOnly ? null : OnAnswerChanged);
                if (answerDict != null && !string.IsNullOrEmpty(question.QuestionId) &&
                    answerDict.TryGetValue(question.QuestionId, out var answer))
                {
                    item.ApplyAnswer(answer);
                }

                item.SetReadOnly(readOnly);
                _questionItems.Add(item);
            }
        }

        private UIOutsideQuestionnaireQuestionMono CreateQuestionItem()
        {
            GameObject go;
            if (QuestionPrefab != null)
            {
                go = Instantiate(QuestionPrefab, QuestionListContent);
            }
            else
            {
                go = new GameObject("Question", typeof(RectTransform));
                go.transform.SetParent(QuestionListContent, false);
            }

            var item = go.GetComponent<UIOutsideQuestionnaireQuestionMono>();
            if (item == null)
            {
                item = go.AddComponent<UIOutsideQuestionnaireQuestionMono>();
            }

            return item;
        }

        private void OnSubmitClicked()
        {
            if (_isUploading) return;
            _ = SubmitQuestionnaireAsync();
        }

        private async System.Threading.Tasks.Task SubmitQuestionnaireAsync()
        {
            if (_questionnaireInfo == null) return;
            var sheets = QuestionnaireAnswerStore.Instance.GetAnswerSheets(_questionnaireInfo.QuestionnaireId);
            if (!CanStartNewSubmission(_questionnaireInfo, sheets, out var blockReason))
            {
                SetStatus(blockReason);
                return;
            }

            if (!ValidateRequiredQuestions())
            {
                SetStatus(ResolveText(_questionnaireInfo.RequiredMessage));
                return;
            }

            var submitted = false;
            SetUploading(true);
            try
            {
                var sheet = new QuestionnaireAnswerSheet
                {
                    QuestionnaireId = _questionnaireInfo.QuestionnaireId,
                    QuestionnaireRevision = _questionnaireInfo.Revision,
                    ClientVersion = QuestionnaireUploadService.GetCurrentVersion(),
                    DefinitionSnapshot = CreateDefinitionSnapshot(_questionnaireInfo),
                    Answers = new List<QuestionnaireAnswer>()
                };

                foreach (var item in _questionItems)
                {
                    sheet.Answers.Add(item.CreateAnswer());
                }

                if (!QuestionnaireAnswerStore.Instance.SaveAnswerSheet(sheet))
                {
                    SetStatus(ResolveText(_questionnaireInfo.SaveFailedMessage));
                    return;
                }

                submitted = true;
                _currentSheet = sheet;
                SetStatus(ResolveQuestionnaireMessage(_questionnaireInfo.UploadingMessage,
                    _questionnaireInfo.SubmittedMessage));

                if (!TryGetSteamId(out var steamId))
                {
                    QuestionnaireAnswerStore.Instance.SaveUploadResultByResponseId(sheet.ResponseId, false, null,
                        "Steam login unavailable");
                    SetStatus(ResolveQuestionnaireMessage(_questionnaireInfo.UploadAuthFailedMessage,
                        _questionnaireInfo.SubmittedMessage));
                    return;
                }

                await UploadSavedSheetAsync(steamId, sheet);
            }
            catch (Exception ex)
            {
                LogSystem.LogError($"Questionnaire submit exception: {ex}");
                SetStatus(ResolveQuestionnaireMessage(_questionnaireInfo.UploadFailedMessage,
                    _questionnaireInfo.SubmittedMessage));
            }
            finally
            {
                SetUploading(false);
                if (submitted)
                {
                    BuildQuestionnaireList();
                    SelectQuestionnaire(_questionnaireInfo);
                }
            }
        }

        private async System.Threading.Tasks.Task UploadSavedSheetAsync(string steamId, QuestionnaireAnswerSheet sheet)
        {
            try
            {
                var version = QuestionnaireUploadService.GetCurrentVersion();
                var bytes = QuestionnaireUploadService.BuildPayloadBytes(steamId, sheet, version);
                if (bytes.Length > QuestionnaireUploadService.MaxQuestionnaireUploadBytes)
                {
                    LogSystem.LogError(
                        $"Questionnaire upload failed: package size {bytes.Length} exceeds {QuestionnaireUploadService.MaxQuestionnaireUploadBytes}");
                    QuestionnaireAnswerStore.Instance.SaveUploadResultByResponseId(sheet.ResponseId, false, null,
                        "Questionnaire payload too large");
                    SetStatus(ResolveQuestionnaireMessage(_questionnaireInfo.UploadFailedMessage,
                        _questionnaireInfo.SubmittedMessage));
                    return;
                }

                var result = await OssManager.Instance.UploadQuestionnaireAnswerAsync(steamId, bytes, version);
                QuestionnaireAnswerStore.Instance.SaveUploadResultByResponseId(sheet.ResponseId, result.success,
                    result.objectKey, result.success ? string.Empty : "OSS upload failed");

                SetStatus(result.success
                    ? ResolveQuestionnaireMessage(_questionnaireInfo.UploadSuccessMessage, _questionnaireInfo.SubmittedMessage)
                    : ResolveQuestionnaireMessage(_questionnaireInfo.UploadFailedMessage, _questionnaireInfo.SubmittedMessage));
            }
            catch (Exception ex)
            {
                LogSystem.LogError($"Questionnaire submit exception: {ex}");
                QuestionnaireAnswerStore.Instance.SaveUploadResultByResponseId(sheet.ResponseId, false, null, ex.Message);
                SetStatus(ResolveQuestionnaireMessage(_questionnaireInfo.UploadFailedMessage,
                    _questionnaireInfo.SubmittedMessage));
            }
        }

        private bool ValidateRequiredQuestions()
        {
            foreach (var item in _questionItems)
            {
                if (item.QuestionInfo != null && item.QuestionInfo.Required && !item.HasAnswer())
                {
                    return false;
                }
            }

            return true;
        }

        private void OnRefillClicked()
        {
            foreach (var item in _questionItems)
            {
                item.ClearAnswer();
            }

            SetStatus(ResolveText(_questionnaireInfo?.RefillHintText));
        }

        private void OnAnswerChanged()
        {
            if (!string.IsNullOrEmpty(StatusText?.text))
            {
                SetStatus(string.Empty);
            }
        }

        private void OnCloseClicked()
        {
            OnBtnCloseClick?.Invoke();
        }

        private void SetStatus(string text)
        {
            if (StatusText == null) return;
            StatusText.text = text ?? string.Empty;
            StatusText.gameObject.SetActive(!string.IsNullOrEmpty(StatusText.text));
        }

        private void SetUploading(bool uploading)
        {
            _isUploading = uploading;
            if (SubmitButton != null) SubmitButton.interactable = !uploading;
            if (RefillButton != null) RefillButton.interactable = !uploading;
            if (CloseButton != null) CloseButton.interactable = !uploading;
            if (_recordsButton != null) _recordsButton.interactable = !uploading;
            ApplyQuestionnaireButtonState(SubmitButton, true);
            ApplyQuestionnaireButtonState(RefillButton, false);
            ApplyQuestionnaireButtonState(_recordsButton, false);
            ApplyQuestionnaireButtonState(_startButton, true);
        }

        private void ApplyQuestionnaireButtonState(Button button, bool primary)
        {
            if (button == null) return;
            var image = button.targetGraphic as Image;
            if (image == null) image = button.GetComponent<Image>();
            if (image == null) return;

            ApplySprite(image, button.interactable ? (primary ? SpriteButtonPrimary : SpriteButtonSecondary) : SpriteButtonDisabled,
                PanelTint, false, GetActionButtonPixelsPerUnitMultiplier(primary));
        }

        private static bool CanStartNewSubmission(QuestionnaireInfo info, List<QuestionnaireAnswerSheet> sheets,
            out string reason)
        {
            reason = string.Empty;
            if (info == null)
            {
                reason = L(TextQuestionnaireMissing);
                return false;
            }

            var now = DateTime.UtcNow;
            if (!info.CanSubmitAt(now))
            {
                reason = info.GetEffectiveStatus(now) == QuestionnaireStatus.Expired
                    ? L(TextQuestionnaireEnded)
                    : L(TextQuestionnaireUnavailable);
                return false;
            }

            var submittedCount = sheets?.Count ?? 0;
            if (submittedCount > 0 && !info.AllowMultipleSubmissions)
            {
                reason = L(TextQuestionnaireAlreadySubmitted);
                return false;
            }

            if (info.MaxSubmissionCount > 0 && submittedCount >= info.MaxSubmissionCount)
            {
                reason = L(TextQuestionnaireSubmissionLimit);
                return false;
            }

            if (info.MinSubmitIntervalHours > 0 && sheets != null && sheets.Count > 0)
            {
                var latestUnix = sheets[0].SubmittedAtUnix;
                if (latestUnix > 0)
                {
                    var nextAt = DateTimeOffset.FromUnixTimeSeconds(latestUnix).UtcDateTime
                                 .AddHours(info.MinSubmitIntervalHours);
                    if (now < nextAt)
                    {
                        reason = L(TextQuestionnaireInterval, nextAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm"));
                        return false;
                    }
                }
            }

            return true;
        }

        private static string ResolveQuestionnaireMessage(string message, string fallback)
        {
            var resolved = ResolveText(message);
            return string.IsNullOrEmpty(resolved) ? ResolveText(fallback) : resolved;
        }

        private string ResolveSubmittedMessage(QuestionnaireAnswerSheet sheet)
        {
            if (sheet == null || _questionnaireInfo == null) return string.Empty;
            if (!string.IsNullOrEmpty(sheet.LastUploadObjectKey))
                return ResolveQuestionnaireMessage(_questionnaireInfo.UploadSuccessMessage,
                    _questionnaireInfo.SubmittedMessage);
            if (!string.IsNullOrEmpty(sheet.LastUploadError))
                return ResolveQuestionnaireMessage(_questionnaireInfo.UploadFailedMessage,
                    _questionnaireInfo.SubmittedMessage);
            return ResolveText(_questionnaireInfo.SubmittedMessage);
        }

        private static bool TryGetSteamId(out string steamId)
        {
            steamId = string.Empty;
#if STEAM_CHANNEL || STEAMWORKS_NET
            try
            {
                if (!SteamUser.BLoggedOn())
                    return false;

                var id = SteamUser.GetSteamID().m_SteamID;
                if (id == 0)
                    return false;

                steamId = id.ToString();
                return true;
            }
            catch (Exception ex)
            {
                LogSystem.LogWarning($"Questionnaire SteamID unavailable: {ex.Message}");
                return false;
            }
#else
            return false;
#endif
        }

        private static QuestionnaireDefinitionSnapshot CreateDefinitionSnapshot(QuestionnaireInfo info)
        {
            if (info == null) return null;

            var snapshot = new QuestionnaireDefinitionSnapshot
            {
                QuestionnaireId = info.QuestionnaireId,
                Revision = info.Revision,
                Title = ResolveText(info.Title),
                Description = ResolveText(info.Description),
                Questions = new List<QuestionnaireQuestionSnapshot>()
            };

            if (info.Questions == null) return snapshot;

            foreach (var question in info.Questions)
            {
                if (question == null) continue;

                var questionSnapshot = new QuestionnaireQuestionSnapshot
                {
                    QuestionId = question.QuestionId,
                    QuestionType = question.QuestionType,
                    Title = ResolveText(question.Title),
                    Hint = ResolveText(question.Hint),
                    Required = question.Required,
                    Options = new List<QuestionnaireOptionSnapshot>()
                };

                if (question.Options != null)
                {
                    foreach (var option in question.Options)
                    {
                        if (option == null) continue;
                        questionSnapshot.Options.Add(new QuestionnaireOptionSnapshot
                        {
                            OptionId = option.OptionId,
                            Text = ResolveText(option.Text)
                        });
                    }
                }

                snapshot.Questions.Add(questionSnapshot);
            }

            return snapshot;
        }

        private static List<QuestionnaireQuestionInfo> BuildQuestionsFromSnapshot(QuestionnaireDefinitionSnapshot snapshot)
        {
            if (snapshot?.Questions == null || snapshot.Questions.Count == 0) return null;

            var result = new List<QuestionnaireQuestionInfo>();
            foreach (var question in snapshot.Questions)
            {
                if (question == null) continue;

                var info = new QuestionnaireQuestionInfo
                {
                    QuestionId = question.QuestionId,
                    QuestionType = question.QuestionType,
                    Title = question.Title,
                    Hint = question.Hint,
                    Required = question.Required,
                    Options = new List<QuestionnaireOptionInfo>()
                };

                if (question.Options != null)
                {
                    foreach (var option in question.Options)
                    {
                        if (option == null) continue;
                        info.Options.Add(new QuestionnaireOptionInfo
                        {
                            OptionId = option.OptionId,
                            Text = option.Text
                        });
                    }
                }

                result.Add(info);
            }

            return result;
        }

        private void EnsureLayout()
        {
            var rootRect = GetComponent<RectTransform>();
            rootRect.anchorMin = Vector2.zero;
            rootRect.anchorMax = Vector2.one;
            rootRect.offsetMin = Vector2.zero;
            rootRect.offsetMax = Vector2.zero;

            var canvasGroup = GetComponent<CanvasGroup>();
            if (canvasGroup == null)
            {
                gameObject.AddComponent<CanvasGroup>();
            }

            var background = GetComponent<Image>();
            if (background == null)
            {
                background = gameObject.AddComponent<Image>();
                background.color = new Color(0f, 0f, 0f, 0.5882353f);
            }

            if (_layoutBuilt) return;
            _layoutBuilt = true;

            if (TryBindPrefabLayout())
            {
                return;
            }

            CreateMainLayout();
        }

        private bool TryBindPrefabLayout()
        {
            var center = transform.Find("QuestionnaireCenter");
            var sidebar = FindPanelChild(center, "Sidebar");
            var right = FindPanelChild(center, "RightPanel");
            var close = transform.Find("CloseButton") ??
                        (center != null ? center.Find("TitleArea/CloseButton") : null) ??
                        FindDeepChild(center, "CloseButton");
            if (center == null || sidebar == null || right == null)
            {
                return false;
            }

            var sidebarScroll = sidebar != null ? sidebar.Find("SidebarScroll") : null;
            var sidebarContent = sidebarScroll != null ? sidebarScroll.Find("Viewport/Content") : null;
            var rightHeader = right != null ? right.Find("Header") : null;
            var bodyScroll = right != null ? right.Find("BodyScroll") : null;
            var bodyContent = bodyScroll != null ? bodyScroll.Find("Viewport/Content") : null;
            var footer = right != null ? right.Find("Footer") : null;

            if (close == null || center == null || sidebarContent == null || rightHeader == null ||
                bodyContent == null || footer == null)
            {
                return false;
            }

            _sidebarContent = sidebarContent;

            _rightBody = bodyContent;
            _rightFooter = footer;
            BindCloseButton(close);
            BindRightHeader(rightHeader);
            BindScroll(sidebarScroll, sidebarContent);
            BindScroll(bodyScroll, bodyContent);

            if (Application.isPlaying)
            {
                ExtractPrefabTemplates();
            }

            return CloseButton != null && _rightBody != null && _rightFooter != null && _sidebarContent != null;
        }

        private void BindCloseButton(Transform close)
        {
            CloseButton = close != null ? close.GetComponent<Button>() : null;
            if (CloseButton == null && close != null)
            {
                CloseButton = close.gameObject.AddComponent<Button>();
            }

            var label = close != null ? close.Find("Label") : null;
            CloseButtonText = label != null ? label.GetComponent<TextMeshProUGUI>() : null;
        }

        private void BindRightHeader(Transform rightHeader)
        {
            _rightHeaderRoot = rightHeader;
            _rightHeaderTitle = FindExistingText(rightHeader, "Title");
            _rightHeaderSubtitle = FindExistingText(rightHeader, "Subtitle");
        }

        private static TextMeshProUGUI FindExistingText(Transform parent, string objectName)
        {
            if (parent == null) return null;
            return (parent.Find(objectName) ?? FindDeepChild(parent, objectName))?.GetComponent<TextMeshProUGUI>();
        }

        private static void BindScroll(Transform scrollRoot, Transform content)
        {
            if (scrollRoot == null || content == null) return;
            var scrollRect = scrollRoot.GetComponent<ScrollRect>();
            if (scrollRect == null) return;

            var viewport = scrollRoot.Find("Viewport") as RectTransform;
            scrollRect.viewport = viewport;
            scrollRect.content = content as RectTransform;
        }

        private void ExtractPrefabTemplates()
        {
            if (_templatesExtracted) return;
            _templatesExtracted = true;

            _runtimeTemplateRoot = transform.Find("RuntimeTemplates");
            if (_runtimeTemplateRoot == null)
            {
                var templateRoot = new GameObject("RuntimeTemplates", typeof(RectTransform));
                templateRoot.transform.SetParent(transform, false);
                _runtimeTemplateRoot = templateRoot.transform;
            }

            ExtractTemplate(ref QuestionnaireItemTemplate, _sidebarContent, "QuestionnaireItemTemplate");
            ExtractTemplate(ref SectionHeaderTemplate, _sidebarContent, "SectionHeaderTemplate");
            ExtractTemplate(ref DividerTemplate, _sidebarContent, "DividerTemplate");
            ExtractTemplate(ref InfoStripTemplate, _rightBody, "InfoStripTemplate");
            ExtractTemplate(ref LatestRecordPreviewTemplate, _rightBody, "LatestRecordPreviewTemplate");
            ExtractTemplate(ref RecordRowTemplate, _rightBody, "RecordRowTemplate");
            ExtractTemplate(ref PrimaryButtonTemplate, _rightFooter, "PrimaryButtonTemplate");
            ExtractTemplate(ref SecondaryButtonTemplate, _rightFooter, "SecondaryButtonTemplate");

            _runtimeTemplateRoot.gameObject.SetActive(false);
        }

        private void ExtractTemplate(ref GameObject template, Transform preferredParent, string objectName)
        {
            var templateTransform = template != null
                ? template.transform
                : preferredParent != null
                    ? preferredParent.Find(objectName)
                    : null;

            templateTransform ??= FindDeepChild(transform, objectName);
            if (templateTransform == null) return;

            template = templateTransform.gameObject;
            template.SetActive(false);
            templateTransform.SetParent(_runtimeTemplateRoot, false);
        }

        private GameObject InstantiateTemplate(GameObject template, Transform parent, string objectName)
        {
            if (template == null || parent == null) return null;
            var go = Instantiate(template, parent, false);
            go.name = objectName;
            go.SetActive(true);
            return go;
        }

        private static Image EnsureImage(Transform target, Color color, bool raycastTarget)
        {
            var image = target.GetComponent<Image>();
            if (image == null)
            {
                image = target.gameObject.AddComponent<Image>();
            }

            image.color = color;
            image.raycastTarget = raycastTarget;
            return image;
        }

        private static TextMeshProUGUI EnsureText(Transform parent, string objectName, string text, float fontSize,
            Color color, TextAlignmentOptions alignment)
        {
            var child = parent.Find(objectName) ?? FindDeepChild(parent, objectName);
            TextMeshProUGUI label;
            if (child == null)
            {
                label = CreateText(parent, objectName, text, fontSize, color, alignment);
            }
            else
            {
                label = child.GetComponent<TextMeshProUGUI>();
                if (label == null)
                {
                    label = child.gameObject.AddComponent<TextMeshProUGUI>();
                }
            }

            label.text = text;
            label.fontSize = fontSize;
            label.color = color;
            label.alignment = alignment;
            return label;
        }

        private static Transform FindDeepChild(Transform parent, string objectName)
        {
            if (parent == null || string.IsNullOrEmpty(objectName)) return null;
            for (var i = 0; i < parent.childCount; i++)
            {
                var child = parent.GetChild(i);
                if (child.name == objectName) return child;

                var result = FindDeepChild(child, objectName);
                if (result != null) return result;
            }

            return null;
        }

        private static Transform FindPanelChild(Transform parent, string objectName)
        {
            if (parent == null) return null;
            return parent.Find($"ContentArea/{objectName}") ?? parent.Find(objectName) ?? FindDeepChild(parent, objectName);
        }

        private static Transform EnsureFullscreenLibraryStructure(Transform center, Transform sidebar, Transform right,
            Transform close)
        {
            ConfigureOutsideRoot(center);
            var topBar = EnsureLibraryTopBar(center);
            HideLegacyTopStripe(center);

            var titleArea = EnsureTitleArea(center);
            var contentArea = EnsureContentArea(center);
            MoveIntoContentArea(sidebar, contentArea, 0);
            MoveIntoContentArea(right, contentArea, 1);

            close ??= EnsureCloseButton(center);
            close.SetParent(center, false);
            EnsurePanelTitle(titleArea);

            topBar.SetSiblingIndex(0);
            titleArea.SetSiblingIndex(1);
            contentArea.SetSiblingIndex(2);
            close.SetAsLastSibling();
            return close;
        }

        private static void ConfigureOutsideRoot(Transform center)
        {
            if (center is RectTransform rect)
            {
                rect.anchorMin = Vector2.zero;
                rect.anchorMax = Vector2.one;
                rect.offsetMin = Vector2.zero;
                rect.offsetMax = Vector2.zero;
                rect.pivot = new Vector2(0.5f, 0.5f);
            }

            var image = EnsureImage(center, PanelTint, true);
            ApplySprite(image, SpriteFullscreenBackdrop, PanelTint);
            image.type = Image.Type.Tiled;
            image.preserveAspect = false;
            image.raycastTarget = true;

            var horizontal = center.GetComponent<HorizontalLayoutGroup>();
            if (horizontal != null)
            {
                horizontal.enabled = false;
            }

            var layout = center.GetComponent<VerticalLayoutGroup>();
            if (layout == null)
            {
                layout = center.gameObject.AddComponent<VerticalLayoutGroup>();
            }

            layout.padding = new RectOffset((int)LibraryFrameHorizontalPadding, (int)LibraryFrameHorizontalPadding,
                (int)LibraryFrameTopPadding, (int)LibraryFrameBottomPadding);
            layout.spacing = ContentAreaSpacing;
            layout.childAlignment = TextAnchor.UpperLeft;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;
        }

        private static Transform EnsureLibraryTopBar(Transform center)
        {
            var topBar = center.Find("TopBar");
            if (topBar == null)
            {
                var go = new GameObject("TopBar", typeof(RectTransform), typeof(Image), typeof(LayoutElement));
                go.transform.SetParent(center, false);
                topBar = go.transform;
            }

            if (topBar is RectTransform rect)
            {
                rect.anchorMin = new Vector2(0f, 1f);
                rect.anchorMax = new Vector2(1f, 1f);
                rect.pivot = new Vector2(0.5f, 1f);
                rect.anchoredPosition = Vector2.zero;
                rect.sizeDelta = new Vector2(0f, LibraryTopBarHeight);
            }

            var image = EnsureImage(topBar, PanelTint, true);
            ApplySprite(image, SpriteLibraryTopBar, PanelTint);
            image.type = Image.Type.Filled;
            image.fillMethod = Image.FillMethod.Radial360;
            image.fillOrigin = 2;
            image.fillAmount = 1f;

            var layoutElement = topBar.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = topBar.gameObject.AddComponent<LayoutElement>();
            }

            layoutElement.ignoreLayout = true;
            return topBar;
        }

        private static Transform EnsureTitleArea(Transform center)
        {
            var titleArea = center.Find("TitleArea");
            if (titleArea == null)
            {
                var go = new GameObject("TitleArea", typeof(RectTransform), typeof(HorizontalLayoutGroup),
                    typeof(LayoutElement));
                go.transform.SetParent(center, false);
                titleArea = go.transform;
            }

            var image = titleArea.GetComponent<Image>();
            if (image != null)
            {
                image.sprite = null;
                image.color = TransparentPanelTint;
                image.raycastTarget = false;
            }

            var layout = titleArea.GetComponent<HorizontalLayoutGroup>();
            if (layout == null)
            {
                layout = titleArea.gameObject.AddComponent<HorizontalLayoutGroup>();
            }

            layout.padding = new RectOffset(68, 0, 0, 0);
            layout.spacing = 14f;
            layout.childAlignment = TextAnchor.MiddleLeft;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = false;
            layout.childForceExpandHeight = false;

            var layoutElement = titleArea.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = titleArea.gameObject.AddComponent<LayoutElement>();
            }

            layoutElement.minHeight = TitleAreaHeight;
            layoutElement.preferredHeight = TitleAreaHeight;
            return titleArea;
        }

        private static Transform EnsureContentArea(Transform center)
        {
            var contentArea = center.Find("ContentArea");
            if (contentArea == null)
            {
                var go = new GameObject("ContentArea", typeof(RectTransform), typeof(HorizontalLayoutGroup),
                    typeof(LayoutElement));
                go.transform.SetParent(center, false);
                contentArea = go.transform;
            }

            var layout = contentArea.GetComponent<HorizontalLayoutGroup>();
            if (layout == null)
            {
                layout = contentArea.gameObject.AddComponent<HorizontalLayoutGroup>();
            }

            layout.padding = new RectOffset(0, 0, 0, 0);
            layout.spacing = ContentAreaSpacing;
            layout.childAlignment = TextAnchor.UpperLeft;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = false;
            layout.childForceExpandHeight = true;

            var layoutElement = contentArea.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = contentArea.gameObject.AddComponent<LayoutElement>();
            }

            layoutElement.minHeight = 480f;
            layoutElement.flexibleHeight = 1f;
            return contentArea;
        }

        private static void MoveIntoContentArea(Transform child, Transform contentArea, int siblingIndex)
        {
            if (child == null || contentArea == null) return;
            if (child.parent != contentArea)
            {
                child.SetParent(contentArea, false);
            }

            child.SetSiblingIndex(siblingIndex);
        }

        private static Transform EnsureCloseButton(Transform root)
        {
            var close = root.Find("CloseButton") ?? FindDeepChild(root, "CloseButton");
            if (close != null) return close;

            var go = new GameObject("CloseButton", typeof(RectTransform), typeof(Image), typeof(Button),
                typeof(LayoutElement));
            go.transform.SetParent(root, false);
            return go.transform;
        }

        private void ConfigureCloseButton(Transform close)
        {
            var closeImage = EnsureImage(close, PanelTint, true);
            ApplySprite(closeImage, SpriteReturnButton, PanelTint, true);
            CloseButton = close.GetComponent<Button>();
            if (CloseButton == null)
            {
                CloseButton = close.gameObject.AddComponent<Button>();
            }

            CloseButton.transition = Selectable.Transition.ColorTint;
            CloseButton.targetGraphic = closeImage;

            if (close is RectTransform rect)
            {
                rect.anchorMin = new Vector2(0f, 1f);
                rect.anchorMax = new Vector2(0f, 1f);
                rect.pivot = new Vector2(0.5f, 0.5f);
                rect.anchoredPosition = new Vector2(53f, -39f);
                rect.sizeDelta = new Vector2(46f, 46f);
            }

            var layoutElement = close.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = close.gameObject.AddComponent<LayoutElement>();
            }

            layoutElement.ignoreLayout = true;
            layoutElement.minWidth = 46f;
            layoutElement.preferredWidth = 46f;
            layoutElement.minHeight = 46f;
            layoutElement.preferredHeight = 46f;

            var label = close.Find("Label");
            CloseButtonText = label != null ? label.GetComponent<TextMeshProUGUI>() : null;
            if (CloseButtonText != null)
            {
                CloseButtonText.text = string.Empty;
                CloseButtonText.raycastTarget = false;
                CloseButtonText.gameObject.SetActive(false);
            }
        }

        private static void EnsurePanelTitle(Transform titleArea)
        {
            var textRoot = titleArea.Find("TitleTextRoot");
            if (textRoot == null)
            {
                var go = new GameObject("TitleTextRoot", typeof(RectTransform), typeof(VerticalLayoutGroup),
                    typeof(LayoutElement));
                go.transform.SetParent(titleArea, false);
                textRoot = go.transform;
            }

            textRoot.SetSiblingIndex(0);
            var rootLayoutElement = textRoot.GetComponent<LayoutElement>();
            if (rootLayoutElement == null)
            {
                rootLayoutElement = textRoot.gameObject.AddComponent<LayoutElement>();
            }

            rootLayoutElement.flexibleWidth = 1f;

            var rootLayout = textRoot.GetComponent<VerticalLayoutGroup>();
            if (rootLayout == null)
            {
                rootLayout = textRoot.gameObject.AddComponent<VerticalLayoutGroup>();
            }

            rootLayout.padding = new RectOffset(0, 0, 8, 0);
            rootLayout.spacing = 0f;
            rootLayout.childControlWidth = true;
            rootLayout.childControlHeight = true;
            rootLayout.childForceExpandWidth = true;
            rootLayout.childForceExpandHeight = false;

            var title = EnsureText(textRoot, "PanelTitle", L(TextQuestionnaireCenter), 34f, InkLightColor, TextAlignmentOptions.Left);
            ApplyTitleFont(title);
            title.enableAutoSizing = true;
            title.fontSizeMin = 22f;
            title.fontSizeMax = 34f;
            title.enableWordWrapping = false;

            var subtitle = EnsureText(textRoot, "PanelSubtitle", L(31170), 18f,
                InkLightColor, TextAlignmentOptions.Left);
            subtitle.enableWordWrapping = false;
        }

        private static void HideLegacyTopStripe(Transform center)
        {
            var stripe = center.Find("TopStripe");
            if (stripe != null)
            {
                stripe.gameObject.SetActive(false);
            }
        }

        private static void SetLegacySidebarHeaderVisible(Transform sidebar, bool visible)
        {
            var title = sidebar != null ? sidebar.Find("Title") : null;
            if (title != null)
            {
                title.gameObject.SetActive(visible);
            }

            var subtitle = sidebar != null ? sidebar.Find("Subtitle") : null;
            if (subtitle != null)
            {
                subtitle.gameObject.SetActive(visible);
            }
        }

        private static void ConfigureBoundPrefabLayout(Transform center, Transform sidebar, Transform sidebarScroll,
            Transform sidebarContent, Transform right, Transform rightHeader, Transform bodyScroll, Transform bodyContent,
            Transform footer)
        {
            ConfigureOutsideRoot(center);
            EnsureLibraryTopBar(center).SetSiblingIndex(0);
            HideLegacyTopStripe(center);

            ConfigureBoundPanel(sidebar, TransparentPanelTint, SidebarWidth, 0, 0, 0, 0, null);
            ConfigureBoundPanel(right, PanelTint, 0f, DetailPanelHorizontalPadding, DetailPanelHorizontalPadding,
                DetailPanelTopPadding, DetailPanelBottomPadding, SpriteCommonWindow);
            right.GetComponent<LayoutElement>().flexibleWidth = 1f;
            ConfigureBoundHeader(rightHeader);
            ConfigureBoundScroll(sidebarScroll, sidebarContent);
            ConfigureBoundScroll(bodyScroll, bodyContent);
            ConfigureFooter(footer);
            if (center is RectTransform centerRect)
            {
                LayoutRebuilder.ForceRebuildLayoutImmediate(centerRect);
            }
        }

        private static void ConfigureBoundHeader(Transform header)
        {
            var layout = header.GetComponent<VerticalLayoutGroup>();
            if (layout == null)
            {
                layout = header.gameObject.AddComponent<VerticalLayoutGroup>();
            }

            layout.spacing = DetailHeaderSpacing;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;
        }

        private static void ConfigureBoundPanel(Transform panel, Color color, float preferredWidth,
            int left, int right, int top, int bottom, string spritePath = SpriteCommonPanel)
        {
            var image = EnsureImage(panel, color, true);
            if (string.IsNullOrEmpty(spritePath))
            {
                image.sprite = null;
                image.color = color;
                image.type = Image.Type.Simple;
                image.raycastTarget = color.a > 0.001f;
            }
            else
            {
                ApplySprite(image, spritePath, color);
            }

            var layout = panel.GetComponent<VerticalLayoutGroup>();
            if (layout == null)
            {
                layout = panel.gameObject.AddComponent<VerticalLayoutGroup>();
            }

            layout.padding = new RectOffset(left, right, top, bottom);
            layout.spacing = DetailPanelSpacing;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;

            var layoutElement = panel.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = panel.gameObject.AddComponent<LayoutElement>();
            }

            if (preferredWidth > 0f)
            {
                layoutElement.minWidth = preferredWidth;
                layoutElement.preferredWidth = preferredWidth;
                layoutElement.flexibleWidth = 0f;
            }
            else
            {
                layoutElement.minWidth = 0f;
                layoutElement.preferredWidth = 0f;
                layoutElement.flexibleWidth = 1f;
            }
        }

        private static void ConfigureBoundScroll(Transform scrollRoot, Transform content)
        {
            var layoutElement = scrollRoot.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = scrollRoot.gameObject.AddComponent<LayoutElement>();
            }

            layoutElement.flexibleHeight = 1f;
            layoutElement.minHeight = 120f;

            var viewport = scrollRoot.Find("Viewport") as RectTransform;
            if (viewport == null)
            {
                return;
            }

            viewport.anchorMin = Vector2.zero;
            viewport.anchorMax = Vector2.one;
            viewport.offsetMin = Vector2.zero;
            viewport.offsetMax = Vector2.zero;
            EnsureImage(viewport, new Color(1f, 1f, 1f, 0.01f), false);

            var mask = viewport.GetComponent<Mask>();
            if (mask == null)
            {
                mask = viewport.gameObject.AddComponent<Mask>();
            }

            mask.showMaskGraphic = false;

            var contentRect = content as RectTransform;
            contentRect.anchorMin = new Vector2(0f, 1f);
            contentRect.anchorMax = new Vector2(1f, 1f);
            contentRect.pivot = new Vector2(0.5f, 1f);
            contentRect.offsetMin = Vector2.zero;
            contentRect.offsetMax = Vector2.zero;

            var contentLayout = content.GetComponent<VerticalLayoutGroup>();
            if (contentLayout == null)
            {
                contentLayout = content.gameObject.AddComponent<VerticalLayoutGroup>();
            }

            contentLayout.spacing = DetailContentSpacing;
            contentLayout.childControlWidth = true;
            contentLayout.childControlHeight = true;
            contentLayout.childForceExpandWidth = true;
            contentLayout.childForceExpandHeight = false;

            var fitter = content.GetComponent<ContentSizeFitter>();
            if (fitter == null)
            {
                fitter = content.gameObject.AddComponent<ContentSizeFitter>();
            }

            fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;

            var scrollRect = scrollRoot.GetComponent<ScrollRect>();
            if (scrollRect == null)
            {
                scrollRect = scrollRoot.gameObject.AddComponent<ScrollRect>();
            }

            scrollRect.viewport = viewport;
            scrollRect.content = contentRect;
            scrollRect.horizontal = false;
            scrollRect.vertical = true;
            scrollRect.scrollSensitivity = 30f;
            scrollRect.movementType = ScrollRect.MovementType.Clamped;
        }

        private static void ConfigureFooter(Transform footer)
        {
            var layout = footer.GetComponent<HorizontalLayoutGroup>();
            if (layout == null)
            {
                layout = footer.gameObject.AddComponent<HorizontalLayoutGroup>();
            }

            layout.spacing = 16f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = false;
            layout.childForceExpandHeight = false;
            layout.childAlignment = TextAnchor.MiddleRight;

            var layoutElement = footer.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = footer.gameObject.AddComponent<LayoutElement>();
            }

            layoutElement.minHeight = 58f;
            layoutElement.preferredHeight = 60f;
        }

        private void CreateMainLayout()
        {
            var root = new GameObject("QuestionnaireCenter", typeof(RectTransform), typeof(Image),
                typeof(VerticalLayoutGroup));
            root.transform.SetParent(transform, false);
            ConfigureOutsideRoot(root.transform);
            EnsureLibraryTopBar(root.transform);

            var titleArea = EnsureTitleArea(root.transform);
            var close = EnsureCloseButton(root.transform);
            ConfigureCloseButton(close);
            EnsurePanelTitle(titleArea);

            var contentArea = EnsureContentArea(root.transform);
            CreateSidebar(contentArea);
            CreateRightPanel(contentArea);
            close.SetAsLastSibling();
        }

        private void CreateSidebar(Transform parent)
        {
            var sidebar = CreatePanel(parent, "Sidebar", TransparentPanelTint, SidebarWidth, null);
            var layout = sidebar.GetComponent<VerticalLayoutGroup>();
            layout.padding = new RectOffset(0, 0, 0, 0);
            layout.spacing = 12f;

            CreateScroll(sidebar.transform, "SidebarScroll", out _sidebarContent);
        }

        private void CreateRightPanel(Transform parent)
        {
            var right = CreatePanel(parent, "RightPanel", PanelTint, 0f, SpriteCommonWindow);
            var rightLayoutElement = right.GetComponent<LayoutElement>();
            rightLayoutElement.flexibleWidth = 1f;

            var layout = right.GetComponent<VerticalLayoutGroup>();
            layout.padding = new RectOffset(DetailPanelHorizontalPadding, DetailPanelHorizontalPadding,
                DetailPanelTopPadding, DetailPanelBottomPadding);
            layout.spacing = DetailPanelSpacing;

            var header = new GameObject("Header", typeof(RectTransform), typeof(VerticalLayoutGroup));
            header.transform.SetParent(right.transform, false);
            var headerLayout = header.GetComponent<VerticalLayoutGroup>();
            headerLayout.spacing = DetailHeaderSpacing;
            headerLayout.childControlWidth = true;
            headerLayout.childControlHeight = true;
            headerLayout.childForceExpandWidth = true;
            headerLayout.childForceExpandHeight = false;

            _rightHeaderTitle = CreateText(header.transform, "Title", "", 26f,
                InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(_rightHeaderTitle);
            _rightHeaderSubtitle = CreateText(header.transform, "Subtitle", "", 20f,
                InkMutedColor, TextAlignmentOptions.Left);
            _rightHeaderSubtitle.enableWordWrapping = true;

            CreateScroll(right.transform, "BodyScroll", out _rightBody);

            var footer = new GameObject("Footer", typeof(RectTransform), typeof(HorizontalLayoutGroup), typeof(LayoutElement));
            footer.transform.SetParent(right.transform, false);
            _rightFooter = footer.transform;
            var footerLayout = footer.GetComponent<HorizontalLayoutGroup>();
            footerLayout.spacing = 16f;
            footerLayout.childControlWidth = true;
            footerLayout.childControlHeight = true;
            footerLayout.childForceExpandWidth = false;
            footerLayout.childForceExpandHeight = false;
            footerLayout.childAlignment = TextAnchor.MiddleRight;
            var footerLayoutElement = footer.GetComponent<LayoutElement>();
            footerLayoutElement.minHeight = 58f;
            footerLayoutElement.preferredHeight = 60f;
        }

        private void CreateQuestionListRoot()
        {
            var root = new GameObject("QuestionListContent", typeof(RectTransform), typeof(VerticalLayoutGroup),
                typeof(ContentSizeFitter));
            root.transform.SetParent(_rightBody, false);
            var layout = root.GetComponent<VerticalLayoutGroup>();
            layout.spacing = DetailContentSpacing;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;
            root.GetComponent<ContentSizeFitter>().verticalFit = ContentSizeFitter.FitMode.PreferredSize;
            QuestionListContent = root.transform;
        }

        private void ClearRight()
        {
            DestroyChildren(_rightBody);
            DestroyChildren(_rightFooter);
            ConfigureFooter(_rightFooter);
            _questionItems.Clear();
            QuestionListContent = null;
            SubmitButton = null;
            RefillButton = null;
            StatusText = null;
            _recordsButton = null;
            _startButton = null;
        }

        private void ShowEmptyState(string text)
        {
            ClearRight();
            SetRightHeader(L(TextQuestionnaireCenter), string.Empty);
            var empty = CreateText(_rightBody, "EmptyState", text, 24f,
                InkMutedColor, TextAlignmentOptions.Center);
            empty.enableWordWrapping = true;
        }

        private void SetRightHeader(string title, string subtitle)
        {
            var hasTitle = !string.IsNullOrEmpty(title);
            var hasSubtitle = !string.IsNullOrEmpty(subtitle);
            if (_rightHeaderRoot != null) _rightHeaderRoot.gameObject.SetActive(hasTitle || hasSubtitle);

            if (_rightHeaderTitle != null)
            {
                _rightHeaderTitle.text = title ?? string.Empty;
                _rightHeaderTitle.gameObject.SetActive(hasTitle);
            }

            if (_rightHeaderSubtitle != null)
            {
                _rightHeaderSubtitle.text = subtitle ?? string.Empty;
                _rightHeaderSubtitle.gameObject.SetActive(hasSubtitle);
            }
        }

        private GameObject CreatePanel(Transform parent, string objectName, Color color, float preferredWidth = 0f,
            string spritePath = SpriteCommonPanel)
        {
            var go = new GameObject(objectName, typeof(RectTransform), typeof(Image), typeof(VerticalLayoutGroup),
                typeof(LayoutElement));
            go.transform.SetParent(parent, false);
            var image = go.GetComponent<Image>();
            if (string.IsNullOrEmpty(spritePath))
            {
                image.sprite = null;
                image.color = color;
                image.type = Image.Type.Simple;
                image.raycastTarget = color.a > 0.001f;
            }
            else
            {
                ApplySprite(image, spritePath, color);
            }

            var layout = go.GetComponent<VerticalLayoutGroup>();
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;

            var layoutElement = go.GetComponent<LayoutElement>();
            if (preferredWidth > 0f)
            {
                layoutElement.minWidth = preferredWidth;
                layoutElement.preferredWidth = preferredWidth;
                layoutElement.flexibleWidth = 0f;
            }
            else
            {
                layoutElement.minWidth = 0f;
                layoutElement.preferredWidth = 0f;
                layoutElement.flexibleWidth = 1f;
            }

            return go;
        }

        private static void CreateScroll(Transform parent, string objectName, out Transform content)
        {
            var scrollRoot = new GameObject(objectName, typeof(RectTransform), typeof(ScrollRect), typeof(LayoutElement));
            scrollRoot.transform.SetParent(parent, false);
            var layoutElement = scrollRoot.GetComponent<LayoutElement>();
            layoutElement.flexibleHeight = 1f;
            layoutElement.minHeight = 120f;

            var viewport = new GameObject("Viewport", typeof(RectTransform), typeof(Image), typeof(Mask));
            viewport.transform.SetParent(scrollRoot.transform, false);
            var viewportRect = viewport.GetComponent<RectTransform>();
            viewportRect.anchorMin = Vector2.zero;
            viewportRect.anchorMax = Vector2.one;
            viewportRect.offsetMin = Vector2.zero;
            viewportRect.offsetMax = Vector2.zero;
            viewport.GetComponent<Image>().color = new Color(1f, 1f, 1f, 0.01f);
            viewport.GetComponent<Mask>().showMaskGraphic = false;

            var contentRoot = new GameObject("Content", typeof(RectTransform), typeof(VerticalLayoutGroup),
                typeof(ContentSizeFitter));
            contentRoot.transform.SetParent(viewport.transform, false);
            var contentRect = contentRoot.GetComponent<RectTransform>();
            contentRect.anchorMin = new Vector2(0f, 1f);
            contentRect.anchorMax = new Vector2(1f, 1f);
            contentRect.pivot = new Vector2(0.5f, 1f);
            contentRect.offsetMin = Vector2.zero;
            contentRect.offsetMax = Vector2.zero;

            var layout = contentRoot.GetComponent<VerticalLayoutGroup>();
            layout.spacing = 10f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;
            contentRoot.GetComponent<ContentSizeFitter>().verticalFit = ContentSizeFitter.FitMode.PreferredSize;

            var scrollRect = scrollRoot.GetComponent<ScrollRect>();
            scrollRect.viewport = viewportRect;
            scrollRect.content = contentRect;
            scrollRect.horizontal = false;
            scrollRect.vertical = true;
            scrollRect.scrollSensitivity = 30f;
            scrollRect.movementType = ScrollRect.MovementType.Clamped;

            content = contentRoot.transform;
        }

        private void CreateSectionHeader(Transform parent, string text)
        {
            var go = InstantiateTemplate(SectionHeaderTemplate, parent, "SectionHeader");
            var header = go != null
                ? EnsureText(go.transform, "Label", text, 30f, GoldColor, TextAlignmentOptions.Left)
                : CreateText(parent, "SectionHeader", text, 30f,
                GoldColor, TextAlignmentOptions.Left);
            ApplyTitleFont(header);
            header.enableAutoSizing = false;
        }

        private void CreateExpiredHeader(int expiredCount)
        {
            var button = CreateButton(_sidebarContent, "ExpiredToggle",
                _showExpired ? $"{L(TextPastQuestionnaires)}  v" : $"{L(TextPastQuestionnaires)}  >",
                false, out _expiredToggleText, 0f);
            var image = button.targetGraphic as Image;
            if (image == null) image = button.GetComponent<Image>();
            ApplySprite(image, SpriteItemButton, PanelTint, false, ItemButtonPixelsPerUnitMultiplier);
            var layout = button.GetComponent<LayoutElement>();
            layout.minHeight = 56f;
            layout.preferredHeight = 60f;
            _expiredToggleText.color = InkColor;
            _expiredToggleText.fontSize = 24f;
            _expiredToggleText.fontSizeMin = 20f;
            if (expiredCount > 0)
            {
                _expiredToggleText.text = _showExpired
                    ? $"{L(TextPastQuestionnaires)} ({expiredCount})  v"
                    : $"{L(TextPastQuestionnaires)} ({expiredCount})  >";
            }

            button.onClick.AddListener(() =>
            {
                _showExpired = !_showExpired;
                BuildQuestionnaireList();
                UpdateListSelection();
            });
        }

        private void CreateDivider(Transform parent)
        {
            var divider = InstantiateTemplate(DividerTemplate, parent, "Divider");
            if (divider == null)
            {
                divider = new GameObject("Divider", typeof(RectTransform), typeof(Image), typeof(LayoutElement));
                divider.transform.SetParent(parent, false);
            }

            ApplySprite(EnsureImage(divider.transform, PanelTint, false), SpriteDivider, PanelTint);
            var layout = divider.GetComponent<LayoutElement>();
            if (layout == null)
            {
                layout = divider.AddComponent<LayoutElement>();
            }

            layout.minHeight = 1f;
            layout.preferredHeight = 1f;
        }

        private void CreateInfoStrip(Transform parent, string text)
        {
            CreateInfoStrip(parent, text, InkLightColor);
        }

        private void CreateInfoStrip(Transform parent, string text, Color textColor)
        {
            var strip = InstantiateTemplate(InfoStripTemplate, parent, "InfoStrip");
            if (strip == null)
            {
                strip = new GameObject("InfoStrip", typeof(RectTransform), typeof(Image), typeof(LayoutElement));
                strip.transform.SetParent(parent, false);
            }

            ApplySprite(EnsureImage(strip.transform, PanelTint, true), SpriteCommonSelectLabel, PanelTint, false,
                ItemButtonPixelsPerUnitMultiplier);
            var layoutElement = strip.GetComponent<LayoutElement>();
            if (layoutElement == null)
            {
                layoutElement = strip.AddComponent<LayoutElement>();
            }

            layoutElement.minHeight = 46f;

            var label = EnsureText(strip.transform, "Label", text, 18f, textColor, TextAlignmentOptions.Left);
            label.enableWordWrapping = true;
            label.rectTransform.anchorMin = Vector2.zero;
            label.rectTransform.anchorMax = Vector2.one;
            label.rectTransform.offsetMin = new Vector2(14f, 8f);
            label.rectTransform.offsetMax = new Vector2(-14f, -8f);
        }

        private Button CreateButton(Transform parent, string objectName, string text, bool primary,
            out TextMeshProUGUI label, float preferredWidth)
        {
            var template = primary ? PrimaryButtonTemplate : SecondaryButtonTemplate;
            var go = InstantiateTemplate(template, parent, objectName);
            if (go == null)
            {
                go = new GameObject(objectName, typeof(RectTransform), typeof(Image), typeof(Button), typeof(LayoutElement));
                go.transform.SetParent(parent, false);
            }

            return ConfigureButton(go, text, primary, out label, preferredWidth);
        }

        private Button CreateDetailStartButton(string text, bool interactable)
        {
            var area = new GameObject("DetailStartActionArea", typeof(RectTransform), typeof(VerticalLayoutGroup),
                typeof(LayoutElement));
            area.transform.SetParent(_rightBody, false);

            var areaLayout = area.GetComponent<VerticalLayoutGroup>();
            areaLayout.childAlignment = TextAnchor.MiddleCenter;
            areaLayout.childControlWidth = true;
            areaLayout.childControlHeight = true;
            areaLayout.childForceExpandWidth = false;
            areaLayout.childForceExpandHeight = false;

            var areaLayoutElement = area.GetComponent<LayoutElement>();
            areaLayoutElement.minHeight = 480f;
            areaLayoutElement.preferredHeight = 520f;
            areaLayoutElement.flexibleWidth = 1f;

            var button = CreateButton(area.transform, "StartButton", text, true, out _startButtonText, 560f);
            var buttonLayout = button.GetComponent<LayoutElement>();
            buttonLayout.minWidth = 520f;
            buttonLayout.preferredWidth = 560f;
            buttonLayout.minHeight = 120f;
            buttonLayout.preferredHeight = 128f;

            var buttonRect = button.transform as RectTransform;
            if (buttonRect != null)
            {
                buttonRect.sizeDelta = new Vector2(560f, 128f);
            }

            _startButtonText.fontSize = 48f;
            ApplyTitleFont(_startButtonText);
            _startButtonText.enableAutoSizing = false;

            button.interactable = interactable;
            return button;
        }

        private static void ConfigureFormFooter(Transform footer)
        {
            if (footer == null) return;

            var layout = footer.GetComponent<HorizontalLayoutGroup>();
            if (layout != null)
            {
                layout.spacing = 24f;
                layout.childAlignment = TextAnchor.MiddleRight;
                layout.childControlWidth = true;
                layout.childControlHeight = true;
                layout.childForceExpandWidth = false;
                layout.childForceExpandHeight = false;
            }

            var layoutElement = footer.GetComponent<LayoutElement>();
            if (layoutElement != null)
            {
                layoutElement.minHeight = 88f;
                layoutElement.preferredHeight = 92f;
            }
        }

        private static void ConfigureFormFooterButton(Button button, TextMeshProUGUI label, float width)
        {
            if (button == null) return;

            var layout = button.GetComponent<LayoutElement>();
            if (layout != null)
            {
                layout.minWidth = width;
                layout.preferredWidth = width;
                layout.minHeight = 68f;
                layout.preferredHeight = 72f;
            }

            if (button.transform is RectTransform rect)
            {
                rect.sizeDelta = new Vector2(width, 72f);
            }

            if (label == null) return;
            label.fontSize = 27f;
            ApplyTitleFont(label);
            label.enableAutoSizing = false;
        }

        private static Button ConfigureButton(GameObject go, string text, bool primary, out TextMeshProUGUI label,
            float preferredWidth)
        {
            var layout = go.GetComponent<LayoutElement>();
            if (layout == null)
            {
                layout = go.AddComponent<LayoutElement>();
            }

            layout.minWidth = preferredWidth > 0f ? preferredWidth : 120f;
            layout.preferredWidth = preferredWidth > 0f ? preferredWidth : 150f;
            layout.minHeight = 50f;
            layout.preferredHeight = 54f;

            var image = EnsureImage(go.transform, PanelTint, true);
            ApplySprite(image, primary ? SpriteButtonPrimary : SpriteButtonSecondary, PanelTint, false,
                GetActionButtonPixelsPerUnitMultiplier(primary));

            var button = go.GetComponent<Button>();
            if (button == null)
            {
                button = go.AddComponent<Button>();
            }

            button.transition = Selectable.Transition.ColorTint;
            button.targetGraphic = image;
            button.onClick.RemoveAllListeners();

            label = EnsureText(go.transform, "Label", text, 22f,
                InkLightColor, TextAlignmentOptions.Center);
            label.rectTransform.anchorMin = Vector2.zero;
            label.rectTransform.anchorMax = Vector2.one;
            label.rectTransform.offsetMin = Vector2.zero;
            label.rectTransform.offsetMax = Vector2.zero;
            label.enableWordWrapping = false;
            return button;
        }

        private static float GetActionButtonPixelsPerUnitMultiplier(bool primary)
        {
            return primary ? PrimaryButtonPixelsPerUnitMultiplier : SecondaryButtonPixelsPerUnitMultiplier;
        }

#if UNITY_EDITOR
        private void EnsureDesignTemplates(bool rebuild)
        {
            if (Application.isPlaying) return;

            if (_layoutBuilt && (_sidebarContent == null || _rightBody == null || _rightFooter == null))
            {
                _layoutBuilt = false;
            }

            EnsureLayout();
            if (_sidebarContent == null || _rightBody == null || _rightFooter == null) return;
            if (_runtimeTemplateRoot != null)
            {
                RestoreDesignTemplate(QuestionnaireItemTemplate, _sidebarContent);
                RestoreDesignTemplate(SectionHeaderTemplate, _sidebarContent);
                RestoreDesignTemplate(DividerTemplate, _sidebarContent);
                RestoreDesignTemplate(InfoStripTemplate, _rightBody);
                RestoreDesignTemplate(LatestRecordPreviewTemplate, _rightBody);
                RestoreDesignTemplate(RecordRowTemplate, _rightBody);
                RestoreDesignTemplate(PrimaryButtonTemplate, _rightFooter);
                RestoreDesignTemplate(SecondaryButtonTemplate, _rightFooter);
                _runtimeTemplateRoot.gameObject.SetActive(false);
                _templatesExtracted = false;
            }

            if (rebuild)
            {
                RemoveExistingTemplate("QuestionnaireItemTemplate");
                RemoveExistingTemplate("SectionHeaderTemplate");
                RemoveExistingTemplate("DividerTemplate");
                RemoveExistingTemplate("InfoStripTemplate");
                RemoveExistingTemplate("LatestRecordPreviewTemplate");
                RemoveExistingTemplate("RecordRowTemplate");
                RemoveExistingTemplate("PrimaryButtonTemplate");
                RemoveExistingTemplate("SecondaryButtonTemplate");
            }

            SectionHeaderTemplate = EnsureSectionHeaderTemplate();
            QuestionnaireItemTemplate = EnsureQuestionnaireItemTemplate();
            DividerTemplate = EnsureDividerTemplate();
            InfoStripTemplate = EnsureInfoStripTemplate();
            LatestRecordPreviewTemplate = EnsureLatestRecordPreviewTemplate();
            RecordRowTemplate = EnsureRecordRowTemplate();
            SecondaryButtonTemplate = EnsureActionButtonTemplate("SecondaryButtonTemplate", "查看记录", false, 140f);
            PrimaryButtonTemplate = EnsureActionButtonTemplate("PrimaryButtonTemplate", "开始填写", true, 150f);

            SortTemplate(_sidebarContent, "SectionHeaderTemplate", 0);
            SortTemplate(_sidebarContent, "QuestionnaireItemTemplate", 1);
            SortTemplate(_sidebarContent, "DividerTemplate", 2);
            SortTemplate(_rightBody, "InfoStripTemplate", 0);
            SortTemplate(_rightBody, "LatestRecordPreviewTemplate", 1);
            SortTemplate(_rightBody, "RecordRowTemplate", 2);
            SortTemplate(_rightFooter, "SecondaryButtonTemplate", 0);
            SortTemplate(_rightFooter, "PrimaryButtonTemplate", 1);
        }

        private static void RestoreDesignTemplate(GameObject template, Transform targetParent)
        {
            if (template == null || targetParent == null) return;
            if (!template.name.EndsWith("Template", StringComparison.Ordinal)) return;

            template.transform.SetParent(targetParent, false);
            template.SetActive(true);
        }

        private void RemoveExistingTemplate(string objectName)
        {
            var existing = FindDeepChild(transform, objectName);
            if (existing == null) return;
            UnityEditor.Undo.DestroyObjectImmediate(existing.gameObject);
        }

        private static void SortTemplate(Transform parent, string objectName, int index)
        {
            var child = parent != null ? parent.Find(objectName) : null;
            if (child == null) return;
            child.SetSiblingIndex(Mathf.Clamp(index, 0, parent.childCount - 1));
        }

        private GameObject EnsureSectionHeaderTemplate()
        {
            var go = FindOrCreateTemplate(_sidebarContent, "SectionHeaderTemplate", typeof(LayoutElement));
            var label = EnsureText(go.transform, "Label", "当期问卷", 30f, GoldColor, TextAlignmentOptions.Left);
            ApplyTitleFont(label);
            label.enableWordWrapping = false;
            label.enableAutoSizing = false;

            var layout = go.GetComponent<LayoutElement>();
            layout.minHeight = 42f;
            layout.preferredHeight = 46f;
            return go;
        }

        private GameObject EnsureQuestionnaireItemTemplate()
        {
            var go = FindOrCreateTemplate(_sidebarContent, "QuestionnaireItemTemplate", typeof(Image),
                typeof(Button), typeof(VerticalLayoutGroup), typeof(LayoutElement));
            ApplySprite(EnsureImage(go.transform, PanelTint, true), SpriteItemButton, PanelTint, false,
                ItemButtonPixelsPerUnitMultiplier);

            var layout = go.GetComponent<VerticalLayoutGroup>();
            layout.padding = new RectOffset(26, 26, 16, 16);
            layout.spacing = 5f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;

            var layoutElement = go.GetComponent<LayoutElement>();
            layoutElement.minHeight = 98f;
            layoutElement.preferredHeight = 102f;

            var button = go.GetComponent<Button>();
            button.transition = Selectable.Transition.ColorTint;
            button.targetGraphic = go.GetComponent<Image>();

            var header = FindOrCreateChild(go.transform, "Header", typeof(HorizontalLayoutGroup));
            var headerLayout = header.GetComponent<HorizontalLayoutGroup>();
            headerLayout.spacing = 8f;
            headerLayout.childControlWidth = true;
            headerLayout.childControlHeight = true;
            headerLayout.childForceExpandWidth = false;
            headerLayout.childForceExpandHeight = false;
            headerLayout.childAlignment = TextAnchor.MiddleLeft;

            var title = EnsureText(header, "Title", "TOHOTOPIA玩法与策略反馈问卷", 24f, InkColor,
                TextAlignmentOptions.Left);
            ApplyTitleFont(title);
            title.enableWordWrapping = true;
            title.enableAutoSizing = false;
            EnsureLayoutElement(title.gameObject).flexibleWidth = 1f;

            var meta = EnsureText(go.transform, "Meta", "22题 · 未填写", 20f, InkMutedColor,
                TextAlignmentOptions.Left);
            meta.enableWordWrapping = true;
            meta.enableAutoSizing = false;
            return go;
        }

        private GameObject EnsureDividerTemplate()
        {
            var go = FindOrCreateTemplate(_sidebarContent, "DividerTemplate", typeof(Image), typeof(LayoutElement));
            ApplySprite(EnsureImage(go.transform, PanelTint, false), SpriteDivider, PanelTint);
            var layout = go.GetComponent<LayoutElement>();
            layout.minHeight = 1f;
            layout.preferredHeight = 1f;
            return go;
        }

        private GameObject EnsureInfoStripTemplate()
        {
            var go = FindOrCreateTemplate(_rightBody, "InfoStripTemplate", typeof(Image), typeof(LayoutElement));
            ApplySprite(EnsureImage(go.transform, PanelTint, true), SpriteCommonSelectLabel, PanelTint, false,
                ItemButtonPixelsPerUnitMultiplier);
            var layout = go.GetComponent<LayoutElement>();
            layout.minHeight = 46f;
            layout.preferredHeight = 46f;

            var label = EnsureText(go.transform, "Label", "当期 · 22题 · 未填写", 18f, InkLightColor,
                TextAlignmentOptions.Left);
            label.enableWordWrapping = true;
            label.rectTransform.anchorMin = Vector2.zero;
            label.rectTransform.anchorMax = Vector2.one;
            label.rectTransform.offsetMin = new Vector2(14f, 8f);
            label.rectTransform.offsetMax = new Vector2(-14f, -8f);
            return go;
        }

        private GameObject EnsureLatestRecordPreviewTemplate()
        {
            var go = FindOrCreateTemplate(_rightBody, "LatestRecordPreviewTemplate", typeof(Image),
                typeof(VerticalLayoutGroup), typeof(LayoutElement));
            ApplySprite(EnsureImage(go.transform, PanelTint, true), SpriteCommonPanel, PanelTint);

            var layout = go.GetComponent<VerticalLayoutGroup>();
            layout.padding = new RectOffset(16, 16, 14, 14);
            layout.spacing = 6f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = false;

            var layoutElement = go.GetComponent<LayoutElement>();
            layoutElement.minHeight = 74f;
            layoutElement.preferredHeight = 78f;

            var title = EnsureText(go.transform, "Title", "最近一次填写", 20f, InkColor,
                TextAlignmentOptions.Left);
            ApplyTitleFont(title);
            var meta = EnsureText(go.transform, "Meta", "2026-06-30 15:30 · 已上传", 17f,
                InkMutedColor, TextAlignmentOptions.Left);
            meta.enableWordWrapping = true;
            return go;
        }

        private GameObject EnsureRecordRowTemplate()
        {
            var go = FindOrCreateTemplate(_rightBody, "RecordRowTemplate", typeof(Image),
                typeof(HorizontalLayoutGroup), typeof(LayoutElement));
            ApplySprite(EnsureImage(go.transform, PanelTint, true), SpriteCommonLabel, PanelTint);

            var layout = go.GetComponent<HorizontalLayoutGroup>();
            layout.padding = new RectOffset(16, 14, 12, 12);
            layout.spacing = 14f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = false;
            layout.childForceExpandHeight = false;
            layout.childAlignment = TextAnchor.MiddleLeft;

            var layoutElement = go.GetComponent<LayoutElement>();
            layoutElement.minHeight = 76f;
            layoutElement.preferredHeight = 78f;

            var textRoot = FindOrCreateChild(go.transform, "TextRoot", typeof(VerticalLayoutGroup),
                typeof(LayoutElement));
            EnsureLayoutElement(textRoot.gameObject).flexibleWidth = 1f;
            var textLayout = textRoot.GetComponent<VerticalLayoutGroup>();
            textLayout.spacing = 3f;
            textLayout.childControlWidth = true;
            textLayout.childControlHeight = true;
            textLayout.childForceExpandWidth = true;
            textLayout.childForceExpandHeight = false;

            var title = EnsureText(textRoot, "Title", "记录 1", 20f, InkColor, TextAlignmentOptions.Left);
            ApplyTitleFont(title);
            var meta = EnsureText(textRoot, "Meta", "2026-06-30 15:30 · 已上传", 17f,
                InkMutedColor, TextAlignmentOptions.Left);
            meta.enableWordWrapping = true;

            var viewButton = FindOrCreateChild(go.transform, "ViewButton", typeof(Image), typeof(Button),
                typeof(LayoutElement));
            ConfigureButton(viewButton.gameObject, "查看", false, out _, 104f);
            return go;
        }

        private GameObject EnsureActionButtonTemplate(string objectName, string text, bool primary, float preferredWidth)
        {
            var go = FindOrCreateTemplate(_rightFooter, objectName, typeof(Image), typeof(Button),
                typeof(LayoutElement));
            ConfigureButton(go, text, primary, out _, preferredWidth);
            return go;
        }

        private static GameObject FindOrCreateTemplate(Transform parent, string objectName, params Type[] componentTypes)
        {
            var child = parent.Find(objectName);
            if (child != null)
            {
                foreach (var componentType in componentTypes)
                {
                    if (child.GetComponent(componentType) == null)
                    {
                        UnityEditor.Undo.AddComponent(child.gameObject, componentType);
                    }
                }

                child.gameObject.SetActive(true);
                return child.gameObject;
            }

            var go = new GameObject(objectName, typeof(RectTransform));
            UnityEditor.Undo.RegisterCreatedObjectUndo(go, $"Create {objectName}");
            go.transform.SetParent(parent, false);
            foreach (var componentType in componentTypes)
            {
                UnityEditor.Undo.AddComponent(go, componentType);
            }

            return go;
        }

        private static Transform FindOrCreateChild(Transform parent, string objectName, params Type[] componentTypes)
        {
            var child = parent.Find(objectName);
            if (child == null)
            {
                var go = new GameObject(objectName, typeof(RectTransform));
                UnityEditor.Undo.RegisterCreatedObjectUndo(go, $"Create {objectName}");
                go.transform.SetParent(parent, false);
                child = go.transform;
            }

            foreach (var componentType in componentTypes)
            {
                if (child.GetComponent(componentType) == null)
                {
                    UnityEditor.Undo.AddComponent(child.gameObject, componentType);
                }
            }

            return child;
        }

        private static LayoutElement EnsureLayoutElement(GameObject go)
        {
            var layout = go.GetComponent<LayoutElement>();
            return layout != null ? layout : UnityEditor.Undo.AddComponent<LayoutElement>(go);
        }
#endif

        private void UpdateListSelection()
        {
            foreach (var item in _listItems)
            {
                var selected = item.Info == _questionnaireInfo;
                ApplySprite(item.Background, selected ? SpriteItemButtonSelected : SpriteItemButton, PanelTint, false,
                    ItemButtonPixelsPerUnitMultiplier);
                item.TitleText.color = selected
                    ? InkLightColor
                    : InkColor;
            }
        }

        private static string BuildListMetaText(QuestionnaireInfo info)
        {
            var sheets = QuestionnaireAnswerStore.Instance.GetAnswerSheets(info.QuestionnaireId);
            var questionCount = info.Questions?.Count ?? 0;
            if (sheets.Count == 0) return L(TextListMetaNotFilled, questionCount);
            return L(TextListMetaSubmitted, questionCount, sheets.Count);
        }

        private static string GetStatusText(QuestionnaireInfo info)
        {
            if (info == null) return string.Empty;
            return info.GetEffectiveStatus(DateTime.UtcNow) switch
            {
                QuestionnaireStatus.Featured => L(TextStatusCurrent),
                QuestionnaireStatus.LongTerm => L(TextStatusLongTerm),
                QuestionnaireStatus.Expired => L(TextStatusPast),
                _ => L(TextStatusHidden)
            };
        }

        private static string FormatSubmittedAt(QuestionnaireAnswerSheet sheet)
        {
            if (sheet == null) return string.Empty;
            if (sheet.SubmittedAtUnix > 0)
            {
                return DateTimeOffset.FromUnixTimeSeconds(sheet.SubmittedAtUnix).ToLocalTime()
                    .ToString("yyyy-MM-dd HH:mm");
            }

            if (DateTime.TryParse(sheet.SubmittedAtUtc, out var parsed))
            {
                return parsed.ToLocalTime().ToString("yyyy-MM-dd HH:mm");
            }

            return L(TextUnknownTime);
        }

        private static string GetUploadStateText(QuestionnaireAnswerSheet sheet)
        {
            if (sheet == null) return string.Empty;
            if (!string.IsNullOrEmpty(sheet.LastUploadObjectKey)) return L(TextUploaded);
            if (!string.IsNullOrEmpty(sheet.LastUploadError)) return L(TextLocalOnly);
            return L(TextWaitingUploadResult);
        }

        private static void DestroyChildren(Transform parent)
        {
            if (parent == null) return;
            for (var i = parent.childCount - 1; i >= 0; i--)
            {
                var child = parent.GetChild(i);
                if (child.name.EndsWith("Template", StringComparison.Ordinal) ||
                    child.name == "RuntimeTemplates")
                {
                    continue;
                }

                child.gameObject.SetActive(false);
                child.SetParent(null, false);
                Destroy(child.gameObject);
            }
        }

        private class QuestionnaireListItem
        {
            public QuestionnaireInfo Info;
            public Image Background;
            public TextMeshProUGUI TitleText;
            public TextMeshProUGUI MetaText;
        }
    }
}