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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.gregorian.*;
import org.litesoft.configuration.*;
import org.litesoft.core.*;
import org.litesoft.logger.*;
import org.litesoft.logger.nonpublic.*;
import org.litesoft.loggerconfig.*;
import org.litesoft.reports.*;
import org.litesoft.util.*;
import org.litesoft.util.template.*;

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

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

@SuppressWarnings({"UnusedDeclaration"})
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;
    }

    protected final String mAppName;

    protected AbstractServerApp( String pAppName ) {
        mAppName = pAppName;
    }

    @Override
    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();
        if ( zSC != null ) {
            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() ) {
            ServletContext zSC = getServletContext();
            if ( zSC != null ) {
                Enumeration zParamNames = zSC.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 );
    }

    protected LoggerLevel instantiateConfiguration() {
        instantiateServerConfiguration();
        return new ConfigurationLoggerLevel();
    }

    protected void instantiateServerConfiguration() {
        ConfigDataAccessorFactory zFactory = new WebInfConfigAccessorLocator( mAppName );
        zFactory = new ServerConfigDataAccessorFactoryProxy( zFactory );
        new ServerConfiguration( zFactory );// force creation & self registration of Configuration
        if ( (null != ConstrainTo.significantOrNull( Configuration.getString( "databaseURL" ) )) && (System.getProperty( "HSQL" ) != null) ) {
            // JDBC HSQL stuff:
            Configuration.setKeyValue( ConfigDataAccessor.Level.RUN, "databaseDriverClassName", "org.hsqldb.jdbcDriver" );
            Configuration.setKeyValue( ConfigDataAccessor.Level.RUN, "databaseURL", "jdbc:hsqldb:mem:production_pos" );
            Configuration.setKeyValue( ConfigDataAccessor.Level.RUN, "databaseUserName", "sa" );
            Configuration.setKeyValue( ConfigDataAccessor.Level.RUN, "databaseUserPassword", "" ); // Must treat "" as No Password!
            Configuration.setKeyValue( ConfigDataAccessor.Level.RUN, "populateDatabase", "true" );
        }
    }

    abstract protected String getApplicationVersion();

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

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

    @Override
    protected void service( HttpServletRequest pRequest, HttpServletResponse pResponse )
            throws ServletException, IOException {
        String query = ConstrainTo.significantOrNull( 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();
        }
    }

    /**
     * For Overriding!
     */
    protected TemplateControl resolveQuery( HttpServletRequest pRequest, String pQuery )
            throws IOException {
        return null;
    }
}