package nextrek.widgets;

import java.lang.ref.WeakReference;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;

import nextrek.lib.SICKey;
import android.R;
import android.content.Context;
import android.graphics.drawable.BitmapDrawable;
import android.os.Handler;
import android.os.Handler.Callback;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;

public class WebImageView extends RelativeLayout {

    private static final int DEFAULT_POOL_SIZE = 3;
    private static ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(DEFAULT_POOL_SIZE, new ThreadFactory() {

        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setPriority(Thread.MIN_PRIORITY);
            return thread;
        }
    });

    private enum ImageState {
        LOADING, SET, ERROR
    }

    class loaderMessage {
        private SICKey key;
        private BitmapDrawable drawable = null;

        public loaderMessage(SICKey key) {
            this.key = key;
        }

        public String getImageUrl() {
            return key.getName();
        }

        public BitmapDrawable getDrawable() {
            return drawable;
        }

        public void setDrawable(BitmapDrawable drawable) {
            this.drawable = drawable;
        }

        public void destroy() {
            key = null;
            drawable = null;
        }
    }

    private static final int COMPLETE = 0;
    private static final int FAILED = 1;
    protected static final String TAG = "WebImageView";
    /**
     * Callback that is received once the image has been downloaded
     */
    private Handler imageLoadedHandler = new Handler(new Callback() {
        public boolean handleMessage(Message msg) {
            if ((msg == null) || ((msg.what != COMPLETE) & (msg.what != FAILED))) {
                return true;
            }

            final loaderMessage message = (loaderMessage) msg.obj;
            if (message != null) {
                final String targetUrl = (String) getImageView().getTag();
                if ((targetUrl != null) && (message.getImageUrl() != null) && (targetUrl.equals(message.getImageUrl()))) {
                    if (msg.what == COMPLETE) {

                        if (message.getDrawable() != null) {
                            setImageState(message.getDrawable(), targetUrl, ImageState.SET);
                        } else {
                            Log.e(TAG, "imageLoadedHandler: drawable is null");
                        }

                    } else {
                        if (msg.what == FAILED) {

                            setImageState(null, targetUrl, ImageState.ERROR);

                            // Could change image here to a 'failed' image
                            // otherwise will just keep on spinning
                            Log.e(TAG, "imageLoadedHandler: failed to fetch image");
                        } else {
                            Log.e(TAG, "imageLoadedHandler: received " + msg.what);
                        }
                    }
                }
            }
            message.destroy();
            return true;
        }
    });

    /**
     * Set's the view's drawable, this uses the internet to retrieve the image
     * don't forget to add the correct permissions to your manifest
     * 
     * @param imageUrl
     *            the url of the image you wish to load
     */

    private String lastUrl = "";
    private int L0_downsample = 1;

    public void setDownsample(int downsample) {
        L0_downsample = downsample;
    }

    private synchronized ImageView getImageView() {
        return (ImageView) getChildAt(1);
    }

    private synchronized ProgressBar getSpinnerView() {
        return (ProgressBar) getChildAt(0);
    }

    /**
     * This is used when creating the view in XML To have an image load in XML
     * use the tag
     * 'image="http://developer.android.com/images/dialog_buttons.png"'
     * Replacing the url with your desired image Once you have instantiated the
     * XML view you can call setImageDrawable(url) to change the image
     * 
     * @param context
     * @param attrSet
     */
    public WebImageView(final Context context, final AttributeSet attrSet) {
        super(context, attrSet);
        final String url = attrSet.getAttributeValue(null, "image");
        if (url != null) {
            instantiate(context, url);
        } else {
            instantiate(context, null);
        }
    }

    /**
     * This is used when creating the view programatically Once you have
     * instantiated the view you can call setImageDrawable(url) to change the
     * image
     * 
     * @param context
     *            the Activity context
     * @param imageUrl
     *            the Image URL you wish to load
     */
    public WebImageView(final Context context, final String imageUrl) {
        super(context);
        instantiate(context, imageUrl);
    }

    /**
     * First time loading of the LoaderImageView Sets up the LayoutParams of the
     * view, you can change these to get the required effects you want
     */
    private void instantiate(final Context context, final String imageUrl) {

        setPersistentDrawingCache(PERSISTENT_NO_CACHE);
        setDrawingCacheEnabled(false);
        destroyDrawingCache();

        ProgressBar mSpinner = new ProgressBar(context);
        mSpinner.setDrawingCacheEnabled(false);
        mSpinner.destroyDrawingCache();

        LayoutParams lp = new LayoutParams(android.view.ViewGroup.LayoutParams.WRAP_CONTENT, android.view.ViewGroup.LayoutParams.WRAP_CONTENT);
        lp.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE);
        mSpinner.setLayoutParams(lp);

        mSpinner.setIndeterminate(true);
        // mSpinner.setBackgroundColor(0x80808080);

        addView(mSpinner);

        ImageView mImage = new ImageView(context);
        mImage.setDrawingCacheEnabled(false);
        mImage.destroyDrawingCache();

        mImage.setLayoutParams(new LayoutParams(android.view.ViewGroup.LayoutParams.FILL_PARENT, android.view.ViewGroup.LayoutParams.FILL_PARENT));
        mImage.setScaleType(ScaleType.FIT_CENTER);

        addView(mImage);

        lastUrl = "";

        if (imageUrl != null) {
            setImageUrl(imageUrl);
        } else {

            mSpinner.setVisibility(View.GONE);
        }
        if (isInEditMode()) {
            setBackgroundColor(0xFFFF0000);
        }

    }

    private synchronized void setImageState(BitmapDrawable drawable, String imageUrl, ImageState state) {
        ProgressBar spinner = getSpinnerView();
        ImageView image = getImageView();
        if (state == ImageState.LOADING) {
            if (image != null)
                image.setVisibility(View.GONE);
            if (spinner != null)
                spinner.setVisibility(View.VISIBLE);
        } else {
            if (spinner != null)
                spinner.setVisibility(View.GONE);
            if (image != null)
                image.setVisibility(View.VISIBLE);
        }
        if (image != null) {
            synchronized (image) {
                try {
                    if (state == ImageState.ERROR) {
                        image.setImageResource(R.drawable.ic_dialog_alert);
                        image.setTag(null);
                    } else {
                        image.setImageDrawable(drawable);
                        image.setTag(imageUrl);
                    }
                } finally {
                    image = null;
                }
            }
        }
    }

    private WeakReference<asyncLoad> mLastRequest = null;

    private synchronized void stopRunner() {
        if (mLastRequest != null) {
            if (mLastRequest.get() != null) {
                executor.remove(mLastRequest.get());
                mLastRequest = null;
            }
        }
    }

    private synchronized void startRunner(SICKey key) {
        mLastRequest = new WeakReference<asyncLoad>(new asyncLoad(key, new WeakReference<Handler>(imageLoadedHandler)));
        executor.execute(mLastRequest.get());
    }

    public void setImageUrl(final String imageUrl) {

        if (imageUrl == null) {
            lastUrl = "";
            stopRunner();
            setImageState(null, null, ImageState.SET);
            return;
        }

        if ((lastUrl.equals(imageUrl))) {
            // already in loaded or loading in progress
            return;
        }

        lastUrl = imageUrl;

        SICKey key = new SICKey(imageUrl, L0_downsample);

        /*
         * 1st level cache
         */
        if (key.inL0()) {
            BitmapDrawable drawable = key.getL0();
            if (drawable != null) {
                stopRunner();
                setImageState(drawable, imageUrl, ImageState.SET);
                return;
            }
        }
        /*
         * if (key.inL1()) {
         * 
         * // decode it on the fly without thread
         * BitmapDrawable drawable = key.getDrawable();
         * if (drawable != null) {
         * stopRunner();
         * setImageState(drawable, imageUrl, ImageState.SET);
         * return;
         * }
         * }
         */
        /**
         * 3rd cache & HTTP
         */
        stopRunner();
        setImageState(null, imageUrl, ImageState.LOADING);
        startRunner(key);
        key = null; // forget;
    }

    class asyncLoad implements Runnable {

        private SICKey key;
        private WeakReference<Handler> handler;

        asyncLoad(SICKey key, WeakReference<Handler> handler) {
            super();

            this.handler = handler;
            this.key = key;
        }

        @Override
        protected void finalize() throws Throwable {
            key = null;
            handler = null;
            super.finalize();
        }

        public void run() {

            BitmapDrawable drawable = null;

            drawable = key.get();

            if (drawable == null) {
                Log.e(TAG, "Error, retrying 2/3" + key.getName());
                try {
                    Thread.sleep(1000, 0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                drawable = key.get();
            }

            if (drawable == null) {
                Log.e(TAG, "Error, retrying 3/3" + key.getName());
                try {
                    Thread.sleep(1000, 0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                drawable = key.get();
            }

            loaderMessage msg = new loaderMessage(key);
            if (drawable != null) {
                msg.setDrawable(drawable);
                drawable = null;
                if (handler.get() != null)
                    handler.get().sendMessage(handler.get().obtainMessage(COMPLETE, msg));
            } else {
                Log.e(TAG, "Error, cannot retrieve: " + key.getName());

                if (handler.get() != null)
                    handler.get().sendMessage(handler.get().obtainMessage(FAILED, msg));
            }

        }

    }
}