package org.litesoft.mgwt.client.pavsupport;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.pavsupport.*;
import org.litesoft.commonfoundation.annotations.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.core.util.*;
import org.litesoft.core.util.externalization.*;
import org.litesoft.mgwt.client.*;
import org.litesoft.mgwt.client.widgets.Button;
import org.litesoft.mgwt.client.widgets.*;

import com.google.gwt.dom.client.*;
import com.google.gwt.event.logical.shared.*;
import com.google.gwt.safehtml.shared.*;
import com.google.gwt.user.client.*;
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.ButtonBase;
import com.googlecode.mgwt.ui.client.widget.base.*;
import com.googlecode.mgwt.ui.client.widget.buttonbar.*;

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";
    public static final String BUTTON_TEXT_DONE = "Done";
    public static final String BUTTON_TEXT_ABOUT = "About";

    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()
    {
        main.getElement().setId( mClassName );

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

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

        if ( !(this instanceof RootView) && MGWT.getOsDetection().isIOs() )
        {
            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( @NotNull String pTitleCode )
    {
        title.setHTML( getResolver().resolve( Strings.noEmpty( pTitleCode, "NoHeaderTitle" ) ) );
    }

    protected <T extends Widget> T setContent( @NotNull T 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 );
        return pWidget;
    }

    // "Forward" Header Buttons

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

    protected HeaderButton setForwardButton( @NotNull String pName, @Nullable Command pOnTapCommand )
    {
        return add( setForwardButton( pName ), pOnTapCommand );
    }

    // Common Content Types

    protected Panel createContentFlowPanel( @Nullable Widget... pWidgets )
    {
        FlowPanel zPanel = new FlowPanel();
        zPanel.getElement().getStyle().setMarginTop( 20, Style.Unit.PX );
        return setContent( addTo( zPanel, pWidgets ) );
    }

    protected Panel createContentRoundPanel( @Nullable Widget... pWidgets )
    {
        return setContent( addTo( new RoundPanel(), pWidgets ) );
    }

    protected <T> OptionList<T> createContentOptionList( @Nullable SelectedListener<T> pSelectedListener )
    {
        return setContent( new OptionList<T>( getResolver(), pSelectedListener ) );
    }

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

    // ButtonBar

    protected ButtonBar addButtonBar( @Nullable Widget... pWidgets )
    {
        ButtonBar zButtonBar = new ButtonBar();
        addTo( zButtonBar, pWidgets );
        main.add( zButtonBar );
        return zButtonBar;
    }

    protected ButtonBarText createButtonBarText()
    {
        return new ButtonBarText( getResolver().resolve( "ButtonBarText" ) );
    }

    protected ButtonBarSpacer createButtonBarSpacer()
    {
        return new ButtonBarSpacer();
    }

    // Non-Header Buttons

    protected Button addButton( @NotNull HasWidgets pContainer, @NotNull String pLabelTextCode, @Nullable Command pOnTapCommand )
    {
        Button zButton = createButton( pLabelTextCode, pOnTapCommand );
        pContainer.add( zButton );
        return zButton;
    }

    protected Button createButton( @NotNull String pLabelTextCode, @Nullable Command pOnTapCommand )
    {
        return add( new Button( getResolver().resolve( Strings.assertNotNullNotEmpty( "Label Text Code", pLabelTextCode ) + "Button" ) ), pOnTapCommand );
    }

    protected TrashButton createButtonTrash( @Nullable Command pOnTapCommand )
    {
        return add( new TrashButton(), pOnTapCommand );
    }

    protected CameraButton createButtonCamera( @Nullable Command pOnTapCommand )
    {
        return add( new CameraButton(), pOnTapCommand );
    }

    protected ActionButton createButtonAction( @Nullable Command pOnTapCommand )
    {
        return add( new ActionButton(), pOnTapCommand );
    }

    protected ArrowDownButton createButtonArrowDown( @Nullable Command pOnTapCommand )
    {
        return add( new ArrowDownButton(), pOnTapCommand );
    }

    protected ArrowUpButton createButtonArrowUp( @Nullable Command pOnTapCommand )
    {
        return add( new ArrowUpButton(), pOnTapCommand );
    }

    protected ArrowLeftButton createButtonArrowLeft( @Nullable Command pOnTapCommand )
    {
        return add( new ArrowLeftButton(), pOnTapCommand );
    }

    protected ArrowRightButton createButtonArrowRight( @Nullable Command pOnTapCommand )
    {
        return add( new ArrowRightButton(), pOnTapCommand );
    }

    protected BookmarkButton createButtonBookmark( @Nullable Command pOnTapCommand )
    {
        return add( new BookmarkButton(), pOnTapCommand );
    }

    protected ComposeButton createButtonCompose( @Nullable Command pOnTapCommand )
    {
        return add( new ComposeButton(), pOnTapCommand );
    }

    protected FastForwardButton createButtonFastForward( @Nullable Command pOnTapCommand )
    {
        return add( new FastForwardButton(), pOnTapCommand );
    }

    protected InfoButton createButtonInfo( @Nullable Command pOnTapCommand )
    {
        return add( new InfoButton(), pOnTapCommand );
    }

    protected LocateButton createButtonLocate( @Nullable Command pOnTapCommand )
    {
        return add( new LocateButton(), pOnTapCommand );
    }

    protected NewIconButton createButtonNewIcon( @Nullable Command pOnTapCommand )
    {
        return add( new NewIconButton(), pOnTapCommand );
    }

    protected NextSlideButton createButtonNextSlide( @Nullable Command pOnTapCommand )
    {
        return add( new NextSlideButton(), pOnTapCommand );
    }

    protected OrganizeButton createButtonOrganize( @Nullable Command pOnTapCommand )
    {
        return add( new OrganizeButton(), pOnTapCommand );
    }

    protected PauseButton createButtonPause( @Nullable Command pOnTapCommand )
    {
        return add( new PauseButton(), pOnTapCommand );
    }

    protected PlayButton createButtonPlay( @Nullable Command pOnTapCommand )
    {
        return add( new PlayButton(), pOnTapCommand );
    }

    protected PlusButton createButtonPlus( @Nullable Command pOnTapCommand )
    {
        return add( new PlusButton(), pOnTapCommand );
    }

    protected PreviousSlideButton createButtonPreviousSlide( @Nullable Command pOnTapCommand )
    {
        return add( new PreviousSlideButton(), pOnTapCommand );
    }

    protected ReplyButton createButtonReply( @Nullable Command pOnTapCommand )
    {
        return add( new ReplyButton(), pOnTapCommand );
    }

    protected RewindButton createButtonRewind( @Nullable Command pOnTapCommand )
    {
        return add( new RewindButton(), pOnTapCommand );
    }

    protected SearchButton createButtonSearch( @Nullable Command pOnTapCommand )
    {
        return add( new SearchButton(), pOnTapCommand );
    }

    protected StopButton createButtonStop( @Nullable Command pOnTapCommand )
    {
        return add( new StopButton(), pOnTapCommand );
    }

    // FlowPanel Widgets

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

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

        return addTo( zList, pWidgets );
    }

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

    protected HTML createLabel( @NotNull E13nData pE13nData )
    {
        return createLabel( makeSafeHtml( getResolver().resolve( Objects.assertNotNull( "Label E13nData", pE13nData ) ) ) );
    }

    protected HTML createLabel( @NotNull String pLabelTextCode )
    {
        return createLabel( makeSafeHtml( getResolver().resolve( Strings.assertNotNullNotEmpty( "Label Text Code", pLabelTextCode ) ) ) );
    }

    protected HTML createLabel( @NotNull SafeHtml pSafeHtml )
    {
        return new HTML( Objects.assertNotNull( "Label SafeHtml", pSafeHtml ) );
    }

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

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

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

    protected <T> RadioGroup<T> createInputRadioGroup( @Nullable SelectedListener<T> pSelectedListener )
    {
        return new RadioGroup<T>( getResolver(), pSelectedListener );
    }

    protected MRadioButton createInputRadioButton( @NotNull String pLabelTextCode, @Nullable ValueChangeHandler<Boolean> pChangeHandler )
    {
        return createInputRadioButton( HTMLPanel.createUniqueId(), pLabelTextCode, pChangeHandler );
    }

    protected MRadioButton createInputRadioButton( @NotNull String pGroupID, @NotNull String pLabelTextCode, @Nullable ValueChangeHandler<Boolean> pChangeHandler )
    {
        MRadioButton zRB = new MRadioButton( pGroupID );
        zRB.setText( getResolver().resolve( Strings.assertNotNullNotEmpty( "Label Text Code", pLabelTextCode ) ) );
        return add( zRB, pChangeHandler );
    }

    protected <T> OptionListBox<T> createInputOptionListBox( @Nullable List<T> pOptions, @Nullable SelectedListener<T> pSelectedListener )
    {
        return createInputOptionListBox( pSelectedListener ).options( pOptions );
    }

    protected <T> OptionListBox<T> createInputOptionListBox( @Nullable SelectedListener<T> pSelectedListener, @Nullable T... pOptions )
    {
        return createInputOptionListBox( pSelectedListener ).options( pOptions );
    }

    protected <T> OptionListBox<T> createInputOptionListBox( @Nullable T... pOptions )
    {
        return new OptionListBox<T>( getResolver() ).options( pOptions );
    }

    protected <T> OptionListBox<T> createInputOptionListBox( @Nullable SelectedListener<T> pSelectedListener )
    {
        return new OptionListBox<T>( getResolver(), pSelectedListener );
    }

    protected MLabeledCheckBox createInputLabeledCheckBox( @NotNull String pLabelTextCode, @Nullable ValueChangeHandler<Boolean> pChangeHandler )
    {
        return add( new MLabeledCheckBox( getResolver().resolve( Strings.assertNotNullNotEmpty( "Label Text Code", pLabelTextCode ) ) ), pChangeHandler );
    }

    protected MCheckBox createInputCheckBox( @Nullable ValueChangeHandler<Boolean> pChangeHandler )
    {
        return add( new MCheckBox(), pChangeHandler );
    }

    protected MCheckBox createInputCheckBoxImportant( @Nullable ValueChangeHandler<Boolean> pChangeHandler )
    {
        MCheckBox zCheckBox = new MCheckBox();
        zCheckBox.setImportant( true );
        return add( zCheckBox, pChangeHandler );
    }

    protected MTextArea createInputTextArea( @Nullable ValueChangeHandler<String> pChangeHandler )
    {
        return add( new MTextArea(), pChangeHandler );
    }

    protected MTextBox createInputTextBox( @Nullable ValueChangeHandler<String> pChangeHandler )
    {
        return add( new MTextBox(), pChangeHandler );
    }

    protected MPasswordTextBox createInputPasswordTextBox( @Nullable ValueChangeHandler<String> pChangeHandler )
    {
        return add( new MPasswordTextBox(), pChangeHandler );
    }

    protected MPhoneNumberTextBox createInputPhoneNumberTextBox( @Nullable ValueChangeHandler<String> pChangeHandler )
    {
        return add( new MPhoneNumberTextBox(), pChangeHandler );
    }

    protected MUrlTextBox createInputUrlTextBox( @Nullable ValueChangeHandler<String> pChangeHandler )
    {
        return add( new MUrlTextBox(), pChangeHandler );
    }

    protected MEmailTextBox createInputEmailTextBox( @Nullable ValueChangeHandler<String> pChangeHandler )
    {
        return add( new MEmailTextBox(), pChangeHandler );
    }

    protected MNumberTextBox createInputNumberTextBox( @Nullable ValueChangeHandler<String> pChangeHandler )
    {
        return add( new MNumberTextBox(), pChangeHandler );
    }

    protected MDateBox createInputDateBox( @Nullable ValueChangeHandler<Date> pChangeHandler )
    {
        return add( new MDateBox(), pChangeHandler );
    }

    // Error "Alert" Dialogs

    @Override
    public void showError( @NotNull String pTitleCode, @NotNull String pErrorCode )
    {
        alert( pTitleCode, getResolver().resolve( Strings.assertNotNullNotEmpty( "Error Code", pErrorCode ) ), null );
    }

    @Override
    public void showError( @NotNull String pTitleCode, @NotNull E13nData pErrorData )
    {
        alert( pTitleCode, getResolver().resolve( Objects.assertNotNull( "Error Data", pErrorData ) ), null );
    }

    // Dialogs

    protected void alert( @NotNull String pWhatCode, @Nullable DialogCloseCallBack pCallBack )
    {
        pWhatCode = Strings.assertNotNullNotEmpty( "What Code", pWhatCode );
        alert( pWhatCode, resolveDialogBody( pWhatCode ), pCallBack );
    }

    private void alert( @NotNull String pTitleCode, String pBody, @Nullable 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( @NotNull String pWhatCode, @Nullable final ConfirmCallBack pCallBack )
    {
        pWhatCode = Strings.assertNotNullNotEmpty( "What Code", pWhatCode );
        confirm( pWhatCode, resolveDialogBody( pWhatCode ), pCallBack );
    }

    private void confirm( @NotNull String pTitleCode, String pBody, @Nullable 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( @NotNull T... pOptions )
    {
        popUp( Arrays.asList( pOptions ), null );
    }

    protected <T> void popUp( @NotNull List<T> pOptions, @Nullable 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" );
    }

    private <V, T extends HasValue<V>> T add( T pHasValueHandler, ValueChangeHandler<V> pChangeHandler )
    {
        if ( pChangeHandler != null )
        {
            pHasValueHandler.addValueChangeHandler( pChangeHandler );
        }
        return pHasValueHandler;
    }

    private <T extends ButtonBase> T add( T pButton, Command pOnTapCommand )
    {
        if ( pOnTapCommand != null )
        {
            pButton.addTapHandler( new CommandTapHandler( pOnTapCommand ) );
        }
        return pButton;
    }
}