Commercialization.tapadn/Samples~/IAAAdDebugSample/Runtime/TapadnIAAAdDebugSampleGui.cs

using System;
using System.Collections.Generic;
using System.IO;
using Runtime.ADAggregator;
using UnityEngine;

public sealed class TapadnIAAAdDebugSampleGui : MonoBehaviour
{
    private const float ReferenceWidth = 1080f;
    private const float ReferenceHeight = 2340f;
    private const int MaxLogEntries = 140;
    private const float StatusRefreshInterval = 1f;

    public ADConfig adConfig;
    public string userId = "debug_user_001";
    public string rewardedScenario = "reward_debug";
    public string interstitialScenario = "interstitial_debug";
    public string splashScenario = "splash_debug";
    public bool autoInitialize = true;
    public bool forcePortrait = true;
    public bool captureUnityLogs = true;
    public bool showVerboseState = true;
    public bool autoWriteLogsToFile = true;

    private readonly List<string> _logs = new List<string>(MaxLogEntries);
    private Vector2 _pageScroll;
    private Vector2 _logScroll;
    private bool _initInvoked;
    private bool _initCallbackReceived;
    private bool _stylesInitialized;
    private GUIStyle _titleStyle;
    private GUIStyle _sectionStyle;
    private GUIStyle _textStyle;
    private GUIStyle _buttonStyle;
    private GUIStyle _textFieldStyle;
    private GUIStyle _logStyle;
    private bool _rewardedReadyCache;
    private bool _interstitialReadyCache;
    private bool _splashReadyCache;
    private bool _maskOpen;
    private string _lastEventLog = "<none>";
    private float _nextStatusRefreshTime;
    private string _sessionLogFilePath;
    private string _sessionLogDirectory;

    private void Awake()
    {
        Application.targetFrameRate = 60;
        Screen.sleepTimeout = SleepTimeout.NeverSleep;
        if (forcePortrait)
        {
            Screen.orientation = ScreenOrientation.Portrait;
        }

        if (captureUnityLogs)
        {
            Application.logMessageReceived += OnLogMessageReceived;
        }

        ADManager.Instance.GLOBAL_ShowAwardVideoBefore += OnRewardedBefore;
        ADManager.Instance.GLOBAL_ShowAwardVideoComplete += OnRewardedComplete;
        InitializeLogFile();
        AppendLog("TapADN IAA Ad Debug Sample is ready.");
    }

    private void Start()
    {
        if (autoInitialize)
        {
            TryInitialize();
        }

        RefreshStatusCaches(true);
    }

    private void OnDestroy()
    {
        if (captureUnityLogs)
        {
            Application.logMessageReceived -= OnLogMessageReceived;
        }

        ADManager.Instance.GLOBAL_ShowAwardVideoBefore -= OnRewardedBefore;
        ADManager.Instance.GLOBAL_ShowAwardVideoComplete -= OnRewardedComplete;
    }

    private void OnGUI()
    {
        EnsureStyles();

        var safeArea = Screen.safeArea;
        var scaleX = safeArea.width / ReferenceWidth;
        var scaleY = safeArea.height / ReferenceHeight;
        var previousMatrix = GUI.matrix;
        GUI.matrix = Matrix4x4.TRS(
            new Vector3(safeArea.x, safeArea.y, 0f),
            Quaternion.identity,
            new Vector3(scaleX, scaleY, 1f));

        GUILayout.BeginArea(new Rect(24f, 24f, ReferenceWidth - 48f, ReferenceHeight - 48f), GUI.skin.box);
        _pageScroll = GUILayout.BeginScrollView(_pageScroll, false, true);
        DrawHeader();
        DrawSetupSection();
        DrawStatusSection();
        DrawControlSection();
        DrawLogSection();
        GUILayout.EndScrollView();
        GUILayout.EndArea();

        GUI.matrix = previousMatrix;
    }

