using System;
using System.Collections.Generic;
using System.IO;
using Bansonic;
using UnityEngine;
using UnityEngine.UI;

public class storeSystem : MonoBehaviour
{
    [Header("Player Data")]
    [SerializeField] private Player_SO playerData;

    [Header("list toggles")]
    public ToggleGroup toggleGroup;
    public Toggle allItems_toggle;
    public Toggle recentlyHot_toggle;
    public Toggle idols_toggle;
    public Toggle songs_toggle;
    public Toggle storyPassage_toggle;
    public Toggle consumable_toggle;
    public Toggle otherType_toggle;

    [Header("objects")]
    public GameObject itemPrefab;
    public Transform contentParent;

    [Header("paths")]
    [SerializeField] private string editorStoreItemPath;
    [SerializeField] private string runtimeStoreItemPath;

    [Header("sprites")]
    public Sprite coinSprite;
    public Sprite cannotBuySprite;

    [Header("selecting item purchase")]
    public Text p_itemName;
    public Image p_itemImage;
    public Image p_sumCostImage;
    public Text p_sumCostText;
    public Button p_iAmount_plus;
    public Button p_iAmount_minus;
    public InputField p_iAmount_input;
    public Button purchaseButton;
    public Text p_detailedDescriptionText;

    private const int MinPurchaseAmount = 1;
    private const int MaxPurchaseAmount = 999999;

    private readonly List<storeItemSO> cachedItems = new List<storeItemSO>();
    private readonly List<Toggle> toggles = new List<Toggle>();
    private StoreRuntimeSaveData persistedState = new StoreRuntimeSaveData();

    private storeItemSO currentSelectedItem;
    private int currentSelectedItemId = -1;
    private int currentPurchaseAmount = MinPurchaseAmount;
    private bool suppressAmountInputCallback;

    private string SaveFilePath
    {
        get { return Path.Combine(Application.persistentDataPath, "storeSystem_state.json"); }
    }

    private void Awake()
    {
        CacheToggles();
        RegisterToggleCallbacks();
        RegisterPurchasePanelCallbacks();
    }

    private void Start()
    {
        ResetPriceImageObjects();
        SetDefaultToggleState();
        LoadPersistedState();
        LoadAllStoreItems();
        ApplyPersistedStateToItems();
        RefreshCurrentView();
    }

    private void OnDestroy()
    {
        UnregisterToggleCallbacks();
        UnregisterPurchasePanelCallbacks();
    }

    private void CacheToggles()
    {
        toggles.Clear();
        AddToggle(allItems_toggle);
        AddToggle(recentlyHot_toggle);
        AddToggle(idols_toggle);
        AddToggle(songs_toggle);
        AddToggle(storyPassage_toggle);
        AddToggle(consumable_toggle);
        AddToggle(otherType_toggle);
    }

    private void AddToggle(Toggle toggle)
    {
        if (toggle != null && !toggles.Contains(toggle))
        {
            toggles.Add(toggle);
        }
    }

    private void RegisterToggleCallbacks()
    {
        for (int i = 0; i < toggles.Count; i++)
        {
            toggles[i].onValueChanged.AddListener(OnFilterToggleValueChanged);
        }
    }

    private void UnregisterToggleCallbacks()
    {
        for (int i = 0; i < toggles.Count; i++)
        {
            if (toggles[i] != null)
            {
                toggles[i].onValueChanged.RemoveListener(OnFilterToggleValueChanged);
            }
        }
    }

    private void RegisterPurchasePanelCallbacks()
    {
        if (p_iAmount_plus != null)
        {
            p_iAmount_plus.onClick.AddListener(OnPurchaseAmountPlusClicked);
        }

        if (p_iAmount_minus != null)
        {
            p_iAmount_minus.onClick.AddListener(OnPurchaseAmountMinusClicked);
        }

        if (p_iAmount_input != null)
        {
            p_iAmount_input.onEndEdit.AddListener(OnPurchaseAmountInputEndEdit);
        }
    }

