PreviewController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Data;
using Loading;
using Services;
using UnityEngine;
using UnityEngine.Assertions;
using UnityEngine.VFX;
using Utils;

namespace Preview
{
    public class PreviewController : MonoBehaviour
    {
        [SerializeField] private Camera mainCamera;
        [SerializeField] private PreviewCameraController previewCameraController;

        [SerializeField] private DragRotator avatarRotator;
        [SerializeField] private DragRotator wearableRotator;
        [SerializeField] private PreviewUIPresenter previewUIPresenter;

        [SerializeField] private AvatarLoader avatarLoader;
        [SerializeField] private WearableLoader wearableLoader;
        [SerializeField] private Vector3 wearableOffset = new(-5, 0, 0);

        [SerializeField] private EmoteAnimationController emoteAnimationController;
        [SerializeField] private VisualEffect             confirmationVFX;

        [SerializeField] private GameObject animationReference;
        [SerializeField] private GameObject platform;

        [SerializeField] private float wearablePadding = 0.15f;

        private bool _loading;
        private bool _shouldReload;
        private bool _shouldCleanup;
        private AvatarColors _marketplaceColors;
        private string _marketplaceColorsProfile;

        private void Start()
        {
            previewUIPresenter.ShowAvatarClicked += OnShowAvatarClicked;
            previewUIPresenter.ShowWearableClicked += OnShowWearableClicked;
            previewUIPresenter.EmoteToggleClicked += OnEmoteToggleClicked;
            previewUIPresenter.AvatarColorChanged += OnAvatarColorChanged;
            previewUIPresenter.ContainerDrag += avatarRotator.OnDrag;
            previewUIPresenter.ContainerDrag += wearableRotator.OnDrag;
            emoteAnimationController.EmoteAnimationEnded += OnEmoteAnimationEnded;

            avatarRotator.AllowVertical = false;
            wearableRotator.AllowVertical = false;

            StartCoroutine(Reload());
        }

        private void OnEmoteAnimationEnded()
        {
            previewUIPresenter.SetAnimationPlaying(false);
        }

        private void OnEmoteToggleClicked(bool playing)
        {
            if (playing)
            {
                emoteAnimationController.ReplayEmote();
            }
            else
            {
                emoteAnimationController.StopEmote();
            }
        }

        private void OnAvatarColorChanged(PreviewUIPresenter.ColorTarget target, Color color)
        {
            if (_marketplaceColors == null) return;

            _marketplaceColors = new AvatarColors(
                target == PreviewUIPresenter.ColorTarget.Eyes ? color : _marketplaceColors.Eyes,
                target == PreviewUIPresenter.ColorTarget.Hair ? color : _marketplaceColors.Hair,
                target == PreviewUIPresenter.ColorTarget.Skin ? color : _marketplaceColors.Skin);

            avatarLoader.ApplyColors(_marketplaceColors);
            wearableLoader.ApplyColors(_marketplaceColors);
        }

        private void OnShowWearableClicked()
        {
            PlayerPrefs.SetInt("PreviewAvatarShown", 0);

            previewCameraController.ShowMarketplaceWearable(true);
            wearableRotator.ResetRotation();
        }

        private void OnShowAvatarClicked()
        {
            PlayerPrefs.SetInt("PreviewAvatarShown", 1);

            previewCameraController.ShowMarketplaceWearable(false);
            avatarRotator.ResetRotation();
        }

        public void SetSpringBonesParams(SpringBones.SpringBonesParamsPayload payload) =>
            avatarLoader.SetSpringBonesParams(payload);

        public float GetEmoteLength() => emoteAnimationController.GetEmoteLength();

        public bool IsEmotePlaying() => emoteAnimationController.IsEmotePlaying();

        public void PlayEmote()
        {
            if (emoteAnimationController.IsPaused)
                emoteAnimationController.ResumeEmote();
            else
                emoteAnimationController.ReplayEmote();
        }

