BannerCanvasOffsetHelper.cs

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
 
namespace SCG.SpaceAdMobile.UI
{
    [AddComponentMenu("SCG/SpaceAdMobile/" + nameof(BannerCanvasOffsetHelper))]
    public class BannerCanvasOffsetHelper : MonoBehaviour
    {
        #region Constants
 
        private const string SubRootName = "sub-root";
        private const int MinOffsetApplyAttempts = 1;
        private const int MaxOffsetApplyAttempts = 10;
        private const float MinApplyOffsetDelaySeconds = 0f;
        private const float MaxApplyOffsetDelaySeconds = 1f;
 
#if UNITY_6000_4_OR_NEWER
        private static readonly Dictionary<EntityId, Dictionary<BannerAnchor, EntityId>> sideLocksByContainer = new();
#else
        private static readonly Dictionary<int, Dictionary<BannerAnchor, int>> sideLocksByContainer = new();
#endif
 
        #endregion
 
        #region Serialized fields

        [Tooltip("Canvas that hosts UI content. If null, it is searched on this GameObject.")]
        [SerializeField] private Canvas canvas;

        [Tooltip("Banner ad component implementing IBannerAd.")]
        [SerializeField] private AdUnitBehaviourBase bannerAdComponent;

        [Tooltip("Optional banner ad controller that keeps a Banner reference available, including when the Banner persists between scenes.")]
        [SerializeField] private AdControllerBase bannerAdController;

        [Tooltip("Optional container to offset. If null, a default sub-root is created and used.")]
        [SerializeField] private RectTransform explicitContainer;

        [Tooltip("Delay in seconds between repeated offset applications. Zero waits until the end of the frame.")]
        [Range(MinApplyOffsetDelaySeconds, MaxApplyOffsetDelaySeconds)]
        [SerializeField] private float applyOffsetDelaySeconds = MinApplyOffsetDelaySeconds;

        [Tooltip("Number of offset applications performed after a banner becomes visible.")]
        [Range(MinOffsetApplyAttempts, MaxOffsetApplyAttempts)]
        [SerializeField] private int offsetApplyAttempts = 1;

        [Tooltip("Extra canvas-unit margin applied when the banner is anchored to the top.")]
        [SerializeField] private float marginTop;

        [Tooltip("Extra canvas-unit margin applied when the banner is anchored to the bottom.")]
        [SerializeField] private float marginBottom;

        [Tooltip("Extra canvas-unit margin applied when the banner is anchored to the left.")]
        [SerializeField] private float marginLeft;

        [Tooltip("Extra canvas-unit margin applied when the banner is anchored to the right.")]
        [SerializeField] private float marginRight;

        [Tooltip("When true, only the banner side is inset. When false, full shift is allowed if the opposite side is free.")]
        [SerializeField] private bool shiftOnlyBannerSide = true;

        [Tooltip("When true, safe-area inset on the banner side is subtracted from the applied banner offset.")]
        [SerializeField] private bool accountForSafeArea = true;
 
        #endregion
 
        #region Runtime state
 
        // This flag is read by callbacks that may be invoked from an ad SDK thread.
        private volatile bool isComponentActive;
 
        private IBannerAd bannerAd;
        private RectTransform targetContainer;
        private BannerAnchor appliedAnchor;
        private (float top, float bottom, float left, float right) appliedInsets;
        private bool hasAppliedInsets;
        private Vector2 appliedShiftOffset;
        private bool hasAppliedShiftOffset;
        private bool hasInitialState;
        private bool isSubscribed;
        private Coroutine offsetRefreshCoroutine;
        private int offsetRefreshVersion;
 
        #endregion
 
        #region Unity lifecycle
 
#if UNITY_EDITOR
        protected virtual void OnValidate()
        {
            if (Application.isPlaying) return;
 
            if (canvas == null)
                TryGetComponent(out canvas);
 
            bannerAdComponent = bannerAdComponent ? bannerAdComponent : FindBannerAdCandidate();
 
            if (bannerAdComponent == null || bannerAdComponent is IBannerAd) return;
 
            Debug.LogWarning(
                $"{nameof(BannerCanvasOffsetHelper)}: Assigned banner component must implement {nameof(IBannerAd)}.",
                this);
            bannerAdComponent = null;
        }