    private void DrawHeader()
    {
        GUILayout.Label("TapADN IAA Ad Debug Sample", _titleStyle);
        GUILayout.Label(
            $"Screen: {Screen.width} x {Screen.height} | SafeArea: {Screen.safeArea.width:0} x {Screen.safeArea.height:0}",
            _textStyle);
        GUILayout.Label(
            $"Reference Layout: {ReferenceWidth:0} x {ReferenceHeight:0} | Orientation: {Screen.orientation}",
            _textStyle);
        GUILayout.Space(10f);
    }

    private void DrawSetupSection()
    {
        GUILayout.Label("Setup", _sectionStyle);
        GUILayout.Label(
            $"ADConfig Asset: {(adConfig != null ? adConfig.name : "Missing")} | Init Invoked: {_initInvoked} | Init Callback: {_initCallbackReceived}",
            _textStyle);

        userId = DrawLabeledTextField("User ID", userId);
        rewardedScenario = DrawLabeledTextField("Rewarded Scene", rewardedScenario);
        interstitialScenario = DrawLabeledTextField("Interstitial Scene", interstitialScenario);
        splashScenario = DrawLabeledTextField("Splash Scene", splashScenario);

        GUILayout.Label($"MediaId: {DisplayValue(adConfig?.Id)}", _textStyle);
        GUILayout.Label($"Rewarded SpaceId: {DisplayValue(adConfig?.BaseAwardAdKeyValue?.value)}", _textStyle);
        GUILayout.Label($"Interstitial SpaceId: {DisplayValue(adConfig?.BaseInteractionAdKeyValue?.value)}", _textStyle);
        GUILayout.Label($"Splash SpaceId: {DisplayValue(adConfig?.BaseSplashAdKeyValue?.value)}", _textStyle);
        GUILayout.Space(6f);

        if (GUILayout.Button("Initialize ADManager", _buttonStyle, GUILayout.Height(78f)))
        {
            TryInitialize();
        }

        GUILayout.Space(10f);
    }

    private void DrawStatusSection()
    {
        GUILayout.Label("Runtime Status", _sectionStyle);

        if (_initInvoked)
        {
            RefreshStatusCaches();
            GUILayout.Label($"Rewarded Ready: {_rewardedReadyCache}", _textStyle);
            GUILayout.Label($"Interstitial Ready: {_interstitialReadyCache}", _textStyle);
            GUILayout.Label($"Splash Ready: {_splashReadyCache}", _textStyle);
            GUILayout.Label($"Mask Open: {_maskOpen}", _textStyle);
            GUILayout.Label($"Last EventLog: {_lastEventLog}", _textStyle);
            GUILayout.Label($"Last SDK Version: {DisplayValue(TapadnAdController.LastSdkVersion)}", _textStyle);
            GUILayout.Label($"Last Init Error: {DisplayValue(TapadnAdController.LastInitError)}", _textStyle);
            GUILayout.Label($"Rewarded Selected SpaceId: {GetResolvedRewardedSlotForDisplay(rewardedScenario)}", _textStyle);
        }
        else
        {
            GUILayout.Label("Status unavailable before initialization.", _textStyle);
        }

        var options = TapadnAdController.CurrentOptions;
        if (options != null)
        {
            GUILayout.Label(
                $"Rewarded Auto/Prewarm/Retry: {options.RewardedAutoLoad}/{options.RewardedPrewarmOnInit}/{options.RewardedMaxLoadAttempts}@{options.RewardedLoadRetryDelayMs}ms",
                _textStyle);
            GUILayout.Label(
                $"Interstitial Auto/Prewarm/Retry: {options.InterstitialAutoLoad}/{options.InterstitialPrewarmOnInit}/{options.InterstitialMaxLoadAttempts}@{options.InterstitialLoadRetryDelayMs}ms",
                _textStyle);
            GUILayout.Label(
                $"Splash Auto/Prewarm/Retry: {options.SplashAutoLoad}/{options.SplashPrewarmOnInit}/{options.SplashMaxLoadAttempts}@{options.SplashLoadRetryDelayMs}ms",
                _textStyle);
            GUILayout.Label(
                $"Channel/SubChannel/Debug: {DisplayValue(options.Channel)}/{DisplayValue(options.SubChannel)}/{options.Debug}",
                _textStyle);
            GUILayout.Label($"Smart Preload: enabled={options.SmartPreloadEnabled}, asset={DisplayValue(options.SmartPreloadConfigAssetPath)}", _textStyle);
            GUILayout.Label($"Smart Policy Snapshot: {TapadnSmartLoadOrchestrator.GetDebugStateDump()}", _textStyle);
        }

        if (showVerboseState && GUILayout.Button("Refresh Status Snapshot", _buttonStyle, GUILayout.Height(64f)))
        {
            RefreshStatusCaches(true);
            AppendLog("Manual status snapshot refreshed.");
        }

        if (GUILayout.Button("Reset SmartLoad Learning State", _buttonStyle, GUILayout.Height(64f)))
        {
            TapadnSmartLoadOrchestrator.ResetLearningState();
            AppendLog("TapADN SmartLoad learning state reset.");
        }

        GUILayout.Space(10f);
    }

