package org.litesoft.sandbox.infrastructure.client;

import org.litesoft.logger.*;

import com.google.gwt.activity.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 PlaceActivityMapper<CommonActivityParam extends MessageUserSinkAccessor> extends ActivityFactoryRegistry implements PlaceChanger,
                                                                                                                                 ActivityMapper
{
    private static Logger LOGGER = LoggerFactory.getLogger( PlaceActivityMapper.class );

    private final CommonActivityParam mCommonActivityParam;

    private final EventBus mEventBus;
    private final Delegate mDelegate;
    private Place mCurrentPlace = Place.NOWHERE;
    private Place mPendingAsyncPlace;

    public PlaceActivityMapper( EventBus pEventBus, Delegate pDelegate, CommonActivityParam pCommonActivityParam )
    {
        mCommonActivityParam = (pCommonActivityParam != null) ? pCommonActivityParam : DefaultCommonActivityParam.<CommonActivityParam>createInstance();
        mEventBus = pEventBus;
        mDelegate = (pDelegate != null) ? pDelegate : new DefaultDelegate();
        mDelegate.addWindowClosingHandler( new Window.ClosingHandler()
        {
            @Override
            public void onWindowClosing( Window.ClosingEvent event )
            {
                String warning = maybeGoTo( Place.NOWHERE );
                if ( warning != null )
                {
                    event.setMessage( warning );
                }
            }
        } );
    }

    public PlaceActivityMapper( EventBus pEventBus, CommonActivityParam pCommonActivityParam )
    {
        this( pEventBus, null, pCommonActivityParam );
    }

    public PlaceActivityMapper( EventBus pEventBus )
    {
        this( pEventBus, null, null );
    }

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

    @Override
    public GoToPlace goTo( Place pNewPlace )
    {
        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 && !mDelegate.confirm( zWarning ) )
        {
            return GoToPlace.CurrentActivityRejectedLeaving;
        }
        if ( zFactory instanceof ActivityFactory.Asynchronous ) // Un-Happy Case!
        {
            return LoadSyncFactory( (ActivityFactory.Asynchronous) zFactory, mPendingAsyncPlace = pNewPlace );
        }
        mPendingAsyncPlace = null;
        return justGo( pNewPlace );
    }

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

    private GoToPlace justGo( Place pPlace )
    {
        mCurrentPlace = pPlace;
        mEventBus.fireEvent( new PlaceChangeEvent( pPlace ) );
        return null;
    }

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

    @Override
    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 String maybeGoTo( Place newPlace )
    {
        PlaceChangeRequestEvent willChange = new PlaceChangeRequestEvent( newPlace );
        mEventBus.fireEvent( willChange );
        return willChange.getWarning();
    }

    /**
     * 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();
        }
    }

    /**
     * Default implementation of {@link Delegate}, based on {@link Window}.
     */
    private static class DefaultDelegate implements Delegate
    {
        @Override
        public HandlerRegistration addWindowClosingHandler( Window.ClosingHandler handler )
        {
            return Window.addWindowClosingHandler( handler );
        }

        @Override
        public boolean confirm( String message )
        {
            return Window.confirm( message );
        }
    }
}