using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Recipes
{
	public class RegistrationPage : MonoBehaviour
	{
		// Declaration of variables for UI elements on the page

		[SerializeField] private InputField UsernameInput;

		[SerializeField] private InputField EmailInputField;

		[SerializeField] private InputField PasswordInputField;

		[SerializeField] private Button RegisterButton;

		private void Start()
		{
			// Handling the button click
			RegisterButton.onClick.AddListener(() =>
			{
				var username = UsernameInput.text;
				var email = EmailInputField.text;
				var password = PasswordInputField.text;

				XsollaAuth.Instance.Register(username, password, email, onSuccess: OnSuccess, onError: OnError);
			});
		}

		private void OnSuccess()
		{
			UnityEngine.Debug.Log("Registration successful");
			// Some actions
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.Log($"Registration failed. Description: {error.errorMessage}");
			// Some actions
		}
	}
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Recipes
{
	public class ResendConfirmationEmail : MonoBehaviour
	{
		// Declaration of variables for UI elements on the page

		[SerializeField] private InputField UsernameInput;

		[SerializeField] private Button ResendEmailButton;

		private void Start()
		{
			// Handling the button click
			ResendEmailButton.onClick.AddListener(() =>
			{
				var username = UsernameInput.text;

				XsollaAuth.Instance.ResendConfirmationLink(username, onSuccess: OnSuccess, onError: OnError);
			});
		}

		private void OnSuccess()
		{
			UnityEngine.Debug.Log("Resend confirmation email successful");
			// Some actions
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.Log($"Resend confirmation email failed. Description: {error.errorMessage}");
			// Some actions
		}
	}
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Recipes
{
	public class AuthorizationPage : MonoBehaviour
	{
		// Declaration of variables for UI elements on the page

		[SerializeField] private InputField UsernameInput;

		[SerializeField] private InputField PasswordInputField;

		[SerializeField] private Toggle RememberMeToggle;

		[SerializeField] private Button AuthorizationButton;

		private void Start()
		{
			// Handling the button click

			AuthorizationButton.onClick.AddListener(() =>
			{
				var username = UsernameInput.text;
				var password = PasswordInputField.text;
				var rememberMe = RememberMeToggle.isOn;

				XsollaAuth.Instance.SignIn(username, password, rememberMe, null, onSuccess: OnSuccess, onError: OnError);
			});
		}

		private void OnSuccess(string token)
		{
			UnityEngine.Debug.Log($"Authorization successful. Token: {token}");
			// Some actions
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.Log($"Authorization failed. Description: {error.errorMessage}");
			// Some actions
		}
	}
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Recipes
{
	public class ResetPasswordPage : MonoBehaviour
	{
		// Declaration of variables for UI elements on the page

		[SerializeField] private InputField UsernameInput;

		[SerializeField] private Button ResetPasswordButton;

		private void Start()
		{
			// Handling the button click

			ResetPasswordButton.onClick.AddListener(() =>
			{
				var username = UsernameInput.text;

				XsollaAuth.Instance.ResetPassword(username, null, null, OnSuccess, OnError);
			});
		}

		private void OnSuccess()
		{
			UnityEngine.Debug.Log("Password reset successful");
			// Some actions
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.Log($"Password reset failed. Description: {error.errorMessage}");
			// Some actions
		}
	}
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Recipes
{
	public class SocialAuthorizationPage : MonoBehaviour
	{
		// Declaration of variables for UI elements on the page

		[SerializeField] private Button FacebookButton;

		private void Start()
		{
			// Handling the button click

			FacebookButton.onClick.AddListener(() =>
			{
				// Opening browser

				var url = XsollaAuth.Instance.GetSocialNetworkAuthUrl(SocialProvider.Facebook);
				BrowserHelper.Instance.Open(url, true);

				// Determining the end of authentication
				BrowserHelper.Instance.InAppBrowser.AddUrlChangeHandler(OnUrlChanged);
			});
		}

		// Getting token
		private void OnUrlChanged(string url)
		{
			if (ParseUtils.TryGetValueFromUrl(url, ParseParameter.code, out var code))
			{
				XsollaAuth.Instance.ExchangeCodeToToken(code, OnSuccess, OnError);
				BrowserHelper.Instance.Close();
			}
		}

		private void OnSuccess(string token)
		{
			UnityEngine.Debug.Log($"Authorization successful. Token: {token}");
			// Some actions
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.Log($"Authorization failed. Description: {error.errorMessage}");
			// Some actions
		}
	}
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements

		public Text NameText;

		public Text DescriptionText;

		public Text PriceText;

		public Image IconImage;
	}
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Recipes
{
    public class VirtualItemsPage : MonoBehaviour
    {
        // Declaration of variables for containers and widget prefabs

        public Transform WidgetsContainer;

        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process

            XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, null, OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess(string token)
        {
            // After successful authentication starting the request for catalog from store

            XsollaCatalog.Instance.GetCatalog(XsollaSettings.StoreProjectId, OnItemsRequestSuccess, OnError, offset: 0, limit: 50);
        }

        private void OnItemsRequestSuccess(StoreItems storeItems)
        {
            // Iterating the items collection and assign values for appropriate ui elements

            foreach (var storeItem in storeItems.items)
            {
                var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<VirtualItemWidget>();

                widget.NameText.text = storeItem.name;
                widget.DescriptionText.text = storeItem.description;

                if (storeItem.price != null)
                {
                    var realMoneyPrice = storeItem.price;
                    widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
                }
                else if (storeItem.virtual_prices != null)
                {
                    var virtualCurrencyPrice = storeItem.virtual_prices.First(x => x.is_default);
                    widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
                }

                ImageLoader.Instance.GetImageAsync(storeItem.image_url, (url, sprite) => widget.IconImage.sprite = sprite);
            }
        }

        private void OnError(Error error)
        {
            UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
        }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements

		public Text NameText;

		public Text DescriptionText;

		public Text PriceText;

		public Image IconImage;
	}
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
    public class VirtualItemGroupButton : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;

        public Button Button;
    }
}

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Recipes
{
	public class VirtualItemsByGroupsPage : MonoBehaviour
	{
		// Declaration of variables for containers and widget prefabs
		public Transform GroupButtonsContainer;

		public GameObject GroupButtonPrefab;

		public Transform ItemWidgetsContainer;

		public GameObject ItemWidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, onSuccess: OnAuthenticationSuccess,
				onError: OnError);
		}

		private void OnAuthenticationSuccess(string token)
		{
			// After successful authentication starting the request for catalog from store
			XsollaCatalog.Instance.GetCatalog(XsollaSettings.StoreProjectId, OnItemsRequestSuccess, OnError, offset: 0,
				limit: 50);
		}

		private void OnItemsRequestSuccess(StoreItems storeItems)
		{
			// Selecting the group’s name from items and order them alphabetical
			var groupNames = storeItems.items
				.SelectMany(x => x.groups)
				.GroupBy(x => x.name)
				.Select(x => x.First())
				.OrderBy(x => x.name)
				.Select(x => x.name)
				.ToList();

			// Add group name for “all groups”, which will mean show all items regardless of group affiliation
			groupNames.Insert(0, "All");

			// Clear container
			DeleteAllChildren(GroupButtonsContainer);

			// Iterating the group names and creating ui-button for each
			foreach (var groupName in groupNames)
			{
				var buttonObj = Instantiate(GroupButtonPrefab, GroupButtonsContainer, false);
				var groupButton = buttonObj.GetComponent<VirtualItemGroupButton>();

				groupButton.NameText.text = groupName;
				groupButton.Button.onClick.AddListener(() => OnGroupSelected(groupName, storeItems));
			}

			// Calling method for redraw page
			OnGroupSelected("All", storeItems);
		}

		private void OnGroupSelected(string groupName, StoreItems storeItems)
		{
			// Declaring variable for items which will display on page
			IEnumerable<StoreItem> itemsForDisplay;
			if (groupName == "All")
			{
				itemsForDisplay = storeItems.items;
			}
			else
			{
				itemsForDisplay = storeItems.items.Where(item => item.groups.Any(group => group.name == groupName));
			}

			// Clear container
			DeleteAllChildren(ItemWidgetsContainer);

			// Iterating the items collection and assign values for appropriate ui elements
			foreach (var storeItem in itemsForDisplay)
			{
				var widgetGo = Instantiate(ItemWidgetPrefab, ItemWidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualItemWidget>();

				widget.NameText.text = storeItem.name;
				widget.DescriptionText.text = storeItem.description;

				if (storeItem.price != null)
				{
					var realMoneyPrice = storeItem.price;
					widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
				}
				else if (storeItem.virtual_prices != null)
				{
					var virtualCurrencyPrice = storeItem.virtual_prices.First(x => x.is_default);
					widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
				}

				ImageLoader.Instance.GetImageAsync(storeItem.image_url,
					(url, sprite) => widget.IconImage.sprite = sprite);
			}
		}

		// Utility method for delete all children of container
		private static void DeleteAllChildren(Transform parent)
		{
			var childList = parent.Cast<Transform>().ToList();
			foreach (var childTransform in childList)
			{
				Destroy(childTransform.gameObject);
			}
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
		}
	}
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
	public class BundleWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements
		public Text NameText;

		public Text DescriptionText;

		public Text PriceText;

		public Text ContentText;

		public Image IconImage;
	}
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Recipes
{
	public class BundlesPage : MonoBehaviour
	{
		// Declaration of variables for containers and widget prefabs
		public Transform WidgetsContainer;

		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, onSuccess: OnAuthenticationSuccess, onError: OnError);
		}

		private void OnAuthenticationSuccess(string token)
		{
			// After successful authentication starting the request for bundles from store
			XsollaCatalog.Instance.GetBundles(XsollaSettings.StoreProjectId, OnBundlesRequestSuccess, OnError);
		}

		private void OnBundlesRequestSuccess(BundleItems bundleItems)
		{
			// Iterating the bundles collection and assign values for appropriate ui elements
			foreach (var bundleItem in bundleItems.items)
			{
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<BundleWidget>();

				widget.NameText.text = bundleItem.name;
				widget.DescriptionText.text = bundleItem.description;

				var bundleContent = bundleItem.content.Select(x => $"{x.name} x {x.quantity}");
				widget.ContentText.text = string.Join("\n", bundleContent);

				if (bundleItem.price != null)
				{
					var realMoneyPrice = bundleItem.price;
					widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
				}
				else if (bundleItem.virtual_prices != null)
				{
					var virtualCurrencyPrice = bundleItem.virtual_prices.First(x => x.is_default);
					widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
				}

				ImageLoader.Instance.GetImageAsync(bundleItem.image_url,
					(url, sprite) => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
		}
	}
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
	public class VirtualCurrencyPackageWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements

		public Text NameText;

		public Text DescriptionText;

		public Text PriceText;

		public Image IconImage;
	}
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Recipes
{
	public class VirtualCurrencyPackagesPage : MonoBehaviour
	{
		// Declaration of variables for containers and widget prefabs
		public Transform WidgetsContainer;

		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, onSuccess: OnAuthenticationSuccess, onError: OnError);
		}

		private void OnAuthenticationSuccess(string token)
		{
			// After successful authentication starting the request for packages from store
			XsollaCatalog.Instance.GetVirtualCurrencyPackagesList(XsollaSettings.StoreProjectId, OnPackagesRequestSuccess, OnError);
		}

		private void OnPackagesRequestSuccess(VirtualCurrencyPackages packageItems)
		{
			// Iterating the packages collection and assign values for appropriate ui elements
			foreach (var packageItem in packageItems.items)
			{
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualCurrencyPackageWidget>();

				widget.NameText.text = packageItem.name;
				widget.DescriptionText.text = packageItem.description;

				if (packageItem.price != null)
				{
					var realMoneyPrice = packageItem.price;
					widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
				}
				else if (packageItem.virtual_prices != null)
				{
					var virtualCurrencyPrice = packageItem.virtual_prices.First(x => x.is_default);
					widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
				}

				ImageLoader.Instance.GetImageAsync(packageItem.image_url,
					(url, sprite) => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
		}
	}
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements

		public Text NameText;

		public Text DescriptionText;

		public Text PriceText;

		public Image IconImage;

		public Button BuyButton;
	}
}

using System.Collections;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;
using Xsolla.Orders;

namespace Recipes
{
	public class VirtualItemsPage : MonoBehaviour
	{
		// Declaration of variables for containers and widget prefabs

		public Transform WidgetsContainer;

		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process

			XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, onSuccess: OnAuthenticationSuccess, onError: OnError);
		}

		private void OnAuthenticationSuccess(string token)
		{
			// After successful authentication starting the request for catalog from store
			Token.Instance = Token.Create(token);
			XsollaCatalog.Instance.GetCatalog(XsollaSettings.StoreProjectId, OnItemsRequestSuccess, OnError, offset: 0, limit: 50);
		}

		private void OnItemsRequestSuccess(StoreItems storeItems)
		{
			// Iterating the items collection and assign values for appropriate ui elements

			foreach (var storeItem in storeItems.items)
			{
				if (storeItem.price == null)
					continue;

				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualItemWidget>();

				widget.NameText.text = storeItem.name;
				widget.DescriptionText.text = storeItem.description;

				var realMoneyPrice = storeItem.price;
				widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";

				ImageLoader.Instance.GetImageAsync(storeItem.image_url,
					(url, sprite) => widget.IconImage.sprite = sprite);

				widget.BuyButton.onClick.AddListener(() =>
				{
					XsollaCatalog.Instance.PurchaseItem(XsollaSettings.StoreProjectId, storeItem.sku, OnOrderCreateSuccess, OnError);
				});
			}
		}

		private void OnOrderCreateSuccess(PurchaseData purchaseData)
		{
			XsollaOrders.Instance.OpenPurchaseUi(purchaseData);
			StartCoroutine(TrackOrderStatus(purchaseData));
		}

		private IEnumerator TrackOrderStatus(PurchaseData purchaseData)
		{
			var isDone = false;
			while (!isDone)
			{
				XsollaOrders.Instance.CheckOrderStatus
				(
					XsollaSettings.StoreProjectId,
					purchaseData.order_id,
					status =>
					{
						if (status.status == "paid" || status.status == "done")
						{
							isDone = true;
							OnPurchaseSuccess();
						}
					},
					error => { OnError(error); }
				);

				yield return new WaitForSeconds(1f);
			}
		}

		private void OnPurchaseSuccess()
		{
			UnityEngine.Debug.Log($"Purchase successful");
			BrowserHelper.Instance.Close();
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
		}
	}
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
	public class VirtualItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements

		public Text NameText;

		public Text DescriptionText;

		public Text PriceText;

		public Image IconImage;

		public Button BuyButton;
	}
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;
using Xsolla.Orders;