    private void DrawControlSection()
    {
        GUILayout.Label("Ad Actions", _sectionStyle);

        GUILayout.BeginHorizontal();
        DrawEnterButton("Enter Rewarded", AD_Type.AwardVideo, rewardedScenario);
        DrawEnterButton("Enter Interstitial", AD_Type.Interaction, interstitialScenario);
        DrawEnterButton("Enter Splash", AD_Type.Splash, splashScenario);
        GUILayout.EndHorizontal();

        GUILayout.BeginHorizontal();
        DrawLoadButton("Load Rewarded", AD_Type.AwardVideo);
        DrawLoadButton("Load Interstitial", AD_Type.Interaction);
        DrawLoadButton("Load Splash", AD_Type.Splash);
        GUILayout.EndHorizontal();

        GUILayout.BeginHorizontal();
        DrawPlayButton("Play Rewarded", AD_Type.AwardVideo, rewardedScenario);
        DrawPlayButton("Play Interstitial", AD_Type.Interaction, interstitialScenario);
        DrawPlayButton("Play Splash", AD_Type.Splash, splashScenario);
        GUILayout.EndHorizontal();

        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Close Interstitial", _buttonStyle, GUILayout.Height(70f)))
        {
            ADManager.Instance.CloseAd(AD_Type.Interaction);
            AppendLog("Close interstitial requested.");
        }

        if (GUILayout.Button("Close Splash", _buttonStyle, GUILayout.Height(70f)))
        {
            ADManager.Instance.CloseAd(AD_Type.Splash);
            AppendLog("Close splash requested.");
        }
        GUILayout.EndHorizontal();

        GUILayout.Space(10f);
    }

    private void DrawEnterButton(string label, AD_Type adType, string scenario)
    {
        if (!GUILayout.Button(label, _buttonStyle, GUILayout.Height(84f)))
        {
            return;
        }

        if (EnsureInitialized(label))
        {
            LogRewardedResolvedSlot(adType, scenario, "Enter scenario");
            ADManager.Instance.EnterAdScenario(adType, scenario);
            AppendLog($"Enter scenario requested. type={adType}, scenario={scenario}");
        }
    }

    private void DrawLoadButton(string label, AD_Type adType)
    {
        if (!GUILayout.Button(label, _buttonStyle, GUILayout.Height(84f)))
        {
            return;
        }

        if (EnsureInitialized(label))
        {
            ADManager.Instance.LoadAD(adType);
            AppendLog($"Manual load requested. type={adType}");
        }
    }