    private void UnregisterPurchasePanelCallbacks()
    {
        if (p_iAmount_plus != null)
        {
            p_iAmount_plus.onClick.RemoveListener(OnPurchaseAmountPlusClicked);
        }

        if (p_iAmount_minus != null)
        {
            p_iAmount_minus.onClick.RemoveListener(OnPurchaseAmountMinusClicked);
        }

        if (p_iAmount_input != null)
        {
            p_iAmount_input.onEndEdit.RemoveListener(OnPurchaseAmountInputEndEdit);
        }
    }

    private void OnFilterToggleValueChanged(bool _)
    {
        currentSelectedItem = null;
        currentSelectedItemId = -1;
        currentPurchaseAmount = MinPurchaseAmount;
        RefreshCurrentView();
    }

    private void SetDefaultToggleState()
    {
        if (allItems_toggle == null)
        {
            return;
        }

        for (int i = 0; i < toggles.Count; i++)
        {
            if (toggles[i] != null && toggles[i] != allItems_toggle)
            {
                toggles[i].SetIsOnWithoutNotify(false);
            }
        }

        allItems_toggle.SetIsOnWithoutNotify(true);
    }

    private void LoadAllStoreItems()
    {
        cachedItems.Clear();
        var uniqueItemIds = new HashSet<int>();

#if UNITY_EDITOR
        if (!string.IsNullOrEmpty(editorStoreItemPath))
        {
            var guids = UnityEditor.AssetDatabase.FindAssets("t:storeItemSO", new[] { editorStoreItemPath });
            for (int i = 0; i < guids.Length; i++)
            {
                var assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(guids[i]);
                var itemSO = UnityEditor.AssetDatabase.LoadAssetAtPath<storeItemSO>(assetPath);
                TryCacheStoreItem(itemSO, assetPath, uniqueItemIds);
            }
        }
#endif

        if (!string.IsNullOrEmpty(runtimeStoreItemPath))
        {
            var runtimeItems = Resources.LoadAll<storeItemSO>(runtimeStoreItemPath);
            for (int i = 0; i < runtimeItems.Length; i++)
            {
                var itemSO = runtimeItems[i];
                var sourceLabel = string.IsNullOrEmpty(itemSO != null ? itemSO.name : string.Empty)
                    ? runtimeStoreItemPath
                    : runtimeStoreItemPath + "/" + itemSO.name;
                TryCacheStoreItem(itemSO, sourceLabel, uniqueItemIds);
            }
        }
    }

    private void TryCacheStoreItem(storeItemSO itemSO, string sourceLabel, HashSet<int> uniqueItemIds)
    {
        if (itemSO == null)
        {
            return;
        }

        if (!uniqueItemIds.Add(itemSO.itemID))
        {
            Debug.LogWarning($"storeSystem: duplicate itemID {itemSO.itemID} found at '{sourceLabel}'. Duplicate item was skipped.", itemSO);
            return;
        }

        cachedItems.Add(itemSO);
    }

    private void ApplyPersistedStateToItems()
    {
        bool stateChanged = false;

        for (int i = 0; i < cachedItems.Count; i++)
        {
            var itemSO = cachedItems[i];
            StoreRuntimeEntry savedEntry;
            if (!TryGetEntry(itemSO.itemID, out savedEntry))
            {
#if UNITY_EDITOR
                if (itemSO.user_has_read || itemSO.purchasedCount > 0)
                {
                    savedEntry = GetOrCreateEntry(itemSO.itemID);
                    savedEntry.userHasRead = itemSO.user_has_read;
                    savedEntry.purchasedCount = itemSO.purchasedCount;
                    stateChanged = true;
                }
#endif
                continue;
            }

#if UNITY_EDITOR
            bool editorHasRead = itemSO.user_has_read;
            int editorPurchasedCount = itemSO.purchasedCount;

            if (savedEntry.userHasRead != editorHasRead || savedEntry.purchasedCount != editorPurchasedCount)
            {
                savedEntry.userHasRead = editorHasRead;
                savedEntry.purchasedCount = editorPurchasedCount;
                stateChanged = true;
            }
#else
            bool mergedHasRead = itemSO.user_has_read || savedEntry.userHasRead;
            int mergedPurchasedCount = Mathf.Max(itemSO.purchasedCount, savedEntry.purchasedCount);

            itemSO.user_has_read = mergedHasRead;
            itemSO.purchasedCount = mergedPurchasedCount;

            if (savedEntry.userHasRead != mergedHasRead || savedEntry.purchasedCount != mergedPurchasedCount)
            {
                savedEntry.userHasRead = mergedHasRead;
                savedEntry.purchasedCount = mergedPurchasedCount;
                stateChanged = true;
            }
#endif
        }

        if (stateChanged)
        {
            SavePersistedState();
        }
    }

