package org.litesoft.GWT.client.widgets;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;
import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.core.*;
import org.litesoft.core.delayed.*;
import org.litesoft.core.util.*;
import org.litesoft.logger.*;

public class SizeableDualImage extends AbstractSizeableComposite implements SourcesClickEvents,
                                                                            SourcesMouseEvents,
                                                                            SourcesLoadEvents
{
    public static final String IMAGE_LOAD_ERROR = "common/images/misc/NotFound.cache.gif";

    private static final Logger LOGGER = LoggerFactory.getLogger( SizeableDualImage.class );

    private MyHtmlPanel mHtmlPanel = new MyHtmlPanel( StaticSimpleIdSource.getNext() );

    public SizeableDualImage( String pUrl )
    {
        initWidget( new ConstrainingSizeableOuterLayers( mHtmlPanel, "litesoft-DualImage", true,
                                                         mHtmlPanel.getInnerTD() ) );

        setUrl( pUrl );
        setImageSize( 100, 100 );
    }

    public SizeableDualImage()
    {
        this( null );
    }

    public SizeableDualImage style( String pStyleName )
    {
        addStyleName( pStyleName );
        return this;
    }

    public SizeableDualImage imageSize( int pWidthPixels, int pHeightPixels )
    {
        setImageSize( pWidthPixels, pHeightPixels );
        return this;
    }

    public void setImageSize( int pWidthPixels, int pHeightPixels )
    {
        UtilsCommon.assertPositive( "Width", pWidthPixels );
        UtilsCommon.assertPositive( "Height", pHeightPixels );
        mHtmlPanel.setImageSize( pWidthPixels, pHeightPixels );
    }

    public void setImageWidth( int pWidthPixels )
    {
        UtilsCommon.assertPositive( "Width", pWidthPixels );
        mHtmlPanel.setContainerWidth( pWidthPixels );
    }

    public void setImageHeight( int pHeightPixels )
    {
        UtilsCommon.assertPositive( "Height", pHeightPixels );
        mHtmlPanel.setContainerHeight( pHeightPixels );
    }

    /**
     * Gets the URL of the image.
     *
     * @return the image URL
     */
    public String getUrl()
    {
        return mHtmlPanel.getHiddenImage().getUrl();
    }

    /**
     * Sets the URL of the image to be displayed.
     *
     * @param pUrl the image URL
     */
    public void setUrl( String pUrl )
    {
        setUrl( pUrl, pUrl, null );
    }

    public void setUrl( String pUrl, String pTitle, Command pClickCommand )
    {
        mHtmlPanel.setUrl( pUrl, pTitle, pClickCommand );
    }

    // proxies to FocusPanel

    private DelegatingClickListenerCollection mClickListeners;
    private DelegatingMouseListenerCollection mMouseListeners;
    private DelegatingLoadListenerCollection mLoadListeners;

    public void addClickListener( ClickListener listener )
    {
        if ( listener != null )
        {
            if ( mClickListeners == null )
            {
                mClickListeners = new DelegatingClickListenerCollection( this, mHtmlPanel.getDisplayImage() );
            }
            mClickListeners.add( listener );
        }
    }

    public void removeClickListener( ClickListener listener )
    {
        if ( (listener != null) && (mClickListeners != null) && //
             mClickListeners.remove( listener ) && mClickListeners.isEmpty() )
        {
            mHtmlPanel.getDisplayImage().removeClickListener( mClickListeners );
            mClickListeners = null;
        }
    }

    public void addMouseListener( MouseListener listener )
    {
        if ( listener != null )
        {
            if ( mMouseListeners == null )
            {
                mMouseListeners = new DelegatingMouseListenerCollection( this, mHtmlPanel.getDisplayImage() );
            }
            mMouseListeners.add( listener );
        }
    }

    public void removeMouseListener( MouseListener listener )
    {
        if ( (listener != null) && (mMouseListeners != null) && //
             mMouseListeners.remove( listener ) && mMouseListeners.isEmpty() )
        {
            mHtmlPanel.getDisplayImage().removeMouseListener( mMouseListeners );
            mMouseListeners = null;
        }
    }

    public void addLoadListener( LoadListener listener )
    {
        if ( listener != null )
        {
            if ( mLoadListeners == null )
            {
                mLoadListeners = new DelegatingLoadListenerCollection( this, mHtmlPanel.getDisplayImage() );
            }
            mLoadListeners.add( listener );
        }
    }

    public void removeLoadListener( LoadListener listener )
    {
        if ( (listener != null) && (mLoadListeners != null) && //
             mLoadListeners.remove( listener ) && mLoadListeners.isEmpty() )
        {
            mHtmlPanel.getDisplayImage().removeLoadListener( mLoadListeners );
            mLoadListeners = null;
        }
    }

    //****** Implementation Code Block to support delegation to AbsoluteSizeHelper

    public SizeableDualImage stretchable()
    {
        LLstretchable();
        return this;
    }

    // private implementation

    public void setWidth( String width )
    {
        super.setWidth( width );
    }

    public void setHeight( String height )
    {
        super.setHeight( height );
    }

    public static class DelegatingLoadListenerCollection extends LoadListenerCollection
            implements LoadListener
    {
        @SuppressWarnings({"GwtInconsistentSerializableClass"})
        private final Widget owner;

        /**
         * Constructor for {@link DelegatingLoadListenerCollection}.
         *
         * @param owner       owner of listeners
         * @param delegatedTo source of events
         */
        public DelegatingLoadListenerCollection( Widget owner, SourcesLoadEvents delegatedTo )
        {
            this.owner = owner;
            delegatedTo.addLoadListener( this );
        }

        public void onError( Widget sender )
        {
            fireError( owner );
        }

        public void onLoad( Widget sender )
        {
            fireLoad( owner );
        }
    }

    private static class MyHtmlPanel extends HTMLPanel implements LoadListener,
                                                                  ClickListener
    {
        private static final String HIDDEN_PARENT_ID_PREFIX = "DIHI_";
        private static final String DISPLAY_PARENT_ID_PREFIX = "DIVI_";

        private static final String TRANSPARENT_SPACER =
                "<img width='1' height='1' src='" + TransparentImage.URL + "'>";

        private OurImage mHiddenImage = new OurImage( TransparentImage.URL );
        private OurImage mDisplayImage = new OurImage( TransparentImage.URL );
        private Element mInnerTD;
        private String mTitle = "";
        private Command mClickCommand = null;
        private String mPendingURL = null;

        public MyHtmlPanel( int zUniqueID )
        {
            super( "<table cellpadding='0' cellspacing='0' border='0'>" + //
                   /**/"<tr>" + //
                   /*  */"<td colspan='3' class='litesoft-DualImageInnerBorder'>" + //
                   /*    */"<div id='" + HIDDEN_PARENT_ID_PREFIX + zUniqueID + "' style='height:1px; width:1px; overflow:hidden;'>" +
                   /*            */TRANSPARENT_SPACER + "<br>" + //
                   /*    */"</div>" + //
                   /*  */"</td>" + //
                   /**/"</tr>" + //
                   /**/"<tr>" + //
                   /*  */"<td class='litesoft-DualImageInnerBorder'>" + TRANSPARENT_SPACER + "</td>" + //
                   /*  */"<td class='litesoft-DualImageBG' align='center' valign='middle' id='" + DISPLAY_PARENT_ID_PREFIX + zUniqueID + "'></td>" + //
                   /*  */"<td class='litesoft-DualImageInnerBorder'>" + TRANSPARENT_SPACER + "</td>" + //
                   /**/"</tr>" + //
                   /**/"<tr>" + //
                   /*  */"<td colspan='3' class='litesoft-DualImageInnerBorder'>" + TRANSPARENT_SPACER + "</td>" +
                   /**/"</tr>" + //
                   "</table>" );

            add( mHiddenImage, HIDDEN_PARENT_ID_PREFIX + zUniqueID );
            add( mDisplayImage, DISPLAY_PARENT_ID_PREFIX + zUniqueID );

            mInnerTD = DOM.getParent( mDisplayImage.getElement() );

            mHiddenImage.addLoadListener( this );
            mDisplayImage.addClickListener( this );
        }

        public void onClick( Widget sender )
        {
            if ( mClickCommand != null )
            {
                mClickCommand.execute();
            }
        }

        public Element getInnerTD()
        {
            return mInnerTD;
        }

        public Image getHiddenImage()
        {
            return mHiddenImage;
        }

        public Image getDisplayImage()
        {
            return mDisplayImage;
        }

        public void setUrl( String pUrl, String pTitle, Command pClickCommand )
        {
            if ( null != (pUrl = UtilsCommon.noEmpty( pUrl )) )
            {
                mTitle = UtilsCommon.deNull( pTitle );
                mClickCommand = pClickCommand;
                String zCurrentHiddenUrl = mHiddenImage.getUrl();
                if ( pUrl.equals( zCurrentHiddenUrl ) )
                {
                    mDisplayImage.setTitle( mTitle );
                }
                else if ( isAttached() )
                {
                    LLsetURL( pUrl );
                }
                else
                {
                    mPendingURL = pUrl;
                }
            }
        }

        protected void onAttach()
        {
            super.onAttach();
            if ( mPendingURL != null )
            {
                String zURL = mPendingURL;
                mPendingURL = null;
                LLsetURL( zURL );
            }
        }

        private void LLsetURL( String pUrl )
        {
            LOGGER.info.log( "Loading: ", pUrl );
            setLoading();
            // Eliminate the "magic" width & height that IE somehow added!
            DOM.removeElementAttribute( mHiddenImage.getElement(), "width" );
            DOM.removeElementAttribute( mHiddenImage.getElement(), "height" );
            mHiddenImage.setUrl( pUrl );
        }

        public void setImageSize( int pWidthPixels, int pHeightPixels )
        {
            setContainerWidth( pWidthPixels );
            setContainerHeight( pHeightPixels );
        }

        private int getContainerHeight()
        {
            return DOM.getElementPropertyInt( mInnerTD, "height" );
        }

        public void setContainerHeight( int pHeightPixels )
        {
            DOM.setElementPropertyInt( mInnerTD, "height", pHeightPixels );
        }

        private int getContainerWidth()
        {
            return DOM.getElementPropertyInt( mInnerTD, "width" );
        }

        public void setContainerWidth( int pWidthPixels )
        {
            DOM.setElementPropertyInt( mInnerTD, "width", pWidthPixels );
        }

        public void setWidth( String pWidth )
        {
            int zNewSize = parse( "Width", pWidth );
            int zCurImageSize = mDisplayImage.getWidth();
            int zCurContainerSize = getContainerWidth();
            if ( zNewSize != zCurContainerSize )
            {
                if ( zNewSize < zCurImageSize )
                {
                    mDisplayImage.setWidth( zNewSize );
                }
                setContainerWidth( zNewSize );
                reScale();
            }
        }

        public void setHeight( String pHeight )
        {
            int zNewSize = parse( "Height", pHeight );
            int zCurImageSize = mDisplayImage.getHeight();
            int zCurContainerSize = getContainerHeight();
            if ( zNewSize != zCurContainerSize )
            {
                if ( zNewSize < zCurImageSize )
                {
                    mDisplayImage.setHeight( zNewSize );
                }
                setContainerHeight( zNewSize );
                reScale();
            }
        }

        private int parse( String pWhat, String pValue )
        {
            try
            {
                return AbstractSizeableWidget.parse( pValue );
            }
            catch ( NumberFormatException e )
            {
                throw new IllegalArgumentException(
                        "Attempt to set" + pWhat + "( \"" + pValue + "\" ) on " + getClass().getName() );
            }
        }

        private void reScale()
        {
            if ( mLoaded )
            {
                int zCurImageWidth = mHiddenImage.getOffsetWidth();
                int zCurImageHeight = mHiddenImage.getOffsetHeight();

                if ( (zCurImageHeight == 1) && (zCurImageWidth == 1) )
                {
                    LOGGER.warn.log( "Hidden Image still reporting 1x1" );
                    TimedRunnableManager.INSTANCE.runIn( new TimedRunnable()
                    {
                        public Again runOnce()
                        {
                            reScale();
                            return null;
                        }
                    }, 50 );
                }

                int zCurContainerWidth = getContainerWidth();
                int zCurContainerHeight = getContainerHeight();
                float zFactorWidth = (1.0f * zCurContainerWidth) / zCurImageWidth;
                float zFactorHeight = (1.0f * zCurContainerHeight) / zCurImageHeight;
                float zFactor = Math.min( zFactorWidth, zFactorHeight );
                int zNewWidth = (int) (zFactor * zCurImageWidth);
                int zNewHeight = (int) (zFactor * zCurImageHeight);
                mDisplayImage.setWidth( zNewWidth );
                mDisplayImage.setHeight( zNewHeight );

                //                System.out.println( "reScale:\n" + //
                ////                Window.alert( //
                //                mHiddenImage.getUrl() + "\n" + //
                //                "zCurImageWidth=" + zCurImageWidth + "\n"+ //
                //                "zCurImageHeight=" + zCurImageHeight + "\n"+ //
                ////                "zCurContainerWidth=" + zCurContainerWidth + "\n"+ //
                ////                "zCurContainerHeight=" + zCurContainerHeight + "\n"+ //
                ////                "zFactorWidth=" + zFactorWidth + "\n"+ //
                ////                "zFactorHeight=" + zFactorHeight + "\n"+ //
                //                "zFactor=" + zFactor + "\n"+ //
                //                "zNewWidth=" + zNewWidth + "\n"+ //
                //                "zNewHeight=" + zNewHeight + "\n"+ //
                ////                "mDisplayImage.getWidth()=" + mDisplayImage.getWidth() + "\n"+ //
                ////                "mDisplayImage.getHeight()=" + mDisplayImage.getHeight() + "\n"+ //
                ////                "mDisplayImage.getOffsetWidth()=" + mDisplayImage.getOffsetWidth() + "\n"+ //
                ////                "mDisplayImage.getOffsetHeight()=" + mDisplayImage.getOffsetHeight() + "\n"+ //
                //                "" );

                String zHiddenUrl = mHiddenImage.getUrl();
                if ( !UtilsCommon.areNonArraysEqual( zHiddenUrl, mDisplayImage.getUrl() ) )
                {
                    mDisplayImage.setUrl( zHiddenUrl );
                }
            }
        }

        private boolean mLoaded = false;

        private void setLoading()
        {
            mLoaded = false;
        }

        private void setLoaded()
        {
            if ( !mLoaded )
            {
                mLoaded = true;
                reScale();
                mDisplayImage.setTitle( mTitle );
            }
        }

        public void onError( Widget sender )
        {
            String zNotFound = "Not found: " + mHiddenImage.getUrl();
            LOGGER.error.log( zNotFound );
            setUrl( IMAGE_LOAD_ERROR, zNotFound, null );
        }

        public void onLoad( Widget sender )
        {
            LOGGER.info.log( "Loaded: ", mHiddenImage.getUrl() );
            setLoaded();
        }
    }
}