BannerToolkitOffsetHelper.cs

using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using UnityEngine;
using UnityEngine.UIElements;
 
namespace SCG.SpaceAdMobile.UI
{
    public enum BannerToolkitLayoutOffsetMode
    {
        [Tooltip("Applies banner offset to the target element margin.")]
        Margin = 0,

        [Tooltip("Applies banner offset to the target element padding.")]
        Padding = 1
    }

    [AddComponentMenu("SCG/SpaceAdMobile/" + nameof(BannerToolkitOffsetHelper))]
    public class BannerToolkitOffsetHelper : MonoBehaviour
    {
        #region Constants
 
        private const string SubRootName = "sub-root";
        private const int MillisecondsPerSecond = 1000;
        private const int PanelReadyRefreshDelayMs = 50;
        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<int, Dictionary<BannerAnchor, EntityId>> sideLocksByContainer = new();
#else
        private static readonly Dictionary<int, Dictionary<BannerAnchor, int>> sideLocksByContainer = new();
#endif
 
        #endregion
 
        #region Serialized fields

        [Tooltip("UIDocument that hosts UI Toolkit content. If null, it is searched on this GameObject.")]
#if UNITY_EDITOR && UNITY_6000_5_OR_NEWER
        [Editor.ShowIf(nameof(HasPanelRenderer), invert: true)]
#endif
        [SerializeField] private UIDocument uiDocument;
 
#if UNITY_6000_5_OR_NEWER
        [Tooltip("PanelRenderer that hosts UI Toolkit content when no UIDocument is available.")]
#if UNITY_EDITOR
        [Editor.ShowIf(nameof(HasUIDocument), invert: true)]
#endif
        [SerializeField] private PanelRenderer panelRenderer;
#endif