    public void RefreshCurrentView()
    {
        if (itemPrefab == null || contentParent == null)
        {
            ClearPurchasePanel();
            return;
        }

        ClearSpawnedItems();
        var visibleItems = new List<storeItemSO>();

        for (int i = 0; i < cachedItems.Count; i++)
        {
            var itemSO = cachedItems[i];
            if (!ShouldDisplay(itemSO))
            {
                continue;
            }

            visibleItems.Add(itemSO);
            SpawnItem(itemSO);
        }

        ResolveVisibleSelection(visibleItems);
    }

    private bool ShouldDisplay(storeItemSO itemSO)
    {
        if (itemSO == null)
        {
            return false;
        }

        if (!itemSO.isOnShelf)
        {
            return false;
        }

        if (recentlyHot_toggle != null && recentlyHot_toggle.isOn)
        {
            return itemSO.isHot;
        }

        if (idols_toggle != null && idols_toggle.isOn)
        {
            return itemSO.itemType == storeItemSO.ItemType.character;
        }

        if (songs_toggle != null && songs_toggle.isOn)
        {
            return itemSO.itemType == storeItemSO.ItemType.song;
        }

        if (storyPassage_toggle != null && storyPassage_toggle.isOn)
        {
            return itemSO.itemType == storeItemSO.ItemType.storyPassage;
        }

        if (consumable_toggle != null && consumable_toggle.isOn)
        {
            return itemSO.itemType == storeItemSO.ItemType.consumable;
        }

        if (otherType_toggle != null && otherType_toggle.isOn)
        {
            return itemSO.itemType == storeItemSO.ItemType.otherType;
        }

        return allItems_toggle == null || allItems_toggle.isOn;
    }

    private void SpawnItem(storeItemSO itemSO)
    {
        var instance = Instantiate(itemPrefab, contentParent);
        var itemView = instance.GetComponent<storeItemPrefab>();
        if (itemView == null)
        {
            Debug.LogWarning("storeSystem: itemPrefab missing storeItemPrefab component.", instance);
            Destroy(instance);
            return;
        }

        itemView.thisItemSO = itemSO;
        itemView.onItemClicked = HandleItemClicked;

        var button = instance.GetComponent<Button>();
        if (button != null)
        {
            button.onClick.AddListener(itemView.NotifyClicked);
        }

        if (itemView.thisItem_iconImage != null)
        {
            itemView.thisItem_iconImage.sprite = itemSO.itemIcon;
        }

        if (itemView.thisItem_nameText != null)
        {
            itemView.thisItem_nameText.text = itemSO.itemName;
        }

        itemView.SetDescriptionContent(itemSO.itemName, itemSO.itemDescription);

        if (itemView.thisItem_amountAndLimitationText != null)
        {
            itemView.thisItem_amountAndLimitationText.text = GetAmountAndQuotaText(itemSO);
        }

        SetupPrice(itemView, itemSO);
        SetupAvailabilityState(itemView, itemSO);
        SetupReadState(itemView, itemSO);
    }

