package org.litesoft.GWT.server;

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

import org.litesoft.configuration.*;
import org.litesoft.core.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.logger.*;
import org.litesoft.logger.nonpublic.*;
import org.litesoft.util.*;
import org.litesoft.util.template.*;
import org.litesoft.reports.*;

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

public abstract class AbstractServerApp extends RemoteServiceServlet // don't forget this!
{
    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 static synchronized boolean isOneTimeInitComplete()
    {
        return sOneTimeInitComplete;
    }

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

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

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

    /**
     * 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" );
        try
        {
            initializeLogger( instantiateConfiguration() );
            logConfigurationLoadingWarnings();
            new ServerContext( new ContextID( "StartUp", "App" ), new SimpleMapServerSession() ).set();
            startUpApplication();
            logServletContextInitParameterNames();
            initComplete();
            System.err.println( new UtilDateAdaptor() + " | Application Server Start Up Complete" );
        }
        catch ( RuntimeException e )
        {
            setOneTimeInitException( e );
            throw e;
        }
        catch ( Exception e )
        {
            RuntimeException zRTE = new RuntimeException( e );
            setOneTimeInitException( zRTE );
            throw zRTE;
        }
        finally
        {
            sOneTimeInitComplete = true;
        }
    }

    private void initializeLogger( LoggerLevel pLoggerLevel )
    {
        ServletContext zSC = getServletContext();
        zSC.log( "****** Test ******" ); // todo: Note that the ServletContext has Logging support, we should look into using it as an additional Logging sync

        LoggerFactory.init( pLoggerLevel );
    }

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

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

    abstract protected String getApplicationVersion();

    abstract protected LoggerLevel instantiateConfiguration();

    abstract protected void startUpApplication();

    protected void initComplete()
    {
    }

    protected void register( ServerReportFactory... pFactories )
    {
        if ( pFactories != null )
        {
            for ( ServerReportFactory zFactory : pFactories )
            {
                if ( zFactory != null )
                ServerReportFactory.Registry.register( zFactory );
            }
        }
    }
    
    /**
     * 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;
    }
}