        private AdUnitBehaviourBase FindBannerAdCandidate()
        {
            if (bannerAdController != null && bannerAdController.Ad is IBannerAd)
                return bannerAdController.Ad;
 
#if UNITY_6000_3_OR_NEWER
            var behaviours = FindObjectsByType<AdUnitBehaviourBase>(FindObjectsInactive.Exclude);
#elif UNITY_2023_1_OR_NEWER
            var behaviours = FindObjectsByType<AdUnitBehaviourBase>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
#else
            var behaviours = FindObjectsOfType<AdUnitBehaviourBase>();
#endif
            return behaviours.OfType<IBannerAd>().FirstOrDefault() as AdUnitBehaviourBase;
        }

        protected virtual void Reset()
        {
            if (Application.isPlaying) return;
 
            if (canvas == null)
                TryGetComponent(out canvas);
 
            if (canvas != null)
                return;
 
#if UNITY_6000_3_OR_NEWER
            canvas = FindAnyObjectByType<Canvas>();
#elif UNITY_2023_1_OR_NEWER
            canvas = FindFirstObjectByType<Canvas>();
#else
            canvas = FindObjectOfType<Canvas>();
#endif
        }
#endif

        protected virtual void Awake() => isComponentActive = isActiveAndEnabled;

        protected virtual void OnEnable()
        {
            isComponentActive = true;
            CancelOffsetRefresh();
            ClearAppliedOffsetState();
 
            if (!ResolveRuntimeReferences())
                return;
 
            Subscribe();
        }

        protected virtual void Start() => RefreshOffset();

        protected virtual void OnDisable()
        {
            isComponentActive = false;
            CancelOffsetRefresh();
            Unsubscribe();
            ResetOffset();
            ClearRuntimeReferences();
        }
 
        #endregion
 
        #region Public API

        public void RefreshOffset()
        {
            if (!isComponentActive)
                return;
 
            if (!EnsureRuntimeReferences())
                return;
 
            switch (bannerAd)
            {
                case { IsVisible: true }:
                    ApplyOffset();
                    ScheduleOffsetRefresh();
                    return;
                case { IsVisible: false }:
                    CancelOffsetRefresh();
                    ResetOffset();
                    break;
            }
        }
 
        #endregion
 
        #region Event handlers

        private void OnBannerShown() => RefreshOffset();

        private void OnBannerHidden() => RefreshOffset();
 
        #endregion
 
        #region Resolution

        private bool EnsureRuntimeReferences()
        {
            if (!hasInitialState || bannerAd == null || targetContainer == null)
            {
                if (!ResolveRuntimeReferences())
                    return false;
            }
 
            Subscribe();
            return true;
        }

        private bool ResolveRuntimeReferences()
        {
            if (canvas == null)
                TryGetComponent(out canvas);
 
            if (canvas == null)
            {
                Debug.LogWarning($"{nameof(BannerCanvasOffsetHelper)}: Canvas not found.", this);
                return false;
            }
 
            bannerAd = ResolveBannerAd();
            if (bannerAd == null)
            {
                Debug.LogWarning(
                    $"{nameof(BannerCanvasOffsetHelper)}: Banner component implementing {nameof(IBannerAd)} not found.",
                    this);
                return false;
            }
 
            targetContainer = ResolveTargetContainer();
            if (targetContainer == null)
                return false;
 
            WarnIfContainerIsNotStretched(targetContainer);
            hasInitialState = true;
            return true;
        }

        private IBannerAd ResolveBannerAd()
        {
            if (bannerAdComponent != null)
            {
                if (bannerAdComponent is IBannerAd directBanner)
                    return directBanner;
 
                Debug.LogWarning(
                    $"{nameof(BannerCanvasOffsetHelper)}: Assigned banner component must implement {nameof(IBannerAd)}.",
                    this);
                return null;
            }
 
            if (bannerAdController != null && bannerAdController.Ad is IBannerAd controllerBanner)
            {
                bannerAdComponent = bannerAdController.Ad;
                return controllerBanner;
            }
 
            return null;
        }