    private void ResolveVisibleSelection(List<storeItemSO> visibleItems)
    {
        if (visibleItems == null || visibleItems.Count == 0)
        {
            currentSelectedItem = null;
            currentSelectedItemId = -1;
            currentPurchaseAmount = MinPurchaseAmount;
            ClearPurchasePanel();
            return;
        }

        storeItemSO itemToSelect = null;
        if (currentSelectedItemId >= 0)
        {
            for (int i = 0; i < visibleItems.Count; i++)
            {
                if (visibleItems[i].itemID == currentSelectedItemId)
                {
                    itemToSelect = visibleItems[i];
                    break;
                }
            }
        }

        bool resetAmount = false;
        if (itemToSelect == null)
        {
            itemToSelect = visibleItems[0];
            resetAmount = true;
        }

        ApplySelectedItem(itemToSelect, resetAmount);
    }

    private void ApplySelectedItem(storeItemSO itemSO, bool resetAmount)
    {
        currentSelectedItem = itemSO;
        currentSelectedItemId = itemSO != null ? itemSO.itemID : -1;

        if (itemSO == null)
        {
            ClearPurchasePanel();
            return;
        }

        if (p_itemName != null)
        {
            p_itemName.text = itemSO.itemName ?? string.Empty;
        }

        if (p_itemImage != null)
        {
            p_itemImage.sprite = itemSO.itemIcon;
            p_itemImage.enabled = itemSO.itemIcon != null;
        }

        if (p_detailedDescriptionText != null)
        {
            p_detailedDescriptionText.text = string.IsNullOrWhiteSpace(itemSO.itemDetailedDescription)
                ? "暂无描述信息"
                : itemSO.itemDetailedDescription;
        }

        if (resetAmount)
        {
            SetPurchaseAmount(MinPurchaseAmount, false);
        }
        else
        {
            UpdatePurchaseAmountInput();
            RefreshPurchaseSummary();
        }

        RefreshPurchaseButtonState();
    }

    private void ClearPurchasePanel()
    {
        if (p_itemName != null)
        {
            p_itemName.text = string.Empty;
        }

        if (p_itemImage != null)
        {
            p_itemImage.sprite = null;
            p_itemImage.enabled = false;
        }

        if (p_detailedDescriptionText != null)
        {
            p_detailedDescriptionText.text = string.Empty;
        }

        if (p_sumCostText != null)
        {
            p_sumCostText.text = string.Empty;
        }

        SetPriceImageState(p_sumCostImage, null, false);

        currentPurchaseAmount = MinPurchaseAmount;
        UpdatePurchaseAmountInput();
        RefreshPurchaseButtonState();
    }

    private void OnPurchaseAmountPlusClicked()
    {
        SetPurchaseAmount(currentPurchaseAmount + 1, true);
    }

    private void OnPurchaseAmountMinusClicked()
    {
        SetPurchaseAmount(currentPurchaseAmount - 1, true);
    }

    private void OnPurchaseAmountInputEndEdit(string value)
    {
        if (suppressAmountInputCallback)
        {
            return;
        }

        long parsedValue;
        if (!long.TryParse((value ?? string.Empty).Trim(), out parsedValue))
        {
            parsedValue = MinPurchaseAmount;
        }

        int safeValue;
        if (parsedValue > int.MaxValue)
        {
            safeValue = int.MaxValue;
        }
        else if (parsedValue < int.MinValue)
        {
            safeValue = int.MinValue;
        }
        else
        {
            safeValue = (int)parsedValue;
        }

        SetPurchaseAmount(safeValue, true);
    }

    private void SetPurchaseAmount(int amount, bool showWarnings)
    {
        int clampedAmount = amount;

        if (amount > MaxPurchaseAmount)
        {
            clampedAmount = MaxPurchaseAmount;
            if (showWarnings)
            {
                gNotice.warning.display("达到单次购买限额");
            }
        }
        else if (amount < MinPurchaseAmount)
        {
            clampedAmount = MinPurchaseAmount;
            if (showWarnings)
            {
                gNotice.warning.display("本店禁止无实物交易");
            }
        }

        currentPurchaseAmount = clampedAmount;
        UpdatePurchaseAmountInput();
        RefreshPurchaseSummary();
    }