namespace Recipes
{
    public class VirtualItemsPage : MonoBehaviour
    {
        // Declaration of variables for containers and widget prefabs

        public Transform WidgetsContainer;

        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process

            XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, onSuccess: OnAuthenticationSuccess, onError: OnError);
        }

        private void OnAuthenticationSuccess(string token)
        {
            // After successful authentication starting the request for catalog from store
	        Token.Instance = Token.Create(token);
	        XsollaCatalog.Instance.GetCatalog(XsollaSettings.StoreProjectId, OnItemsRequestSuccess, OnError, offset: 0, limit: 50);
        }

        private void OnItemsRequestSuccess(StoreItems storeItems)
        {
            // Iterating the items collection and assign values for appropriate ui elements
         foreach (var storeItem in storeItems.items)
            {
                if (storeItem.virtual_prices.Length == 0)
                    continue;

                var widget = Instantiate(WidgetPrefab, WidgetsContainer, false).GetComponent<VirtualItemWidget>();

                widget.NameText.text = storeItem.name;
                widget.DescriptionText.text = storeItem.description;

                var defaultPrice = storeItem.virtual_prices.First(x => x.is_default);
                widget.PriceText.text = $"{defaultPrice.name}: {defaultPrice.amount}";

                ImageLoader.Instance.GetImageAsync(storeItem.image_url, (url, sprite) => widget.IconImage.sprite = sprite);

                widget.BuyButton.onClick.AddListener(() =>
                {
                    var price = storeItem.virtual_prices.First(x => x.is_default);
                    XsollaCatalog.Instance.PurchaseItemForVirtualCurrency(XsollaSettings.StoreProjectId, storeItem.sku, price.sku, OnOrderCreateSuccess, OnError);
                });
            }
        }

        private void OnOrderCreateSuccess(PurchaseData purchaseData)
        {
	        XsollaOrders.Instance.CheckOrderStatus
            (
                XsollaSettings.StoreProjectId,
                purchaseData.order_id,
                status =>
                {
                    if (status.status == "paid" || status.status == "done")
                    {
                        OnPurchaseSuccess();
                    }
                },
                error =>
                {
                    OnError(error);
                }
            );
        }


        private void OnPurchaseSuccess()
        {
            UnityEngine.Debug.Log($"Purchase successful");
        }

        private void OnError(Error error)
        {
            UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
        }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
    public class VirtualCurrencyWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements

        public Text NameText;

        public Text AmountText;

        public Image IconImage;
    }
}