        private RectTransform ResolveTargetContainer()
        {
            var root = canvas.transform as RectTransform;
            if (root == null)
            {
                Debug.LogWarning($"{nameof(BannerCanvasOffsetHelper)}: Canvas root RectTransform not found.", this);
                return null;
            }
 
            if (explicitContainer == null)
                return EnsureSubRoot(root);
 
            if (explicitContainer.transform.IsChildOf(root))
                return explicitContainer;
 
            Debug.LogWarning(
                $"{nameof(BannerCanvasOffsetHelper)}: Explicit container is outside the Canvas hierarchy. " +
                $"Falling back to '{SubRootName}'.",
                this);
 
            return EnsureSubRoot(root);
        }

        private static RectTransform EnsureSubRoot(RectTransform root)
        {
            var subRoot = root.Find(SubRootName) as RectTransform;
            if (subRoot == null)
            {
                var subRootObject = new GameObject(SubRootName, typeof(RectTransform));
                subRoot = subRootObject.GetComponent<RectTransform>();
                subRoot.SetParent(root, false);
                ConfigureSubRoot(subRoot);
            }
 
            var children = new List<Transform>(root.childCount);
            for (var index = 0; index < root.childCount; index++)
            {
                var child = root.GetChild(index);
                if (child == subRoot)
                    continue;
 
                children.Add(child);
            }
 
            foreach (var child in children)
            {
                child.SetParent(subRoot, false);
            }
 
            return subRoot;
        }

        private static void ConfigureSubRoot(RectTransform subRoot)
        {
            subRoot.anchorMin = Vector2.zero;
            subRoot.anchorMax = Vector2.one;
            subRoot.offsetMin = Vector2.zero;
            subRoot.offsetMax = Vector2.zero;
            subRoot.anchoredPosition = Vector2.zero;
            subRoot.localScale = Vector3.one;
        }

        protected virtual void WarnIfContainerIsNotStretched(RectTransform container)
        {
            if (!shiftOnlyBannerSide || container == null)
                return;
 
            if (IsStretched(container))
                return;
 
            Debug.LogWarning(
                $"{nameof(BannerCanvasOffsetHelper)}: Target container is not stretched. " +
                "Single-side inset mode modifies RectTransform offsets and is intended for stretched containers.",
                this);
        }

        private static bool IsStretched(RectTransform rectTransform) =>
            rectTransform.anchorMin == Vector2.zero &&
            rectTransform.anchorMax == Vector2.one;

        private void ClearRuntimeReferences()
        {
            bannerAd = null;
            targetContainer = null;
            ClearAppliedOffsetState();
            hasInitialState = false;
        }
 
        #endregion
 
        #region Event subscription

        private void Subscribe()
        {
            if (isSubscribed || bannerAd == null)
                return;
 
            bannerAd.OnShown += OnBannerShown;
            bannerAd.OnHide += OnBannerHidden;
            isSubscribed = true;
        }

        private void Unsubscribe()
        {
            if (!isSubscribed)
                return;
 
            if (bannerAd != null)
            {
                bannerAd.OnShown -= OnBannerShown;
                bannerAd.OnHide -= OnBannerHidden;
            }
 
            isSubscribed = false;
        }
 
        #endregion
 
        #region Offset logic

        private void ApplyOffset()
        {
            if (!hasInitialState || targetContainer == null || bannerAd == null)
                return;
 
            if (shiftOnlyBannerSide)
            {
                ApplySingleSideInset();
                return;
            }
 
            ApplyFullShiftOffset();
        }

        private void ScheduleOffsetRefresh()
        {
            CancelOffsetRefresh();
 
            var attempts = Mathf.Clamp(offsetApplyAttempts, MinOffsetApplyAttempts, MaxOffsetApplyAttempts);
            if (attempts <= 1)
                return;
 
            var requestVersion = offsetRefreshVersion;
            offsetRefreshCoroutine = StartCoroutine(RefreshOffsetAfterFrames(requestVersion, attempts - 1));
        }