    private void UpdatePurchaseAmountInput()
    {
        if (p_iAmount_input == null)
        {
            return;
        }

        suppressAmountInputCallback = true;
        p_iAmount_input.text = currentPurchaseAmount.ToString();
        suppressAmountInputCallback = false;
    }

    private void RefreshPurchaseSummary()
    {
        ResetPriceImageObjectState(p_sumCostImage);

        if (currentSelectedItem == null)
        {
            if (p_sumCostText != null)
            {
                p_sumCostText.text = string.Empty;
            }

            SetPriceImageState(p_sumCostImage, null, false);
            RefreshPurchaseButtonState();
            return;
        }

        if (!CanPurchaseCurrentSelection(currentSelectedItem))
        {
            if (p_sumCostText != null)
            {
                p_sumCostText.text = "不可购买";
            }

            SetCannotBuyImageState(p_sumCostImage);
            RefreshPurchaseButtonState();
            return;
        }

        var cost = currentSelectedItem.costRequirements[0];
        long totalCost = (long)cost.amount * currentPurchaseAmount;

        if (p_sumCostText != null)
        {
            p_sumCostText.text = totalCost.ToString();
        }

        SetPriceImageState(p_sumCostImage, GetCurrencySprite(cost.currencyType), true);
        RefreshPurchaseButtonState();
    }

    private Sprite GetCurrencySprite(storeItemSO.CurrencyType currencyType)
    {
        if (currencyType == storeItemSO.CurrencyType.coins)
        {
            return coinSprite;
        }

        return null;
    }

    private bool HasCoinRequirement(storeItemSO itemSO)
    {
        if (itemSO == null || itemSO.costRequirements == null || itemSO.costRequirements.Count == 0)
        {
            return false;
        }

        return GetCurrencySprite(itemSO.costRequirements[0].currencyType) != null;
    }

    private void SetPriceImageState(Image priceImage, Sprite sprite, bool shouldShow)
    {
        if (priceImage == null)
        {
            return;
        }

        priceImage.gameObject.SetActive(shouldShow);
        if (!shouldShow)
        {
            priceImage.sprite = null;
            priceImage.enabled = false;
            return;
        }

        priceImage.sprite = sprite;
        priceImage.enabled = sprite != null;
    }

    private void SetCannotBuyImageState(Image priceImage)
    {
        if (priceImage == null)
        {
            return;
        }

        if (cannotBuySprite == null)
        {
            SetPriceImageState(priceImage, null, false);
            return;
        }

        SetPriceImageState(priceImage, cannotBuySprite, true);
    }

    private void ResetPriceImageObjects()
    {
        ResetPriceImageObjectState(p_sumCostImage);
    }

    private void ResetPriceImageObjectState(Image priceImage)
    {
        if (priceImage == null)
        {
            return;
        }

        priceImage.gameObject.SetActive(true);
        priceImage.sprite = null;
        priceImage.enabled = false;
    }

    private void RefreshPurchaseButtonState()
    {
        if (purchaseButton == null)
        {
            return;
        }

        purchaseButton.interactable = CanPurchaseCurrentSelection(currentSelectedItem);
    }

    private string GetAmountAndQuotaText(storeItemSO itemSO)
    {
        string prefix = itemSO.itemSinglePurchaseQty == 1 ? string.Empty : $"{itemSO.itemSinglePurchaseQty}个装/";

        if (itemSO.itemPurchaseQuota < 0)
        {
            return prefix + "不限购";
        }

        return $"{prefix}限购{itemSO.purchasedCount}/{itemSO.itemPurchaseQuota}个";
    }