        [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 name of the target container in the visual tree.")]
        [SerializeField] private string explicitContainerName;

        [Tooltip("Controls whether banner-side offsets are written as margin or padding.")]
        [SerializeField] private BannerToolkitLayoutOffsetMode layoutOffsetMode = BannerToolkitLayoutOffsetMode.Margin;

        [Tooltip("Delay in seconds before applying offset after a visible banner refresh.")]
        [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 = 3;

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

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

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

        [Tooltip("Extra 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 VisualElement targetContainer;
        private BannerAnchor appliedAnchor;
        private BannerToolkitLayoutOffsetMode appliedLayoutOffsetMode;
        private (float top, float bottom, float left, float right) appliedInsets;
        private bool hasAppliedInsets;
        private Vector2 appliedTranslateOffset;
        private bool hasAppliedTranslateOffset;
        private bool hasInitialState;
        private bool isSubscribed;
        private int applyOffsetRequestVersion;
#if UNITY_6000_5_OR_NEWER
        private VisualElement currentRoot;
        private PanelRenderer registeredPanelRenderer;
        private int lastPanelReloadVersion = -1;
#endif
 
        #endregion
 
#if UNITY_EDITOR && UNITY_6000_5_OR_NEWER
        #region Editor state
 
        private bool HasUIDocument => uiDocument != null;
 
        private bool HasPanelRenderer => panelRenderer != null;
 
        #endregion
#endif
 
        #region Unity lifecycle
 
#if UNITY_EDITOR
        protected virtual void OnValidate()
        {
            if (Application.isPlaying) return;
 
            if (uiDocument == null)
                TryGetComponent(out uiDocument);
#if UNITY_6000_5_OR_NEWER
            if (uiDocument == null && panelRenderer == null)
                TryGetComponent(out panelRenderer);
#endif
 
            bannerAdComponent = bannerAdComponent ? bannerAdComponent : FindBannerAdCandidate();
 
            if (bannerAdComponent == null || bannerAdComponent is IBannerAd) return;
 
            Debug.LogWarning(
                $"{nameof(BannerToolkitOffsetHelper)}: 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 (uiDocument == null)
                TryGetComponent(out uiDocument);
 
#if UNITY_6000_5_OR_NEWER
            if (uiDocument == null && panelRenderer == null)
                TryGetComponent(out panelRenderer);
#endif
 
            if (uiDocument != null)
                return;
 
#if UNITY_6000_5_OR_NEWER
            if (panelRenderer != null)
                return;
#endif
 
#if UNITY_6000_3_OR_NEWER
            uiDocument = FindAnyObjectByType<UIDocument>();
#elif UNITY_2023_1_OR_NEWER
            uiDocument = FindFirstObjectByType<UIDocument>();
#else
            uiDocument = FindObjectOfType<UIDocument>();
#endif
        }
#endif

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

        protected virtual void OnEnable()
        {
            isComponentActive = true;
            InvalidatePendingApplyOffset();
            ClearAppliedOffsetState();
 
#if UNITY_6000_5_OR_NEWER
            SynchronizeSource();
#else
            ResetOffset();
            ClearRuntimeReferences();
#endif
#if UNITY_6000_5_OR_NEWER
            if (uiDocument != null || currentRoot != null)
            {
                if (ResolveRuntimeReferences())
                    Subscribe();
            }
            else if (registeredPanelRenderer == null)
            {
                ResolveRuntimeReferences();
            }
#else
            if (ResolveRuntimeReferences())
                Subscribe();
#endif
 
            SchedulePanelReadyRefresh();
        }

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

        protected virtual void OnDisable()
        {
            isComponentActive = false;
            InvalidatePendingApplyOffset();
            Unsubscribe();
#if UNITY_6000_5_OR_NEWER
            UnregisterPanelRenderer();
#endif
            ResetOffset();
            ClearRuntimeReferences();
        }
 
        #endregion
 
        #region Public API

        public void RefreshSource()
        {
            if (!isComponentActive)
                return;
 
#if UNITY_6000_5_OR_NEWER
            SynchronizeSource();
#else
            ResetOffset();
            ClearRuntimeReferences();
#endif
#if UNITY_6000_5_OR_NEWER
            if (uiDocument == null && registeredPanelRenderer != null && currentRoot == null)
            {
                RequestPanelRendererUpdate();
                SchedulePanelReadyRefresh();
                return;
            }
#endif
            if (!ResolveRuntimeReferences())
                return;
 
            Subscribe();
            RefreshOffset();
        }

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

        private void OnBannerShown() => RefreshOffset();

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

        private void SchedulePanelReadyRefresh()
        {
            var root = ResolveCurrentRoot();
            root?.schedule.Execute(RefreshAfterPanelReady).StartingIn(PanelReadyRefreshDelayMs);
        }

        private void RefreshAfterPanelReady()
        {
            if (!isComponentActive)
                return;
 
            RefreshOffset();
        }

        private bool EnsureRuntimeReferences()
        {
#if UNITY_6000_5_OR_NEWER
            if (uiDocument == null && currentRoot == null)
                return false;
#endif
            if (!hasInitialState || bannerAd == null || targetContainer == null)
            {
                if (!ResolveRuntimeReferences())
                    return false;
            }
 
            Subscribe();
            return true;
        }

        private bool ResolveRuntimeReferences()
        {
            if (uiDocument == null)
                TryGetComponent(out uiDocument);
 
#if UNITY_6000_5_OR_NEWER
            if (uiDocument == null && registeredPanelRenderer == null)
            {
                Debug.LogWarning($"{nameof(BannerToolkitOffsetHelper)}: UIDocument or PanelRenderer not found.", this);
                return false;
            }
#else
            if (uiDocument == null)
            {
                Debug.LogWarning($"{nameof(BannerToolkitOffsetHelper)}: UIDocument not found.", this);
                return false;
            }
#endif
 
            var root = ResolveCurrentRoot();
            if (root == null)
            {
                Debug.LogWarning($"{nameof(BannerToolkitOffsetHelper)}: UI Toolkit root is not available.", this);
                return false;
            }
 
            bannerAd = ResolveBannerAd();
            if (bannerAd == null)
            {
                Debug.LogWarning(
                    $"{nameof(BannerToolkitOffsetHelper)}: Banner component implementing {nameof(IBannerAd)} not found.",
                    this);
                return false;
            }
 
            targetContainer = ResolveTargetContainer(root);
            if (targetContainer == null)
                return false;
 
            hasInitialState = true;
            return true;
        }

        private VisualElement ResolveCurrentRoot() =>
            uiDocument != null ? uiDocument.rootVisualElement :
#if UNITY_6000_5_OR_NEWER
            registeredPanelRenderer != null ? currentRoot :
#endif
            null;
 
#if UNITY_6000_5_OR_NEWER
        private void SynchronizeSource()
        {
            var resolvedDocument = uiDocument;
            if (resolvedDocument == null)
                TryGetComponent(out resolvedDocument);
 
            var resolvedRenderer = resolvedDocument == null ? panelRenderer : null;
            if (resolvedDocument == null && resolvedRenderer == null)
                TryGetComponent(out resolvedRenderer);
 
            var sourceChanged = uiDocument != resolvedDocument || registeredPanelRenderer != resolvedRenderer;
            if (sourceChanged)
            {
                Unsubscribe();
                ResetOffset();
                ClearAppliedOffsetState();
                targetContainer = null;
                currentRoot = null;
                hasInitialState = false;
                lastPanelReloadVersion = -1;
            }
 
            uiDocument = resolvedDocument;
 
            if (uiDocument != null)
            {
                UnregisterPanelRenderer();
                currentRoot = uiDocument.rootVisualElement;
                return;
            }
 
            if (registeredPanelRenderer == resolvedRenderer)
                return;
 
            UnregisterPanelRenderer();
            registeredPanelRenderer = resolvedRenderer;
            if (registeredPanelRenderer == null) return;
            registeredPanelRenderer.RegisterUIReloadCallback(OnUIReload);
            ((IPanelComponent)registeredPanelRenderer).PerformUpdate();
        }
 
        private void UnregisterPanelRenderer()
        {
            if (registeredPanelRenderer == null)
                return;
 
            registeredPanelRenderer.UnregisterUIReloadCallback(OnUIReload);
            registeredPanelRenderer = null;
            currentRoot = null;
        }
 
        private void RequestPanelRendererUpdate()
        {
            var renderer = registeredPanelRenderer;
            if (renderer == null)
                return;
 
            ((IPanelComponent)renderer).PerformUpdate();
            renderer.UnregisterUIReloadCallback(OnUIReload);
            renderer.RegisterUIReloadCallback(OnUIReload);
        }

        private void OnUIReload(PanelRenderer renderer, VisualElement root, int version)
        {
            if (!isComponentActive)
                return;
 
            SynchronizeSource();
            if (uiDocument != null)
            {
                if (!ResolveRuntimeReferences()) return;
                Subscribe();
                RefreshOffset();
 
                return;
            }
 
            if (renderer != registeredPanelRenderer)
                return;
 
            if (root != null && version == lastPanelReloadVersion && currentRoot != null)
                return;
 
            ResetOffset();
            currentRoot = root;
            targetContainer = null;
            hasInitialState = false;
 
            if (root == null)
                return;
 
            lastPanelReloadVersion = version;
 
            if (!ResolveRuntimeReferences())
                return;
 
            Subscribe();
            RefreshOffset();
        }
#endif

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

        private VisualElement ResolveTargetContainer(VisualElement root)
        {
            if (string.IsNullOrWhiteSpace(explicitContainerName))
                return EnsureSubRoot(root);
 
            var explicitContainer = root.Q<VisualElement>(explicitContainerName);
            if (explicitContainer != null)
                return explicitContainer;
 
            Debug.LogWarning(
                $"{nameof(BannerToolkitOffsetHelper)}: Container '{explicitContainerName}' not found. " +
                $"Falling back to '{SubRootName}'.",
                this);
 
            return EnsureSubRoot(root);
        }

        private static VisualElement EnsureSubRoot(VisualElement root)
        {
            VisualElement subRoot = null;
            for (var index = 0; index < root.childCount; index++)
            {
                var child = root[index];
                if (child.name != SubRootName)
                    continue;
 
                subRoot = child;
                break;
            }
 
            if (subRoot == null)
            {
                subRoot = new VisualElement { name = SubRootName };
                ConfigureSubRoot(subRoot);
                root.Add(subRoot);
            }
 
            var children = new List<VisualElement>(root.childCount);
            for (var index = 0; index < root.childCount; index++)
            {
                var child = root[index];
                if (ReferenceEquals(child, subRoot))
                    continue;
 
                children.Add(child);
            }
 
            foreach (var child in children)
            {
                child.RemoveFromHierarchy();
                subRoot.Add(child);
            }
 
            return subRoot;
        }

        private static void ConfigureSubRoot(VisualElement subRoot)
        {
            subRoot.style.flexGrow = 1f;
            subRoot.style.width = new Length(100f, LengthUnit.Percent);
            subRoot.style.height = new Length(100f, LengthUnit.Percent);
        }

        private void ClearRuntimeReferences()
        {
            bannerAd = null;
            targetContainer = null;
#if UNITY_6000_5_OR_NEWER
            currentRoot = null;
#endif
            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()
        {
            var requestVersion = ++applyOffsetRequestVersion;
            var delayMilliseconds = GetApplyOffsetDelayMilliseconds();
            if (delayMilliseconds <= 0)
            {
                ApplyOffsetAttempt(requestVersion, 1);
                return;
            }
 
            ScheduleOffsetAttempt(requestVersion, 1, delayMilliseconds);
        }

        private void ScheduleOffsetAttempt(int requestVersion, int attempt, long delayMilliseconds)
        {
            var root = ResolveCurrentRoot();
            if (root == null)
            {
                ApplyOffsetAttempt(requestVersion, attempt);
                return;
            }
 
            root.schedule.Execute(() => ApplyOffsetAttempt(requestVersion, attempt)).StartingIn(delayMilliseconds);
        }

        private void ApplyOffsetAttempt(int requestVersion, int attempt)
        {
            ApplyOffsetNow(requestVersion);
 
            if (requestVersion != applyOffsetRequestVersion || !isComponentActive || bannerAd is not { IsVisible: true } ||
                attempt >= Mathf.Clamp(offsetApplyAttempts, MinOffsetApplyAttempts, MaxOffsetApplyAttempts))
                return;
 
            ScheduleOffsetAttempt(requestVersion, attempt + 1, 0);
        }

        private void ApplyOffsetNow(int requestVersion)
        {
            if (requestVersion != applyOffsetRequestVersion)
                return;
 
            if (!isComponentActive || !hasInitialState || targetContainer == null || bannerAd == null)
                return;
 
            if (!bannerAd.IsVisible)
                return;
 
            if (shiftOnlyBannerSide)
            {
                ApplySingleSideInset();
                return;
            }
 
            ApplyFullShiftOffset();
        }

        private long GetApplyOffsetDelayMilliseconds() =>
            Mathf.RoundToInt(Mathf.Clamp(
                applyOffsetDelaySeconds,
                MinApplyOffsetDelaySeconds,
                MaxApplyOffsetDelaySeconds) * MillisecondsPerSecond);

        private void InvalidatePendingApplyOffset() => applyOffsetRequestVersion++;

        private void ResetOffset()
        {
            InvalidatePendingApplyOffset();
 
            if (!hasInitialState || targetContainer == null)
                return;
 
            RemoveAppliedLayoutOffset();
            RemoveAppliedTranslateOffset();
            ReleaseSideLock(appliedAnchor);
            ClearAppliedOffsetState();
        }

        private void ApplySingleSideInset()
        {
            RemoveAppliedLayoutOffset();
            RemoveAppliedTranslateOffset();
            ReleaseSideLock(appliedAnchor);
 
            var insets = GetInsetValues();
            if (IsZeroInsets(insets))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            var side = GetInsetSide(insets);
            if (!TryAcquireSideLock(side))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            var currentOffsets = GetCurrentLayoutOffsetValues(layoutOffsetMode);
            ApplyLayoutOffsetValues(AddInsets(currentOffsets, insets), layoutOffsetMode);
 
            appliedAnchor = side;
            appliedLayoutOffsetMode = layoutOffsetMode;
            appliedInsets = insets;
            hasAppliedInsets = true;
            appliedTranslateOffset = Vector2.zero;
            hasAppliedTranslateOffset = false;
        }

        private void ApplyFullShiftOffset()
        {
            RemoveAppliedLayoutOffset();
            RemoveAppliedTranslateOffset();
            ReleaseSideLock(appliedAnchor);
 
            var offset = GetShiftOffsetVector();
            if (IsZeroVector(offset))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            var side = GetShiftLockSide();
            if (!TryAcquireSideLock(side))
            {
                ClearAppliedOffsetState();
                return;
            }
 
            var currentTranslate = GetCurrentTranslateValues();
            ApplyTranslateValues(currentTranslate + offset);
 
            appliedAnchor = side;
            appliedInsets = (0f, 0f, 0f, 0f);
            hasAppliedInsets = false;
            appliedTranslateOffset = offset;
            hasAppliedTranslateOffset = true;
        }

        private void RemoveAppliedLayoutOffset()
        {
            if (!hasAppliedInsets || targetContainer == null)
                return;
 
            var currentOffsets = GetCurrentLayoutOffsetValues(appliedLayoutOffsetMode);
            ApplyLayoutOffsetValues(SubtractInsets(currentOffsets, appliedInsets), appliedLayoutOffsetMode);
 
            appliedInsets = (0f, 0f, 0f, 0f);
            hasAppliedInsets = false;
        }

        private void RemoveAppliedTranslateOffset()
        {
            if (!hasAppliedTranslateOffset || targetContainer == null)
                return;
 
            var currentTranslate = GetCurrentTranslateValues();
            ApplyTranslateValues(currentTranslate - appliedTranslateOffset);
 
            appliedTranslateOffset = Vector2.zero;
            hasAppliedTranslateOffset = 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 resolvedBannerExtent = GetResolvedBannerExtent(anchor);
            var margin = GetMarginForAnchor(anchor);
            if (!accountForSafeArea)
                return resolvedBannerExtent + margin;
 
            return Mathf.Max(0f, resolvedBannerExtent - GetSafeAreaInsetForAnchor(anchor)) + margin;
        }

        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 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()
        {
            if (bannerAd == null)
                return BannerAnchor.Custom;
 
            return bannerAd.GetBannerAnchor() switch
            {
                BannerAnchor.Top => BannerAnchor.Bottom,
                BannerAnchor.Bottom => BannerAnchor.Top,
                BannerAnchor.Left => BannerAnchor.Right,
                BannerAnchor.Right => BannerAnchor.Left,
                _ => BannerAnchor.Custom
            };
        }

        private (float top, float bottom, float left, float right) GetCurrentLayoutOffsetValues(BannerToolkitLayoutOffsetMode mode) =>
            mode == BannerToolkitLayoutOffsetMode.Margin
                ? GetCurrentMarginValues()
                : GetCurrentPaddingValues();

        private void ApplyLayoutOffsetValues(
            (float top, float bottom, float left, float right) offsetValues,
            BannerToolkitLayoutOffsetMode mode)
        {
            if (mode == BannerToolkitLayoutOffsetMode.Margin)
            {
                ApplyMarginValues(offsetValues);
                return;
            }
 
            ApplyPaddingValues(offsetValues);
        }

        private (float top, float bottom, float left, float right) GetCurrentPaddingValues()
        {
            var resolvedStyle = targetContainer.resolvedStyle;
            return (
                top: ResolveStyleLengthValue(targetContainer.style.paddingTop, resolvedStyle.paddingTop),
                bottom: ResolveStyleLengthValue(targetContainer.style.paddingBottom, resolvedStyle.paddingBottom),
                left: ResolveStyleLengthValue(targetContainer.style.paddingLeft, resolvedStyle.paddingLeft),
                right: ResolveStyleLengthValue(targetContainer.style.paddingRight, resolvedStyle.paddingRight));
        }

        private void ApplyPaddingValues((float top, float bottom, float left, float right) paddingValues)
        {
            targetContainer.style.paddingTop = paddingValues.top;
            targetContainer.style.paddingBottom = paddingValues.bottom;
            targetContainer.style.paddingLeft = paddingValues.left;
            targetContainer.style.paddingRight = paddingValues.right;
        }

        private (float top, float bottom, float left, float right) GetCurrentMarginValues()
        {
            var resolvedStyle = targetContainer.resolvedStyle;
            return (
                top: ResolveStyleLengthValue(targetContainer.style.marginTop, resolvedStyle.marginTop),
                bottom: ResolveStyleLengthValue(targetContainer.style.marginBottom, resolvedStyle.marginBottom),
                left: ResolveStyleLengthValue(targetContainer.style.marginLeft, resolvedStyle.marginLeft),
                right: ResolveStyleLengthValue(targetContainer.style.marginRight, resolvedStyle.marginRight));
        }

        private void ApplyMarginValues((float top, float bottom, float left, float right) marginValues)
        {
            targetContainer.style.marginTop = marginValues.top;
            targetContainer.style.marginBottom = marginValues.bottom;
            targetContainer.style.marginLeft = marginValues.left;
            targetContainer.style.marginRight = marginValues.right;
        }

        private Vector2 GetCurrentTranslateValues()
        {
            var resolvedTranslate = targetContainer.resolvedStyle.translate;
            var resolvedValues = (Vector2)resolvedTranslate;
 
            var styleTranslate = targetContainer.style.translate;
            if (styleTranslate.keyword is StyleKeyword.Null or StyleKeyword.Auto)
                return resolvedValues;
 
            var value = styleTranslate.value;
            var x = ResolveTranslateLength(value.x, resolvedValues.x);
            var y = ResolveTranslateLength(value.y, resolvedValues.y);
            return new Vector2(x, y);
        }

        private void ApplyTranslateValues(Vector2 translateValues) =>
            targetContainer.style.translate = new Translate(
                new Length(translateValues.x, LengthUnit.Pixel),
                new Length(translateValues.y, LengthUnit.Pixel),
                0f);

        private static float ResolveStyleLengthValue(StyleLength styleLength, float fallback) =>
            styleLength.keyword is StyleKeyword.Null or StyleKeyword.Auto
                ? fallback
                : styleLength.value.unit == LengthUnit.Pixel
                    ? styleLength.value.value
                    : fallback;

        private static float ResolveTranslateLength(Length length, float fallback) =>
            length.unit == LengthUnit.Pixel ? length.value : fallback;

        private static (float top, float bottom, float left, float right) AddInsets(
            (float top, float bottom, float left, float right) left,
            (float top, float bottom, float left, float right) right) =>
            (
                top: left.top + right.top,
                bottom: left.bottom + right.bottom,
                left: left.left + right.left,
                right: left.right + right.right);

        private static (float top, float bottom, float left, float right) SubtractInsets(
            (float top, float bottom, float left, float right) left,
            (float top, float bottom, float left, float right) right) =>
            (
                top: left.top - right.top,
                bottom: left.bottom - right.bottom,
                left: left.left - right.left,
                right: left.right - right.right);

        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;
            appliedLayoutOffsetMode = layoutOffsetMode;
            appliedInsets = (0f, 0f, 0f, 0f);
            hasAppliedInsets = false;
            appliedTranslateOffset = Vector2.zero;
            hasAppliedTranslateOffset = 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;
 
            var containerId = RuntimeHelpers.GetHashCode(targetContainer);
            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;
 
            var containerId = RuntimeHelpers.GetHashCode(targetContainer);
            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
    }
}