package org.litesoft.mgwt.client.pavsupport;

import java.util.*;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.pavsupport.*;
import org.litesoft.core.util.*;
import org.litesoft.core.util.externalization.*;
import org.litesoft.mgwt.client.Button;
import org.litesoft.mgwt.client.*;

import com.google.gwt.dom.client.*;
import com.google.gwt.safehtml.shared.*;
import com.google.gwt.user.client.ui.*;
import com.googlecode.mgwt.dom.client.event.tap.*;
import com.googlecode.mgwt.ui.client.*;
import com.googlecode.mgwt.ui.client.dialog.*;
import com.googlecode.mgwt.ui.client.dialog.ConfirmDialog;
import com.googlecode.mgwt.ui.client.widget.*;
import com.googlecode.mgwt.ui.client.widget.HeaderPanel;
import com.googlecode.mgwt.ui.client.widget.LayoutPanel;
import com.googlecode.mgwt.ui.client.widget.ScrollPanel;
import com.googlecode.mgwt.ui.client.widget.base.*;

public abstract class AbstractBackableViewImpl<Presenter extends AbstractBackablePresenter> extends AbstractViewImpl<Presenter> implements AbstractBackableView<Presenter>
{
    public static final String BUTTON_TEXT_OK = "Ok";
    public static final String BUTTON_TEXT_CANCEL = "Cancel";

    protected final LayoutPanel main = new LayoutPanel();
    protected final ScrollPanel scrollPanel = new ScrollPanel();
    protected final HeaderPanel headerPanel = new HeaderPanel();
    protected final HTML title = new HTML();
    protected final HeaderButton headerBackButton = new HeaderButton();

    public AbstractBackableViewImpl( E13nResolver pResolver )
    {
        super( pResolver );

        main.getElement().setId( mClassName );

        main.add( headerPanel );
        main.add( scrollPanel );

        headerPanel.setCenterWidget( title );
        setTitleCode( "Title" );

        if ( !(this instanceof RootView) && MGWT.getOsDetection().isPhone() )
        {
            headerPanel.setLeftWidget( headerBackButton );
            headerBackButton.setBackButton( true );
            headerBackButton.addTapHandler( new TapHandler()
            {
                @Override
                public void onTap( TapEvent event )
                {
                    mPresenter.goBack();
                }
            } );
            headerBackButton.setText( getResolver().resolve( "BackButton" ) );
        }
    }

    @Override
    public final Widget asWidget()
    {
        return main;
    }

    @Override
    public final String getTitleText()
    {
        return title.getText();
    }

    @Override
    public final void setTitleCode( String pTitleCode )
    {
        title.setText( getResolver().resolve( UtilsCommon.noEmpty( pTitleCode, "NoHeaderTitle" ) ) );
    }

    protected void setContent( Widget pWidget )
    {
        scrollPanel.setWidget( pWidget );
        scrollPanel.setScrollingEnabledX( false );
        // workaround for android formfields jumping around when using
        // -webkit-transform
        scrollPanel.setUsePos( MGWT.getOsDetection().isAndroid() );

        ChromeWorkaround.maybeUpdateScroller( scrollPanel );
    }

    // "Forward" Header Buttons

    protected HeaderButton setForwardButton( String pName )
    {
        HeaderButton zHeaderButton = new HeaderButton();
        headerPanel.setRightWidget( zHeaderButton );
        zHeaderButton.setText( getResolver().resolve( UtilsCommon.assertNotNullNotEmpty( "Forward Button Name", pName ) + "ForwardButton" ) );
        zHeaderButton.setForwardButton( true );
        return zHeaderButton;
    }

    protected HeaderButton setForwardButton( String pName, TapHandler pHandler )
    {
        HeaderButton zHeaderButton = setForwardButton( pName );
        if ( pHandler != null )
        {
            zHeaderButton.addTapHandler( pHandler );
        }
        return zHeaderButton;
    }

    // Common Content Types

    protected Panel createContentFlowPanel( Widget... pWidgets )
    {
        FlowPanel zPanel = new FlowPanel();
        zPanel.getElement().getStyle().setMarginTop( 20, Style.Unit.PX );

        setContent( zPanel );

        return addTo( zPanel, pWidgets );
    }

