using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using HC.Plugins;
using Newtonsoft.Json.Linq;
using UnityEngine;

namespace HC
{
    public class HCAdsManager : HCSingleton<HCAdsManager>
    {
        public enum HCArraignmentModeType
        {
            // 正式模式
            Online,

            // 提审模式
            Review
        }

        private bool m_isInitialized = false;

        int m_rewardRetryAttempt;
        int m_interRetryAttempt;
        int m_bannerRetryAttempt;

        bool m_rewardIdLoad = false;


        private float m_oldTimeScale = 1f;
        private float m_oldVolume = 1f;

        private float m_rvStartLoadTime = 0;
        private float m_ivStartLoadTime = 0;

        private Dictionary<int, int> ivsCount = new Dictionary<int, int>();

        private Action<bool> m_rewardCallback;
        private Action m_showFailCallback;
        //private bool m_reward = false;

        private Action m_interCloseCallback;

        private HCIBaseAds plugin;

        private Dictionary<HCIVADType, float> adTypeTimeInterVal = new();

        private HCIVADType currentShowIVADType = HCIVADType.NULL;

        private HCIVPositionName mIVPos;
        private HCRVPositionName mRVPos;

        private float GetCurrentTimeInterVal(HCIVADType type)
        {
            if (adTypeTimeInterVal.TryGetValue(type, out var val))
            {
                return val;
            }

            return 0;
        }

        private void SaveCurrentTimeInterVal(HCIVADType type)
        {
            adTypeTimeInterVal[type] = Time.time;
        }
        
        public void InitializeSdk()
        {
            if (m_isInitialized) return;

            plugin = new HCWebGLAdPlugin();
// #else
//             plugin = new HCMaxSdkAdPlugin();
// #endif
            plugin.InitializeSdk(result => { StartCoroutine(LoadAds()); });

            // rv
            plugin.HCOnRewardedRevenue += OnRewardedRevenue;
            plugin.HCOnRewardedAdLoadedEvent += OnRewardedAdLoadedEvent;
            plugin.HCOnRewardedAdLoadFailedEvent += OnRewardedAdLoadFailedEvent;
            plugin.HCOnRewardedAdDisplayedEvent += OnRewardedAdDisplayedEvent;
            plugin.HCOnRewardedAdClickedEvent += OnRewardedAdClickedEvent;
            plugin.HCOnRewardedAdFailedToDisplayEvent += OnRewardedAdFailedToDisplayEvent;
            plugin.HCOnRewardedAdReceivedRewardEvent += OnRewardedAdReceivedRewardEvent;
            plugin.HCOnRewardedAdHiddenEvent += OnRewardedAdHiddenEvent;


            // iv
            plugin.HCOnInterstitialLoadFailedEvent += OnInterstitialLoadFailedEvent;
            plugin.HCOnInterstitialAdFailedToDisplayEvent += OnInterstitialAdFailedToDisplayEvent;
            plugin.HCOnInterstitialHiddenEvent += OnInterstitialHiddenEvent;
            plugin.HCOnInterstitialClickedEvent += OnInterstitialClickedEvent;
            plugin.HCOnInterstitialDisplayedEvent += OnInterstitialDisplayedEvent;
            plugin.HCOnInterstitialLoadedEvent += OnInterstitialLoadedEvent;
            plugin.HCOnInterstitialRevenue += OnInterstitialRevenue;


            // banner
            plugin.HCOnBannerAdLoadedEvent += OnBannerAdLoadedEvent;
            plugin.HCOnBannerAdLoadFailedEvent += OnBannerAdLoadFailedEvent;
            plugin.HCOnBannerAdClickedEvent += OnBannerAdClickedEvent;
            plugin.HCOnBannerAdRevenuePaidEvent += OnBannerAdRevenuePaidEvent;
            plugin.HCOnBannerAdExpandedEvent += OnBannerAdExpandedEvent;
            plugin.HCOnBannerAdCollapsedEvent += OnBannerAdCollapsedEvent;
            m_isInitialized = true;
        }


        private IEnumerator LoadAds()
        {
            LoadRewardedAd();
            LoadInterstitial();
            yield return new WaitForSeconds(0.25f);
            LoadBanner();
            yield return new WaitForSeconds(0.5f);
            LoadNative();
        }