        private IEnumerator RefreshOffsetAfterFrames(int requestVersion, int remainingAttempts)
        {
            while (remainingAttempts > 0)
            {
                var delaySeconds = Mathf.Clamp(
                    applyOffsetDelaySeconds,
                    MinApplyOffsetDelaySeconds,
                    MaxApplyOffsetDelaySeconds);
                if (delaySeconds <= MinApplyOffsetDelaySeconds)
                    yield return new WaitForEndOfFrame();
                else
                    yield return new WaitForSeconds(delaySeconds);
 
                if (requestVersion != offsetRefreshVersion || !isComponentActive || bannerAd is not { IsVisible: true })
                    yield break;
 
                ApplyOffset();
                remainingAttempts--;
            }
 
            offsetRefreshCoroutine = null;
        }

        private void CancelOffsetRefresh()
        {
            offsetRefreshVersion++;
 
            if (offsetRefreshCoroutine == null)
                return;
 
            StopCoroutine(offsetRefreshCoroutine);
            offsetRefreshCoroutine = null;
        }

        private void ResetOffset()
        {
            if (!hasInitialState || targetContainer == null)
                return;
 
            RemoveAppliedInsets();
            RemoveAppliedShiftOffset();
            ReleaseSideLock(appliedAnchor);
            ClearAppliedOffsetState();
        }

        private void ApplySingleSideInset()
        {
            RemoveAppliedInsets();
            RemoveAppliedShiftOffset();
            ReleaseSideLock(appliedAnchor);
 
            var insets = GetInsetValues();
            if (IsZeroInsets(insets))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            var side = GetInsetSide(insets);
            if (!TryAcquireSideLock(side))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            var offsetMin = targetContainer.offsetMin;
            var offsetMax = targetContainer.offsetMax;
            AddInsetsToOffsets(ref offsetMin, ref offsetMax, insets);
            targetContainer.offsetMin = offsetMin;
            targetContainer.offsetMax = offsetMax;
 
            appliedAnchor = side;
            appliedInsets = insets;
            hasAppliedInsets = true;
            appliedShiftOffset = Vector2.zero;
            hasAppliedShiftOffset = false;
        }

        private void ApplyFullShiftOffset()
        {
            RemoveAppliedInsets();
            RemoveAppliedShiftOffset();
            ReleaseSideLock(appliedAnchor);
 
            var offset = GetShiftOffsetVector();
            if (IsZeroVector(offset))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            var side = GetShiftLockSide();
            if (!TryAcquireSideLock(side))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            targetContainer.anchoredPosition += offset;
 
            appliedAnchor = side;
            appliedInsets = (0f, 0f, 0f, 0f);
            hasAppliedInsets = false;
            appliedShiftOffset = offset;
            hasAppliedShiftOffset = true;
        }

        private void RemoveAppliedInsets()
        {
            if (!hasAppliedInsets || targetContainer == null)
                return;
 
            var offsetMin = targetContainer.offsetMin;
            var offsetMax = targetContainer.offsetMax;
            RemoveInsetsFromOffsets(ref offsetMin, ref offsetMax, appliedInsets);
            targetContainer.offsetMin = offsetMin;
            targetContainer.offsetMax = offsetMax;
 
            appliedInsets = (0f, 0f, 0f, 0f);
            hasAppliedInsets = false;
        }

        private void RemoveAppliedShiftOffset()
        {
            if (!hasAppliedShiftOffset || targetContainer == null)
                return;
 
            targetContainer.anchoredPosition -= appliedShiftOffset;
 
            appliedShiftOffset = Vector2.zero;
            hasAppliedShiftOffset = false;
        }

        private (float top, float bottom, float left, float right) GetInsetValues()
        {
            if (bannerAd == null)
                return (0f, 0f, 0f, 0f);
 
            var anchor = bannerAd.GetBannerAnchor();
            var effectiveExtent = GetEffectiveBannerExtent(anchor);
 
            return anchor switch
            {
                BannerAnchor.Top => (effectiveExtent, 0f, 0f, 0f),
                BannerAnchor.Bottom => (0f, effectiveExtent, 0f, 0f),
                BannerAnchor.Left => (0f, 0f, effectiveExtent, 0f),
                BannerAnchor.Right => (0f, 0f, 0f, effectiveExtent),
                _ => (0f, 0f, 0f, 0f)
            };
        }

