using UnityEngine;
using Singular;
using GoogleMobileAds.Api;

public class AdMobRevenueTracking : MonoBehaviour
{
    private const string AD_UNIT_ID = "YOUR_AD_UNIT_ID";
    private RewardedAd rewardedAd;
    
    void Start()
    {
        // Initialize Mobile Ads SDK
        MobileAds.Initialize(initStatus =>
        {
            Debug.Log("AdMob initialized");
            LoadRewardedAd();
        });
    }
    
    private void LoadRewardedAd()
    {
        // Create ad request
        AdRequest adRequest = new AdRequest();
        
        // Load rewarded ad
        RewardedAd.Load(AD_UNIT_ID, adRequest, (RewardedAd ad, LoadAdError error) =>
        {
            if (error != null || ad == null)
            {
                Debug.LogError($"Rewarded ad failed to load: {error}");
                return;
            }
            
            Debug.Log("Rewarded ad loaded");
            rewardedAd = ad;
            
            // Register event handlers
            RegisterEventHandlers(ad);
        });
    }
    
    private void RegisterEventHandlers(RewardedAd ad)
    {
        // Raised when the ad is estimated to have earned money
        ad.OnAdPaid += (AdValue adValue) =>
        {
            // Validate and ensure revenue data is within an expected range
            float revenue = adValue.Value / 1_000_000f; // Convert micros to dollars
            string currency = adValue.CurrencyCode;
            
            // Check if revenue is positive and currency is valid
            if (revenue > 0 && !string.IsNullOrEmpty(currency))
            {
                // Construct and send the Singular Ad Revenue Event
                SingularAdData data = new SingularAdData(
                    "AdMob",
                    currency,
                    revenue
                );
                
                SingularSDK.AdRevenue(data);
                
                // Log the revenue data for debugging purposes
                Debug.Log($"Ad Revenue reported to Singular: {data}");
            }
            else
            {
                Debug.LogError($"Invalid ad revenue data: revenue = {revenue}, currency = {currency}");
            }
        };
        
        // Additional event handlers
        ad.OnAdFullScreenContentOpened += () =>
        {
            Debug.Log("Rewarded ad full screen content opened");
        };
        
        ad.OnAdFullScreenContentClosed += () =>
        {
            Debug.Log("Rewarded ad full screen content closed");
            // Load next ad
            LoadRewardedAd();
        };
        
        ad.OnAdFullScreenContentFailed += (AdError error) =>
        {
            Debug.LogError($"Rewarded ad failed to show: {error}");
            // Load next ad
            LoadRewardedAd();
        };
    }
    
    public void ShowRewardedAd()
    {
        if (rewardedAd != null && rewardedAd.CanShowAd())
        {
            rewardedAd.Show((Reward reward) =>
            {
                Debug.Log($"User earned reward: {reward.Type} - {reward.Amount}");
            });
        }
        else
        {
            Debug.Log("Rewarded ad is not ready yet");
        }
    }
}

using UnityEngine;
using Singular;

public class AppLovinRevenueTracking : MonoBehaviour
{
    void Start()
    {
        // Attach callbacks based on the ad format(s) you are using
        MaxSdkCallbacks.Interstitial.OnAdRevenuePaidEvent += OnAdRevenuePaidEvent;
        MaxSdkCallbacks.Rewarded.OnAdRevenuePaidEvent += OnAdRevenuePaidEvent;
        MaxSdkCallbacks.Banner.OnAdRevenuePaidEvent += OnAdRevenuePaidEvent;
        MaxSdkCallbacks.MRec.OnAdRevenuePaidEvent += OnAdRevenuePaidEvent;
    }
    
    private void OnAdRevenuePaidEvent(string adUnitId, MaxSdkBase.AdInfo adInfo)
    {
        double revenue = adInfo.Revenue;
        
        if (revenue > 0)
        {
            // Create a SingularAdData object with relevant information
            SingularAdData adData = new SingularAdData(
                "AppLovin",
                "USD", // AppLovin typically reports in USD
                revenue
            );
            
            // Send ad revenue data to Singular
            SingularSDK.AdRevenue(adData);
            
            Debug.Log($"Ad Revenue reported to Singular: {revenue} USD from {adUnitId}");
        }
        else
        {
            Debug.LogError("Failed to parse valid revenue value from ad info or revenue is not greater than 0");
        }
    }
    
    void OnDestroy()
    {
        // Detach callbacks to prevent memory leaks
        MaxSdkCallbacks.Interstitial.OnAdRevenuePaidEvent -= OnAdRevenuePaidEvent;
        MaxSdkCallbacks.Rewarded.OnAdRevenuePaidEvent -= OnAdRevenuePaidEvent;
        MaxSdkCallbacks.Banner.OnAdRevenuePaidEvent -= OnAdRevenuePaidEvent;
        MaxSdkCallbacks.MRec.OnAdRevenuePaidEvent -= OnAdRevenuePaidEvent;
    }
}

