using System;
using Azerion.BlueStack.Internal;
using Azerion.BlueStack.Common;
using UnityEngine;

namespace Azerion.BlueStack.API
{
    public class NativeAd
    {
        private INativeAdClient _nativeAdClient;
        private bool _isDisposed;
        private Texture2D _iconTexture;
        private Texture2D _imageTexture;
        private bool _isIconTextureProcessed;
        private bool _isCoverTextureProcessed;

        internal event EventHandler<EventArgs> OnNativeAdDidLoad;
        internal event EventHandler<BlueStackError> OnNativeAdDidFail;
        // internal event EventHandler<EventArgs> OnNativeAdOpening; //TODO
        internal event EventHandler<EventArgs> OnNativeAdClosed;
        public event EventHandler<EventArgs> OnNativeAdImpression;
        public event EventHandler<EventArgs> OnNativeAdClicked;

        private NativeAdInteractionHandler _nativeAdInteractionHandler;

        internal NativeAd(string placementId) : this(placementId,
            BlueStackAds.GetClientsFactory().CreateNativeAdClient())
        {
        }

        internal NativeAd(string placementId, INativeAdClient nativeAdClient)
        {
            // AdsEventExecutor.Initialize();
            _nativeAdClient = nativeAdClient;
            _nativeAdClient.Create(placementId);
            ConfigureEvents();
            InitializeTextures();
            _nativeAdInteractionHandler = new NativeAdInteractionHandler(_nativeAdClient);
        }
        
        // Event Handlers
        private void HandleNativeAdDidLoad(object sender, EventArgs args)
        {
            AdsEventExecutor.ExecuteInUpdate(delegate { LoadTextures(); });
            // SetClickUrl();
        }

        private void HandleNativeAdDidFail(object sender, BlueStackError args)
        {
            OnNativeAdDidFail?.Invoke(this, args);
        }

        private void HandleNativeAdImpression(object sender, EventArgs args)
        {
            OnNativeAdImpression?.Invoke(this, args);
        }

        private void HandleNativeAdClicked(object sender, EventArgs args)
        {
            OnNativeAdClicked?.Invoke(this, args);
        }

        private void HandleNativeAdClosed(object sender, EventArgs args)
        {
            OnNativeAdClosed?.Invoke(this, args);
        }

        // Configure Events
        private void ConfigureEvents()
        {
            _nativeAdClient.OnNativeAdDidLoad += HandleNativeAdDidLoad;
            _nativeAdClient.OnNativeAdDidFail += HandleNativeAdDidFail;
            _nativeAdClient.OnNativeAdImpression += HandleNativeAdImpression;
            _nativeAdClient.OnNativeAdClicked += HandleNativeAdClicked;
            _nativeAdClient.OnNativeAdClosed += HandleNativeAdClosed;
        }

        // Unsubscribe Events
        private void UnsubscribeEvents()
        {
            if (_nativeAdClient == null)
                return;

            _nativeAdClient.OnNativeAdDidLoad -= HandleNativeAdDidLoad;
            _nativeAdClient.OnNativeAdDidFail -= HandleNativeAdDidFail;
            _nativeAdClient.OnNativeAdImpression -= HandleNativeAdImpression;
            _nativeAdClient.OnNativeAdClicked -= HandleNativeAdClicked;
            _nativeAdClient.OnNativeAdClosed -= HandleNativeAdClosed;
        }

        internal void Load()
        {
            Preference preference = new Preference();
            _nativeAdClient.Load(preference.getIPreferenceClient());
        }

        internal void Load(Preference preference)
        {
            _nativeAdClient.Load(preference.getIPreferenceClient());
        }

        private void InitializeTextures()
        {
            this._iconTexture = null;
            this._imageTexture = null;
            this._isIconTextureProcessed = false;
            this._isCoverTextureProcessed = false;
        }