    private void DrawPlayButton(string label, AD_Type adType, string scenario)
    {
        if (!GUILayout.Button(label, _buttonStyle, GUILayout.Height(84f)))
        {
            return;
        }

        if (EnsureInitialized(label))
        {
            LogRewardedResolvedSlot(adType, scenario, "AsyncPlayAD");
            ADManager.Instance.AsyncPlayAD(adType, scenario, result =>
            {
                AppendLog($"{adType} callback: {result}");
            });
            AppendLog($"AsyncPlayAD requested. type={adType}, scenario={scenario}");
        }
    }

    private void DrawLogSection()
    {
        GUILayout.Label("Diagnostics", _sectionStyle);
        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Clear Logs", _buttonStyle, GUILayout.Height(70f)))
        {
            _logs.Clear();
            AppendLog("Logs cleared.");
        }

        if (GUILayout.Button("Copy All Logs", _buttonStyle, GUILayout.Height(70f)))
        {
            GUIUtility.systemCopyBuffer = string.Join("\n", _logs);
            AppendLog($"Copied {_logs.Count} log lines to clipboard.");
        }

        if (GUILayout.Button("Log Current Options", _buttonStyle, GUILayout.Height(70f)))
        {
            LogCurrentOptions();
        }
        GUILayout.EndHorizontal();

        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Export Logs To File", _buttonStyle, GUILayout.Height(70f)))
        {
            ExportVisibleLogsToFile();
        }

        if (GUILayout.Button("Copy Log File Path", _buttonStyle, GUILayout.Height(70f)))
        {
            if (string.IsNullOrWhiteSpace(_sessionLogFilePath))
            {
                AppendLog("Log file path unavailable.");
            }
            else
            {
                GUIUtility.systemCopyBuffer = _sessionLogFilePath;
                AppendLog($"Copied log file path: {_sessionLogFilePath}");
            }
        }
        GUILayout.EndHorizontal();

        GUILayout.Label($"Log File: {DisplayValue(_sessionLogFilePath)}", _textStyle);

        _logScroll = GUILayout.BeginScrollView(_logScroll, GUILayout.Height(520f));
        foreach (var line in _logs)
        {
            GUILayout.Label(line, _logStyle);
        }
        GUILayout.EndScrollView();
    }

    private string DrawLabeledTextField(string label, string value)
    {
        GUILayout.BeginHorizontal();
        GUILayout.Label(label, _textStyle, GUILayout.Width(300f));
        value = GUILayout.TextField(value ?? string.Empty, _textFieldStyle, GUILayout.Height(64f));
        GUILayout.EndHorizontal();
        return value;
    }

    private bool TryInitialize()
    {
        if (_initInvoked)
        {
            AppendLog("Initialize skipped: ADManager already initialized by sample.");
            return true;
        }

        if (adConfig == null)
        {
            AppendLog("Initialize failed: sample ADConfig asset is missing.");
            return false;
        }

        if (string.IsNullOrWhiteSpace(adConfig.Id) || string.IsNullOrWhiteSpace(adConfig.Key))
        {
            AppendLog("Initialize warning: MediaId/MediaKey is empty. Please fill the sample ADConfig asset.");
        }

        _initInvoked = true;
        var controller = new SampleTapadnAdController(
            isOpen =>
            {
                _maskOpen = isOpen;
                AppendLog($"Mask changed => open={isOpen}");
            },
            (eventTable, eventValue, eventMessage) =>
            {
                _lastEventLog = $"{eventTable}:{eventValue}:{eventMessage}";
                AppendLog($"EventLog => table={eventTable}, value={eventValue}, message={eventMessage}");
            });

        ADManager.Instance.Init(() =>
        {
            _initCallbackReceived = true;
            AppendLog("ADManager.Init callback received.");
        }, userId, adConfig, controller);

        AppendLog($"ADManager.Init invoked with userId={userId}");
        AppendLog($"Rewarded={adConfig.BaseAwardAdKeyValue?.value}, interstitial={adConfig.BaseInteractionAdKeyValue?.value}, splash={adConfig.BaseSplashAdKeyValue?.value}");
        return true;
    }