using UnityEngine;
using Singular;

public class IronSourceRevenueTracking : MonoBehaviour
{
    void Start()
    {
        // Ensure the listener is added before initializing the SDK
        IronSourceEvents.onImpressionDataReadyEvent += ImpressionDataReadyEvent;
        
        // Initialize the IronSource SDK here if not already done
        // IronSource.Agent.init("YOUR_IRONSOURCE_APP_KEY");
    }
    
    private void ImpressionDataReadyEvent(IronSourceImpressionData impressionData)
    {
        if (impressionData != null)
        {
            // Ensure revenue value is valid
            double? revenue = impressionData.revenue;
            
            if (revenue.HasValue && revenue.Value > 0)
            {
                // Create SingularAdData object with appropriate values
                SingularAdData adData = new SingularAdData(
                    "IronSource",
                    "USD", // IronSource typically reports in USD
                    revenue.Value
                );
                
                // Send the Ad Revenue data to Singular
                SingularSDK.AdRevenue(adData);
                
                // Log the data for debugging
                Debug.Log($"Ad Revenue reported to Singular: AdPlatform: {adData.AdPlatform}, " +
                         $"Currency: {adData.Currency}, Revenue: {adData.Revenue}");
            }
            else
            {
                Debug.LogError($"Invalid revenue value: {revenue}");
            }
        }
        else
        {
            Debug.LogError("Impression data is null");
        }
    }
    
    void OnDestroy()
    {
        // Detach the callback to prevent memory leaks
        IronSourceEvents.onImpressionDataReadyEvent -= ImpressionDataReadyEvent;
    }
}

using UnityEngine;
using Singular;
using System.Collections.Generic;
using System.Globalization;

public class TradPlusRevenueTracking : MonoBehaviour
{
    private const string TAG = "TradPlusRevenue";
    
    void Start()
    {
        // Add Global Ad Impression Listener
        TradplusAds.Instance().AddGlobalAdImpression(OnGlobalAdImpression);
    }
    
    void OnGlobalAdImpression(Dictionary<string, object> adInfo)
    {
        // Ensure adInfo is not null
        if (adInfo == null)
        {
            Debug.LogError($"{TAG}: AdInfo is null");
            return;
        }
        
        // Ensure eCPM is present and valid
        if (!adInfo.ContainsKey("ecpm") || adInfo["ecpm"] == null)
        {
            Debug.LogError($"{TAG}: eCPM value is null or missing");
            return;
        }
        
        // Parse the eCPM value
        if (!double.TryParse(adInfo["ecpm"].ToString(), NumberStyles.Float | NumberStyles.AllowThousands, 
            CultureInfo.InvariantCulture, out double revenue))
        {
            Debug.LogError($"{TAG}: Failed to parse eCPM value");
            return;
        }
        
        // Convert eCPM to revenue (eCPM is in milli-units)
        revenue = revenue / 1000.0;
        
        // Validate the revenue value
        if (revenue <= 0)
        {
            Debug.LogError($"{TAG}: Ad Revenue value out of expected range: {revenue}");
            return;
        }
        
        // Create SingularAdData object with the necessary fields
        SingularAdData data = new SingularAdData(
            "TradPlus",
            "USD",
            revenue
        );
        
        // Send the Ad Revenue data to Singular
        SingularSDK.AdRevenue(data);
        
        // Log the data for debugging purposes
        Debug.Log($"{TAG}: Ad Revenue reported to Singular: AdPlatform: {data.AdPlatform}, " +
                 $"Currency: {data.Currency}, Revenue: {data.Revenue}");
    }
}

using UnityEngine;
using Singular;

public class GenericAdRevenueTracking : MonoBehaviour
{
    // Function to report ad revenue to Singular
    public void ReportAdRevenue(string adPlatform, string currency, float revenue)
    {
        // Validate the input: ensure revenue is positive and currency is not null or empty
        if (revenue > 0 && !string.IsNullOrEmpty(currency))
        {
            // Create a SingularAdData object with the validated data
            SingularAdData data = new SingularAdData(
                adPlatform,
                currency,
                revenue
            );
            
            // Send the ad revenue data to Singular
            SingularSDK.AdRevenue(data);
            
            // Log the reported data for debugging
            Debug.Log($"Ad Revenue reported to Singular: Platform = {adPlatform}, " +
                     $"Currency = {currency}, Revenue = {revenue}");
        }
        else
        {
            // Log a warning if validation fails
            Debug.LogWarning($"Invalid ad revenue data: Platform = {adPlatform}, " +
                           $"Revenue = {revenue}, Currency = {currency}");
        }
    }
    
    // Example usage
    void ExampleUsage()
    {
        // Report revenue from a custom mediation platform
        ReportAdRevenue("MyMediationPlatform", "USD", 0.05f);
    }
}