using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Advertisements;
using UnityEngine.Diagnostics;

public class AdsManager : MonoBehaviour, IUnityAdsInitializationListener, IUnityAdsLoadListener, IUnityAdsShowListener {
    [SerializeField] string m_androidGameId;
    [SerializeField] string m_iOSGameId;
    [SerializeField] bool m_testMode = true;
    [SerializeField] BannerPosition m_bannerPosition = BannerPosition.TOP_CENTER;
    [SerializeField] float m_bannerDuration;

    private string m_gameId;
    string m_intersitialUnitsId;
    string m_bannerUnitsId;
    string m_rewardedUnitsId;

    float m_bannerTimer;
    bool m_canDisplayBanner;

    public static AdsManager instance;
    public delegate void AdEvents();
    public static AdEvents AdLoaded, AdEnded;
    adType typeOnHold = adType.None;

    private void Awake() {
        init();
    }

    private void Update() {
        updateTimer();
    }

    /// <summary>
    /// inicalizaciones requeridas por el manager
    /// </summary>
    private void init() {
        //referencia singleton
        if (instance != null) {
            Destroy(this);
            return;
        }
        instance = this;

        //asignar valores de las Ids dependiendo del sistema operativo
#if UNITY_IOS
        m_gameId = _iOSGameId;
        m_intersitialId = "Interstitial_iOS";
        m_bannerId = "Banner_iOS";
        m_rewardedUnitsId = "Rewarded_iOS";

#elif UNITY_ANDROID
        m_gameId = m_androidGameId;
        m_intersitialUnitsId = "Interstitial_Android";
        m_bannerUnitsId = "Banner_android";
        m_rewardedUnitsId = "Rewarded_Android";

#elif UNITY_EDITOR
        m_gameId = _androidGameId; //Only for testing the functionality in the Editor
        m_intersitialId = "Interstitial_Android";
        m_bannerId = "Banner_Android";
        m_rewardedUnitsId = "Rewarded_Android";

#endif
        //inicializar el servicio de ads
        if (!Advertisement.isInitialized && Advertisement.isSupported) {
            Advertisement.Initialize(m_gameId, m_testMode, this);
        }

        //suscribirse a su propio evento de OnLoadedAd
        AdLoaded += onLoadedAd;

        //configurar la posición del banner e inicializarlo
        Advertisement.Banner.SetPosition(m_bannerPosition);
        loadAndShowAd(adType.Banner);
    }

    /// <summary>
    /// Actualiza el timer del banner y carga otro nuevo de ser necesario
    /// </summary>
    void updateTimer() {
        if (m_bannerTimer > 0 && m_canDisplayBanner)
            m_bannerTimer -= Time.deltaTime;
        else if (m_canDisplayBanner) {
            Advertisement.Banner.Hide();
            Debug.Log("LoadingNewAd");
            loadBanner();
        }
    }

    /// <summary>
    /// cosas para hacer de a cuerdo a la ad cargada
    /// </summary>
    void onLoadedAd() {

        switch (typeOnHold) {
            case adType.Intersitial:
                showIntersitialAd();
                break;

            case adType.Rewarded:
                Debug.Log("Show rewarded ad");
                showRewardedAd();
                break;

            case adType.IntersitialRewarded:

                break;

            default:
                Debug.LogError($"Non Valid ad type!!!");
                break;
        }
        typeOnHold = adType.None;
    }



    #region Intersitial
    /// <summary>
    /// Carga en memoria la nueva ad de tipo intersicial
    /// </summary>
    void loadIntersitialAd() {
        // IMPORTANT! Only load content AFTER initialization (in this example, initialization is handled in a different script).
        Debug.Log("Loading Ad: " + m_intersitialUnitsId);
        Advertisement.Load(m_intersitialUnitsId, this);
    }

    /// <summary>
    /// muestra la ad de tipo intersicial
    /// </summary>
    void showIntersitialAd() {
        Advertisement.Show(m_intersitialUnitsId, this);
    }
    #endregion

    #region Rewarded
    /// <summary>
    /// Carga en memoria la nueva ad de tipo Rewarded
    /// </summary>
    void loadRewardedAd() {
        Debug.Log("Load rewarded ad");
        Advertisement.Load(m_rewardedUnitsId, this);
    }

    /// <summary>
    /// muestra la ad de tipo Rewarded
    /// </summary>
    void showRewardedAd() {
        Advertisement.Show(m_rewardedUnitsId, this);
    }
    #endregion

    #region IntersitialRewarded
    #endregion


