using UnityEngine;
using UnityEngine.UI;
using Yodo1.MAS;

public class Yodo1AdsDemo : MonoBehaviour
{
    public static Yodo1AdsDemo Instance { get; private set; }

    private void Awake()
    {
        // If an instance already exists and it's not this one, destroy this
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }

        // Assign instance and persist across scenes
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }
    void Start()
    {
        Yodo1U3dMasCallback.OnSdkInitializationEvent += (Yodo1MasSdkConfiguration configuration, Yodo1U3dAdError error) =>
        {
            if (configuration != null)
            {
                Debug.Log(Yodo1U3dMas.TAG + "OnSdkInitializationEvent, Yodo1MasSdkConfiguration: " + configuration.ToString());

                Yodo1U3dMas.SetUserIdentifier(SystemInfo.deviceUniqueIdentifier);

                InitializeBannerAds();
                InitializeInterstitialAds();
                InitializeRewardedAds();
                InitializeNativeAds();
                InitializeAppOpenAds();
            }
            else
            {
                Debug.Log(Yodo1U3dMas.TAG + "OnSdkInitializationEvent, Yodo1U3dAdError: " + error.ToString());
            }
        };

        Yodo1U3dMasCallback.OnUmpCompletionEvent += (Yodo1U3dAdError error) =>
        {
            if (error == null)
            {
                Debug.Log(Yodo1U3dMas.TAG + "OnUmpCompletionEvent completed successfully");
            }
            else
            {
                Debug.Log(Yodo1U3dMas.TAG + "OnUmpCompletionEvent error: code=" + error.Code + " msg=" + error.Message);
            }
        };

        Yodo1MasUserPrivacyConfig userPrivacyConfig = new Yodo1MasUserPrivacyConfig()
            .titleBackgroundColor(Color.white)
            .titleTextColor(Color.black)
            .contentBackgroundColor(Color.white)
            .contentTextColor(Color.black)
            .buttonBackgroundColor(Color.yellow)
            .buttonTextColor(Color.white);

        Yodo1AdBuildConfig config = new Yodo1AdBuildConfig()
            .enableUserPrivacyDialog(false)
            .userPrivacyConfig(userPrivacyConfig)
            .enableUserMessageingPlatform(Yodo1MasUMPState.ENABLE)
            .enableATTAuthorization(true);
        Yodo1U3dMas.SetAdBuildConfig(config);


        Yodo1U3dMas.SetCOPPA(false);
        Yodo1U3dMas.SetGDPR(true);
        Yodo1U3dMas.SetCCPA(false);

        Yodo1U3dMas.InitializeMasSdk();
    }

    #region Banner Ad Methods
    private void InitializeBannerAds()
    {
        InitializeBannerAdsV2();
    }

    public void ShowBannerAds(string bannerType)
    {
        Yodo1U3dBannerAdSize.Type type = Yodo1U3dBannerAdSize.Type.Banner;
        if (!string.IsNullOrEmpty(bannerType))
        {
            if (bannerType.Equals("standard"))
            {
                type = Yodo1U3dBannerAdSize.Type.Banner;
            }
            else if (bannerType.Equals("large"))
            {
                type = Yodo1U3dBannerAdSize.Type.LargeBanner;
            }
            else if (bannerType.Equals("IAB"))
            {
                type = Yodo1U3dBannerAdSize.Type.IABMediumRectangle;
            }
            else if (bannerType.Equals("smart"))
            {
                type = Yodo1U3dBannerAdSize.Type.SmartBanner;
            }
            else if (bannerType.Equals("adaptive"))
            {
                type = Yodo1U3dBannerAdSize.Type.AdaptiveBanner;
            }
        }
        ShowBannerAdsV2(type);
    }

    public void HideAllBannerAds()
    {
        HideAllBannerAdsV2();
    }
    #endregion

    #region Banner Ad Methods - V2
    Yodo1U3dBannerAdView bannerAdView = null;
    Yodo1U3dBannerAdView standardBannerAdView = null;
    Yodo1U3dBannerAdView largeBannerAdView = null;
    Yodo1U3dBannerAdView IABBannerAdView = null;
    Yodo1U3dBannerAdView smartBannerAdView = null;
    Yodo1U3dBannerAdView adaptiveBannerAdView = null;

    /// <summary>
    /// The banner is displayed automatically after loaded
    /// </summary>
    private void InitializeBannerAdsV2()
    {
        // Clean up banner before reusing
        if (bannerAdView != null)
        {
            bannerAdView.Destroy();
            bannerAdView = null;
        }

        // Create a 320x50 banner
        bannerAdView = new Yodo1U3dBannerAdView(Yodo1U3dBannerAdSize.Banner, Yodo1U3dBannerAdPosition.BannerTop | Yodo1U3dBannerAdPosition.BannerRight);

        // Add Events
        bannerAdView.OnAdLoadedEvent += OnBannerAdLoadedEvent;
        bannerAdView.OnAdFailedToLoadEvent += OnBannerAdFailedToLoadEvent;
        bannerAdView.OnAdOpenedEvent += OnBannerAdOpenedEvent;
        bannerAdView.OnAdFailedToOpenEvent += OnBannerAdFailedToOpenEvent;
        bannerAdView.OnAdClosedEvent += OnBannerAdClosedEvent;
        bannerAdView.OnAdPayRevenueEvent += OnBannerAdPayRevenueEvent;

        // Load banner ads, the banner ad will be displayed automatically after loaded
        bannerAdView.LoadAd();

        // Standard Banner
        if (standardBannerAdView != null)
        {
            standardBannerAdView.Destroy();
            standardBannerAdView = null;
        }

        // Create a 320x50 banner
        standardBannerAdView = new Yodo1U3dBannerAdView(Yodo1U3dBannerAdSize.Banner, Yodo1U3dBannerAdPosition.BannerBottom | Yodo1U3dBannerAdPosition.BannerHorizontalCenter);

        // Add Events
        standardBannerAdView.OnAdLoadedEvent += OnBannerAdLoadedEvent;
        standardBannerAdView.OnAdFailedToLoadEvent += OnBannerAdFailedToLoadEvent;
        standardBannerAdView.OnAdOpenedEvent += OnBannerAdOpenedEvent;
        standardBannerAdView.OnAdFailedToOpenEvent += OnBannerAdFailedToOpenEvent;
        standardBannerAdView.OnAdClosedEvent += OnBannerAdClosedEvent;
        standardBannerAdView.OnAdPayRevenueEvent += OnBannerAdPayRevenueEvent;

        // Large Banner
        if (largeBannerAdView != null)
        {
            largeBannerAdView.Destroy();
            largeBannerAdView = null;
        }

        // Create a 320x100 banner 
        largeBannerAdView = new Yodo1U3dBannerAdView(Yodo1U3dBannerAdSize.LargeBanner, Yodo1U3dBannerAdPosition.BannerLeft | Yodo1U3dBannerAdPosition.BannerHorizontalCenter);

        // Add Events
        largeBannerAdView.OnAdLoadedEvent += OnBannerAdLoadedEvent;
        largeBannerAdView.OnAdFailedToLoadEvent += OnBannerAdFailedToLoadEvent;
        largeBannerAdView.OnAdOpenedEvent += OnBannerAdOpenedEvent;
        largeBannerAdView.OnAdFailedToOpenEvent += OnBannerAdFailedToOpenEvent;
        largeBannerAdView.OnAdClosedEvent += OnBannerAdClosedEvent;
        largeBannerAdView.OnAdPayRevenueEvent += OnBannerAdPayRevenueEvent;

        // IAB Banner
        if (IABBannerAdView != null)
        {
            IABBannerAdView.Destroy();
            IABBannerAdView = null;
        }

        // Create a 300x250 banner
        IABBannerAdView = new Yodo1U3dBannerAdView(Yodo1U3dBannerAdSize.IABMediumRectangle, Yodo1U3dBannerAdPosition.BannerRight | Yodo1U3dBannerAdPosition.BannerVerticalCenter);

        // Add Events
        IABBannerAdView.OnAdLoadedEvent += OnBannerAdLoadedEvent;
        IABBannerAdView.OnAdFailedToLoadEvent += OnBannerAdFailedToLoadEvent;
        IABBannerAdView.OnAdOpenedEvent += OnBannerAdOpenedEvent;
        IABBannerAdView.OnAdFailedToOpenEvent += OnBannerAdFailedToOpenEvent;
        IABBannerAdView.OnAdClosedEvent += OnBannerAdClosedEvent;
        IABBannerAdView.OnAdPayRevenueEvent += OnBannerAdPayRevenueEvent;

        // Smart Banner
        if (smartBannerAdView != null)
        {
            smartBannerAdView.Destroy();
            smartBannerAdView = null;
        }

        smartBannerAdView = new Yodo1U3dBannerAdView(Yodo1U3dBannerAdSize.SmartBanner, Yodo1U3dBannerAdPosition.BannerBottom | Yodo1U3dBannerAdPosition.BannerHorizontalCenter);

        // Add Events
        smartBannerAdView.OnAdLoadedEvent += OnBannerAdLoadedEvent;
        smartBannerAdView.OnAdFailedToLoadEvent += OnBannerAdFailedToLoadEvent;
        smartBannerAdView.OnAdOpenedEvent += OnBannerAdOpenedEvent;
        smartBannerAdView.OnAdFailedToOpenEvent += OnBannerAdFailedToOpenEvent;
        smartBannerAdView.OnAdClosedEvent += OnBannerAdClosedEvent;
        smartBannerAdView.OnAdPayRevenueEvent += OnBannerAdPayRevenueEvent;

        // Adaptive Banner
        if (adaptiveBannerAdView != null)
        {
            adaptiveBannerAdView.Destroy();
            adaptiveBannerAdView = null;
        }

        adaptiveBannerAdView = new Yodo1U3dBannerAdView(Yodo1U3dBannerAdSize.AdaptiveBanner, Yodo1U3dBannerAdPosition.BannerTop | Yodo1U3dBannerAdPosition.BannerHorizontalCenter);

        // Add Events
        adaptiveBannerAdView.OnAdLoadedEvent += OnBannerAdLoadedEvent;
        adaptiveBannerAdView.OnAdFailedToLoadEvent += OnBannerAdFailedToLoadEvent;
        adaptiveBannerAdView.OnAdOpenedEvent += OnBannerAdOpenedEvent;
        adaptiveBannerAdView.OnAdFailedToOpenEvent += OnBannerAdFailedToOpenEvent;
        adaptiveBannerAdView.OnAdClosedEvent += OnBannerAdClosedEvent;
        adaptiveBannerAdView.OnAdPayRevenueEvent += OnBannerAdPayRevenueEvent;
    }

    private void OnBannerAdLoadedEvent(Yodo1U3dBannerAdView adView)
    {
        // Banner ad is ready to be shown.
        Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdLoadedEvent event received");
    }

    private void OnBannerAdFailedToLoadEvent(Yodo1U3dBannerAdView adView, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdFailedToLoadEvent event received, error: " + adError.ToString());
    }

    private void OnBannerAdOpenedEvent(Yodo1U3dBannerAdView adView)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdOpenedEvent event received");
    }

    private void OnBannerAdFailedToOpenEvent(Yodo1U3dBannerAdView adView, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdFailedToOpenEvent event received, error: " + adError.ToString());
    }

    private void OnBannerAdClosedEvent(Yodo1U3dBannerAdView adView)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdClosedEvent event received");
    }

    private void OnBannerAdPayRevenueEvent(Yodo1U3dBannerAdView adView, Yodo1U3dAdValue adValue)
    {
        if (adValue == null)
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdPayRevenueEvent event received, adValue is null");
        }
        else
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdPayRevenueEvent event received, adValue " + adValue.ToString());
            Debug.Log(Yodo1U3dMas.TAG + "OnBannerAdPayRevenueEvent event received, adValue revenue " + adValue.Revenue);
        }
    }

    /// <summary>
    /// (Optional) Show banner ads
    /// </summary>
    private void ShowBannerAdsV2(Yodo1U3dBannerAdSize.Type type)
    {
        if (type == Yodo1U3dBannerAdSize.Type.Banner)
        {
            if (standardBannerAdView != null)
            {
                // Load banner ads, the banner ad will be displayed automatically after loaded
                standardBannerAdView.LoadAd();
            }
        }
        else if (type == Yodo1U3dBannerAdSize.Type.LargeBanner)
        {
            if (largeBannerAdView != null)
            {
                // Load banner ads, the banner ad will be displayed automatically after loaded
                largeBannerAdView.LoadAd();
            }
        }
        else if (type == Yodo1U3dBannerAdSize.Type.IABMediumRectangle)
        {
            if (IABBannerAdView != null)
            {
                // Load banner ads, the banner ad will be displayed automatically after loaded
                IABBannerAdView.LoadAd();
            }
        }
        else if (type == Yodo1U3dBannerAdSize.Type.SmartBanner)
        {
            if (smartBannerAdView != null)
            {
                // Load banner ads, the banner ad will be displayed automatically after loaded
                smartBannerAdView.LoadAd();
            }
        }
        else if (type == Yodo1U3dBannerAdSize.Type.AdaptiveBanner)
        {

            if (adaptiveBannerAdView != null)
            {
                // Load banner ads, the banner ad will be displayed automatically after loaded
                adaptiveBannerAdView.LoadAd();
            }
        }
    }

    /// <summary>
    /// (Optional) Hide banner ads
    /// </summary>
    private void HideAllBannerAdsV2()
    {
        if (bannerAdView != null)
        {
            bannerAdView.Hide();
        }
        if (standardBannerAdView != null)
        {
            standardBannerAdView.Hide();
        }
        if (largeBannerAdView != null)
        {
            largeBannerAdView.Hide();
        }
        if (IABBannerAdView != null)
        {
            IABBannerAdView.Hide();
        }
        if (smartBannerAdView != null)
        {
            smartBannerAdView.Hide();
        }
        if (adaptiveBannerAdView != null)
        {
            adaptiveBannerAdView.Hide();
        }
    }
    #endregion

    #region Interstitial Ad Methods
    private void InitializeInterstitialAds()
    {

        InitializeInterstitialAdsV2();
    }

    public void ShowInterstitialAds(string adPlacement)
    {
        
        ShowInterstitialAdsV2(adPlacement);

    }
    #endregion

    #region Interstitial Ad Methods - V2
    private void InitializeInterstitialAdsV2()
    {
        Yodo1U3dInterstitialAd.GetInstance().OnAdLoadedEvent += OnInterstitialAdLoadedEvent;
        Yodo1U3dInterstitialAd.GetInstance().OnAdLoadFailedEvent += OnInterstitialAdLoadFailedEvent;
        Yodo1U3dInterstitialAd.GetInstance().OnAdOpeningEvent += OnInterstitialAdOpeningEvent;
        Yodo1U3dInterstitialAd.GetInstance().OnAdOpenedEvent += OnInterstitialAdOpenedEvent;
        Yodo1U3dInterstitialAd.GetInstance().OnAdOpenFailedEvent += OnInterstitialAdOpenFailedEvent;
        Yodo1U3dInterstitialAd.GetInstance().OnAdClosedEvent += OnInterstitialAdClosedEvent;

        Yodo1U3dInterstitialAd.GetInstance().OnAdPayRevenueEvent += OnInterstitialAdPayRevenueEvent;
        LoadInterstitialAdV2();
    }

    public void LoadInterstitialAdV2()
    {
        Yodo1U3dInterstitialAd.GetInstance().LoadAd();
    }

    private void OnInterstitialAdLoadedEvent(Yodo1U3dInterstitialAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdLoadedEvent event received");
    }

    private void OnInterstitialAdLoadFailedEvent(Yodo1U3dInterstitialAd ad, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdLoadFailedEvent event received with error: " + adError.ToString());
        LoadInterstitialAdV2();
    }

    private void OnInterstitialAdOpeningEvent(Yodo1U3dInterstitialAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdOpeningEvent event received");
    }

    private void OnInterstitialAdOpenedEvent(Yodo1U3dInterstitialAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdOpenedEvent event received");
    }

    private void OnInterstitialAdOpenFailedEvent(Yodo1U3dInterstitialAd ad, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdOpenFailedEvent event received with error: " + adError.ToString());
    }

    private void OnInterstitialAdClosedEvent(Yodo1U3dInterstitialAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdClosedEvent event received");
        LoadInterstitialAdV2();
    }

    private void OnInterstitialAdPayRevenueEvent(Yodo1U3dInterstitialAd ad, Yodo1U3dAdValue adValue)
    {
        if (adValue == null)
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdPayRevenueEvent event received, adValue is null");
        }
        else
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdPayRevenueEvent event received, adValue " + adValue.ToString());
            Debug.Log(Yodo1U3dMas.TAG + "OnInterstitialAdPayRevenueEvent event received, adValue revenue " + adValue.Revenue);

        }
    }

    private void ShowInterstitialAdsV2(string adPlacement)
    {
        if (string.IsNullOrEmpty(adPlacement))
        {
            Yodo1U3dInterstitialAd.GetInstance().ShowAd();
        }
        else
        {
            Yodo1U3dInterstitialAd.GetInstance().ShowAd(adPlacement);
        }
    }

    #endregion


    #region Reward video Ad Methods
    private void InitializeRewardedAds()
    {
        InitializeRewardedAdsV2();
    }

    public void ShowRewardedAds(string adPlacement)
    {
        ShowRewardedAdsV2(adPlacement);
    }
    #endregion

    #region Reward video Ad Methods - V2

    private void InitializeRewardedAdsV2()
    {
        Yodo1U3dRewardAd.GetInstance().OnAdLoadedEvent += OnRewardAdLoadedEvent;
        Yodo1U3dRewardAd.GetInstance().OnAdLoadFailedEvent += OnRewardAdLoadFailedEvent;
        Yodo1U3dRewardAd.GetInstance().OnAdOpeningEvent += OnRewardAdOpeningEvent;
        Yodo1U3dRewardAd.GetInstance().OnAdOpenedEvent += OnRewardAdOpenedEvent;
        Yodo1U3dRewardAd.GetInstance().OnAdOpenFailedEvent += OnRewardAdOpenFailedEvent;
        Yodo1U3dRewardAd.GetInstance().OnAdClosedEvent += OnRewardAdClosedEvent;
        Yodo1U3dRewardAd.GetInstance().OnAdEarnedEvent += OnRewardAdEarnedEvent;

        Yodo1U3dRewardAd.GetInstance().OnAdPayRevenueEvent += OnRewardAdPayRevenueEvent;
        LoadRewardAdV2();
    }

    public void LoadRewardAdV2()
    {
        Yodo1U3dRewardAd.GetInstance().LoadAd();
    }

    private void OnRewardAdLoadedEvent(Yodo1U3dRewardAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdLoadedEvent event received");
    }

    private void OnRewardAdLoadFailedEvent(Yodo1U3dRewardAd ad, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdLoadFailedEvent event received with error: " + adError.ToString());
        LoadRewardAdV2();
    }

    private void OnRewardAdOpeningEvent(Yodo1U3dRewardAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdOpeningEvent event received");
    }

    private void OnRewardAdOpenedEvent(Yodo1U3dRewardAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdOpenedEvent event received");
    }

    private void OnRewardAdOpenFailedEvent(Yodo1U3dRewardAd ad, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdOpenFailedEvent event received with error: " + adError.ToString());
    }

    private void OnRewardAdClosedEvent(Yodo1U3dRewardAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdClosedEvent event received");
        LoadRewardAdV2();
    }

    private void OnRewardAdEarnedEvent(Yodo1U3dRewardAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdEarnedEvent event received");
    }

    private void OnRewardAdPayRevenueEvent(Yodo1U3dRewardAd ad, Yodo1U3dAdValue adValue)
    {
        if (adValue == null)
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdPayRevenueEvent event received, adValue is null");
        }
        else
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdPayRevenueEvent event received, adValue " + adValue.ToString());
            Debug.Log(Yodo1U3dMas.TAG + "OnRewardAdPayRevenueEvent event received, adValue revenue " + adValue.Revenue);
        }
    }

    private void ShowRewardedAdsV2(string adPlacement)
    {
        if (string.IsNullOrEmpty(adPlacement))
        {
            Yodo1U3dRewardAd.GetInstance().ShowAd();
        }
        else
        {
            Yodo1U3dRewardAd.GetInstance().ShowAd(adPlacement);
        }
    }

    #endregion

    #region Native Ad Methods
    Yodo1U3dNativeAdView nativeAdViewTop = null;
    Yodo1U3dNativeAdView nativeAdViewBottom = null;

    /// <summary>
    /// The banner is displayed automatically after loaded
    /// </summary>
    public void InitializeNativeAds()
    {
        // the sample is using the medium size(6:5)
        int width = (int)(Screen.width * 0.7);
        int height = (int)(width / 6 * 5);

        // Clean up native before reusing
        if (nativeAdViewTop != null)
        {
            nativeAdViewTop.Destroy();
            nativeAdViewTop = null;
        }
        
        nativeAdViewTop = new Yodo1U3dNativeAdView(Yodo1U3dNativeAdPosition.NativeTop | Yodo1U3dNativeAdPosition.NativeHorizontalCenter, 0, 0, width, height);

        nativeAdViewTop.SetBackgroundColor(Color.grey);
        // Add Events
        nativeAdViewTop.OnAdLoadedEvent += OnNativeAdLoadedEvent;
        nativeAdViewTop.OnAdFailedToLoadEvent += OnNativeAdFailedToLoadEvent;
        nativeAdViewTop.OnAdPayRevenueEvent += OnNativeAdPayRevenueEvent;


        // Clean up native before reusing
        if (nativeAdViewBottom != null)
        {
            nativeAdViewBottom.Destroy();
            nativeAdViewBottom = null;
        }

        nativeAdViewBottom = new Yodo1U3dNativeAdView(Yodo1U3dNativeAdPosition.NativeBottom | Yodo1U3dNativeAdPosition.NativeHorizontalCenter, 0, 0, width, height);

        nativeAdViewBottom.SetBackgroundColor(Color.grey);
        // Add Events
        nativeAdViewBottom.OnAdLoadedEvent += OnNativeAdLoadedEvent;
        nativeAdViewBottom.OnAdFailedToLoadEvent += OnNativeAdFailedToLoadEvent;
        nativeAdViewBottom.OnAdPayRevenueEvent += OnNativeAdPayRevenueEvent;
    }

    public void ShowNativeAd(string adPlacement)
    {
        // Load native ads, the native ad will be displayed automatically after loaded
        if (nativeAdViewTop != null && adPlacement.Equals("test_native_placement_top"))
        {
            nativeAdViewTop.SetAdPlacement(adPlacement);
            nativeAdViewTop.LoadAd();
        }
        if (nativeAdViewBottom != null && adPlacement.Equals("test_native_placement_bottom"))
        {
            nativeAdViewBottom.SetAdPlacement(adPlacement);
            nativeAdViewBottom.LoadAd();
        }
    }

    public void HideAllNativeAds()
    {
        if (nativeAdViewTop != null)
        {
            nativeAdViewTop.Hide();
        }
        if (nativeAdViewBottom != null)
        {
            nativeAdViewBottom.Hide();
        }
    }

    private void OnNativeAdLoadedEvent(Yodo1U3dNativeAdView adView)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnNativeAdLoadedEvent event received");
    }

    private void OnNativeAdFailedToLoadEvent(Yodo1U3dNativeAdView adView, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnNativeAdFailedToLoadEvent event received, adError " + adError.ToString());
    }

    private void OnNativeAdPayRevenueEvent(Yodo1U3dNativeAdView adView, Yodo1U3dAdValue adValue)
    {
        if (adValue == null)
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnNativeAdPayRevenueEvent event received, adValue is null");
        }
        else
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnNativeAdPayRevenueEvent event received, adValue " + adValue.ToString());
            Debug.Log(Yodo1U3dMas.TAG + "OnNativeAdPayRevenueEvent event received, adValue revenue " + adValue.Revenue);
        }
    }
    #endregion


    #region AppOpen Ad Methods
    private void InitializeAppOpenAds()
    {
        // Instantiate
        Yodo1U3dAppOpenAd.GetInstance();

        // Ad Events
        Yodo1U3dAppOpenAd.GetInstance().OnAdLoadedEvent += OnAppOpenAdLoadedEvent;
        Yodo1U3dAppOpenAd.GetInstance().OnAdLoadFailedEvent += OnAppOpenAdLoadFailedEvent;
        Yodo1U3dAppOpenAd.GetInstance().OnAdOpeningEvent += OnAppOpenAdOpeningEvent;
        Yodo1U3dAppOpenAd.GetInstance().OnAdOpenedEvent += OnAppOpenAdOpenedEvent;
        Yodo1U3dAppOpenAd.GetInstance().OnAdOpenFailedEvent += OnAppOpenAdOpenFailedEvent;
        Yodo1U3dAppOpenAd.GetInstance().OnAdClosedEvent += OnAppOpenAdClosedEvent;

        Yodo1U3dAppOpenAd.GetInstance().OnAdPayRevenueEvent += OnAppOpenAdPayRevenueEvent;

        Yodo1U3dAppOpenAd.GetInstance().LoadAd();
    }

    public void LoadAppOpenAds()
    {
        Yodo1U3dAppOpenAd.GetInstance().LoadAd();
    }



    public void ShowAppOpenAds(string adPlacement)
    {
        bool isLoaded = Yodo1U3dAppOpenAd.GetInstance().IsLoaded();

        if (isLoaded) Yodo1U3dAppOpenAd.GetInstance().ShowAd(adPlacement);
    }

    private void OnAppOpenAdLoadedEvent(Yodo1U3dAppOpenAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdLoadedEvent event received");
    }

    private void OnAppOpenAdLoadFailedEvent(Yodo1U3dAppOpenAd ad, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdLoadFailedEvent event received with error: " + adError.ToString());
    }

    private void OnAppOpenAdOpeningEvent(Yodo1U3dAppOpenAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdOpeningEvent event received");
    }

    private void OnAppOpenAdOpenedEvent(Yodo1U3dAppOpenAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdOpenedEvent event received");
    }

    private void OnAppOpenAdOpenFailedEvent(Yodo1U3dAppOpenAd ad, Yodo1U3dAdError adError)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdOpenFailedEvent event received with error: " + adError.ToString());
        // Load the next ad
        this.LoadAppOpenAds();
    }

    private void OnAppOpenAdClosedEvent(Yodo1U3dAppOpenAd ad)
    {
        Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdClosedEvent event received");
        // Load the next ad
        this.LoadAppOpenAds();
    }

    private void OnAppOpenAdPayRevenueEvent(Yodo1U3dAppOpenAd ad, Yodo1U3dAdValue adValue)
    {
        if (adValue == null)
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdPayRevenueEvent event received, adValue is null");
        }
        else
        {
            Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdPayRevenueEvent event received, adValue " + adValue.ToString());
            Debug.Log(Yodo1U3dMas.TAG + "OnAppOpenAdPayRevenueEvent event received, adValue revenue " + adValue.Revenue);
        }
    }
    #endregion
}