    private void SetupPrice(storeItemPrefab itemView, storeItemSO itemSO)
    {
        if (itemView.thisItem_priceText != null)
        {
            itemView.thisItem_priceText.text = GetPriceAmountText(itemSO);
        }

        if (itemView.thisPrice_iconImage == null)
        {
            return;
        }

        ResetPriceImageObjectState(itemView.thisPrice_iconImage);

        if (!ShouldShowPriceIcon(itemSO))
        {
            SetCannotBuyImageState(itemView.thisPrice_iconImage);
            return;
        }

        var cost = itemSO.costRequirements[0];
        SetPriceImageState(itemView.thisPrice_iconImage, GetCurrencySprite(cost.currencyType), true);
    }

    private string GetPriceAmountText(storeItemSO itemSO)
    {
        if (itemSO == null || !itemSO.canbepurchased || !HasCoinRequirement(itemSO))
        {
            return "不可购买";
        }

        return itemSO.costRequirements[0].amount.ToString();
    }

    private bool ShouldShowPriceIcon(storeItemSO itemSO)
    {
        return itemSO != null && itemSO.canbepurchased && HasCoinRequirement(itemSO);
    }

    private bool CanPurchaseCurrentSelection(storeItemSO itemSO)
    {
        return itemSO != null
            && itemSO.canbepurchased
            && !IsSoldOut(itemSO)
            && HasCoinRequirement(itemSO);
    }

    private void SetupAvailabilityState(storeItemPrefab itemView, storeItemSO itemSO)
    {
        bool isSoldOut = IsSoldOut(itemSO);
        bool cannotPurchase = !itemSO.canbepurchased;

        if (itemView.leftCorner_statusImage != null)
        {
            itemView.leftCorner_statusImage.SetActive(isSoldOut);
        }

        if (itemView.lock_cannotClickImage != null)
        {
            itemView.lock_cannotClickImage.SetActive(isSoldOut || cannotPurchase);
        }

        if (itemView.why_cannot_buy != null)
        {
            if (isSoldOut)
            {
                itemView.why_cannot_buy.text = "已售罄";
            }
            else if (cannotPurchase)
            {
                itemView.why_cannot_buy.text = "物品未上架";
            }
            else
            {
                itemView.why_cannot_buy.text = string.Empty;
            }
        }
    }

    private void SetupReadState(storeItemPrefab itemView, storeItemSO itemSO)
    {
        if (itemView.rightCorner_statusImage != null)
        {
            itemView.rightCorner_statusImage.SetActive(!itemSO.user_has_read);
        }
    }

    private bool IsSoldOut(storeItemSO itemSO)
    {
        if (itemSO == null || itemSO.itemPurchaseQuota < 0)
        {
            return false;
        }

        return itemSO.purchasedCount >= itemSO.itemPurchaseQuota;
    }

    private void HandleItemClicked(storeItemPrefab itemView)
    {
        if (itemView == null || itemView.thisItemSO == null)
        {
            return;
        }

        currentSelectedItemId = itemView.thisItemSO.itemID;
        ApplySelectedItem(itemView.thisItemSO, true);

        if (!itemView.thisItemSO.user_has_read)
        {
            itemView.thisItemSO.user_has_read = true;
            var entry = GetOrCreateEntry(itemView.thisItemSO.itemID);
            entry.userHasRead = true;
            entry.purchasedCount = itemView.thisItemSO.purchasedCount;
            SavePersistedState();
            RefreshCurrentView();
        }
    }

    public void RegisterPurchasedCount(int itemID, int purchasedAmount)
    {
        if (purchasedAmount <= 0)
        {
            return;
        }

        for (int i = 0; i < cachedItems.Count; i++)
        {
            var itemSO = cachedItems[i];
            if (itemSO.itemID != itemID)
            {
                continue;
            }

            itemSO.purchasedCount += purchasedAmount;
            var entry = GetOrCreateEntry(itemID);
            entry.userHasRead = itemSO.user_has_read;
            entry.purchasedCount = itemSO.purchasedCount;
            SavePersistedState();
            RefreshCurrentView();
            return;
        }
    }