    private bool EnsureInitialized(string actionName)
    {
        if (TryInitialize())
        {
            return true;
        }

        AppendLog($"{actionName} cancelled: initialization failed.");
        return false;
    }

    private void RefreshStatusCaches(bool force = false)
    {
        if (!force && Time.unscaledTime < _nextStatusRefreshTime)
        {
            return;
        }

        _nextStatusRefreshTime = Time.unscaledTime + StatusRefreshInterval;
        _rewardedReadyCache = _initInvoked && ADManager.Instance.IsRealy(AD_Type.AwardVideo);
        _interstitialReadyCache = _initInvoked && ADManager.Instance.IsRealy(AD_Type.Interaction);
        _splashReadyCache = _initInvoked && ADManager.Instance.IsRealy(AD_Type.Splash);
    }

    private void LogCurrentOptions()
    {
        var options = TapadnAdController.CurrentOptions;
        if (options == null)
        {
            AppendLog("Current options unavailable: controller not initialized.");
            return;
        }

        AppendLog($"Options => mediaId={options.MediaId}, channel={options.Channel}, sub={options.SubChannel}, debug={options.Debug}, rewardAuto={options.RewardedAutoLoad}, interAuto={options.InterstitialAutoLoad}, splashAuto={options.SplashAutoLoad}");
        AppendLog($"Rewarded selected slot => {GetResolvedRewardedSlotForDisplay(rewardedScenario)}, configuredSceneSlots={options.RewardedSceneSlotIds?.Count ?? 0}");
    }

    private void LogRewardedResolvedSlot(AD_Type adType, string scenario, string actionName)
    {
        if (adType != AD_Type.AwardVideo)
        {
            return;
        }

        AppendLog($"{actionName} rewarded slot => {GetResolvedRewardedSlotForDisplay(scenario)}");
    }

    private string GetResolvedRewardedSlotForDisplay(string scenario)
    {
        var defaultSlotId = adConfig?.BaseAwardAdKeyValue?.value;
        var options = TapadnAdController.CurrentOptions;
        if (options == null)
        {
            return $"{DisplayValue(defaultSlotId)} (source=default, scenario={DisplayValue(scenario)})";
        }

        var slotId = options.ResolveRewardedSlotId(defaultSlotId, scenario, out var mapped);
        return $"{DisplayValue(slotId)} (source={(mapped ? "scene" : "default")}, scenario={DisplayValue(scenario)})";
    }

    private void OnRewardedBefore(string placementId, string scenario)
    {
        AppendLog($"Rewarded before show => placement={placementId}, scenario={scenario}");
    }

    private void OnRewardedComplete(bool completed)
    {
        AppendLog($"Rewarded global complete => reward={completed}");
    }

    private void OnLogMessageReceived(string condition, string stackTrace, LogType type)
    {
        if (type != LogType.Error && type != LogType.Exception && type != LogType.Warning)
        {
            if (!condition.Contains("[TapADN]") &&
                !condition.Contains("[Dirichlet]") &&
                !condition.Contains("Rewarded") &&
                !condition.Contains("Interstitial") &&
                !condition.Contains("Splash"))
            {
                return;
            }
        }

        AppendLog($"[{type}] {condition}");
    }

    private void AppendLog(string message)
    {
        var line = $"{DateTime.Now:HH:mm:ss} {message}";
        if (_logs.Count >= MaxLogEntries)
        {
            _logs.RemoveAt(0);
        }

        _logs.Add(line);
        TryAppendLineToFile(line);
        _logScroll.y = float.MaxValue;
    }

