package org.litesoft.security;

import java.lang.reflect.*;

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

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 = ServerContext.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 );
    }

    @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 );
            ServerContext.get().getServerSession().setAttribute( mClassVO, pVO );
            zOld = mPO;
            zNew = mPO = pPO;
        }
        if ( !Objects.areNonArraysEqual( 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 && //
                   Objects.areNonArraysEqual( mPO.getID(), mVO.getID() ) && //
                   Objects.areNonArraysEqual( mPO.getRecordVersion(), mVO.getRecordVersion() );
        }

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