package org.litesoft.GWT.eventbus.server;

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

import org.litesoft.GWT.eventbus.client.*;
import org.litesoft.GWT.eventbus.client.eventpackages.*;
import org.litesoft.GWT.eventbus.client.nonpublic.*;
import org.litesoft.GWT.eventbus.client.rpc.*;
import org.litesoft.GWT.eventbus.server.nonpublic.*;
import org.litesoft.configuration.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.logger.*;
import org.litesoft.logger.nonpublic.*;
import org.litesoft.sequences.*;
import org.litesoft.ui_1_5.def.nonpublic.*;
import org.litesoft.ui_1_5.filtering.*;
import org.litesoft.util.*;
import org.litesoft.util.template.*;

import com.google.gwt.user.client.rpc.*;
import com.google.gwt.user.server.rpc.*;

public abstract class AbstractServerApp extends RemoteServiceServlet // don't forget this!
        implements EventBusRemoteService,  // don't forget this!
                   ConfigLoadedListener,
                   ThreadLocalContextFactory
{
    public static final String HINT_CATEGORY = "Configuration";

    protected static final String PLUS_OVERFLOW_HIDDEN = " overflow: hidden;";
    protected static final String BODY_STYLE_LESS_OVERFLOW = "border: none; padding: 0; margin: 0;";
    protected static final String FULL_BODY_STYLE = BODY_STYLE_LESS_OVERFLOW + PLUS_OVERFLOW_HIDDEN;

    protected static Logger getLogger()
    {
        Configuration.chkInstantiated();
        return ___NEVER_EVER_TO_USE_DIRECTLY_LOGGER_____USE_GetLogger_METHOD___;
    }

    private static final Logger ___NEVER_EVER_TO_USE_DIRECTLY_LOGGER_____USE_GetLogger_METHOD___ = LoggerFactory.getLogger( AbstractServerApp.class );

    private static boolean sOneTimeInitComplete = false;

    private static RuntimeException sOneTimeInitException = null;

    private Map<String, String> mClientConfig = new HashMap<String, String>();

    public void init()
            throws ServletException
    {
        super.init();
        synchronized ( AbstractServerApp.class )
        {
            if ( getOneTimeInitException() != null )
            {
                throw getOneTimeInitException();
            }
            if ( !isOneTimeInitComplete() )
            {
                oneTimeInit();
            }
        }
    }

    private static synchronized boolean isOneTimeInitComplete()
    {
        return sOneTimeInitComplete;
    }

    private static synchronized RuntimeException getOneTimeInitException()
    {
        return sOneTimeInitException;
    }

    private static synchronized void setOneTimeInitException( RuntimeException pOneTimeInitException )
    {
        sOneTimeInitException = pOneTimeInitException;
    }

    /**
     * Assumption is that this method will ALWAYS be called under synchronized( AbstractServerApp.class )!
     */
    protected void oneTimeInit()
    {
        System.err.println( new UtilDateAdaptor() + " | Application Server Start Up" );
        Configuration.add( this );
        try
        {
            FormQueryFilter.registerRehydrateFactories();
            initializeHintValidators();
            instantiateConfiguration();
            logConfigurationLoadingWarnings();
            getLogger().trace.log( "ClientConfig: ", mClientConfig );
            startUpApplication();
            logServletContextInitParameterNames();
            initComplete();
            System.err.println( new UtilDateAdaptor() + " | Application Server Start Up Complete" );
        }
        catch ( RuntimeException e )
        {
            setOneTimeInitException( e );
            throw e;
        }
        finally
        {
            sOneTimeInitComplete = true;
        }
    }

    private void logServletContextInitParameterNames()
    {
        if ( getLogger().info.isEnabled() )
        {
            Enumeration zParamNames = getServletContext().getInitParameterNames();
            while ( zParamNames.hasMoreElements() )
            {
                String zParamName = (String) zParamNames.nextElement();
                getLogger().info.log( "Context Param " + zParamName, " value is ", getServletContext().getInitParameter( zParamName ) );
            }
        }
    }

    protected void initializeHintValidators()
    {
        CommonHintValidators.register();
    }

    protected void addClientLoggingLevel( String pName, String pEffectiveLevel )
    {
        mClientConfig.put( LoggerLevel.CONFIGURATION_BASE + pName, pEffectiveLevel );
    }

    private void logConfigurationLoadingWarnings()
    {
        if ( !mConfigurationLoadingWarning.isEmpty() )
        {
            AbstractLogger logger = getLogger().warn;
            if ( logger.isEnabled() )
            {
                for ( String warning : mConfigurationLoadingWarning )
                {
                    logger.log( warning );
                }
            }
        }
    }

    private List<String> mConfigurationLoadingWarning = new ArrayList<String>();

    protected void addConfigurationLoadingWarning( String pWarning )
    {
        mConfigurationLoadingWarning.add( pWarning );
    }

    public void configurationJustLoaded()
    {
        loadClientConfigPath();

        String[] keys = Configuration.getAllKeys();
        for ( String key : keys )
        {
            if ( key.startsWith( LoggerLevel.CONFIGURATION_BASE ) )
            {
                mClientConfig.put( key, Configuration.getString( key ) );
            }
            else if ( key.startsWith( HintController.HINT_PROPERTY_PREFIX ) )
            {
                String zName = key.substring( HintController.HINT_PROPERTY_PREFIX.length() ).trim();
                if ( zName.length() == 0 )
                {
                    addConfigurationLoadingWarning( "Configuration has entry with nothing after '" + HintController.HINT_PROPERTY_PREFIX + "'" );
                }
                else
                {
                    String zValue = Configuration.getString( key );
                    String problem = HintController.validate( HINT_CATEGORY, null, zName, zValue );
                    if ( problem != null )
                    {
                        if ( problem.length() != 0 )
                        {
                            throw new IllegalStateException( "Unacceptable Configuration entry '" + key + "'='" + zValue + "':" + problem );
                        }
                        addConfigurationLoadingWarning( HintController.noValidatorText( HINT_CATEGORY, null, zName ) );
                    }
                    HintController.addGlobalHint( zName, zValue );
                }
            }
        }
    }

    protected void loadClientConfigPath()
    {
        File dir = ServerConfiguration.configFilesSubDirectoryByKey( "ClientConfigPath", null );
        if ( dir != null )
        {
            Properties prop = loadProperties( dir.getAbsolutePath() );
            if ( prop != null )
            {
                for ( Object key : prop.keySet() )
                {
                    if ( key != null )
                    {
                        Object value = prop.get( key );
                        if ( value != null )
                        {
                            mClientConfig.put( key.toString(), value.toString() );
                        }
                    }
                }
            }
        }
    }

    private Properties loadProperties( String pPath )
    {
        File fileAt = new File( pPath );
        FileInputStream is;
        try
        {
            is = new FileInputStream( fileAt );
        }
        catch ( IOException e )
        {
            getLogger().error.log( e, "Unable to open: ", fileAt.getAbsolutePath() );
            return null;
        }
        try
        {
            Properties props = new Properties();
            props.load( is );
            System.out.println( "Loaded Client Configuration from: " + fileAt.getAbsolutePath() );
            return props;
        }
        catch ( IOException e )
        {
            getLogger().error.log( e, "Unable to load: ", fileAt.getAbsolutePath() );
            return null;
        }
        finally
        {
            try
            {
                is.close();
            }
            catch ( IOException e )
            {
                // Whatever...
            }
        }
    }

    protected void loadClientConfigConfigurationLoggerLevels()
    {
        String[] keys = Configuration.getAllKeys();
        for ( String key : keys )
        {
            if ( key.startsWith( LoggerLevel.CONFIGURATION_BASE ) )
            {
                mClientConfig.put( key, Configuration.getString( key ) );
            }
        }
    }

    public synchronized AppInitializationResult initialize( String pEncodedClientId )
    {
        Integer existingClientIdNumber;
        try
        {
            existingClientIdNumber = ClientIdCodec.decode( pEncodedClientId );
        }
        catch ( RuntimeException e )
        {
            getLogger().error.log( e, "initialize '", pEncodedClientId, "'" );
            throw e;
        }
        AppInitializationResult result;
        try
        {
            result = initializeForBrowserPageRequest( existingClientIdNumber );
        }
        catch ( RuntimeException e )
        {
            getLogger().error.log( e, "initialize: ", existingClientIdNumber );
            throw e;
        }
        return result;
    }

    public ChannelServiceResult propagate( int pClientIdNumber, int pMessageSequenceNumber, int pPollMillisecs, ChannelServicePackage pToServer )
    {
        try
        {
            return propagateFromChannelClientProcess( pClientIdNumber, pMessageSequenceNumber, pPollMillisecs, pToServer );
        }
        catch ( RuntimeException e )
        {
            getLogger().error.log( e, "Problem processing Client (", pClientIdNumber, ")", pToServer );
            throw e;
        }
    }

    public void clientDead( int pClientIdNumber )
    {
        try
        {
            clientDeadFromChannelClientProcess( pClientIdNumber );
        }
        catch ( RuntimeException e )
        {
            getLogger().error.log( e, "Problem processing Client Dead from Client: ", pClientIdNumber );
            // eat it as there is no longer a client to notify!
        }
    }

    protected void clientDeadFromChannelClientProcess( int pClientIdNumber )
    {
        HttpServletRequest zRequest = getThreadLocalRequest();

        try
        {
            ServerEventBus zSEB = ServerEventBusSessionMapper.getServerEventBus( zRequest, this, pClientIdNumber );
            if ( (zSEB != null) && zSEB.isAliveAndWell() )
            {
                setThreadLocalContextFrom( zSEB );
                try
                {
                    zSEB.publishIfNotDisposed( WindowClosingEventPackage.INSTANCE );
                    zSEB.dispose( "ClientDead" );
                }
                finally
                {
                    clrThreadLocalContext();
                }
            }
        }
        catch ( InvalidSessionException e )
        {
            // Logged by ServerEventBusSessionMapper
            return;
        }
        getLogger().debug.log( "ClientDead: ", pClientIdNumber );
    }

    protected ChannelServiceResult propagateFromChannelClientProcess( int pClientIdNumber, int pMessageSequenceNumber, int pPollMillisecs,
                                                                      ChannelServicePackage pFromClient )
    {
        HttpServletRequest zRequest = getThreadLocalRequest();

        ServerEventBus zSEB;
        try
        {
            zSEB = ServerEventBusSessionMapper.getServerEventBus( zRequest, this, pClientIdNumber );
        }
        catch ( InvalidSessionException e )
        {
            // Logged by ServerEventBusSessionMapper
            return ChannelServiceResult.forceClose( pMessageSequenceNumber );
        }
        if ( (zSEB != null) && !zSEB.isAliveAndWell() )
        {
            getLogger().trace.log( "ServerEventBus Disposed for pClientIdNumber=", pClientIdNumber, //
                                   " is ", zSEB, "!" );
            return ChannelServiceResult.forceClose( pMessageSequenceNumber );
        }
        if ( !(zSEB instanceof NonTemporaryServerEventBus) )
        {
            getLogger().warn.log( "ServerEventBus for pClientIdNumber=", pClientIdNumber, //
                                  " is ", zSEB, "!" );
            return ChannelServiceResult.serverLost( pMessageSequenceNumber );
        }
        setThreadLocalContextFrom( zSEB );
        try
        {
            RemotePeerService zRemotePeerService = ((NonTemporaryServerEventBus) zSEB).getRemotePeerService();
            if ( zRemotePeerService instanceof ServerSideRemotePeerService )
            {
                ServerSideRemotePeerService ssrps = (ServerSideRemotePeerService) zRemotePeerService;
                ChannelServicePackage zPackage = ssrps.processClientRequest( pPollMillisecs, pFromClient );
                return ChannelServiceResult.normal( pMessageSequenceNumber, zPackage );
            }
            getLogger().warn.log( "ServerEventBus for pClientIdNumber=", pClientIdNumber, //
                                  " RemotePeerService is ", zRemotePeerService, "!" );
            return ChannelServiceResult.serverLost( pMessageSequenceNumber );
        }
        finally
        {
            clrThreadLocalContext();
        }
    }

    protected AppInitializationResult initializeForBrowserPageRequest( Integer existingClientIdNumber )
            throws InvalidSessionException
    {
        HttpServletRequest zRequest = getThreadLocalRequest();

        Integer zClientIdNumber = getClientIdNumber( zRequest, existingClientIdNumber );

        if ( zClientIdNumber == null )
        {
            return null; // Force Close!
        }

        getLogger().debug.log( "initialize Page Request, existing: ", //
                               existingClientIdNumber, " -> ", zClientIdNumber );

        NonTemporaryServerEventBus zSEB = createRealServerEventBus( zClientIdNumber );
        ServerSideRemotePeerService zSPS = zSEB.initialize( "initializeForBrowserPageRequest" );

        ServerEventBusSessionMapper.addServerEventBus( zRequest, this, zSEB );
        setThreadLocalContextFrom( zSEB );

        try
        {
            ServerEventBusSubscriptionCollector collector = new ServerEventBusSubscriptionCollector();

            addEventListenersForNewClient( collector );

            collector.subscribe( new RequestNewClientPackageListener() );
            collector.subscribe( new MsgParentPackageListener() );
            collector.subscribe( new MsgChildrenPackageListener() );
            collector.subscribe( new MsgRelatedPackageListener() );
            collector.subscribe( new MsgAllPackageListener() );
            collector.subscribe( new MsgSpecificPackageListener() );

            zSEB.apply( collector );

            finalInitializationBeforeInitializationResultReturned( zSEB );

            return new AppInitializationResult( zClientIdNumber, //
                                                ClientIdCodec.encode( zClientIdNumber ), //
                                                mClientConfig, //
                                                zSPS.processClientRequest( 0, null ), //
                                                getApplicationVersion(), //
                                                zSEB.getAuthenticationData() );
        }
        finally
        {
            clrThreadLocalContext();
        }
    }

    protected NonTemporaryServerEventBus createRealServerEventBus( int pClientIdNumber )
    {
        return new RegularServerEventBus( pClientIdNumber );
    }

    protected void finalInitializationBeforeInitializationResultReturned( ServerEventBus pSEB )
    {
    }

    abstract protected String getApplicationVersion();

    /**
     * @return !null will be Client ID to use, null means it was Disposed!
     */
    private Integer getClientIdNumber( HttpServletRequest pRequest, Integer pExistingClientIdNumber )
            throws InvalidSessionException
    {
        if ( pExistingClientIdNumber != null )
        {
            ServerEventBus zSEB = ServerEventBusSessionMapper.getServerEventBus( pRequest, this, pExistingClientIdNumber );
            if ( zSEB != null )
            {
                return zSEB.isAliveAndWell() ? pExistingClientIdNumber : null;
            }
        }
        return ServerEventBusManager.getNextClientIdNumber();
    }

    protected void setClientIdNumberSequenceSource( SequenceSource pSequenceSource )
    {
        ServerEventBusManager.setClientIdNumberSequenceSource( pSequenceSource );
    }

    abstract protected void instantiateConfiguration();

    abstract protected void startUpApplication();

    protected void initComplete()
    {
    }

    public void setThreadLocalContextFrom( ServerEventBus pSEB )
    {
    }

    public void clrThreadLocalContext()
    {
    }

    abstract protected void addEventListenersForNewClient( ServerEventBusSubscriptionCollector pCollector );

    /**
     * This method controls how data is exported from the parent event bus to
     * the newly created child event bus. Called before a new client window is
     * opened. The default implementation simply returns all the browser
     * properties set on the parent EB.
     *
     * @param pParentEventBus the exiting parent event bus
     *
     * @return a new BrowserDataManager, or <code>null</code>
     */
    protected ClientWindowInstanceDataManager createChildWindowInstanceData( RequestNewClientEventPackage pEvent, EventBus pParentEventBus )
    {
        return new ClientWindowInstanceDataManager( pParentEventBus.getClientWindowInstanceDataManager() );
    }

    private class RequestNewClientPackageListener implements EventPackageSubscriber
    {
        public String subscribeWith()
        {
            return RequestNewClientEventPackage.SubscribeWith;
        }

        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            RequestNewClientEventPackage zEvent = (RequestNewClientEventPackage) pEventPackage;

            ClientWindowInstanceDataManager zInitialClientData;

            try
            {
                zInitialClientData = createChildWindowInstanceData( zEvent, pEventBus );
            }
            catch ( RuntimeException e )
            {
                getLogger().error.log( e );
                pEventBus.publish( (EventPackage) null ); // todo - George: Client Error from Server!!!!
                return;
            }

            TemporaryServerEventBus zTempSEB = createTemporarySEB( "RequestNewClient", //
                                                                   (ServerEventBus) pEventBus, //
                                                                   zInitialClientData );
            int zClientIdNumber = zTempSEB.getClientIdNumber();
            String zNewEncodedClientId = ClientIdCodec.encode( zClientIdNumber );

            pEventBus.publish( new OpenNewClientEventPackage( pEventBus.getForm(), zNewEncodedClientId ) );
        }
    }

    protected TemporaryServerEventBus createTemporarySEB( String pWhy, ServerEventBus pParent, ClientWindowInstanceDataManager pInitialClientData )
    {
        return ServerEventBusManager.INSTANCE.createTemporaryServerEventBus( pWhy, pParent, pInitialClientData );
    }

    protected TemporaryServerEventBus createTemporarySEB( String pWhy, HttpServletRequest pRequest, ClientWindowInstanceDataManager pInitialClientData )
    {
        return ServerEventBusManager.INSTANCE.createTemporaryServerEventBus( pWhy, pRequest, this, pInitialClientData );
    }

    private abstract static class MsgOtherBus implements EventPackageSubscriber
    {
        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            EventPackagePayloadEventPackage eventEventPackage = (EventPackagePayloadEventPackage) pEventPackage;
            ChannelEventPackage event = eventEventPackage.getEventToForward();
            if ( event != null )
            {
                ServerEventBus bus = getAppropriateServerEventBus( (ServerEventBus) pEventBus, //
                                                                   eventEventPackage );
                if ( bus != null )
                {
                    bus.publishIfNotDisposed( event );
                }
            }
        }

        abstract protected ServerEventBus getAppropriateServerEventBus( ServerEventBus pEventBus, EventPackagePayloadEventPackage pEventEventPackage );
    }

    private abstract static class MsgOtherBuses implements EventPackageSubscriber
    {
        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            EventPackagePayloadEventPackage eventEventPackage = (EventPackagePayloadEventPackage) pEventPackage;
            ChannelEventPackage event = eventEventPackage.getEventToForward();
            if ( event != null )
            {
                ServerEventBus serverEventBus = (ServerEventBus) pEventBus;
                ServerEventBus[] buses = getAppropriateServerEventBuses( serverEventBus, eventEventPackage );
                if ( buses != null )
                {
                    for ( ServerEventBus bus : buses )
                    {
                        if ( (bus != null) && (bus != pEventBus) )
                        {
                            bus.publishIfNotDisposed( event );
                        }
                    }
                }
            }
        }

        abstract protected ServerEventBus[] getAppropriateServerEventBuses( ServerEventBus pEventBus, EventPackagePayloadEventPackage pEventEventPackage );
    }

    private static class MsgParentPackageListener extends MsgOtherBus
    {
        public String subscribeWith()
        {
            return MsgParentWindowEventPackage.SubscribeWith;
        }

        protected ServerEventBus getAppropriateServerEventBus( ServerEventBus pEventBus, EventPackagePayloadEventPackage pEventEventPackage )
        {
            return pEventBus.getParentServerEventBus();
        }
    }

    private static class MsgChildrenPackageListener extends MsgOtherBuses
    {
        public String subscribeWith()
        {
            return MsgChildWindowsEventPackage.SubscribeWith;
        }

        protected ServerEventBus[] getAppropriateServerEventBuses( ServerEventBus pEventBus, EventPackagePayloadEventPackage pEventEventPackage )
        {
            return pEventBus.getChildrenServerEventBuses();
        }
    }

    private static class MsgRelatedPackageListener extends MsgOtherBuses
    {
        public String subscribeWith()
        {
            return MsgRelatedWindowsEventPackage.SubscribeWith;
        }

        protected ServerEventBus[] getAppropriateServerEventBuses( ServerEventBus pEventBus, EventPackagePayloadEventPackage pEventEventPackage )
        {
            return pEventBus.getAllRelatedServerEventBuses();
        }
    }

    private static class MsgAllPackageListener extends MsgOtherBuses
    {
        public String subscribeWith()
        {
            return MsgAllWindowsEventPackage.SubscribeWith;
        }

        protected ServerEventBus[] getAppropriateServerEventBuses( ServerEventBus pEventBus, EventPackagePayloadEventPackage pEventEventPackage )
        {
            return pEventBus.getAllServerEventBuses();
        }
    }

    private static class MsgSpecificPackageListener extends MsgOtherBus
    {
        public String subscribeWith()
        {
            return MsgSpecificWindowEventPackage.SubscribeWith;
        }

        protected ServerEventBus getAppropriateServerEventBus( ServerEventBus pEventBus, EventPackagePayloadEventPackage pEventEventPackage )
        {
            int clientIdNumber = ((MsgSpecificWindowEventPackage) pEventEventPackage).getClientIdNumber();
            return ServerEventBusManager.INSTANCE.getServerEventBus( clientIdNumber );
        }
    }

    /**
     * The keepAliveSession accesses the GWT ThreadLocalRequest forcing it to getSession() and logging the
     * particulars of the session at DEBUG level.
     */
    private void keepAliveSession()
    {
        HttpServletRequest zReq = getThreadLocalRequest();
        HttpSession zSession = zReq.getSession();
        if ( zSession == null )
        {
            getLogger().debug.log( "zSession is Null" );
        }
        else if ( zSession.isNew() )
        {
            getLogger().debug.log( "zSession.getId()=", zSession.getId() );
        }
    }

    public String processCall( String payload )
            throws SerializationException
    {
        try
        {
            keepAliveSession();
            return super.processCall( payload );
        }
        catch ( SerializationException e )
        {
            getLogger().error.log( e, "payload:", payload );
            throw e;
        }
        catch ( RuntimeException e )
        {
            getLogger().error.log( e, "payload:", payload );
            throw e;
        }
    }

    protected void service( HttpServletRequest pRequest, HttpServletResponse pResponse )
            throws ServletException, IOException
    {
        String query = Utils.noEmpty( pRequest.getQueryString() );
        if ( query == null )
        {
            super.service( pRequest, pResponse );
            return;
        }
//        System.out.println( "service: " + query );
//        System.out.println( "RequestURI: " + pHttpServletRequest.getRequestURI() );
//        System.out.println( "RequestURL: " + pHttpServletRequest.getRequestURL() );
//        System.out.println( "PathInfo: " + pHttpServletRequest.getPathInfo() );
//        System.out.println( "PathTranslated: " + pHttpServletRequest.getPathTranslated() );
        TemplateControl zTC = resolveQuery( pRequest, query );
        if ( zTC == null )
        {
            throw new ServletException( "Unable to process request: " + query );
        }
        try
        {
            pResponse.setCharacterEncoding( FileUtils.UTF_8 );
            ServletUtils.noCache( pResponse );
            Writer zWriter = new OutputStreamWriter( pResponse.getOutputStream(), FileUtils.UTF_8 );
            try
            {
                zTC.applyTo( zWriter, "&nbsp;" );
            }
            finally
            {
                zWriter.close();
            }
        }
        finally
        {
            zTC.dispose();
        }
    }

    protected TemplateControl resolveQuery( HttpServletRequest pRequest, String pQuery )
            throws IOException
    {
        return null;
    }
}