        private Vector2 GetShiftOffsetVector()
        {
            if (bannerAd == null)
                return Vector2.zero;
 
            var anchor = bannerAd.GetBannerAnchor();
            var effectiveExtent = GetEffectiveBannerExtent(anchor);
 
            return anchor switch
            {
                BannerAnchor.Top => new Vector2(0f, -effectiveExtent),
                BannerAnchor.Bottom => new Vector2(0f, effectiveExtent),
                BannerAnchor.Left => new Vector2(effectiveExtent, 0f),
                BannerAnchor.Right => new Vector2(-effectiveExtent, 0f),
                _ => Vector2.zero
            };
        }

        private float GetEffectiveBannerExtent(BannerAnchor anchor)
        {
            var resolvedBannerExtentPixels = GetResolvedBannerExtent(anchor);
            var safeAreaInsetPixels = accountForSafeArea ? GetSafeAreaInsetForAnchor(anchor) : 0f;
            var effectiveExtentPixels = Mathf.Max(0f, resolvedBannerExtentPixels - safeAreaInsetPixels);
 
            return ConvertScreenPixelsToCanvasUnits(effectiveExtentPixels, anchor) + GetMarginForAnchor(anchor);
        }

        private float GetResolvedBannerExtent(BannerAnchor anchor)
        {
            if (bannerAd == null)
                return 0f;
 
            var resolvedHeight = Mathf.Max(0f, bannerAd.GetBannerHeightPixels());
            var resolvedWidth = Mathf.Max(0f, bannerAd.GetBannerWidthPixels());
            if (resolvedWidth <= 0f)
                resolvedWidth = Screen.width;
 
            return anchor switch
            {
                BannerAnchor.Top or BannerAnchor.Bottom => resolvedHeight,
                BannerAnchor.Left or BannerAnchor.Right => resolvedWidth,
                _ => 0f
            };
        }

        private float ConvertScreenPixelsToCanvasUnits(float screenPixels, BannerAnchor anchor)
        {
            if (Mathf.Approximately(screenPixels, 0f))
                return 0f;
 
            var root = canvas != null ? canvas.transform as RectTransform : null;
            if (root == null)
                return screenPixels;
 
            var isHorizontalAxis = anchor is BannerAnchor.Left or BannerAnchor.Right;
            var screenExtent = isHorizontalAxis ? Screen.width : Screen.height;
            var canvasExtent = isHorizontalAxis ? root.rect.width : root.rect.height;
 
            if (screenExtent > 0f && canvasExtent > 0f)
                return screenPixels * canvasExtent / screenExtent;
 
            var scaleFactor = canvas != null ? Mathf.Max(1f, canvas.scaleFactor) : 1f;
            return screenPixels / scaleFactor;
        }

        private float GetMarginForAnchor(BannerAnchor anchor) =>
            anchor switch
            {
                BannerAnchor.Top => marginTop,
                BannerAnchor.Bottom => marginBottom,
                BannerAnchor.Left => marginLeft,
                BannerAnchor.Right => marginRight,
                _ => 0f
            };

        private static float GetSafeAreaInsetForAnchor(BannerAnchor anchor)
        {
            var (top, bottom, left, right) = GetSafeAreaInsets();
            return anchor switch
            {
                BannerAnchor.Top => top,
                BannerAnchor.Bottom => bottom,
                BannerAnchor.Left => left,
                BannerAnchor.Right => right,
                _ => 0f
            };
        }

        private static (float top, float bottom, float left, float right) GetSafeAreaInsets()
        {
            var safeArea = Screen.safeArea;
            return (
                top: Mathf.Max(0f, Screen.height - (safeArea.y + safeArea.height)),
                bottom: Mathf.Max(0f, safeArea.y),
                left: Mathf.Max(0f, safeArea.x),
                right: Mathf.Max(0f, Screen.width - (safeArea.x + safeArea.width)));
        }

        private BannerAnchor GetShiftLockSide() =>
            bannerAd == null
                ? BannerAnchor.Custom
                : bannerAd.GetBannerAnchor() switch
                {
                    BannerAnchor.Top => BannerAnchor.Bottom,
                    BannerAnchor.Bottom => BannerAnchor.Top,
                    BannerAnchor.Left => BannerAnchor.Right,
                    BannerAnchor.Right => BannerAnchor.Left,
                    _ => BannerAnchor.Custom
                };

