package org.litesoft.initfrom.server;

import org.litesoft.bo.views.*;
import org.litesoft.changemanagement.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.core.*;
import org.litesoft.initfrom.client.boviews.*;
import org.litesoft.initfrom.server.boviews.podataproviders.*;
import org.litesoft.initfrom.server.pos.*;

public class CurrentRestrictedResourceAccessor implements ServerStateChangedListener {
    public static synchronized CurrentRestrictedResourceAccessor get() {
        ServerStore zStore = ServerContext.get().getServerStore();
        CurrentRestrictedResourceAccessor zAccessor = zStore.get( CurrentRestrictedResourceAccessor.class );
        if ( zAccessor == null ) {
            zStore.set( CurrentRestrictedResourceAccessor.class, zAccessor = new CurrentRestrictedResourceAccessor() );
        }
        return zAccessor;
    }

    private boolean mViewStale;
    private ChangeListenerManager mRegisteredWithCLM;
    private RestrictedResource mPO;

    public RestrictedResource getRequiredRestrictedResource() {
        RestrictedResource zRestrictedResource = getOptionalRestrictedResource();
        if ( zRestrictedResource == null ) {
            throw new SessionExpiredException( "No Current RestrictedResource" );
        }
        return zRestrictedResource;
    }

    public RestrictedResource getOptionalRestrictedResource() {
        Pair zPair = getPair();
        if ( zPair.getVO() == null ) {
            return null;
        }
        if ( (zPair.getPO() == null) || !zPair.inSync() ) {
            zPair = refresh( zPair );
        }
        return zPair.getPO();
    }

    public RestrictedResourceView getRestrictedResourceView() {
        Pair zPair = getPair();
        if ( zPair.isStale() ) {
            zPair = refresh( zPair );
        }
        return zPair.getVO();
    }

    public void logout() {
        update( null, null );
    }

    public RestrictedResourceView updateRestrictedResource( RestrictedResource pPO ) {
        RestrictedResourceView zView = getDataProvider().createView( pPO, false );
        update( zView, pPO );
        return zView;
    }

    private Pair refresh( Pair pPair ) {
        RestrictedResourceViewPoServerVoDataProvider zDP = getDataProvider();
        RestrictedResource zRestrictedResource = (RestrictedResource) zDP.getPO( pPair.getVO().getID() );
        return update( zDP.createView( zRestrictedResource, false ), zRestrictedResource );
    }

    private Pair update( RestrictedResourceView pView, RestrictedResource pPO ) {
        Pair rv;
        RestrictedResource zOld, zNew;
        synchronized ( this ) {
            rv = new Pair( mViewStale = false, pView, pPO );
            ServerContext.get().getServerSession().setAttribute( RestrictedResourceView.class, pView );
            zOld = mPO;
            zNew = mPO = pPO;
        }
        if ( !Currently.areEqual( zOld, zNew ) ) {
            if ( zOld != null ) {
                mRegisteredWithCLM.removeListener( this );
                mRegisteredWithCLM = null;
            }
            if ( zNew != null ) {
                (mRegisteredWithCLM = ChangeListenerManager.get()).addListener( this, RestrictedResource.class, zNew.getPersistentObjectUniqueKey() );
            }
        }
        return rv;
    }

    private synchronized Pair getPair() {
        RestrictedResourceView zRestrictedResourceView = ServerContext.get().getServerSession().getAttribute( RestrictedResourceView.class );
        return new Pair( mViewStale, zRestrictedResourceView, mPO );
    }

    @Override
    public synchronized void serverStateChanged( ServerStateChangeSet pServerStateChangeSet ) {
        mViewStale = true;
    }

    private RestrictedResourceViewPoServerVoDataProvider getDataProvider() {
        return (RestrictedResourceViewPoServerVoDataProvider) ServerContext.getMasterServerStore().get( ServerVoDataProviderMap.class )
                .get( RestrictedResourceView.class );
    }

    private static class Pair {
        private boolean mStale;
        private RestrictedResourceView mVO;
        private RestrictedResource mPO;

        private Pair( boolean pStale, RestrictedResourceView pVO, RestrictedResource pPO ) {
            mStale = (pVO != null) && pStale;
            mVO = pVO;
            mPO = pPO;
        }

        public boolean isStale() {
            return mStale;
        }

        public RestrictedResourceView getVO() {
            return mVO;
        }

        public RestrictedResource getPO() {
            return mPO;
        }

        public boolean inSync() // Only called when Both are !null
        {
            return !mStale && //
                   Currently.areEqual( mPO.getID(), mVO.getID() ) && //
                   Currently.areEqual( mPO.getRecordVersion(), mVO.getRecordVersion() );
        }
    }
}