using UnityEngine;
using Xsolla.Auth;
using Xsolla.Core;
using Xsolla.Inventory;

namespace Recipes
{
	public class VirtualCurrenciesPage : MonoBehaviour
	{
		// Declaration of variables for containers and widget prefabs

		public Transform WidgetsContainer;

		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process

			XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, null, OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess(string token)
		{
			// After successful authentication starting the request for virtual currencies

			Token.Instance = Token.Create(token);
			XsollaInventory.Instance.GetVirtualCurrencyBalance(XsollaSettings.StoreProjectId, OnBalanceRequestSuccess, OnError);
		}

		private void OnBalanceRequestSuccess(VirtualCurrencyBalances balance)
		{
			// Iterating the virtual currencies list and assign values for appropriate ui elements

			foreach (var balanceItem in balance.items)
			{
				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<VirtualCurrencyWidget>();

				widget.NameText.text = balanceItem.name;
				widget.AmountText.text = balanceItem.amount.ToString();

				ImageLoader.Instance.GetImageAsync(balanceItem.image_url, (url, sprite) => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
		}
	}
}

using UnityEngine;
using UnityEngine.UI;

namespace Recipes
{
	public class InventoryItemWidget : MonoBehaviour
	{
		// Declaration of variables for UI elements

		public Text NameText;

