package com.intentsoftware.addapptr.ad;

import android.app.Activity;
import android.os.Build;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;

import com.intentsoftware.addapptr.AdNetwork;
import com.intentsoftware.addapptr.module.Logger;
import com.intentsoftware.addapptr.module.ViewableImpressionTracker;

import java.util.HashMap;
import java.util.Map;

import androidx.annotation.CallSuper;
import androidx.annotation.NonNull;

public abstract class NativeAd extends Ad implements NativeAdData, View.OnAttachStateChangeListener, ViewableImpressionTracker.Delegate {

    private ViewableImpressionTracker viewableImpressionTracker;

    @SuppressWarnings("unused")
    public static class NativeAdRating {
        private final double value;
        private final double scale;

        public NativeAdRating(double value, double scale) {
            this.value = value;
            this.scale = scale;
        }

        public double getValue() {
            return value;
        }

        public double getScale() {
            return scale;
        }
    }

    @SuppressWarnings("unused")
    public enum Type {
        APP_INSTALL,
        CONTENT,
        VIDEO,
        UNIFIED,
        OTHER,
        UNKNOWN
    }

    public static final String ICON_IMAGE_ASSET = "icon";
    public static final String MAIN_IMAGE_ASSET = "main";

    public static final String TITLE_TEXT_ASSET = "headline";
    public static final String DESCRIPTION_TEXT_ASSET = "description";
    public static final String CALL_TO_ACTION_TEXT_ASSET = "cta";
    public static final String ADVERTISER_TEXT_ASSET = "advertiser";

    private final Map<String, String> assets = new HashMap<>();
    private NativeAdRating rating;
    private LayoutListener layoutListener;
    private View impressionTrackingView;
    private View nativeAdView;
    private boolean shouldReportImpression = true;

    private boolean shouldRequestMainImage;

    public final void setShouldRequestMainImage(boolean shouldRequestMainImage) {
        this.shouldRequestMainImage = shouldRequestMainImage;
    }

    protected final boolean isShouldRequestMainImage() {
        return shouldRequestMainImage;
    }

    protected final void setRating(NativeAdRating rating) {
        this.rating = rating;
    }

    @Override
    public final NativeAdRating getRating() {
        return rating;
    }

    @Override
    public final String getAsset(String assetName) {
        return assets.get(assetName);
    }

    protected final void setAsset(String assetName, String assetValue) {
        assets.put(assetName, assetValue);
    }

    @Override
    public final AdNetwork getNetwork() {
        return getConfig().getNetwork();
    }

    @Override
    @CallSuper
    public void attachToLayout(ViewGroup layout, View mainImageView, View iconView, View ctaView) {
        nativeAdView = layout;
        if (layoutListener != null) {
            layoutListener.onAdAttachedToLayout(this);
        }

        if (shouldReportImpression && layout != null) {
            if (isExpired()) {
                if (Logger.isLoggable(Log.WARN)) {
                    Logger.w(this, "Ad has expired, impression will not be counted.");
                }
            } else if (isAttachedToWindow(layout)) {
                notifyListenerThatAdIsShown(); //native ad layout has already been added to window
            } else {
                startViewabilityTracking(layout);
            }
        }
    }

    private boolean isAttachedToWindow(View view) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            return view.isAttachedToWindow();
        } else {
            return view.getWindowToken() != null; //logic taken from ViewCompat
        }
    }

    @Override
    public abstract View getBrandingLogo();

    @Override
    public final void detachFromLayout() {
        if (layoutListener != null) {
            layoutListener.onAdDetachedFromLayout(this);
        }
        unload();
    }

    @Override
    public Type getAdType() {
        return Type.UNKNOWN;
    }

    public final void setLayoutListener(LayoutListener layoutListener) {
        this.layoutListener = layoutListener;
    }

    @Override
    @CallSuper
    public void unloadInternal() { //TODO: move to unload?
        stopViewabilityTracking();
        stopViewableImpressionTracking();
        setInteractionListener(null);
        setLoadListener(null);
        setLayoutListener(null);
    }

    @NonNull
    @Override
    public String toString() {
        return getClass().getSimpleName() + ";type:" + getAdType();
    }

    @Override
    protected final void finalize() throws Throwable {
        unload();
        super.finalize();
    }

    private synchronized void startViewabilityTracking(View trackingView) {
        if (trackingView != null) {
            impressionTrackingView = trackingView;
            impressionTrackingView.addOnAttachStateChangeListener(this);
        } else {
            if (Logger.isLoggable(Log.ERROR)) {
                Logger.e(this, "Cannot start viewability tracking, native ad view is null");
            }
        }
    }

    private void startViewableImpressionTracking() {
        if (nativeAdView != null) {
            if (isExpired()) {
                if (Logger.isLoggable(Log.WARN)) {
                    Logger.w(this, "Ad has expired, viewable impression will not be counted.");
                }
            } else {
                viewableImpressionTracker = new ViewableImpressionTracker(this, nativeAdView);
            }
        } else {
            if (Logger.isLoggable(Log.ERROR)) {
                Logger.e(this, "Cannot start viewable tracking, native ad view is null");
            }
        }
    }

    @Override
    @CallSuper
    public void pause() {
        super.pause();
        if (viewableImpressionTracker != null) {
            viewableImpressionTracker.pause();
        }
    }

    @Override
    @CallSuper
    public void resume(Activity activity) {
        super.resume(activity);
        if (viewableImpressionTracker != null) {
            viewableImpressionTracker.resume();
        }
    }

    @Override
    protected final void notifyListenerThatAdIsShown() {
        super.notifyListenerThatAdIsShown();
        startViewableImpressionTracking();
    }

    @Override
    protected final void notifyListenerThatAdWasClicked() {
        super.notifyListenerThatAdWasClicked();
        if (viewableImpressionTracker != null) {
            onViewableImpressionDetected();
        }
    }

    @Override
    public final void onViewAttachedToWindow(View view) {
        stopViewabilityTracking(); //we are just interested in the first impression
        if (shouldReportImpression) {
            shouldReportImpression = false;
            if (isExpired()) {
                if (Logger.isLoggable(Log.WARN)) {
                        Logger.w(this, "Ad has expired, impression will not be counted.");
                }
            } else {
                notifyListenerThatAdIsShown();
            }
        }
    }

    @Override
    public final void onViewDetachedFromWindow(View view) {
    }

    @Override
    public final void onViewableImpressionDetected() {
        stopViewableImpressionTracking();
        notifyListenerViewableImpression();
    }

    @Override
    public final boolean hasExpired() {
        return isExpired();
    }

    private void stopViewabilityTracking() {
        if (impressionTrackingView != null) {
            impressionTrackingView.removeOnAttachStateChangeListener(this);
            impressionTrackingView = null;
        }
    }

    private void stopViewableImpressionTracking() {
        if (viewableImpressionTracker != null) {
            viewableImpressionTracker.destroy();
            viewableImpressionTracker = null;
        }
        if (nativeAdView != null) {
            nativeAdView = null;
        }
    }

    public interface LayoutListener {
        void onAdAttachedToLayout(Ad ad);

        void onAdDetachedFromLayout(Ad ad);
    }
}