package org.litesoft.sandbox.infrastructure.client;

import org.litesoft.logger.*;
import org.litesoft.sandbox.anywhere.util.*;
import org.litesoft.sandbox.infrastructure.client.internal.*;

import com.google.gwt.event.logical.shared.*;
import com.google.gwt.place.shared.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

public class PlaceActivityManager<CommonActivityParam extends CommonActivityParameter> implements PlaceChangerWithCurrentUrlSupport
{
    private static final Logger LOGGER = LoggerFactory.getLogger( PlaceActivityManager.class );

    private final PanelPlaceActivityHelper<CommonActivityParam> mActivityHelper;

    private final CommonActivityParam mCommonActivityParam;

    private final PlaceHistoryMapper mMapper;
    private final WindowClose mWindowClose;
    private final Historian mHistorian;
    private Place mPendingCodePlace;

    public PlaceActivityManager( AcceptsOneWidget pPanel, PlaceHistoryMapper pMapper, WindowClose pWindowClose, Historian pHistorian, CommonActivityParam pCommonActivityParam )
    {
        mCommonActivityParam = (pCommonActivityParam != null) ? pCommonActivityParam : createDefaultCommonActivityParam();
        mActivityHelper = new PanelPlaceActivityHelper<CommonActivityParam>( pPanel, mCommonActivityParam );
        mMapper = (pMapper != null) ? pMapper : new PlaceRegistry( mCommonActivityParam );
        mWindowClose = (pWindowClose != null) ? pWindowClose : new WindowCloseImpl();
        mWindowClose.addWindowClosingHandler( new Window.ClosingHandler()
        {
            @Override
            public void onWindowClosing( Window.ClosingEvent event )
            {
                String zWarning = getLeavingCurrentPlaceWarningText();
                if ( zWarning != null )
                {
                    event.setMessage( zWarning );
                }
            }
        } );
        mHistorian = (pHistorian != null) ? pHistorian : new HistorianImpl();
        mHistorian.addValueChangeHandler( new ValueChangeHandler<String>()
        {
            @Override
            public void onValueChange( ValueChangeEvent<String> event )
            {
                handleHistoryToken( event.getValue() );
            }
        } );
    }

    public PlaceActivityManager( AcceptsOneWidget pPanel, CommonActivityParam pCommonActivityParam )
    {
        this( pPanel, null, null, null, pCommonActivityParam );
    }

    public PlaceActivityManager( AcceptsOneWidget pPanel )
    {
        this( pPanel, null, null, null, null );
    }

    /**
     * Go to the Current URL (current history token).
     * <p/>
     * Typically called at application start, to ensure bookmark launches work.
     */
    @Override
    public void goToCurrentUrl()
    {
        handleHistoryToken( mHistorian.getToken() );
    }

    /**
     * Returns the current place.
     *
     * @return a {@link Place} instance
     */
    @Override
    public Place getWhere()
    {
        return mActivityHelper.getCurrentPlace();
    }

    /**
     * Request a change to a new place. It is not a given that we'll actually get
     * there. If there is an ActivityFactory for the Place, and the user does not
     * reject leaving the current Place, then the URL is adjusted to have the user
     * taken to the new place.
     *
     * @param pNewPlace a {@link Place} instance
     *
     * @return null if going to pNewPlace, !null means NOT going and why
     */
    @Override
    public GoToPlace goTo( Place pNewPlace )
    {
        Place zCurrentPlace = mActivityHelper.getCurrentPlace();
        pNewPlace = UtilsCommon.deNull( pNewPlace, zCurrentPlace );
        if ( pNewPlace.equals( zCurrentPlace ) )
        {
            return GoToPlace.AlreadyThere;
        }
        if ( pNewPlace.equals( mPendingCodePlace ) || mActivityHelper.isPendingAsync( pNewPlace ) )
        {
            return null;
        }
        if ( null == mActivityHelper.get( pNewPlace ) ) // Check for Factory
        {
            return GoToPlace.NoActivity;
        }
        if ( userRejectedLeavingCurrentPlace( pNewPlace ) )
        {
            return GoToPlace.CurrentActivityRejectedLeaving; // From Code, maybe the code shouldn't have allowed it!
        }
        mActivityHelper.clearPendingAsync();
        mPendingCodePlace = pNewPlace;
        mHistorian.newItem( mMapper.getToken( pNewPlace ), true );
        return null;
    }

    private void handleHistoryToken( String pToken )
    {
        Place zWasGoingToCodePlace = mPendingCodePlace;
        mPendingCodePlace = null;
        mCommonActivityParam.getMessageUserSink().clearMessage();

        Place zNewPlace = null;

        if ( null == (pToken = UtilsCommon.noEmpty( pToken )) )
        {
            zNewPlace = PlaceRegistry.getDefaultPlace();
        }
        else
        {
            try
            {
                if ( null == (zNewPlace = mMapper.getPlace( pToken )) )
                {
                    LOGGER.info.log( "Unrecognized history token: ", pToken );
                }
            }
            catch ( RuntimeException e )
            {
                LOGGER.warn.log( e, "Unable to parse history token: ", pToken );
            }
        }
        Place zCurrentPlace = mActivityHelper.getCurrentPlace();
        zNewPlace = UtilsCommon.deNull( zNewPlace, zCurrentPlace );
        if ( zNewPlace.equals( zCurrentPlace ) )
        {
            mActivityHelper.clearPendingAsync();
            return;
        }
        if ( (zWasGoingToCodePlace != null) && !zNewPlace.equals( zWasGoingToCodePlace ) && userWantsToStopUrlChange( zNewPlace ) )
        {
            mActivityHelper.clearPendingAsync();
            resetURLbackTo( zCurrentPlace );
            return;
        }
        if ( !mActivityHelper.activate( zNewPlace ) )
        {
            mCommonActivityParam.getMessageUserSink().setErrorMessage( "No Activity Factory for '" + UtilsCommon.justSimpleName( zNewPlace ) + "' from: " + pToken );
            resetURLbackTo( zCurrentPlace );
        }
    }

    protected boolean userWantsToStopUrlChange( Place pNewPlace )
    {
        return userRejectedLeavingCurrentPlace( pNewPlace );
    }

    protected void resetURLbackTo( Place pCurrentPlace )
    {
        mHistorian.newItem( mMapper.getToken( pCurrentPlace ), false ); // reset the URL back to the Current Place
    }

    protected boolean userRejectedLeavingCurrentPlace( Place newPlace )
    {
        String zWarning = getLeavingCurrentPlaceWarningText();
        return (zWarning != null) && !mWindowClose.confirm( zWarning );
    }

    protected String getLeavingCurrentPlaceWarningText()
    {
        return mActivityHelper.getCurrentActivityMayStop();
    }

    @SuppressWarnings({"unchecked"})
    protected CommonActivityParam createDefaultCommonActivityParam()
    {
        return (CommonActivityParam) new DefaultCommonActivityParam();
    }

    /**
     * Default implementation of CommonActivityParameter, based on {@link Window}.
     */
    private class DefaultCommonActivityParam implements CommonActivityParameter
    {
        @Override
        public MessageUserSink getMessageUserSink()
        {
            return DialogMessageUserSink.INSTANCE;
        }

        @Override
        public Place getWhere()
        {
            return PlaceActivityManager.this.getWhere();
        }

        @Override
        public GoToPlace goTo( Place pNewPlace )
        {
            return PlaceActivityManager.this.goTo( pNewPlace );
        }
    }
}