// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.forms.server;

import java.util.*;

import org.litesoft.GWT.eventbus.client.*;
import org.litesoft.GWT.forms.client.rpc.*;
import org.litesoft.GWT.forms.server.support.nonpublic.*;
import org.litesoft.*;
import org.litesoft.ui_1_5.*;
import org.litesoft.sequences.*;

public class FormServicePeerFactory implements FormComponentBusConstants
{
    public static final ExternalizationInterface DEFAULT_EXTERNALIZATION = DeCamelExternalization.INSTANCE;
    public static final FormAccessControlFactory DEFAULT_FAC_FACTORY = FormAccessControlFactory.NULL;
    public static final SequenceSource DEFAULT_SEQ_SRC = SequenceSource.NULL;
    public static final ISystemUserResolver DEFAULT_USER_RESOLVER = ISystemUserResolver.NULL;

    private static ExternalizationInterface sExternalization = DEFAULT_EXTERNALIZATION;
    private static FormAccessControlFactory sFACfactory = DEFAULT_FAC_FACTORY;
    private static SequenceSource sSeqSrcForUniqueFormID = DEFAULT_SEQ_SRC;
    private static ISystemUserResolver sSystemUserResolver = DEFAULT_USER_RESOLVER;

    public static ExternalizationInterface getExternalization()
    {
        return sExternalization;
    }

    public static void setExternalization( ExternalizationInterface pExternalization )
    {
        sExternalization = (pExternalization != null) ? pExternalization : DEFAULT_EXTERNALIZATION;
    }

    public static FormAccessControlFactory getFACfactory()
    {
        return sFACfactory;
    }

    public static void setFACfactory( FormAccessControlFactory pFACfactory )
    {
        sFACfactory = (pFACfactory != null) ? pFACfactory : DEFAULT_FAC_FACTORY;
    }

    public static SequenceSource getUniqueFormIdNumberSequenceSource()
    {
        return sSeqSrcForUniqueFormID;
    }

    public static void setUniqueFormIdNumberSequenceSource( SequenceSource pSequenceSource )
    {
        sSeqSrcForUniqueFormID = (pSequenceSource != null) ? pSequenceSource : DEFAULT_SEQ_SRC;
    }

    public static ISystemUserResolver getSystemUserResolver()
    {
        return sSystemUserResolver;
    }

    public static void setSystemUserResolver( ISystemUserResolver pSystemUserResolver )
    {
        sSystemUserResolver = (pSystemUserResolver != null) ? pSystemUserResolver : DEFAULT_USER_RESOLVER;
    }

    // Note use of Syncronized Map
    private static Map<String, Class<? extends FormServicePeer>> mServicePeers =
            new Hashtable<String, Class<? extends FormServicePeer>>();

    public static void add( String pFormServicePeerName,
                            Class<? extends FormServicePeer> pFormServicePeerClass )
    {
        mServicePeers.put( pFormServicePeerName, pFormServicePeerClass );
    }

    private static FormServicePeer createFormServicePeer( String pFormServicePeerName )
            throws UnsupportedOperationException
    {
        Class<? extends FormServicePeer> aClass = mServicePeers.get( pFormServicePeerName );
        if ( aClass != null )
        {
            try
            {
                return aClass.newInstance();
            }
            catch ( InstantiationException e )
            {
                throw new UnsupportedOperationException( "InstantiationException creating: " + aClass, e );
            }
            catch ( IllegalAccessException e )
            {
                throw new UnsupportedOperationException( "IllegalAccessException creating: " + aClass, e );
            }
        }
        throw new UnsupportedOperationException(
                "No FormServicePeer registered for : '" + pFormServicePeerName + "'" );
    }

    public static void addEventListenersForNewClient( EventSubscriptionCollector pCollector )
    {
        pCollector.subscribe( FormServicePeerFactory, new MyEventPackageListener() );
    }

    private static class MyEventPackageListener implements EventPackageListener
    {
        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            FormCreationRequestPackage zPackage = (FormCreationRequestPackage) pEventPackage;
            FormServicePeer peer;
            try
            {
                peer = createFormServicePeer( zPackage.getType() );
            }
            catch ( UnsupportedOperationException e )
            {
                FormServicePeer.LOGGER.error.log( e );
                pEventBus.publish( new FormCreationResponsePackage( zPackage.getTargetName(), //
                                                                    zPackage.getSourceName(), //
                                                                    e.getMessage() ) );
                return;
            }
            long zUniqueFormServicePeerID = sSeqSrcForUniqueFormID.getNextSequenceNumber( "UniqueFormServicePeerID" );
            new FormServicePeerPushInterfaceBusAdapter( pEventBus, peer, sSystemUserResolver, zUniqueFormServicePeerID,
                                                        zPackage, sExternalization, sFACfactory );
        }
    }
}