        private static void AddInsetsToOffsets(
            ref Vector2 offsetMin,
            ref Vector2 offsetMax,
            (float top, float bottom, float left, float right) insets)
        {
            offsetMin = new Vector2(offsetMin.x + insets.left, offsetMin.y + insets.bottom);
            offsetMax = new Vector2(offsetMax.x - insets.right, offsetMax.y - insets.top);
        }

        private static void RemoveInsetsFromOffsets(
            ref Vector2 offsetMin,
            ref Vector2 offsetMax,
            (float top, float bottom, float left, float right) insets)
        {
            offsetMin = new Vector2(offsetMin.x - insets.left, offsetMin.y - insets.bottom);
            offsetMax = new Vector2(offsetMax.x + insets.right, offsetMax.y + insets.top);
        }

        private static bool IsZeroInsets((float top, float bottom, float left, float right) insets) =>
            Mathf.Approximately(insets.top, 0f) &&
            Mathf.Approximately(insets.bottom, 0f) &&
            Mathf.Approximately(insets.left, 0f) &&
            Mathf.Approximately(insets.right, 0f);

        private static bool IsZeroVector(Vector2 shiftOffset) =>
            Mathf.Approximately(shiftOffset.x, 0f) &&
            Mathf.Approximately(shiftOffset.y, 0f);

        private void ClearAppliedOffsetState()
        {
            appliedAnchor = BannerAnchor.Custom;
            appliedInsets = (0f, 0f, 0f, 0f);
            hasAppliedInsets = false;
            appliedShiftOffset = Vector2.zero;
            hasAppliedShiftOffset = false;
        }

        private static BannerAnchor GetInsetSide((float top, float bottom, float left, float right) insets) =>
            !Mathf.Approximately(insets.top, 0f) ? BannerAnchor.Top :
            !Mathf.Approximately(insets.bottom, 0f) ? BannerAnchor.Bottom :
            !Mathf.Approximately(insets.left, 0f) ? BannerAnchor.Left :
            !Mathf.Approximately(insets.right, 0f) ? BannerAnchor.Right : BannerAnchor.Custom;

        private bool TryAcquireSideLock(BannerAnchor side)
        {
            side = NormalizeLockAnchor(side);
            if (side == BannerAnchor.Custom || targetContainer == null)
                return true;
 
#if UNITY_6000_4_OR_NEWER
            var containerId = targetContainer.GetEntityId();
#else
            var containerId = targetContainer.GetInstanceID();
#endif
 
            if (!sideLocksByContainer.TryGetValue(containerId, out var sideLocks))
            {
#if UNITY_6000_4_OR_NEWER
                sideLocks = new Dictionary<BannerAnchor, EntityId>();
#else
                sideLocks = new Dictionary<BannerAnchor, int>();
#endif
                sideLocksByContainer[containerId] = sideLocks;
            }
 
#if UNITY_6000_4_OR_NEWER
            var ownerId = GetEntityId();
#else
            var ownerId = GetInstanceID();
#endif
 
            if (sideLocks.TryGetValue(side, out var lockedBy) && lockedBy != ownerId)
                return false;
 
            sideLocks[side] = ownerId;
            return true;
        }

        private void ReleaseSideLock(BannerAnchor side)
        {
            side = NormalizeLockAnchor(side);
            if (side == BannerAnchor.Custom || targetContainer == null)
                return;
 
#if UNITY_6000_4_OR_NEWER
            var containerId = targetContainer.GetEntityId();
#else
            var containerId = targetContainer.GetInstanceID();
#endif
 
            if (!sideLocksByContainer.TryGetValue(containerId, out var sideLocks))
                return;
 
#if UNITY_6000_4_OR_NEWER
            var ownerId = GetEntityId();
#else
            var ownerId = GetInstanceID();
#endif
 
            if (!sideLocks.TryGetValue(side, out var lockedBy) || lockedBy != ownerId)
                return;
 
            sideLocks.Remove(side);
            if (sideLocks.Count == 0)
                sideLocksByContainer.Remove(containerId);
        }

        private static BannerAnchor NormalizeLockAnchor(BannerAnchor anchor) =>
            anchor is BannerAnchor.Center or BannerAnchor.Custom
                ? BannerAnchor.Custom
                : anchor;
 
        #endregion
    }
}