    private void InitializeLogFile()
    {
        try
        {
            _sessionLogDirectory = Path.Combine(Application.persistentDataPath, "TapadnIAAAdDebugLogs");
            Directory.CreateDirectory(_sessionLogDirectory);
            var fileName = $"tapadn-iaa-debug-{DateTime.Now:yyyyMMdd-HHmmss}.log";
            _sessionLogFilePath = Path.Combine(_sessionLogDirectory, fileName);
            File.WriteAllText(_sessionLogFilePath,
                $"TapADN IAA Ad Debug Sample Log{Environment.NewLine}" +
                $"Created: {DateTime.Now:yyyy-MM-dd HH:mm:ss}{Environment.NewLine}" +
                $"persistentDataPath: {Application.persistentDataPath}{Environment.NewLine}" +
                $"----------------------------------------{Environment.NewLine}");
        }
        catch (Exception exception)
        {
            _sessionLogFilePath = null;
            Debug.LogWarning($"[TapADN Sample] Failed to initialize log file: {exception.Message}");
        }
    }

    private void TryAppendLineToFile(string line)
    {
        if (!autoWriteLogsToFile || string.IsNullOrWhiteSpace(_sessionLogFilePath))
        {
            return;
        }

        try
        {
            File.AppendAllText(_sessionLogFilePath, line + Environment.NewLine);
        }
        catch (Exception exception)
        {
            Debug.LogWarning($"[TapADN Sample] Failed to append log file: {exception.Message}");
        }
    }

    private void ExportVisibleLogsToFile()
    {
        try
        {
            if (string.IsNullOrWhiteSpace(_sessionLogDirectory))
            {
                InitializeLogFile();
            }

            var exportPath = Path.Combine(
                _sessionLogDirectory ?? Application.persistentDataPath,
                $"tapadn-iaa-debug-export-{DateTime.Now:yyyyMMdd-HHmmss}.log");
            File.WriteAllLines(exportPath, _logs);
            AppendLog($"Exported {_logs.Count} visible log lines to file: {exportPath}");
        }
        catch (Exception exception)
        {
            AppendLog($"Export log file failed: {exception.Message}");
        }
    }

    private static string DisplayValue(string value)
    {
        return string.IsNullOrWhiteSpace(value) ? "<empty>" : value;
    }

    private void EnsureStyles()
    {
        if (_stylesInitialized)
        {
            return;
        }

        _stylesInitialized = true;
        _titleStyle = new GUIStyle(GUI.skin.label)
        {
            fontSize = 50,
            fontStyle = FontStyle.Bold,
            alignment = TextAnchor.MiddleCenter,
            wordWrap = true
        };
        _sectionStyle = new GUIStyle(GUI.skin.label)
        {
            fontSize = 34,
            fontStyle = FontStyle.Bold,
            wordWrap = true
        };
        _textStyle = new GUIStyle(GUI.skin.label)
        {
            fontSize = 28,
            wordWrap = true
        };
        _buttonStyle = new GUIStyle(GUI.skin.button)
        {
            fontSize = 26,
            wordWrap = true
        };
        _textFieldStyle = new GUIStyle(GUI.skin.textField)
        {
            fontSize = 28
        };
        _logStyle = new GUIStyle(GUI.skin.label)
        {
            fontSize = 24,
            wordWrap = true,
            richText = false
        };
    }

    private sealed class SampleTapadnAdController : IAdController
    {
        private readonly TapadnAdController _inner = new TapadnAdController();
        private readonly Action<bool> _onMaskChanged;
        private readonly Action<string, string, string> _onEventLog;

        public SampleTapadnAdController(Action<bool> onMaskChanged, Action<string, string, string> onEventLog)
        {
            _onMaskChanged = onMaskChanged;
            _onEventLog = onEventLog;
        }

        public void Init(ADConfig adConfig, object[] args)
        {
            _inner.Init(adConfig, args);
        }

        public ADPlayer CreateAdPlayer(AD_Type type)
        {
            return _inner.CreateAdPlayer(type);
        }

        public void EventLog(string eventTable, string eventValue, string eventMessage = null)
        {
            _onEventLog?.Invoke(eventTable, eventValue, eventMessage);
            _inner.EventLog(eventTable, eventValue, eventMessage);
        }

        public void SetMask(bool isOpen)
        {
            _onMaskChanged?.Invoke(isOpen);
            _inner.SetMask(isOpen);
        }
    }
}