    protected Panel createContentRoundPanel( Widget... pWidgets )
    {
        Panel zPanel = new RoundPanel();

        setContent( zPanel );

        return addTo( zPanel, pWidgets );
    }

    protected <T> OptionList<T> createContentOptionList( final SelectedListener<T> pSelectedListener )
    {
        OptionList<T> zList = new OptionList<T>( getResolver(), pSelectedListener );

        setContent( zList );

        return zList;
    }

    protected <T> OptionList<T> createContentOptionList()
    {
        return createContentOptionList( null );
    }

    // Non-Header Buttons

    protected Button createButton( String pLabelTextCode, TapHandler pTapHandler )
    {
        Button zButton = new Button( getResolver().resolve( UtilsCommon.assertNotNullNotEmpty( "Label Text Code", pLabelTextCode ) + "Button" ) );
        if ( pTapHandler != null )
        {
            zButton.addTapHandler( pTapHandler );
        }
        return zButton;
    }

    protected Button addButton( HasWidgets pContainer, String pLabelTextCode, TapHandler pTapHandler )
    {
        Button zButton = createButton( pLabelTextCode, pTapHandler );
        pContainer.add( zButton );
        return zButton;
    }

    // FlowPanel Widgets

    protected Widget createListHeader( String pHeaderTextCode )
    {
        HTML header = new HTML( getResolver().resolve( UtilsCommon.assertNotNullNotEmpty( "Header Text Code", pHeaderTextCode ) ) );
        header.addStyleName( MGWTStyle.getTheme().getMGWTClientBundle().getListCss().listHeader() );
        return header;
    }

    protected WidgetList createRoundWidgetList( Widget... pWidgets )
    {
        WidgetList zList = new WidgetList();
        zList.setRound( true );

        return addTo( zList, pWidgets );
    }

    protected <T extends HasWidgets> T addTo( T pPanel, Widget... pWidgets )
    {
        if ( pWidgets != null )
        {
            for ( Widget zWidget : pWidgets )
            {
                if ( zWidget != null )
                {
                    pPanel.add( zWidget );
                }
            }
        }
        return pPanel;
    }

    protected Widget createLabel( E13nData pE13nData )
    {
        return createLabel( makeSafeHtml( getResolver().resolve( UtilsCommon.assertNotNull( "Label E13nData", pE13nData ) ) ) );
    }

    protected Widget createLabel( String pLabelTextCode )
    {
        return createLabel( makeSafeHtml( getResolver().resolve( UtilsCommon.assertNotNullNotEmpty( "Label Text Code", pLabelTextCode ) ) ) );
    }

    protected Widget createLabel( SafeHtml pSafeHtml )
    {
        return new HTML( UtilsCommon.assertNotNull( "Label SafeHtml", pSafeHtml ) );
    }

    protected SafeHtml makeSafeHtml( String pText )
    {
        return new OnlyToBeUsedInGeneratedCodeStringBlessedAsSafeHtml( HTMLize.escape( pText ) );
    }

    protected Widget withPlaceHolder( HasPlaceHolder pWidget, String pPlaceHolderTextCode )
    {
        pWidget.setPlaceHolder( getResolver().resolve( "PlaceHolder" + UtilsCommon.assertNotNullNotEmpty( "Place Holder Text Code", pPlaceHolderTextCode ) ) );
        return (Widget) pWidget;
    }

    protected Widget createFormListEntry( String pLabelTextCode, Widget pInputWidget )
    {
        return new FormListEntry( getResolver().resolve( UtilsCommon.assertNotNullNotEmpty( "Label Text Code", pLabelTextCode ) ), //
                                  UtilsCommon.assertNotNull( "InputWidget", pInputWidget ) );
    }

    // Dialogs

    protected void alert( String pWhatCode, final DialogCloseCallBack pCallBack )
    {
        pWhatCode = UtilsCommon.assertNotNullNotEmpty( "What Code", pWhatCode );
        alert( pWhatCode, resolveDialogBody( pWhatCode ), pCallBack );
    }

