package org.litesoft.security;

import org.litesoft.bo.views.server.*;
import org.litesoft.changemanagement.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.core.*;

import java.lang.reflect.*;

@SuppressWarnings("Convert2Diamond")
public abstract class AbstractCurrentSecurityPOAccessor<PO extends SecurityPO<PO>, VO extends SecurityVO<VO>> implements ServerStateChangedListener {
    protected final String mWhat;
    protected final Class<PO> mClassPO;
    protected final Class<VO> mClassVO;
    protected final PoServerVoDataProvider<VO> mDataProvider;

    protected PO mPO;
    protected boolean mViewStale;
    protected ChangeListenerManager mRegisteredWithCLM;

    protected AbstractCurrentSecurityPOAccessor( String pWhat, Class<PO> pClassPO, Class<VO> pClassVO, PoServerVoDataProvider<VO> pDataProvider ) {
        mWhat = pWhat;
        mClassPO = pClassPO;
        mClassVO = pClassVO;
        mDataProvider = pDataProvider;
    }

    protected static <T> T getCurrentInstance( Class<T> pClass ) {
        ServerStore zStore = RequestContext.get().getServerStore();
        T zAccessor = zStore.get( pClass );
        if ( zAccessor == null ) {
            try {
                Constructor<T> c = pClass.getDeclaredConstructor();
                c.setAccessible( true ); // Allow 'private' access
                zStore.set( pClass, zAccessor = c.newInstance() );
            }
            catch ( Exception e ) {
                throw new Error( e ); // Good and Well Dorked!
            }
        }
        return zAccessor;
    }

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

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

    protected VO getCachedInstance() {
        return RequestContext.get().getServerSession().getAttribute( mClassVO );
    }

    protected synchronized Pair<PO, VO> createPair(VO pView) {
        return new Pair<PO, VO>( mViewStale, pView, mPO );
    }

    @SuppressWarnings({"unchecked"})
    protected Pair<PO, VO> refresh( Pair pPair ) {
        PO zPO = (PO) mDataProvider.getPO( pPair.getVO().getID() );
        return update( mDataProvider.createView( zPO, false ), zPO );
    }

    protected Pair<PO, VO> update( VO pVO, PO pPO ) {
        Pair<PO, VO> rv;
        PO zOld, zNew;
        synchronized ( this ) {
            rv = new Pair<PO, VO>( mViewStale = false, pVO, pPO );
            RequestContext.get().getServerSession().setAttribute( mClassVO, pVO );
            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, mClassPO, zNew.getPersistentObjectUniqueKey() );
            }
        }
        return rv;
    }

    protected static class Pair<PO extends SecurityPO<PO>, VO extends SecurityVO<VO>> {
        private boolean mStale;
        private VO mVO;
        private PO mPO;

        protected Pair( boolean pStale, VO pVO, PO pPO ) {
            mStale = (pVO != null) && pStale;
            mVO = pVO;
            mPO = pPO;
        }

        public boolean isStale() {
            return mStale;
        }

        public VO getVO() {
            return mVO;
        }

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

        @Override
        public String toString() {
            return "Prioritizer: " + mStale + " PO: " + mPO + " VO: " + mVO;
        }
    }
}