package org.litesoft.sandbox.infrastructure.client;

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

public class CopyPlaceHistoryHandler
{
    private final Historian historian;

    private final PlaceHistoryMapper mapper;

    private PlaceChanger mPlaceChanger;

    private Place defaultPlace = Place.NOWHERE;

    /**
     * Create a new PlaceHistoryHandler with a {@link HistorianImpl}. The
     * HistorianImpl is created via a call to GWT.create(), so an alternative
     * default implementation can be provided through <replace-with> rules
     * in a {@code gwt.xml} file.
     *
     * @param mapper a {@link PlaceHistoryMapper} instance
     */
    public CopyPlaceHistoryHandler( PlaceHistoryMapper mapper )
    {
        this( mapper, (Historian) GWT.create( HistorianImpl.class ) );
    }

    /**
     * Create a new PlaceHistoryHandler.
     *
     * @param mapper    a {@link PlaceHistoryMapper} instance
     * @param historian a {@link Historian} instance
     */
    public CopyPlaceHistoryHandler( PlaceHistoryMapper mapper, Historian historian )
    {
        this.mapper = mapper;
        this.historian = historian;
    }

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

    /**
     * Initialize this place history handler.
     *
     * @return a registration object to de-register the handler
     */
    public HandlerRegistration register( PlaceChanger pPlaceChanger, EventBus eventBus, Place defaultPlace )
    {
        this.mPlaceChanger = pPlaceChanger;
        this.defaultPlace = defaultPlace;

        final HandlerRegistration placeReg = eventBus.addHandler( PlaceChangeEvent.TYPE, new PlaceChangeEvent.Handler()
        {
            @Override public void onPlaceChange( PlaceChangeEvent event )
            {
                Place newPlace = event.getNewPlace();
                historian.newItem( tokenForPlace( newPlace ), false );
            }
        } );

        historian.addValueChangeHandler( new ValueChangeHandler<String>()
        {
            @Override public void onValueChange( ValueChangeEvent<String> event )
            {
                String token = event.getValue();
                handleHistoryToken( token );
            }
        } );

        return new HandlerRegistration()
        {
            @Override public void removeHandler()
            {
                CopyPlaceHistoryHandler.this.defaultPlace = Place.NOWHERE;
                CopyPlaceHistoryHandler.this.mPlaceChanger = null;
                placeReg.removeHandler();
            }
        };
    }

    private void handleHistoryToken( String token )
    {

        Place newPlace = null;

        if ( "".equals( token ) )
        {
            newPlace = defaultPlace;
        }

        if ( newPlace == null )
        {
            newPlace = mapper.getPlace( token );
        }

        if ( newPlace == null )
        {
//      log().warning("Unrecognized history token: " + token);
            newPlace = defaultPlace;
        }

        mPlaceChanger.goTo( newPlace );
    }

    private String tokenForPlace( Place newPlace )
    {
        if ( defaultPlace.equals( newPlace ) )
        {
            return "";
        }

        String token = mapper.getToken( newPlace );
        if ( token != null )
        {
            return token;
        }

//    log().warning("Place not mapped to a token: " + newPlace);
        return "";
    }
}