        private void LoadTextures()
        {
            // Debug.Log("GetIconUrl: " + _nativeAdClient.GetIconUrl());
            string iconUrl = _nativeAdClient.GetIconUrl();
            if (String.IsNullOrEmpty(iconUrl))
            {
                Debug.LogWarning("icon url IsNullOrEmpty");
                _isIconTextureProcessed = true;
                CheckTextureProcess();
            }
            else
            {
                AdsEventExecutor.instance.StartCoroutine(NativeUtils.LoadTextureAsync(iconUrl,
                    delegate(Texture2D texture)
                    {
                        if (texture != null)
                        {
                            this._iconTexture = texture;
                            _isIconTextureProcessed = true;
                            CheckTextureProcess();
                        }
                        else
                        {
                            // OnNativeAdDidFail?.Invoke(this, new BlueStackError(-1, "Failed to load icon texture"));
                            // OnNativeAdDidFail = null;
                            Debug.LogWarning("Failed to load icon texture");
                            _isCoverTextureProcessed = true;
                            CheckTextureProcess();
                        }
                    },
                    delegate(string error)
                    {
                        // OnNativeAdDidFail?.Invoke(this, new BlueStackError(-1, error));
                        // OnNativeAdDidFail = null;
                        Debug.LogWarning(error);
                        _isCoverTextureProcessed = true;
                        CheckTextureProcess();
                    }
                ));
            }

            // Debug.Log("GetCoverImageUrl: " + _nativeAdClient.GetCoverImageUrl());
            string coverImageUrl = _nativeAdClient.GetCoverImageUrl();
            if (String.IsNullOrEmpty(coverImageUrl))
            {
                Debug.LogWarning("coverImage url IsNullOrEmpty");
                _isCoverTextureProcessed = true;
                CheckTextureProcess();
            }
            else
            {
                AdsEventExecutor.instance.StartCoroutine(NativeUtils.LoadTextureAsync(coverImageUrl,
                    delegate(Texture2D texture)
                    {
                        if (texture != null)
                        {
                            this._imageTexture = texture;
                            _isCoverTextureProcessed = true;
                            CheckTextureProcess();
                        }
                        else
                        {
                            // OnNativeAdDidFail?.Invoke(this, new BlueStackError(-1, "Failed to load cover texture"));
                            // OnNativeAdDidFail = null;
                            Debug.LogWarning("Failed to load cover texture");
                            _isCoverTextureProcessed = true;
                            CheckTextureProcess();
                        }
                    },
                    delegate(string error)
                    {
                        // OnNativeAdDidFail?.Invoke(this, new BlueStackError(-1, error));
                        // OnNativeAdDidFail = null;
                        Debug.LogWarning(error);
                        _isCoverTextureProcessed = true;
                        CheckTextureProcess();
                    }
                ));
            }
        }

        private void CheckTextureProcess()
        {
            if (_isIconTextureProcessed && _isCoverTextureProcessed)
            {
                OnNativeAdDidLoad?.Invoke(this, EventArgs.Empty);
            }
        }

        public string GetTitleText()
        {
            return _nativeAdClient.GetTitle();
        }

        public string GetBodyText()
        {
            return _nativeAdClient.GetBodyText();
        }

        public string GetCallToActionText()
        {
            return _nativeAdClient.GetCallToActionText();
        }

        public byte[] GetBadgeBytes()
        {
            return _nativeAdClient.GetBadgeBytes();
        }

        public string GetBadgeText()
        {
            return _nativeAdClient.GetBadge();
        }

        public Texture2D GetIconTexture()
        {
            return this._iconTexture;
        }

        public Texture2D GetCoverImageTexture()
        {
            return this._imageTexture;
        }

        // public void RecordImpression()
        // {
        //     _nativeAdClient.RecordImpression();
        // }
        //
        // public void PerformClick()
        // {
        //     _nativeAdClient.PerformClick();
        // }

        private void SetClickUrl()
        {
            _nativeAdInteractionHandler.SetClickUrl(_nativeAdClient.GetClickUrl());
        }

        public bool RegisterTitleTextGameObject(GameObject gameObject)
        {
            return _nativeAdInteractionHandler.RegisterHeadlineTextGameObject(gameObject);
        }

        public bool RegisterBodyTextGameObject(GameObject gameObject)
        {
            return _nativeAdInteractionHandler.RegisterBodyTextGameObject(gameObject);
        }

        public bool RegisterCoverImageGameObject(GameObject gameObject)
        {
            return _nativeAdInteractionHandler.RegisterImageGameObjects(gameObject);
        }

        public bool RegisterIconImageGameObject(GameObject gameObject)
        {
            return _nativeAdInteractionHandler.RegisterIconImageGameObject(gameObject);
        }

        public bool RegisterCallToActionTextGameObject(GameObject gameObject)
        {
            return _nativeAdInteractionHandler.RegisterCallToActionGameObject(gameObject);
        }

        public bool RegisterBadgeTextGameObject(GameObject gameObject)
        {
            return _nativeAdInteractionHandler.RegisterAdvertiserTextGameObject(gameObject);
        }

        internal void Destroy()
        {
            if (_isDisposed)
                return;

            _isDisposed = true;

            UnsubscribeEvents();
            _nativeAdClient?.Destroy();
            _nativeAdClient = null;
        }

        ~NativeAd()
        {
            Debug.Log("NativeAd Destructor was called");
            if (!_isDisposed)
            {
                AdsEventExecutor.ExecuteInUpdate(Destroy);
            }
        }
    }
}