    private void alert( String pTitleCode, String pBody, final DialogCloseCallBack pCallBack )
    {
        AlertDialog zDialog = new AlertDialog( resolveDialogTitle( pTitleCode ), pBody, resolveDialogButton( BUTTON_TEXT_OK ) );

        if ( pCallBack != null )
        {
            zDialog.addTapHandler( new TapHandler()
            {
                @Override
                public void onTap( TapEvent event )
                {
                    pCallBack.dialogClosed();
                }
            } );
        }
        zDialog.show();
    }

    protected void confirm( String pWhatCode, final ConfirmCallBack pCallBack )
    {
        pWhatCode = UtilsCommon.assertNotNullNotEmpty( "What Code", pWhatCode );
        confirm( pWhatCode, resolveDialogBody( pWhatCode ), pCallBack );
    }

    private void confirm( String pTitleCode, String pBody, final ConfirmCallBack pCallBack )
    {
        ConfirmDialog.ConfirmCallback zCallBack = null;
        if ( pCallBack != null )
        {
            zCallBack = new ConfirmDialog.ConfirmCallback()
            {
                @Override
                public void onOk()
                {
                    pCallBack.confirmed( true );
                }

                @Override
                public void onCancel()
                {
                    pCallBack.confirmed( false );
                }
            };
        }
        ConfirmDialog zDialog = new ConfirmDialog( resolveDialogTitle( pTitleCode ), pBody, //
                                                   zCallBack, //
                                                   resolveDialogButton( BUTTON_TEXT_OK ), //
                                                   resolveDialogButton( BUTTON_TEXT_CANCEL ) );
        zDialog.show();
    }

    protected <T extends Runnable> void popUp( T... pOptions )
    {
        popUp( Arrays.asList( pOptions ), null );
    }

    protected <T> void popUp( List<T> pOptions, SelectedListener<T> pSelectedListener )
    {
        OptionsDialog zDialog = new OptionsDialog();

        int zNonNullCount = 0;
        for ( T zOption : pOptions )
        {
            if ( zOption != null )
            {
                zNonNullCount++;
                Button zButton = new Button( DisplayObject.resolve( getResolver(), "PopUpButton", zOption ) );
                if ( zOption instanceof ButtonTypeAccessor )
                {
                    zButton.of( ((ButtonTypeAccessor) zOption).getButtonType() );
                }
                zButton.addTapHandler( new InternalTouchHandler<T>( zDialog, zOption, pSelectedListener ) );
                zDialog.add( zButton );
                if ( (pSelectedListener == null) && !(zOption instanceof Runnable) )
                {
                    throw new IllegalStateException( "popUp requested with no way to trigger behavior on Option: " + zOption );
                }
            }
        }
        if ( zNonNullCount == 0 )
        {
            throw new IllegalStateException( "popUp requested with no Options!" );
        }
        zDialog.setPanelToOverlay( main );
        zDialog.show();
    }

    private static class InternalTouchHandler<T> implements TapHandler
    {
        private final OptionsDialog mPanel;
        private final T mOption;
        private final SelectedListener<T> mSelectedListener;

        public InternalTouchHandler( OptionsDialog pPanel, T pOption, SelectedListener<T> pSelectedListener )
        {
            mPanel = pPanel;
            mOption = pOption;
            mSelectedListener = pSelectedListener;
        }

        @Override
        public void onTap( TapEvent event )
        {
            mPanel.hide();
            if ( mOption instanceof Runnable )
            {
                ((Runnable) mOption).run();
            }
            else
            {
                mSelectedListener.selected( mOption );
            }
        }
    }

    private String resolveDialogTitle( String pTitleCode )
    {
        return getResolver().resolve( pTitleCode + "DialogTitle" );
    }

    private String resolveDialogBody( String pBodyCode )
    {
        return getResolver().resolve( pBodyCode + "DialogBody" );
    }

    private String resolveDialogButton( String pButtonCode )
    {
        return getResolver().resolve( pButtonCode + "DialogButton" );
    }
}