package org.litesoft.sandbox.infrastructure.client;

import java.util.*;

import org.litesoft.logger.*;
import org.litesoft.sandbox.anywhere.util.*;

import com.google.gwt.event.logical.shared.*;
import com.google.gwt.event.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> extends ActivityFactoryRegistry implements PlaceChanger
{
    private static Logger LOGGER = LoggerFactory.getLogger( PlaceActivityManager.class );

    private static final Activity NULL_ACTIVITY = new AbstractActivity()
    {
        @Override
        public void start( AcceptsOneWidget panel )
        {
        }
    };

    private final AcceptsOneWidget display;
    private final CommonActivityParam mCommonActivityParam;

    private final PlaceHistoryMapper mMapper;
    private final WindowClose mWindowClose;
    private final Historian mHistorian;
    private Place mCurrentPlace = Place.NOWHERE;
    private Place mPendingAsyncPlace;
    private Activity currentActivity = NULL_ACTIVITY;
    private boolean startingNext = false;

    public PlaceActivityManager( AcceptsOneWidget pPanel, PlaceHistoryMapper pMapper, WindowClose pWindowClose, Historian pHistorian, CommonActivityParam pCommonActivityParam )
    {
        display = pPanel;
        mCommonActivityParam = (pCommonActivityParam != null) ? pCommonActivityParam : DefaultCommonActivityParam.<CommonActivityParam>createInstance();
        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 warning = maybeGoTo( Place.NOWHERE );
                if ( warning != null )
                {
                    event.setMessage( warning );
                }
            }
        } );
        mHistorian = (pHistorian != null) ? pHistorian : new HistorianImpl();
        mHistorian.addValueChangeHandler( new ValueChangeHandler<String>()
        {
            @Override
            public void onValueChange( ValueChangeEvent<String> event )
            {
                System.out.println( "PlaceActivityManager.onValueChange: " + event.getValue() ); // todo...
            }
        } );
    }

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

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

    /**
     * Handle the current history token. Typically called at application start, to
     * ensure bookmark launches work.
     */
    public void handleCurrentHistory()
    {
        handleHistoryToken( mHistorian.getToken() );
    }

    @Override
    public Place getWhere()
    {
        return mCurrentPlace;
    }

    @Override
    public GoToPlace goTo( Place pNewPlace )
    {
        return goTo( pNewPlace, false );
    }

    private GoToPlace goTo( Place pNewPlace, boolean pFromHistory )
    {
        if ( (pNewPlace == null) || pNewPlace.equals( mCurrentPlace ) )
        {
            return GoToPlace.AlreadyThere;
        }
        if ( pNewPlace.equals( mPendingAsyncPlace ) )
        {
            return null;
        }

        ActivityFactory zFactory = get( PlaceIdExtractor.getPlaceId( pNewPlace ) );
        if ( zFactory == null )
        {
            return GoToPlace.NoActivity;
        }

        String zWarning = maybeGoTo( pNewPlace );
        if ( zWarning != null && !mWindowClose.confirm( zWarning ) )
        {
            return GoToPlace.CurrentActivityRejectedLeaving; // todo: if from Code, then why didn't the code not allow it, if from History, then the URL no longer matches the View!!!
        }
        if ( zFactory instanceof ActivityFactory.Asynchronous ) // Un-Happy Case!
        {
            return LoadSyncFactory( (ActivityFactory.Asynchronous) zFactory, mPendingAsyncPlace = pNewPlace );
        }
        mPendingAsyncPlace = null;
        // todo: Historian?
        return justGo( pNewPlace, (ActivityFactory.Synchronous) zFactory );
    }

    private String maybeGoTo( Place newPlace )
    {
        return currentActivity.mayStop();
    }

    private void switchAsyncToSync( Place pPlace, ActivityFactory.Asynchronous pAsyncFactory, ActivityFactory.Synchronous pSyncFactory )
    {
        boolean zStillGoing = pPlace.equals( mPendingAsyncPlace );
        mPendingAsyncPlace = null;
        if ( replace( pAsyncFactory, pSyncFactory ) && zStillGoing )
        {
            justGo( pPlace, pSyncFactory );
        }
    }

    private GoToPlace justGo( Place pPlace, ActivityFactory.Synchronous pSyncFactory )
    {
        mCurrentPlace = pPlace;
        Activity zActivity = createActivity( pSyncFactory, pPlace );
        onPlaceChange( pPlace, zActivity );
        return null;
    }

    /**
     * Deactivate the current activity, find the next one from our ActivityMapper,
     * and start it.
     * <p/>
     * The current activity's widget will be hidden immediately, which can cause
     * flicker if the next activity provides its widget asynchronously. That can
     * be minimized by decent caching. Perenially slow activities might mitigate
     * this by providing a widget immediately, with some kind of "loading"
     * treatment.
     */
    private void onPlaceChange( Place pPlace, Activity nextActivity )
    {
        Throwable caughtOnStop = null;
        Throwable caughtOnCancel = null;
        Throwable caughtOnStart = null;

        if ( nextActivity == null )
        {
            nextActivity = NULL_ACTIVITY;
        }

        if ( currentActivity.equals( nextActivity ) )
        {
            return;
        }

        if ( startingNext )
        {
            // The place changed again before the new current activity showed its
            // widget
            caughtOnCancel = tryStopOrCancel( false );
            currentActivity = NULL_ACTIVITY;
            startingNext = false;
        }
        else if ( !currentActivity.equals( NULL_ACTIVITY ) )
        {
            showWidget( null );

            caughtOnStop = tryStopOrCancel( true );
        }

        currentActivity = nextActivity;

        if ( currentActivity.equals( NULL_ACTIVITY ) )
        {
            showWidget( null );
        }
        else
        {
            startingNext = true;
            caughtOnStart = tryStart();
        }

        if ( caughtOnStart != null || caughtOnCancel != null || caughtOnStop != null )
        {
            Set<Throwable> causes = new LinkedHashSet<Throwable>();
            if ( caughtOnStop != null )
            {
                causes.add( caughtOnStop );
            }
            if ( caughtOnCancel != null )
            {
                causes.add( caughtOnCancel );
            }
            if ( caughtOnStart != null )
            {
                causes.add( caughtOnStart );
            }

            throw new UmbrellaException( causes );
        }
    }

    private Throwable tryStopOrCancel( boolean stop )
    {
        Throwable caughtOnStop = null;
        try
        {
            if ( stop )
            {
                currentActivity.onStop();
            }
            else
            {
                currentActivity.onCancel();
            }
        }
        catch ( Throwable t )
        {
            caughtOnStop = t;
        }
        return caughtOnStop;
    }

    private Throwable tryStart()
    {
        Throwable caughtOnStart = null;
        try
        {
            /*
            * Wrap the actual display with a per-call instance that protects the
            * display from canceled or stopped activities, and which maintains our
            * startingNext state.
            */
            currentActivity.start( new ProtectedDisplay( currentActivity ) );
        }
        catch ( Throwable t )
        {
            caughtOnStart = t;
        }
        return caughtOnStart;
    }

    private void showWidget( IsWidget view )
    {
        if ( display != null )
        {
            display.setWidget( view );
        }
    }

    @SuppressWarnings({"unchecked"})
    private GoToPlace LoadSyncFactory( final ActivityFactory.Asynchronous pAsyncFactory, final Place pPlace )
    {
        pAsyncFactory.load( new ActivityFactory.Asynchronous.Callback<CommonActivityParam, IsWidget, Place>()
        {
            @Override
            public void loaded( ActivityFactory.Synchronous<CommonActivityParam, IsWidget, Place> pSynchronousFactory )
            {
                switchAsyncToSync( pPlace, pAsyncFactory, pSynchronousFactory );
            }
        } );
        return null;
    }

    protected String createMessage( String pPlaceId )
    {
        return "Unable to locate 'View' for '" + pPlaceId + "'";
    }

    @SuppressWarnings({"unchecked"})
    protected Activity createActivity( ActivityFactory.Synchronous pFactory, Place pPlace )
    {
        return pFactory.createActivity( mCommonActivityParam, pFactory.getView(), pPlace );
    }

    public Activity getActivity( Place pPlace )
    {
        String zPlaceId = PlaceIdExtractor.getPlaceId( pPlace );
        if ( zPlaceId != null )
        {
            ActivityFactory zFactory = get( zPlaceId );
            if ( zFactory instanceof ActivityFactory.Synchronous )
            {
                try
                {
                    return createActivity( (ActivityFactory.Synchronous) zFactory, pPlace );
                }
                catch ( RuntimeException e )
                {
                    String zMessage = createMessage( zPlaceId );
                    LOGGER.error.log( zMessage, ": ", pPlace.getClass().getName() );
                    mCommonActivityParam.getMessageUserSink().setErrorMessage( zMessage + "!" );
                    return null;
                }
            }
            if ( zFactory instanceof ActivityFactory.Asynchronous )
            {
                String zMessage = createMessage( zPlaceId );
                LOGGER.error.log( zMessage, " - ", zFactory.getClass().getName() );
                mCommonActivityParam.getMessageUserSink().setErrorMessage( zMessage + "?" );
                return null;
            }
            mCommonActivityParam.getMessageUserSink().setErrorMessage( createMessage( zPlaceId ) );
        }
        return null;
    }

    private void handleHistoryToken( String token )
    {
        Place newPlace = null;

        if ( null != (token = UtilsCommon.noEmpty( token )) )
        {
            try
            {
                if ( null == (newPlace = mMapper.getPlace( token )) )
                {
                    LOGGER.info.log( "Unrecognized history token: ", token );
                }
            }
            catch ( RuntimeException e )
            {
                LOGGER.warn.log( e, "Unable to parse history token: ", token );
            }
        }
        if ( newPlace == null )
        {
            newPlace = PlaceRegistry.getDefaultPlace();
        }
        goTo( newPlace, true );
    }

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

        @SuppressWarnings({"unchecked"})
        public static <CommonActivityParam extends MessageUserSinkAccessor> CommonActivityParam createInstance()
        {
            return (CommonActivityParam) new DefaultCommonActivityParam();
        }
    }

    /**
     * Wraps our real display to prevent an Activity from taking it over if it is
     * not the currentActivity.
     */
    private class ProtectedDisplay implements AcceptsOneWidget
    {
        private final Activity activity;

        ProtectedDisplay( Activity activity )
        {
            this.activity = activity;
        }

        @Override
        public void setWidget( IsWidget view )
        {
            if ( this.activity == currentActivity )
            {
                startingNext = false;
                showWidget( view );
            }
        }
    }
}