package org.litesoft.GWT.client.pavsupport;

import org.litesoft.GWT.client.historian.*;
import org.litesoft.GWT.client.pavsupport.internal.*;
import org.litesoft.GWT.client.util.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.logger.*;

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 );
    }

    public void add( PlaceChangeListener pPlaceChangeListener ) {
        mActivityHelper.add( pPlaceChangeListener );
    }

    /**
     * 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 the previous place on the browser's history stack.
     * If there is a previous place on the browser's history stack, the location
     * changes and a {@link PlaceChangeEvent} is posted announcing the previous place.
     */
    @Override
    public void goBack() {
        mActivityHelper.placeChangeRequested( null, PlaceChangeListener.Source.Back );
        mHistorian.back();
    }

    /**
     * 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 goForwardTo( Place pNewPlace ) {
        Place zCurrentPlace = mActivityHelper.getCurrentPlace();
        pNewPlace = Objects.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.placeChangeRequested( pNewPlace, PlaceChangeListener.Source.Forward );
        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 = Strings.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 = Objects.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 '" + ClassName.simple( 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
    }

    @SuppressWarnings("UnusedParameters")
    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 void goBack() {
            PlaceActivityManager.this.goBack();
        }

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