		public Text DescriptionText;

		public Text QuantityText;

		public Image IconImage;
	}
}

using UnityEngine;
using Xsolla.Auth;
using Xsolla.Core;
using Xsolla.Inventory;

namespace Recipes
{
	public class InventoryItemsPage : MonoBehaviour
	{
		// Declaration of variables for containers and widget prefabs
		public Transform WidgetsContainer;

		public GameObject WidgetPrefab;

		private void Start()
		{
			// Starting the authentication process
			XsollaAuth.Instance.SignIn("xsolla", "xsolla", true, null, null, OnAuthenticationSuccess, OnError);
		}

		private void OnAuthenticationSuccess(string token)
		{
			// After successful authentication starting the request for virtual currencies
			Token.Instance = Token.Create(token);
			XsollaInventory.Instance.GetInventoryItems(XsollaSettings.StoreProjectId, OnItemsRequestSuccess, OnError);
		}

		private void OnItemsRequestSuccess(InventoryItems inventoryItems)
		{
			// Iterating the item list and assign values for appropriate ui elements

			foreach (var inventoryItem in inventoryItems.items)
			{
				if (inventoryItem.IsVirtualCurrency())
					continue;

				var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
				var widget = widgetGo.GetComponent<InventoryItemWidget>();

				widget.NameText.text = inventoryItem.name;
				widget.DescriptionText.text = inventoryItem.description;
				widget.QuantityText.text = inventoryItem.quantity.ToString();

				ImageLoader.Instance.GetImageAsync(inventoryItem.image_url, (url, sprite) => widget.IconImage.sprite = sprite);
			}
		}

		private void OnError(Error error)
		{
			UnityEngine.Debug.LogError($"Error message: {error.errorMessage}");
		}
	}
}