    private bool TryGetEntry(int itemID, out StoreRuntimeEntry entry)
    {
        entry = null;
        if (persistedState.entries == null)
        {
            persistedState.entries = new List<StoreRuntimeEntry>();
            return false;
        }

        for (int i = 0; i < persistedState.entries.Count; i++)
        {
            if (persistedState.entries[i] != null && persistedState.entries[i].itemID == itemID)
            {
                entry = persistedState.entries[i];
                return true;
            }
        }

        return false;
    }

    private StoreRuntimeEntry GetOrCreateEntry(int itemID)
    {
        StoreRuntimeEntry entry;
        if (TryGetEntry(itemID, out entry))
        {
            return entry;
        }

        if (persistedState.entries == null)
        {
            persistedState.entries = new List<StoreRuntimeEntry>();
        }

        entry = new StoreRuntimeEntry
        {
            itemID = itemID,
            userHasRead = false,
            purchasedCount = 0
        };
        persistedState.entries.Add(entry);
        return entry;
    }

    private void LoadPersistedState()
    {
        persistedState = new StoreRuntimeSaveData();

        if (!File.Exists(SaveFilePath))
        {
            return;
        }

        try
        {
            var json = File.ReadAllText(SaveFilePath);
            var loadedData = JsonUtility.FromJson<StoreRuntimeSaveData>(json);
            if (loadedData != null && loadedData.entries != null)
            {
                persistedState = loadedData;
                NormalizePersistedEntries();
            }
        }
        catch (Exception ex)
        {
            Debug.LogWarning($"storeSystem: failed to load persisted state. {ex.Message}");
            persistedState = new StoreRuntimeSaveData();
        }
    }

    private void NormalizePersistedEntries()
    {
        if (persistedState.entries == null)
        {
            persistedState.entries = new List<StoreRuntimeEntry>();
            return;
        }

        var normalizedEntries = new List<StoreRuntimeEntry>();
        var indexByItemId = new Dictionary<int, int>();
        bool hadDuplicates = false;

        for (int i = 0; i < persistedState.entries.Count; i++)
        {
            var source = persistedState.entries[i];
            if (source == null)
            {
                continue;
            }

            int existingIndex;
            if (indexByItemId.TryGetValue(source.itemID, out existingIndex))
            {
                var target = normalizedEntries[existingIndex];
                target.userHasRead = target.userHasRead || source.userHasRead;
                target.purchasedCount = Mathf.Max(target.purchasedCount, source.purchasedCount);
                hadDuplicates = true;
                continue;
            }

            var clone = new StoreRuntimeEntry
            {
                itemID = source.itemID,
                userHasRead = source.userHasRead,
                purchasedCount = source.purchasedCount
            };
            indexByItemId.Add(clone.itemID, normalizedEntries.Count);
            normalizedEntries.Add(clone);
        }

        persistedState.entries = normalizedEntries;

        if (hadDuplicates)
        {
            SavePersistedState();
        }
    }

    private void SavePersistedState()
    {
        try
        {
            NormalizePersistedEntries();
            var json = JsonUtility.ToJson(persistedState, true);
            File.WriteAllText(SaveFilePath, json);
#if UNITY_EDITOR
            PersistStateBackToEditorAssets();
#endif
        }
        catch (Exception ex)
        {
            Debug.LogWarning($"storeSystem: failed to save persisted state. {ex.Message}");
        }
    }

#if UNITY_EDITOR
    private void PersistStateBackToEditorAssets()
    {
        for (int i = 0; i < cachedItems.Count; i++)
        {
            UnityEditor.EditorUtility.SetDirty(cachedItems[i]);
        }

        UnityEditor.AssetDatabase.SaveAssets();
    }
#endif

    private void ClearSpawnedItems()
    {
        for (int i = contentParent.childCount - 1; i >= 0; i--)
        {
            Destroy(contentParent.GetChild(i).gameObject);
        }
    }

    [Serializable]
    private class StoreRuntimeSaveData
    {
        public List<StoreRuntimeEntry> entries = new List<StoreRuntimeEntry>();
    }

    [Serializable]
    private class StoreRuntimeEntry
    {
        public int itemID;
        public bool userHasRead;
        public int purchasedCount;
    }
}