        #region reward

        private void LoadRewardedAd()
        {
            if (m_rewardIdLoad)
            {
                return;
            }

            m_rewardIdLoad = true;


            if (IsAdUnitEmpty(IsReviewModel() ? HCStaticParams.ReviewRewardUnitId : HCStaticParams.RewardAdUnitID, ADType.Reward)) return;
            plugin.LoadRewardedAd(IsReviewModel() ? HCStaticParams.ReviewRewardUnitId : HCStaticParams.RewardAdUnitID);
            m_rvStartLoadTime = Time.time;
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_Start_Load);
        }

        public bool IsRewardedAdReady()
        {
            if (IsAdUnitEmpty(IsReviewModel() ? HCStaticParams.ReviewRewardUnitId : HCStaticParams.RewardAdUnitID, ADType.Reward)) return false;
            return plugin.IsRewardedAdReady(IsReviewModel() ? HCStaticParams.ReviewRewardUnitId : HCStaticParams.RewardAdUnitID);
        }

        public void ShowRewardedAd(HCRVPositionName _adPos, Action<bool> _rewardCallback = null, Action _showFCallback = null, bool _useSDKToast = true)
        {
            mRVPos = _adPos;
            HCAnalyticsManager.Instance.LogRewardBtnClick(_adPos.ToString());
            
            if (IsAdUnitEmpty(IsReviewModel() ? HCStaticParams.ReviewRewardUnitId : HCStaticParams.RewardAdUnitID, ADType.Reward)) return;
            m_rewardCallback = _rewardCallback;
            m_showFailCallback = _showFCallback;

            if (IsRewardedAdReady())
            {
                HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_AchieveShow_Match, new Dictionary<string, object> { { HCInnerStaticSting.HC_Position, _adPos.ToString() } });
                // PauseGame();
                plugin.ShowRewardedAd(IsReviewModel() ? HCStaticParams.ReviewRewardUnitId : HCStaticParams.RewardAdUnitID);
            }
            else
            {
                if (_useSDKToast)
                {
                    HCNativeInterface.Instance.ShowToast(HCTools.IsChinese() ? "广告还未准备好" : "This ad is not ready yet.");
                }

                m_showFailCallback?.Invoke();
                m_showFailCallback = null;
                LoadRewardedAd();

                HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_ShowFail_Not_Ready,new Dictionary<string, object> { { HCInnerStaticSting.HC_Position, _adPos.ToString() } });
            }
        }

        private void OnRewardedRevenue(string adunit, Dictionary<string, object> dictionary)
        {
            HCAnalyticsManager.Instance.TrackRevenueEvent(dictionary);
        }

        private void OnRewardedAdLoadedEvent(string adunit, Dictionary<string, object> dictionary)
        {
            m_rewardIdLoad = false;
            m_rewardRetryAttempt = 0;
            float loadTime = Time.time - m_rvStartLoadTime;
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_Loaded,
                new Dictionary<string, object>
                {
                    { HCInnerStaticSting.HC_Time, loadTime.ToString() },
                    { "ad_platform", dictionary.GetValue("networkName", "") },
                    { "ad_id", dictionary.GetValue("networkPlacement", "") },
                    { "ad_ecpm", dictionary.GetValue("revenue", "0") }
                });
        }

        private void OnRewardedAdLoadFailedEvent(string adunit, Dictionary<string, object> dictionary)
        {
            m_rewardIdLoad = false;

            float loadTime = Time.time - m_rvStartLoadTime;
            dictionary ??= new Dictionary<string, object>();
            dictionary[HCInnerStaticSting.HC_Time] = loadTime.ToString();

            if (dictionary.ContainsKey("type"))
            {
                dictionary["return_type"] = dictionary["type"];
                dictionary.Remove("type");
            }
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_Fail_Loaded, dictionary);
            m_rewardRetryAttempt++;
            double retryDelay = Math.Pow(2, Math.Min(6, m_rewardRetryAttempt));
            Invoke("LoadRewardedAd", (float)retryDelay);
        }

        private void OnRewardedAdDisplayedEvent(string adUnitId, Dictionary<string, object> dictionary)
        {
            PauseGame();
            int playCount = HCTools.GetPlayerPrefsInt("REWARD_PLAY_COUNT", 0) + 1;
            HCTools.SavePlayerPrefsInt("REWARD_PLAY_COUNT", playCount);
            HCAnalyticsManager.Instance.SetUserProperties(new Dictionary<string, object>() { { "total_rv_ad_times", playCount } });
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_Show, new Dictionary<string, object>() { { HCInnerStaticSting.HC_Position, mRVPos.ToString() } });
        }

        private void OnRewardedAdClickedEvent(string adUnitId, Dictionary<string, object> dictionary)
        {
        }

        private void OnRewardedAdFailedToDisplayEvent(string adUnitId, Dictionary<string, object> errorInfoDictionary, Dictionary<string, object> dictionary)
        {
            ResumeGame();

            m_showFailCallback?.Invoke();
            m_showFailCallback = null;

            LoadRewardedAd();

            if (errorInfoDictionary.ContainsKey("type"))
            {
                errorInfoDictionary["return_type"] = errorInfoDictionary["type"];
                errorInfoDictionary.Remove("type");
            }
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_ShowFail, errorInfoDictionary);
        }

        private void OnRewardedAdReceivedRewardEvent(string adUnitId, Dictionary<string, object> rewardDictionary, Dictionary<string, object> dictionary)
        {
        }

        private void OnRewardedAdHiddenEvent(string adUnitId, Dictionary<string, object> dictionary)
        {
            ResumeGame();
            var result = (bool)dictionary.GetValue("isEnded", false);
            m_rewardCallback?.Invoke(result);
            
            m_rewardCallback = null;
            if (dictionary.ContainsKey("type"))
            {
                dictionary["return_type"] = dictionary["type"];
                dictionary.Remove("type");
            }
            dictionary.AddIfNotExists(HCInnerStaticSting.HC_Position, mRVPos.ToString());
            HCAnalyticsManager.Instance.TrackEvent("RV_Close", dictionary);
            if (IsDouyinWebGL())
            {
                int playCount = HCTools.GetPlayerPrefsInt("REWARD_PLAY_COUNT", 0) + 1;
                HCTools.SavePlayerPrefsInt("REWARD_PLAY_COUNT", playCount);
                HCAnalyticsManager.Instance.SetUserProperties(new Dictionary<string, object>() { { "total_rv_ad_times", playCount } });
                HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_RV_Show, dictionary);
            }
            
            LoadRewardedAd();
        }
        
        private bool IsDouyinWebGL()
        {
#if UNITY_WEBGL && WEBGL_BYTEDANCE
            return HCWebGLSDKManager.AppInfo.GetPlatform().ToLower().Contains("ios");
#else
            return false;
#endif
        }

        #endregion

        #region inter

        private bool _ivIsLoading;
        
        private void LoadInterstitial()
        {
            if (IsReviewModel() || IsAdUnitEmpty(HCStaticParams.InterAdUnitID, ADType.Intersitital) || HCTools.IsRemoveAds()) return;
            if (IsInterstitialReady())
            {
                HCDebugger.LogDebug("IV已经准备就绪");
                return;
            }
            if (_ivIsLoading)
            {
                HCAnalyticsManager.Instance.TrackEvent("IV_Loading");
                return;
            }

            // 2 s没回来，就算load失败，放开load锁
            Invoke("WatchIvLoadCallback", 2);
            
            _ivIsLoading = true;
            
            plugin.LoadInterstitial(HCStaticParams.InterAdUnitID);

            m_ivStartLoadTime = Time.time;
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_Start_Load);
        }
        
        private void WatchIvLoadCallback()
        {
            _ivIsLoading = false;
            HCDebugger.LogDebug("没有收到回调Iv load 回调");
            HCAnalyticsManager.Instance.TrackEvent("WatchIvLoadCallback");
        }

        public bool IsInterstitialReady()
        {
            if (IsReviewModel() || IsAdUnitEmpty(HCStaticParams.InterAdUnitID, ADType.Intersitital) || HCTools.IsRemoveAds()) return false;
            return plugin.IsInterstitialReady(HCStaticParams.InterAdUnitID);
        }

        public void ShowInterstitial(HCIVPositionName _adPos, HCIVADType _IvType = HCIVADType.IV1, Action _closeCallback = null)
        {
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_Position, new Dictionary<string, object> { { HCInnerStaticSting.HC_Position, _adPos.ToString() }, { HCInnerStaticSting.HC_IV_Type, _IvType.ToString() } });
            if (m_interCloseCallback != null)
            {
                HCDebugger.LogDebug($"[ShowInterstitial] 正在显示插屏广告，显示失败 callback  = {_closeCallback}");
                _closeCallback?.Invoke();
                HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_ShowFail_Rule_Limit,
                    new Dictionary<string, object> { 
                        { HCInnerStaticSting.HC_Position, _adPos.ToString() },
                        { HCInnerStaticSting.HC_IV_Type, _IvType.ToString() },
                        { "IV_STATUS", "playing" },
                        { "IV_CURRENT_AD_TYPE", currentShowIVADType.ToString() },
                    });
                return;
            }

            mIVPos = _adPos;

            var isRemoveAds = HCTools.IsRemoveAds();
            var isReviewModel = IsReviewModel();
            var isAdUnitEmpty = IsAdUnitEmpty(HCStaticParams.InterAdUnitID, ADType.Intersitital);
            var canShowInterval = CanShowInter(_IvType);
            if (isRemoveAds || isReviewModel || isAdUnitEmpty || canShowInterval != null)
            {
                HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_ShowFail_Rule_Limit,
                    new Dictionary<string, object> { 
                        { HCInnerStaticSting.HC_Position, _adPos.ToString() },
                        { HCInnerStaticSting.HC_IV_Type, _IvType.ToString() },
                        { "IV_STATUS", "rule" },
                        { "HC_isRemoveAds", isRemoveAds },
                        { "HC_isReviewModel", isReviewModel },
                        { "HC_isAdUnitEmpty", isAdUnitEmpty },
                        { "HC_canShowInter", canShowInterval },
                    });
                
                HCDebugger.LogDebug($"[ShowInterstitial] 间隔中，显示失败 callback  = {_closeCallback}");
                _closeCallback?.Invoke();
                return;
            }


            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_AchieveShow_Match, HCInnerStaticSting.HC_Position, _adPos.ToString(), HCInnerStaticSting.HC_IV_Type, _IvType.ToString());


            if (IsInterstitialReady())
            {
                currentShowIVADType = _IvType;
                HCDebugger.LogDebug($"[ShowInterstitial] 开始显示插屏 _closeCallback = {_closeCallback}");
                m_interCloseCallback = _closeCallback ?? (() => { HCDebugger.LogDebug($"[ShowInterstitial] close _closeCallback = close iv"); });

                Invoke("CheckCloseCallback", 3);

                HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_AchieveShow, new Dictionary<string, object> { { HCInnerStaticSting.HC_Position, _adPos.ToString() }, { HCInnerStaticSting.HC_IV_Type, _IvType.ToString() } });
                // PauseGame();
                plugin.ShowInterstitial(HCStaticParams.InterAdUnitID);
            }
            else
            {
                currentShowIVADType = HCIVADType.NULL;
                _closeCallback?.Invoke();
                HCDebugger.LogDebug($"[ShowInterstitial] 没有缓存，执行close callback _closeCallback = {_closeCallback}");
                HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_ShowFail_Not_Ready,
                    new Dictionary<string, object> { { HCInnerStaticSting.HC_Position, _adPos.ToString() }, { HCInnerStaticSting.HC_IV_Type, _IvType.ToString() } });
                LoadInterstitial();
            }
        }

        private void CheckCloseCallback()
        {
            // CancelInvoke("CheckCloseCallback");
            HCDebugger.LogError($"[CheckCloseCallback] 3s没收到iv show 的回调，直接回调close m_interCloseCallback = {m_interCloseCallback}");
            m_interCloseCallback?.Invoke();
            m_interCloseCallback = null;
        }

        //Conditional Control
        private string CanShowInter(HCIVADType _type)
        {
            // 【1】前N次不展示插屏
            var checkIfReachFirstNTimes = CheckIfReachFirstNTimes(_type);
            if (checkIfReachFirstNTimes != null)
            {
                return checkIfReachFirstNTimes;
            }

            // 到达N次后，第N+1次直接展示插屏
            if (IfFirstCheckPlayerPrefs(_type))
            {
                // 直接展示
                return null;
            }

            // 非第N+1次，不能直接展示广告； 【2】要判断是否达到了间隔次数；
            
            //innerIvType 和 _type 其实就是一样的
            int innerIvType = GetInterRules(_type, HCInnerStaticSting.HC_TYPE);
            
            int currTimes; // 当前达到的间隔次数
            int needTimes = GetInterRules(_type, HCInnerStaticSting.HC_OVER_LEVEL); // 需要达到的间隔次数
            // 获取当前进程里 iv 的展示次数
            if (ivsCount.ContainsKey(innerIvType))
            {
                // 读取字典里插屏类型的次数
                currTimes = ivsCount[innerIvType] + 1;
                ivsCount[innerIvType] = currTimes;
            }
            else
            {
                // 字典里没有数据，添加数据
                currTimes = 1;
                ivsCount.Add(innerIvType, currTimes);
            }

            HCDebugger.LogDebug("当前间隔次数：" + currTimes + "远端次数：" + needTimes + "IV Type:" + _type);
            if (currTimes <= needTimes)
            {
                // 没到频次控制时间
                return "当前间隔次数：" + currTimes + "远端次数：" + needTimes + "IV Type:" + _type;
            }
            

            //【3】判断是否达到最小时间间隔
            int timeInterVal = GetInterRules(_type, HCInnerStaticSting.HC_INTERVAL);

            var mIvStartTime = GetCurrentTimeInterVal(_type);
            var adInterTime = Time.time - mIvStartTime;
            bool canShowFlag = adInterTime >= timeInterVal;
            var msg = "插屏时间间隔：当前时间：" + adInterTime + "远端时间：" + timeInterVal + "IV Type:" + _type + " canShowFlag:" + canShowFlag;
            HCDebugger.LogDebug(msg);
            if (canShowFlag)
            {
                // 重置次数
                ivsCount[innerIvType] = 0;
            }

            if (!canShowFlag)
            {
                return msg;
            }
            return null;
        }


        private string CheckIfReachFirstNTimes(HCIVADType _type)
        {
            bool canShow = false;

            string reachKey = "ivReachTimes" + _type.ToString();
            //  取出本地插屏播放的次数
            int reachTime = HCTools.GetPlayerPrefsInt(reachKey, 0);
            // 是否到达可播放时机
            if (reachTime >= GetInterRules(_type, HCInnerStaticSting.HC_SKIP_LEVEL))
            {
                canShow = true;
            }

            reachTime += 1;
            HCTools.SavePlayerPrefsInt(reachKey, reachTime);
            var msg = "前N次不展示插屏，本地次数：" + reachTime + "远端参数：" + GetInterRules(_type, HCInnerStaticSting.HC_SKIP_LEVEL) + "IV Type:" + _type;
            HCDebugger.LogDebug(msg);
            if (!canShow)
            {
                return msg;
            }
            return null;
        }

        private bool IfFirstCheckPlayerPrefs(HCIVADType _type)
        {
            string key = HCInnerStaticSting.HC_FIRST_SHOW + _type.ToString();
            string values = HCTools.GetPlayerPrefsString(key, "");

            if (values.Length <= 0)
            {
                HCTools.SavePlayerPrefsString(key, key);
                return true;
            }
            else
            {
                return false;
            }
        }


        private int GetInterRules(HCIVADType index, string key)
        {
            string jsonData = HCAnalyticsManager.Instance.GetRemoteConfigStr(HCInnerStaticSting.HC_INTER_RULES_Remote, HCInnerStaticSting.HC_INTER_RULES_DEFAULT_VALUE);
            JArray jsonArray;
            try
            {
                jsonArray = JArray.Parse(jsonData);
            }
            catch
            {
                jsonArray = JArray.Parse(HCInnerStaticSting.HC_INTER_RULES_DEFAULT_VALUE);
            }

            int temp = 0;
            if ((int)index > jsonArray.Count - 1) return temp;

            int.TryParse((string)jsonArray[(int)index][key], out temp);
            return temp;
        }


        // callback
        private void OnInterstitialLoadedEvent(string adunit, Dictionary<string, object> adInfo)
        {
            CancelInvoke(nameof(WatchIvLoadCallback));
            _ivIsLoading = false;
            
            m_interRetryAttempt = 0;

            float loadTime = Time.time - m_ivStartLoadTime;
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_Loaded,
                new Dictionary<string, object>
                {
                    { HCInnerStaticSting.HC_Time, loadTime.ToString() },
                    { "ad_platform", adInfo.GetValue("networkname", "") },
                    { "ad_id", adInfo.GetValue("networkplacement", "") },
                    { "ad_ecpm", adInfo.GetValue("revenue", "0") }
                });
        }

        private void OnInterstitialLoadFailedEvent(string adUnitId, Dictionary<string, object> errorInfo)
        {
            _ivIsLoading = false;
            CancelInvoke(nameof(WatchIvLoadCallback));
            // HCDebugger.LogDebug($"[HCAdsManager] [OnInterstitialLoadFailedEvent] adUnitId = {adUnitId} m_interCloseCallback = {m_interCloseCallback}");
            // m_interCloseCallback?.Invoke();
            // m_interCloseCallback = null;

            float loadTime = Time.time - m_ivStartLoadTime;
            errorInfo ??= new Dictionary<string, object>();
            errorInfo[HCInnerStaticSting.HC_Time] = loadTime.ToString(CultureInfo.InvariantCulture);

            if (errorInfo.ContainsKey("type"))
            {
                errorInfo["return_type"] = errorInfo["type"];
                errorInfo.Remove("type");
            }
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_Fail_Loaded, errorInfo);

            m_interRetryAttempt++;
            double retryDelay = Math.Pow(2, Math.Max(4, m_interRetryAttempt));
            Invoke("LoadInterstitial", (float)retryDelay);
        }

        private void OnInterstitialAdFailedToDisplayEvent(string adUnitId, Dictionary<string, object> errorInfo, Dictionary<string, object> adInfo)
        {
            CancelInvoke("CheckCloseCallback");
            
            HCDebugger.LogDebug($"[HCAdsManager] [OnInterstitialAdFailedToDisplayEvent] adUnitId = {adUnitId} m_interCloseCallback = {m_interCloseCallback}");
            ResumeGame();
            LoadInterstitial();

            m_interCloseCallback?.Invoke();
            m_interCloseCallback = null;

            if (errorInfo.ContainsKey("type"))
            {
                errorInfo["return_type"] = errorInfo["type"];
                errorInfo.Remove("type");
            }
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_ShowFail, errorInfo);
        }

        private void OnInterstitialClickedEvent(string adUnitId, Dictionary<string, object> adInfo)
        {
        }

        private void OnInterstitialDisplayedEvent(string adUnitId, Dictionary<string, object> info)
        {
            PauseGame();

            CancelInvoke("CheckCloseCallback");
            
            HCDebugger.LogDebug($"[HCAdsManager] [OnInterstitialDisplayedEvent] adUnitId = {adUnitId} m_interCloseCallback = {m_interCloseCallback}");

            int playCount = HCTools.GetPlayerPrefsInt("INTER_PLAY_COUNT", 0) + 1;
            HCTools.SavePlayerPrefsInt("INTER_PLAY_COUNT", playCount);
            HCAnalyticsManager.Instance.SetUserProperties(new Dictionary<string, object>() { { "total_iv_ad_times", playCount } });
            if (info.ContainsKey("type"))
            {
                info["return_type"] = info["type"];
                info.Remove("type");
            }
            info.Add(HCInnerStaticSting.HC_Position, mIVPos.ToString());
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_Show, info);
        }

        private void OnInterstitialHiddenEvent(string adUnitId, Dictionary<string, object> adInfo)
        {
            ResumeGame();

            HCDebugger.LogDebug($"[HCAdsManager] [OnInterstitialHiddenEvent] adUnitId = {adUnitId} m_interCloseCallback = {m_interCloseCallback}");

            m_interCloseCallback?.Invoke();
            m_interCloseCallback = null;

            if (currentShowIVADType != HCIVADType.NULL)
            {
                SaveCurrentTimeInterVal(currentShowIVADType);
            }

            currentShowIVADType = HCIVADType.NULL;
            
            if (adInfo.ContainsKey("type"))
            {
                adInfo["return_type"] = adInfo["type"];
                adInfo.Remove("type");
            }
            
            HCAnalyticsManager.Instance.TrackEvent(HCInnerStaticSting.HC_IV_Close, adInfo);
            LoadInterstitial();
        }

        private void OnInterstitialRevenue(string adunit, Dictionary<string, object> adInfo)
        {
            HCAnalyticsManager.Instance.TrackRevenueEvent(adInfo);
        }

        #endregion

        #region Banner

        private void LoadBanner()
        {
            if (IsAdUnitEmpty(HCStaticParams.BannerAdUnitID, ADType.Banner) || HCTools.IsRemoveAds() || IsReviewModel())
            {
                plugin.DestroyBanner(HCStaticParams.BannerAdUnitID);
                return;
            }

            plugin.CreateBanner(HCStaticParams.BannerAdUnitID);
        }

        public void ShowBanner()
        {
            if (IsAdUnitEmpty(HCStaticParams.BannerAdUnitID, ADType.Banner) || HCTools.IsRemoveAds() || IsReviewModel())
            {
                plugin.DestroyBanner(HCStaticParams.BannerAdUnitID);
                return;
            }

            plugin.ShowBanner(HCStaticParams.BannerAdUnitID);
        }

        public void HideBanner()
        {
            if (IsAdUnitEmpty(HCStaticParams.BannerAdUnitID, ADType.Banner)) return;
            plugin.HideBanner(HCStaticParams.BannerAdUnitID);
        }


        private void OnBannerAdLoadedEvent(string adUnitId, Dictionary<string, object> adInfo)
        {
            m_bannerRetryAttempt = 0;
        }

        private void OnBannerAdLoadFailedEvent(string adUnitId, Dictionary<string, object> errorInfo)
        {
            m_bannerRetryAttempt++;
            double retryDelay = Math.Pow(2, Math.Min(6, m_bannerRetryAttempt));
            Invoke("LoadBanner", (float)retryDelay);
        }

        private void OnBannerAdClickedEvent(string adUnitId, Dictionary<string, object> adInfo)
        {
        }

        private void OnBannerAdRevenuePaidEvent(string adUnitId, Dictionary<string, object> adInfo)
        {
            HCAnalyticsManager.Instance.TrackRevenueEvent(adInfo);
        }

        private void OnBannerAdExpandedEvent(string adUnitId, Dictionary<string, object> adInfo)
        {
        }

        private void OnBannerAdCollapsedEvent(string adUnitId, Dictionary<string, object> adInfo)
        {
        }

        #endregion

        #region native

        private void LoadNative(string adUnit = "")
        {
#if UNITY_WEBGL
            if (IsReviewModel() || HCTools.IsRemoveAds()) return;
            if (HCStaticParams.NativeAdUnitIDDictionary.Count == 0)
            {
                HCDebugger.LogError("广告id没有配置");
                return;
            }

            if (string.IsNullOrEmpty(adUnit))
            {
                foreach (var key in HCStaticParams.NativeAdUnitIDDictionary.Keys)
                {
                    HCNativeInterface.Instance.LoadNative(key);
                }
            }
            else if (HCStaticParams.NativeAdUnitIDDictionary.Keys.Contains(adUnit))
            {
                HCNativeInterface.Instance.LoadNative(adUnit);
            }
            else
            {
                HCDebugger.LogError("加载的广告id没有配置");
            }
#endif
// #else
//             if (IsReviewModel() || IsAdUnitEmpty(HCStaticParams.NativeAdUnitID, ADType.Native) || HCTools.IsRemoveAds()) return;
//             HCNativeInterface.Instance.LoadNative(HCStaticParams.NativeAdUnitID);
// #endif
        }

        public bool IsNativeReady(string adUnit = "")
        {
#if UNITY_WEBGL
            if (IsReviewModel() || HCTools.IsRemoveAds()) return false;
            if (HCStaticParams.NativeAdUnitIDDictionary.Count == 0)
            {
                HCDebugger.LogError("广告id没有配置");
                return false;
            }

            if (string.IsNullOrEmpty(adUnit))
            {
                HCDebugger.LogError("adUnit 不能为空");
                return false;
            }

            if (!HCStaticParams.NativeAdUnitIDDictionary.Keys.Contains(adUnit))
            {
                HCDebugger.LogError("广告id没有配置");
                return false;
            }

            return HCNativeInterface.Instance.IsNativeAdReady(adUnit);
#endif
// #else
//             if (IsReviewModel() || IsAdUnitEmpty(HCStaticParams.NativeAdUnitID, ADType.Native) || HCTools.IsRemoveAds()) return false;
//             return HCNativeInterface.Instance.IsNativeAdReady();
// #endif
            return false;
        }

        public void RemoveNative(string adUnit = "")
        {
#if UNITY_WEBGL
            if (IsReviewModel() || HCTools.IsRemoveAds()) return;
            if (HCStaticParams.NativeAdUnitIDDictionary.Count == 0)
            {
                HCDebugger.LogError("广告id没有配置");
                return;
            }

            if (string.IsNullOrEmpty(adUnit))
            {
                HCDebugger.LogError("adUnit 不能为空");
                return;
            }

            if (!HCStaticParams.NativeAdUnitIDDictionary.Keys.Contains(adUnit))
            {
                HCDebugger.LogError("广告id没有配置");
                return;
            }

            HCNativeInterface.Instance.RemoveNative(adUnit);
#endif
// #else
//             if (IsAdUnitEmpty(HCStaticParams.NativeAdUnitID, ADType.Native)) return;
//             HCNativeInterface.Instance.RemoveNative();
// #endif
        }

        public void ShowNative(RectTransform pRect, Camera pCam = null, string pAdPos = "", string adUnit = "", Action<int, string> _showFailedCallback = null, Action _closeCallback = null)
        {
#if UNITY_WEBGL
            if (IsReviewModel())
            {
                _showFailedCallback?.Invoke(-1, "IsReviewModel");
                return;
            }

            if (HCStaticParams.NativeAdUnitIDDictionary.Count == 0)
            {
                _showFailedCallback?.Invoke(-2, "广告id没有配置");
                HCDebugger.LogError("广告id没有配置");
                return;
            }

            if (string.IsNullOrEmpty(adUnit))
            {
                _showFailedCallback?.Invoke(-3, "adUnit 为空");
                HCDebugger.LogError("adUnit 不能为空");
                return;
            }

            if (!HCStaticParams.NativeAdUnitIDDictionary.Keys.Contains(adUnit))
            {
                _showFailedCallback?.Invoke(-4, "广告id没有配置 " + adUnit);
                HCDebugger.LogError("广告id没有配置");
                return;
            }

            HCNativeInterface.Instance.ShowNative(pRect, pCam, pAdPos, adUnit, _showFailedCallback, _closeCallback);
#endif
// #else
//             if (IsReviewModel() || IsAdUnitEmpty(HCStaticParams.NativeAdUnitID, ADType.Native) || HCTools.IsRemoveAds()) return;
//             HCNativeInterface.Instance.ShowNative(pRect, pCam, pAdPos);
// #endif
        }

        #endregion

        #region other

        public bool IsReviewModel()
        {
            HCDebugger.LogDebug("当前提审模式：" + HCAnalyticsManager.Instance.GetRemoteConfigStr(HCInnerStaticSting.HC_MODE_SWITCH_KEY, HCArraignmentModeType.Online.ToString()));
            return HCAnalyticsManager.Instance.GetRemoteConfigStr(HCInnerStaticSting.HC_MODE_SWITCH_KEY, HCArraignmentModeType.Online.ToString()) == HCArraignmentModeType.Review.ToString();
        }


        private bool IsAdUnitEmpty(string unitId, ADType type)
        {
            if (unitId == "")
            {
                HCDebugger.LogError(string.Format("请填写{0}广告位ID", type.ToString()));
                return true;
            }

            return false;
        }

        private void PauseGame()
        {
            HCSDKManager.Instance.SetGameFocusListener?.Invoke(false);

            //if (Time.timeScale > 0f) m_oldTimeScale = Time.timeScale;
            //if (m_oldVolume > 0f) m_oldVolume = AudioListener.volume;
            //Time.timeScale = 0f;
            //AudioListener.volume = 0f;
        }

        private void ResumeGame()
        {
            HCSDKManager.Instance.SetGameFocusListener?.Invoke(true);
            //Time.timeScale = m_oldTimeScale;
            //AudioListener.volume = m_oldVolume;
        }

        public void SetLogEnable(bool _enable)
        {
            plugin.SetLogEnable(_enable);
        }

        public enum ADType
        {
            Banner,

            Intersitital,

            Reward,

            Native
        }

        #endregion
    }
}