    #region Banner
    /// <summary>
    /// carga el nuevo banner en memoria
    /// </summary>
    void loadBanner() {
        // Set up options to notify the SDK of load events:
        BannerLoadOptions options = new BannerLoadOptions {
            loadCallback = onBannerLoaded,
            errorCallback = onBannerError
        };

        // Load the Ad Unit with banner content:
        Advertisement.Banner.Load(m_bannerUnitsId, options);

        //Muestra el banner tras haberse cargado completamente
        void onBannerLoaded() {
            Debug.Log("Banner loaded");
            m_bannerTimer = m_bannerDuration;
            showBannerAd();
        }

        // Implement code to execute when the load errorCallback event triggers:
        void onBannerError(string message) {
        }
    }

    /// <summary>
    /// Muestra el banner precargado
    /// </summary>
    void showBannerAd() {
        // Set up options to notify the SDK of show events:
        BannerOptions options = new BannerOptions {
            clickCallback = onBannerClicked,
            hideCallback = onBannerHidden,
            showCallback = onBannerShown
        };

        // Show the loaded Banner Ad Unit:
        Advertisement.Banner.Show(m_bannerUnitsId, options);

        void onBannerClicked() { }
        void onBannerShown() { }
        void onBannerHidden() { }
    }

    /// <summary>
    /// Forxa el AdsManager a ocultar el banner actual
    /// </summary>
    public void forceHideBannerAd() {
        // Hide the banner:
        Advertisement.Banner.Hide();
        m_bannerTimer = 0;
        m_canDisplayBanner = false;
    }
    #endregion

    #region AdsInterfaces
    //NOTA: NO RENOMBRAR A LA NOMENCLATURA DEL ESTUDIO. Son funciones requeridas por la API de Unity al heredar de las clases de ads, por más que poco o nada las usemos
    public void OnUnityAdsAdLoaded(string adUnitId) {
        if(adUnitId != m_bannerUnitsId) {
            AdLoaded?.Invoke();
        }
    }

    public void OnUnityAdsFailedToLoad(string _adUnitId, UnityAdsLoadError error, string message) {
        // Optionally execute code if the Ad Unit fails to load, such as attempting to try again.
    }

    public void OnUnityAdsShowFailure(string _adUnitId, UnityAdsShowError error, string message) {
        // Optionally execute code if the Ad Unit fails to show, such as loading another ad.
    }

    public void OnUnityAdsShowStart(string _adUnitId) { }
    public void OnUnityAdsShowClick(string _adUnitId) { }
    public void OnUnityAdsShowComplete(string _adUnitId, UnityAdsShowCompletionState showCompletionState) {
        AdEnded?.Invoke();
        if (_adUnitId.Equals(m_rewardedUnitsId) && showCompletionState.Equals(UnityAdsShowCompletionState.COMPLETED)) {
            Debug.Log("Unity Ads Rewarded Ad Completed");
            //CARPI Aquí va lo de las rewards
        }

    }

    public void OnInitializationComplete() {
        Debug.Log("Unity Ads initialization complete.");
    }

    public void OnInitializationFailed(UnityAdsInitializationError error, string message) {

    }
    #endregion

    #region Shortcuts
    /// <summary>
    /// Función que automatiza el cargado y mostrado de los tipos de publicidad
    /// </summary>
    /// <param name="type"></param>
    void loadAndShowAd(adType type) {
        switch (type) {
            case adType.Intersitial:
                typeOnHold = adType.Intersitial;
                loadIntersitialAd();
                break;

            case adType.Rewarded:
                typeOnHold = adType.Rewarded;
                loadRewardedAd();
                break;

            case adType.IntersitialRewarded:
                /*typeOnHold = adType.IntersitialRewarded;
                loadIntersitialRewarded();*/
                break;
            case adType.Banner:
                m_canDisplayBanner = true;
                loadBanner();
                break;

            default:
                Debug.LogError($"Non Valid ad type!!!");
                break;


        }
    }

    /// <summary>
    /// Carga y muestra una ad del tipo intersitial
    /// </summary>
    public void loadAndShowIntersitialAd() {
        loadAndShowAd(adType.Intersitial);
    }

    /// <summary>
    /// Carga y muestra una ad del tipo rewarded
    /// </summary>
    public void loadAndShowRewarded() {
        loadAndShowAd(adType.Rewarded);
    }

    /// <summary>
    /// [DESHABILITADA] Carga y muestra una ad Intersitial con reward.
    /// </summary>
    public void loadandshowIntersitialRewarded() {
        loadAndShowAd(adType.IntersitialRewarded);

    }

    /// <summary>
    /// carga y muestra un banner
    /// </summary>
    public void loadandShowBanner() {
        loadAndShowAd(adType.Banner);
    }


    #endregion

    /// <summary>
    /// Tipos de Ad
    /// </summary>
    [Serializable]
    public enum adType {
        None,
        Intersitial,
        Rewarded,
        IntersitialRewarded,
        Banner
    }

}