        public void PauseEmote() => emoteAnimationController.PauseEmote();

        public void GoToEmote(float seconds) => emoteAnimationController.GoToEmote(seconds);

        public void StopEmote() => emoteAnimationController.StopEmote();

        public void EnableSound() => emoteAnimationController.EnableSound();

        public void DisableSound() => emoteAnimationController.DisableSound();

        public bool HasSound() => emoteAnimationController.HasAudio;

        public void InvokeReload()
        {
            _shouldCleanup = false;
            StartCoroutine(Reload());
        }

        private async Awaitable Reload()
        {
            if (_loading)
            {
                _shouldReload = true;
                return;
            }

            Cleanup();
            previewUIPresenter.ShowLoader(true);
            _loading = true;
            mainCamera.cullingMask = 0; // Render nothing
            avatarLoader.enabled = false; // Disables Update for Outline
            wearableLoader.enabled = false; // Disables Update for Outline

            do
            {
                _shouldReload = false;

                // We store the instance in case it gets recreated by a call to AangConfiguration.RecreateFrom
                var config = AangConfiguration.Instance;

                avatarRotator.enabled = false;
                wearableRotator.enabled = false;
                avatarRotator.ResetRotation();
                wearableRotator.ResetRotation();

                animationReference.SetActive(config.ShowAnimationReference);
                platform.SetActive(config.Mode is PreviewMode.Authentication);
                mainCamera.backgroundColor = config.Background;
                mainCamera.orthographic = config.Projection == "orthographic";
                previewUIPresenter.EnableLoader(!config.DisableLoader);
                previewCameraController.SetMode(config.Mode);
                confirmationVFX.gameObject.SetActive(config.Mode is PreviewMode.Jesus);

                var hasEmoteOverride = false;
                var hasWearableOverride = false;
                var hasEmoteAudio = false;
                var showingAvatar = false;

                try
                {
                    await EntityService.PreloadBodyEntities();

                    switch (config.Mode)
                    {
                        case PreviewMode.Marketplace:
                            var urns = await LoadUrns(config);
                            Assert.IsTrue(urns.Count == 1,
                                $"Marketplace mode only allows one urn, found: {urns.Count}");
                            var result = await LoadForMarketplace(config.Profile, urns[0], config.Emote);

                            previewUIPresenter.EnableEmoteControls(result.emoteOverride);

                            if (result.validRepresentation)
                            {
                                showingAvatar = PlayerPrefs.GetInt("PreviewAvatarShown", 0) == 1 ||
                                                result.emoteOverride;
                                previewUIPresenter.SetSwitcherState(
                                    showingAvatar
                                        ? PreviewUIPresenter.SwitcherState.Avatar
                                        : PreviewUIPresenter.SwitcherState.Wearable, result.avatarBodyShape);
                            }
                            else
                            {
                                previewUIPresenter.SetSwitcherState(PreviewUIPresenter.SwitcherState.WearableLocked,
                                    result.avatarBodyShape);
                            }

                            hasEmoteOverride = result.emoteOverride;
                            hasWearableOverride = !hasEmoteOverride;
                            hasEmoteAudio = result.emoteOverrideAudio;
                            break;
                        case PreviewMode.Authentication:
                        case PreviewMode.Profile:
                            showingAvatar = true;
                            await LoadForProfile(config.Profile, config.Emote);
                            break;
                        case PreviewMode.Builder:
                            await LoadForBuilder(config.BodyShape,
                                config.EyeColor,
                                config.HairColor,
                                config.SkinColor,
                                config.Urns.ToArray(),
                                config.Emote,
                                config.Base64);
                            break;
                        case PreviewMode.Jesus:
                            showingAvatar = true;
                            confirmationVFX.Play();
                            await LoadForProfile(config.Profile, "character/Particles_Anim", true);
                            break;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
                catch (Exception e)
                {
                    JSBridge.NativeCalls.OnError(e.Message);
                    throw;
                }

                // Wait for 1 frame for animation to kick in before re-centering the object on screen
                await Awaitable.NextFrameAsync();

                if (hasWearableOverride)
                {
                    GameObjectUtils.CenterAndFit(wearableLoader.transform, mainCamera, wearablePadding);
                    wearableLoader.transform.position += wearableOffset;
                }
                else if (hasEmoteOverride)
                {
                    GameObjectUtils.CenterAndFit(avatarLoader.transform, mainCamera, wearablePadding);
                }

                if (config.Mode is PreviewMode.Marketplace)
                {
                    previewCameraController.ShowMarketplaceWearable(!showingAvatar);
                }
                else if (config.Mode is PreviewMode.Builder)
                {
                    avatarRotator.DragSpeed = 2f;
                }

                avatarRotator.enabled = true;
                wearableRotator.enabled = true;
                avatarRotator.EnableAutoRotate = config.Mode is PreviewMode.Marketplace && !hasEmoteOverride;

                previewUIPresenter.EnableEmoteControls(hasEmoteOverride);
                previewUIPresenter.EnableZoom(config.Mode is PreviewMode.Marketplace or PreviewMode.Builder);
                previewUIPresenter.EnableSwitcher(hasWearableOverride);
                previewUIPresenter.EnableAudioControls(hasEmoteAudio);
                previewUIPresenter.EnableColorPicker(config.Mode is PreviewMode.Marketplace);

                if (config.Mode is PreviewMode.Marketplace)
                {
                    previewUIPresenter.SetColorPickerColors(_marketplaceColors);
                }
            } while (_shouldReload);

            previewUIPresenter.ShowLoader(false);
            _loading = false;
            mainCamera.cullingMask = -1; // Render everything
            avatarLoader.enabled = true; // Enables Update for Outline
            wearableLoader.enabled = true;

            if (_shouldCleanup)
            {
                Cleanup();
            }

            JSBridge.NativeCalls.OnLoadComplete();
        }

        private async Awaitable LoadForBuilder(string bodyShapeName,
            Color? eyeColor,
            Color? hairColor,
            Color? skinColor,
            string[] urns,
            string emoteName,
            List<byte[]> base64)
        {
            var bodyShape = bodyShapeName.Equals(WearablesConstants.BODY_SHAPE_FEMALE, StringComparison.OrdinalIgnoreCase)
                ? BodyShape.Female
                : BodyShape.Male;

            var base64Entities = base64.Select(EntityDefinition.FromBase64).ToArray();
            var base64Emote = base64Entities.FirstOrDefault(e => e.Type == EntityType.Emote);
            var base64WearableEntities = base64Entities.Where(e => e.Type != EntityType.Emote);

            var urnEntities = await EntityService.GetEntities(urns);

            // Slot-based deduplication: one wearable per category, base64 items take priority
            var slots = new Dictionary<string, EntityDefinition>();
            foreach (var entity in urnEntities.Where(e => e.Type != EntityType.Emote))
            {
                slots[entity.Category] = entity;
            }
            foreach (var entity in base64WearableEntities)
            {
                slots[entity.Category] = entity;
            }
            var wearableEntities = slots.Values.ToArray();

            var colors = new AvatarColors(eyeColor ?? Color.black, hairColor ?? Color.black, skinColor ?? Color.black);

            var emoteEntity = base64Emote ?? (emoteName == "idle" ? null : EntityDefinition.FromEmbeddedEmote(emoteName, true));

            await avatarLoader.LoadAvatar(bodyShape,
                wearableEntities,
                emoteEntity,
                Array.Empty<string>(),
                colors);

            if (AangConfiguration.Instance.DisableFace)
            {
                avatarLoader.HideFacialFeatures();
            }
        }

        private async Awaitable<(bool emoteOverride, bool emoteOverrideAudio, bool validRepresentation, BodyShape avatarBodyShape)> LoadForMarketplace(string profileID, string urn,
            string defaultEmote)
        {
            Assert.IsNotNull(profileID);
            Assert.IsNotNull(urn);
            Assert.IsNotNull(defaultEmote);

            var avatar = await APIService.GetAvatar(profileID);
            var avatarBodyShape = avatar.GetBodyShape();

            var avatarColors = _marketplaceColors != null && _marketplaceColorsProfile == profileID
                ? _marketplaceColors
                : avatar.GetAvatarColors();
            _marketplaceColors = avatarColors;
            _marketplaceColorsProfile = profileID;
            var allEntities = await EntityService.GetEntities(avatar.wearables.Append(urn).ToArray());
            var overrideDefinition = allEntities.First(ed => ed.URN == urn);

            bool hasValidRepresentation;
            IEnumerable<EntityDefinition> wearables;
            EntityDefinition emoteDefinition;

            switch (overrideDefinition.Type)
            {
                case EntityType.Emote:
                    emoteDefinition = overrideDefinition;
                    wearables = allEntities.Where(wd => wd.URN != emoteDefinition.URN);
                    hasValidRepresentation = true;
                    break;
                case EntityType.Wearable or EntityType.FacialFeature:
                    emoteDefinition = defaultEmote == "idle" ? null : EntityDefinition.FromEmbeddedEmote(defaultEmote, false);
                    wearables = allEntities.Where(ed =>
                        ed.Category != overrideDefinition.Category || ed.URN == overrideDefinition.URN);
                    hasValidRepresentation = overrideDefinition.HasRepresentation(avatarBodyShape);
                    break;
                default:
                    throw new NotSupportedException($"Trying to override type: {overrideDefinition.Type}");
            }

            // Load the avatar
            if (hasValidRepresentation)
            {
                await avatarLoader.LoadAvatar(avatarBodyShape, wearables, emoteDefinition,
                    avatar.forceRender.Append(overrideDefinition.Category).ToArray(),
                    avatarColors);
            }

            if (overrideDefinition.Type is EntityType.Wearable or EntityType.FacialFeature)
            {
                await wearableLoader.LoadWearable(overrideDefinition, avatarBodyShape, avatarColors);
            }
            else
            {
                wearableLoader.Cleanup();
            }

            // TODO: This check for audio clip is ugly
            return (overrideDefinition.Type == EntityType.Emote, emoteAnimationController.HasAudio, hasValidRepresentation, avatarBodyShape);
        }

        private async Awaitable LoadForProfile(string profileID, string defaultEmote, bool loop = false)
        {
            Assert.IsNotNull(profileID);

            var avatar = await APIService.GetAvatar(profileID);
            var entities = await EntityService.GetEntities(avatar.wearables);

            await avatarLoader.LoadAvatar(avatar.GetBodyShape(), entities,
                EntityDefinition.FromEmbeddedEmote(defaultEmote, loop), avatar.forceRender, avatar.GetAvatarColors());
        }

        private async Awaitable<List<string>> LoadUrns(AangConfiguration config)
        {
            if (config.Urns.Count > 0) return config.Urns;

            // If we have a contract and item id or token id we need to fetch the urn first
            if (config.Contract != null && (config.ItemID != null || config.TokenID != null))
            {
                return new List<string>
                {
                    config.ItemID != null
                        ? (await APIService.GetMarketplaceItemFromID(config.Contract, config.ItemID)).data[0].urn
                        : (await APIService.GetMarketplaceItemFromToken(config.Contract, config.TokenID)).data[0].nft
                        .urn
                };
            }

            return null;
        }

        public void Cleanup()
        {
            if (_loading)
            {
                _shouldCleanup = true;
                return;
            }

            _shouldCleanup = false;

            emoteAnimationController.ClearEmote();
            avatarLoader.ClearEmote();
        }
    }
}