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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.GWT.forms.server.support.*;
import org.litesoft.GWT.forms.server.support.mdconstruction.*;
import org.litesoft.GWT.forms.server.support.nonpublic.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.core.simpletypes.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.otherattributeaccessors.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.ui.def.nonpublic.support.*;
import org.litesoft.ui.support.*;
import org.litesoft.ui_1_5.*;

public class POFormServicePeer extends AbstractFormServicePeer
{
    public static final String ERR_PO_NOT_FOUND = "PoNotFound";

    protected final NonTransactionalFinder mFinder;

    public POFormServicePeer( NonTransactionalFinder pFinder )
    {
        Objects.assertNotNull( "Finder", mFinder = pFinder );
    }

    public boolean clearToOneFilter( String pToOneAttributeName )
    {
        return ((POTypeHelper) getRootTypeHelper()).clearToOneFilter( pToOneAttributeName );
    }

    public boolean setToOneFilter( String pToOneAttributeName, String pToOnesAttribute, Object pFilterValue )
    {
        return ((POTypeHelper) getRootTypeHelper()).setToOneFilter( pToOneAttributeName, pToOnesAttribute,
                                                                    pFilterValue );
    }

    public TypeHelper createTypeHelper( FSPTypeHelperBackDoor pBackDoor, //
                                        ExternalizationInterface pExternalization, //
                                        FormAccessControl pAccessControl, //
                                        TypeHelper pParent, String pRelativeType, FormUsage pUsage )
    {
        return new POTypeHelper( pBackDoor, pExternalization, pAccessControl, pParent, pRelativeType,
                                 pUsage );
    }

    public InstanceHelper createRootInstanceHelper( TypeHelper pTypeHelper )
    {
        return new POInstanceHelper( pTypeHelper, null );
    }

    /**
     * subclasses may override this to add values to a newly created PO
     *
     * @param pPO !null
     */
    protected void onRootPoCreate( PersistentObject pPO )
    {
    }

    /**
     * subclasses may override this to fiddle with a PO that has just been loaded in
     *
     * @param pPO !null
     */
    protected void onRootPoLoad( PersistentObject pPO )
    {
    }

    public void reloadOptions( String pToThemRegisteredPOName )
    {
        if ( !isDisposed() )
        {
            updateComboBoxOptions( findAMDconvertPairsByRegisteredPOName( pToThemRegisteredPOName ) );
        }
    }

    private List<AMDconverterPair> findAMDconvertPairsByRegisteredPOName( String pRegisteredPOName )
    {
        List<AMDconverterPair> result = new ArrayList<AMDconverterPair>();

        TypeHelper zHelper = getRootTypeHelper();
        if ( zHelper != null )
        {
            AMDconverterPair[] zPairs = zHelper.getAMDconvertPairs();
            if ( zPairs != null )
            {
                for ( AMDconverterPair pair : zPairs )
                {
                    if ( pair.getDataConverter() instanceof POKeyValuePairConverter )
                    {
                        POKeyValuePairConverter converter = (POKeyValuePairConverter) pair.getDataConverter();

                        if ( pRegisteredPOName.equals( converter.getRegisteredPOName() ) )
                        {
                            result.add( pair );
                        }
                    }
                }
            }
        }

        return result;
    }

    public void reloadOptionsByAttributeReference( String pAttributeReference )
    {
        updateComboBoxOptions( findAMDconvertPairsByAttributeReference( pAttributeReference ) );
    }

    private List<AMDconverterPair> findAMDconvertPairsByAttributeReference( String pAttributeReference )
    {
        List<AMDconverterPair> result = new ArrayList<AMDconverterPair>();

        TypeHelper zHelper = getRootTypeHelper();
        if ( zHelper != null )
        {
            AMDconverterPair[] zPairs = zHelper.getAMDconvertPairs();
            if ( zPairs != null )
            {
                for ( AMDconverterPair pair : zPairs )
                {
                    if ( pAttributeReference.equals( pair.getAttributeMetaData().getAttributeReference() ) )
                    {
                        result.add( pair );
                    }
                }
            }
        }

        return result;
    }

    private void updateComboBoxOptions( List<AMDconverterPair> pPairs )
    {
        boolean updated = false;
        if ( pPairs != null )
        {
            for ( AMDconverterPair pair : pPairs )
            {
                FormSendableDataConverter zDataConverter = pair.getDataConverter();
                if ( zDataConverter instanceof POKeyValuePairConverter )
                {
                    POKeyValuePairConverter dataConverter = (POKeyValuePairConverter) zDataConverter;
                    AttributeMetaData zAttributeMD = pair.getAttributeMetaData();
                    POTypeHelper helper = (POTypeHelper) getRootTypeHelper();
                    if ( helper != null )
                    {
                        SimpleKeyValuePair[] options =
                                helper.getValidOptions( zAttributeMD.getAttributeReference(), dataConverter );
                        if ( Objects.isNotNullOrEmpty( options ) )
                        {
                            ComboBoxAttributeUpdateFormData update =
                                    new ComboBoxAttributeUpdateFormData( null, zAttributeMD, options );

                            getCollectorProxy().add( update );
                            updated = true;
                        }
                    }
                }
            }
        }
        if ( updated )
        {
            sendUnsolicitedData();
        }
    }

    public PersistentObject getRootPO()
    {
        return ((POInstanceHelper) getRootInstanceHelper()).getPO();
    }

    public void setRootPO( PersistentObject pPO )
    {
        ((POInstanceHelper) getRootInstanceHelper()).setPO( pPO );
    }

    protected boolean hasRootObject()
    {
        if ( getRootPO() == null )
        {
            addError( ERR_PO_NOT_FOUND );
            return false;
        }
        return true;
    }

    protected String LLsharedNewRootObject( PersistentObject pPO )
    {
        RuntimeException zProblem;
        if ( pPO != null )
        {
            try
            {
                setRootPO( pPO );
                onRootPoCreate( pPO ); // hook to let subclasses fiddle with the new PO
                return pPO.getPersistentObjectUniqueKey().toString();
            }
            catch ( RuntimeException e )
            {
                zProblem = e;
            }
        }
        else
        {
            zProblem = new RuntimeException( "No New Root Object" );
        }
        setRootPO( null );
        LOGGER.error.log( zProblem );
        addError( ERR_PO_NOT_FOUND, zProblem.getMessage() );
        return null;
    }

    protected Transaction createTransaction()
    {
        return mFinder.createTransaction().setTransactionSource( FormServicePeer.class );
    }

    /**
     * @return new Root Objects Key
     */
    protected String LLnewRootObject()
    {
        PersistentObject<?> zPersistentObject = LLnewRootPO();
        return LLsharedNewRootObject( zPersistentObject );
    }

    /**
     * @return true if succeeded
     */
    protected boolean LLloadExistingRootObject( String pNewRootObjectKey )
    {
        PersistentObject<?> zPO = null;
        RuntimeException zProblem = null;
        try
        {
            PersistentObjectUniqueKey zPOUK =
                    mFinder.createPersistentObjectUniqueKeyFrom( getRootType(), pNewRootObjectKey );
            zPO = LLloadExistingRootPO( zPOUK );
        }
        catch ( RuntimeException e )
        {
            zProblem = e;
        }
        return LLsharedLoadingExistingRootObject( zPO, zProblem );
    }

    /**
     * @return true if succeeded
     */
    protected boolean LLreloadExistingRootObject()
    {
        PersistentObject zPO = null;
        RuntimeException zProblem = null;
        try
        {
            zPO = LLreloadExistingRootPO();
        }
        catch ( RuntimeException e )
        {
            zProblem = e;
        }
        return LLsharedLoadingExistingRootObject( zPO, zProblem );
    }

    protected PersistentObject<?> LLnewRootPO()
    {
        return createTransaction().create( getRootType() );
    }

    protected PersistentObject<?> LLloadExistingRootPO( PersistentObjectUniqueKey pPOUK )
    {
        return createTransaction().findOne( getRootType(), pPOUK );
    }

    protected PersistentObject<?> LLloadExistingRootPO( PersistentObjectURL pURL )
    {
        return createTransaction().findOne( pURL );
    }

    protected PersistentObject<?> LLreloadExistingRootPO()
    {
        return getRootPO().refreshInto( createTransaction() );
    }

    protected boolean LLsharedLoadingExistingRootObject( PersistentObject pPO, RuntimeException pProblem )
    {
        if ( pPO != null )
        {
            try
            {
                setRootPO( pPO );
                onRootPoLoad( pPO );
                return true;
            }
            catch ( RuntimeException e )
            {
                pProblem = e;
            }
        }
        setRootPO( null );
        LOGGER.error.log( pProblem );
        if ( pProblem == null )
        {
            addError( ERR_PO_NOT_FOUND );
        }
        else
        {
            addError( ERR_PO_NOT_FOUND, pProblem.getMessage() );
        }
        return false;
    }

    protected void LLcommit()
    {
        LLcommitPo( getRootPO().getTransaction() ); // commit what we've got
        mIsNewRootObject = false; // if it was new, not it's not!
        // start a new transaction
        Transaction transaction = createTransaction();
        setRootPO( getRootPO().copyInto( transaction ) );
    }

    protected void LLcommitPo( Transaction pTransaction )
    {
        pTransaction.setTransactionSource( FormServicePeer.class );
        pTransaction.commit();
    }

    public class POInstanceHelper extends InstanceHelper
    {
        protected PersistentObject mPO;

        public POInstanceHelper( TypeHelper pTypeHelper, PersistentObject pPO )
        {
            super( pTypeHelper, (pPO != null) ? pPO.getPersistentObjectUniqueKey().toString() : null );
            mPO = pPO;
        }

        public synchronized PersistentObject getPO()
        {
            return mPO;
        }

        public synchronized void setPO( PersistentObject pPO )
        {
            mPO = pPO;
        }

        /**
         * Only called for Non-BaseForms
         *
         * @return true if successful
         */
        protected boolean removeRow()
        {
            PersistentObject zPO = getPO();
            if ( zPO != null )
            {
                if ( zPO.isImmortal() )
                {
                    MetaDataForPO zMetaDataForPO = zPO.getMetaDataForPO();
                    String zImmortalAttributeName = zMetaDataForPO.getInstanceImmortalImmortalAttributeName();
                    if ( Strings.isNullOrEmpty( zImmortalAttributeName ) )
                    {
                        mTypeHelper.getCollectorProxy().addError(
                                mTypeHelper.resolveError( "MayNotRemoveImmortals" ) );
                        return true;
                    }
                    zPO.setAttributeValue( zImmortalAttributeName, Boolean.FALSE );
                }
                zPO.requestDelete();
            }
            return true;
        }

        public boolean valueUpdated( String pAttributeReference, Object pValueForAttribute )
        {
            if ( hasRootObject() )
            {
                setRawAttributeValue( pAttributeReference, pValueForAttribute );
            }
            return true;
        }

        @SuppressWarnings({"unchecked"})
        protected Object getRawAttributeValue( String pAttributeRef )
        {
            PersistentObject zPO = getPO();
            if ( zPO == null )
            {
                return "No PO";
            }

            if ( !zPO.getMetaDataForPO().hasAttribute( pAttributeRef ) )
            {
                return "Field is missing";
            }

            return zPO.getAttributeValue( pAttributeRef );
        }

        protected void setRawAttributeValue( String pAttributeRef, Object pValueForAttribute )
        {
            getPO().setAttributeValue( pAttributeRef, pValueForAttribute );
        }

        protected List<String> getRowKeysFor( String pRelSubFormRef )
        {
            List<PersistentObject> zRelPOs = getRelatedPOs( pRelSubFormRef );
            if ( zRelPOs.isEmpty() )
            {
                return Collections.emptyList();
            }
            List<String> zRowKeys = new ArrayList<String>( zRelPOs.size() );
            for ( PersistentObject zPO : zRelPOs )
            {
                zRowKeys.add( zPO.getPersistentObjectUniqueKey().toString() );
            }
            return zRowKeys;
        }

        @SuppressWarnings({"unchecked"})
        protected List<PersistentObject> getRelatedPOs( String pRelSubFormRef )
        {
            Object zValue = getRawAttributeValue( pRelSubFormRef );
            if ( zValue instanceof List )
            {
                return (List<PersistentObject>) zValue;
            }
            LOGGER.error.log( "getRelatedPOs( '", pRelSubFormRef, "' ) on '", getPO(), "' resulted in: ",
                              zValue );
            return Collections.emptyList();
        }
    }

    protected class POTypeHelper extends TypeHelper
    {
        protected MetaDataForPO mMetaDataForPO;

        public POTypeHelper( FSPTypeHelperBackDoor pBackDoor, //
                             ExternalizationInterface pExternalization, //
                             FormAccessControl pAccessControl, //
                             TypeHelper pParent, String pRelativeType, FormUsage pUsage )
        {
            super( pBackDoor, pExternalization, pAccessControl, pParent, pRelativeType, pUsage );
            mMetaDataForPO = mFinder.getMetaDataRequired( pRelativeType );
        }

        public MetaDataForPO getMetaDataForPO()
        {
            return mMetaDataForPO;
        }

        /**
         * Only called for Non-BaseForms
         *
         * @param pParentInstanceHelper
         *
         * @return true if successful
         */
        protected boolean createNewRow( InstanceHelper pParentInstanceHelper )
        {
            if ( !(pParentInstanceHelper instanceof POInstanceHelper) )
            {
                throw new IllegalStateException( "No Parent or Unacceptable Instance" );
            }
            PersistentObject zPO = ((POInstanceHelper) pParentInstanceHelper).getPO();
            String zRelToThisSubForm = getRelToThisSubForm(); // Where to add
            PersistentObject zPOtoAdd = createNewRow( zPO.getTransaction() );
            if ( zPOtoAdd != null )
            {
                zPO.addToAttributeSet( zRelToThisSubForm, zPOtoAdd );
                return true;
            }
            return false;
        }

        protected PersistentObject createNewRow( Transaction pTransaction )
        {
            return mMetaDataForPO.createNew( pTransaction );
        }

        protected String cleanUpRelativeTypeForToolTip( String pRelativeType )
        {
            String s = "." + pRelativeType;
            return s.substring( s.lastIndexOf( '.' ) + 1 );
        }

        protected InstanceHelper LLcreateRelSubInstanceHelper( InstanceHelper pParent, String pRowKey )
        {
            Transaction zTrans = ((POInstanceHelper) pParent).getPO().getTransaction();
            PersistentObject zPO;
            if ( pRowKey == null )
            {
                zPO = createNewRow( zTrans );
            }
            else
            {
                PersistentObjectUniqueKey zPOUK = mMetaDataForPO.createUniqueKeyFrom( pRowKey );
                zPO = zTrans.findOne( mMetaDataForPO.getPOregistrationName(), zPOUK );
            }
            return LLcreateRelSubInstanceHelper( zPO );
        }

        protected InstanceHelper LLcreateRelSubInstanceHelper( PersistentObject pPO )
        {
            return new POInstanceHelper( this, pPO );
        }

        protected String determineRelSubFormRootType( String pRelAttributeRef )
        {
            AttributeAccessorSCD scd = mMetaDataForPO.getAccessorSCDoptional( pRelAttributeRef );
            if ( scd == null )
            {
                throw new IllegalArgumentException( mMetaDataForPO.getPOregistrationName() +
                                                    " does not have an Attribute for: '" + pRelAttributeRef +
                                                    "'" );
            }
            switch ( scd.getForm() )
            {
                default:
                case Local:
                    throw new IllegalArgumentException( mMetaDataForPO.getPOregistrationName() +
                                                        " does not have a Foreign Attribute for: '" +
                                                        pRelAttributeRef + "'" );
                case ToMany:
                    return ((AbstractAttributeAccessorSCDtoMany) scd).getToThemName();
                case ToOne:
                    if ( scd instanceof AttributeAccessorSCDtoOneRegular )
                    {
                        return ((AttributeAccessorSCDtoOneRegular) scd).getToThemName();
                    }
                    throw new IllegalArgumentException(
                            "Variable, Blobs, & Virtual ToOnes are Not supported: '" + pRelAttributeRef +
                            "' on: " + mMetaDataForPO.getPOregistrationName() );
            }
        }

        protected boolean validAttributeReference( String pLocalReference )
        {
            return (null != mMetaDataForPO.getAccessorSCDoptional( pLocalReference ));
        }

        protected AMDconverterPair createAttributeMetaData( CreateAMDParams pParams )
        {
            AttributeAccessorSCD scd = mMetaDataForPO.getAccessorSCDrequired( pParams.getLocalReference() );
            switch ( scd.getForm() )
            {
                case Local:
                    return createSimpleAMDpair( (AbstractAttributeAccessorSCDlocal) scd, pParams );
                case ToOne:
                    return createToOneAMDpair( (AbstractAttributeAccessorSCDtoOne) scd, pParams );
                case ToMany:
                    throw new UnsupportedOperationException( "createAttributeMetaData: ToManys" );
                default:
                    throw new UnsupportedOperationException( "createAttributeMetaData: ???" );
            }
        }

        protected AMDconverterPair createSimpleAMDpair( AbstractAttributeAccessorSCDlocal pSCD,
                                                        CreateAMDParams pParams )
        {
            return createAttributeMetaData( new CreateAMDParamsPlus( pParams, pSCD ), //
                                            pSCD.getValidOptions(), false, pSCD.getColumnType() );
        }

        protected POQueryIterator getValidOptionsPOsOfType( String pToThemName, WhereClause pWhereClause )
        {
            return mFinder.findAllCursored( pToThemName, pWhereClause );
        }

        protected AMDconverterPair createToOneAMDpair( AbstractAttributeAccessorSCDtoOne pSCD,
                                                       CreateAMDParams pParams )
        {
            POKeyValuePairConverter dataConverter = createToOneDataConverter( pSCD.getToThemName() );

            return createAttributeMetaData( new CreateAMDParamsPlus( pParams, pSCD ), //
                                            getValidOptions( pSCD.getName(), dataConverter ), //
                                            true, POAttributeMetaDataFactory.INSTANCE, //
                                            dataConverter );
        }

        protected POKeyValuePairConverter createToOneDataConverter( String pToThemName )
        {
            return new POKeyValuePairConverter( pToThemName );
        }

        protected SimpleKeyValuePair[] getValidOptions( String pToOneAttributeName,
                                                        POKeyValuePairConverter pDataConverter )
        {
            return getValidOptions( pToOneAttributeName, pDataConverter, null );
        }

        protected SimpleKeyValuePair[] getValidOptions( String pToOneAttributeName,
                                                        POKeyValuePairConverter pDataConverter,
                                                        WhereClause pWhereClause )
        {
            ValidOptionsFieldFilter zFieldFilter = mValidOptionsFieldFilters.get( pToOneAttributeName );
            if ( zFieldFilter != null )
            {
                WhereClauseFactory f = WhereClauseFactory.INSTANCE;
                WhereClause zWhereClause = f.isEqual( zFieldFilter.getSCDtoFilterOn(), //
                                                      zFieldFilter.getFilterValue() );
                pWhereClause = pWhereClause == null ? zWhereClause : f.and( pWhereClause, zWhereClause );
            }
            POQueryIterator it = getValidOptionsPOsOfType( pDataConverter.getRegisteredPOName(), //
                                                           pWhereClause );
            try
            {
                if ( !it.hasNext() )
                {
                    return null;
                }
                List<SimpleKeyValuePair> options = new ArrayList<SimpleKeyValuePair>();
                while ( it.hasNext() )
                {
                    PersistentObject po = it.next();
                    options.add( pDataConverter.createSimpleKeyValuePair( po ) );
                }
                return options.toArray( new SimpleKeyValuePair[options.size()] );
            }
            finally
            {
                it.releaseResources();
            }
        }

        private AMDconverterPair find1stPOKeyAMDconvertPairByAttributeReference( String pAttributeReference )
        {
            for ( AMDconverterPair pair : getRootTypeHelper().getAMDconvertPairs() )
            {
                if ( pAttributeReference.equals( pair.getAttributeMetaData().getAttributeReference() ) &&
                     (pair.getDataConverter() instanceof POKeyValuePairConverter) )
                {
                    return pair;
                }
            }

            return null;
        }

        public boolean clearToOneFilter( String pToOneAttributeName )
        {
            if ( null != mValidOptionsFieldFilters.remove( pToOneAttributeName ) )
            {
                reloadOptionsByAttributeReference( pToOneAttributeName );
                return true;
            }
            return false;
        }

        public boolean setToOneFilter( String pToOneAttributeName, String pToOnesAttribute,
                                       Object pFilterValue )
        {
            AMDconverterPair zPair = find1stPOKeyAMDconvertPairByAttributeReference( pToOneAttributeName );
            if ( zPair != null )
            {
                MetaDataForPO zMDtoOnePO = mFinder.getMetaDataOptional(
                        ((POKeyValuePairConverter) zPair.getDataConverter()).getRegisteredPOName() );
                if ( zMDtoOnePO != null )
                {
                    AttributeAccessorSCD zSCD = zMDtoOnePO.getAccessorSCDoptional( pToOnesAttribute );
                    if ( zSCD != null )
                    {
                        mValidOptionsFieldFilters.put( pToOneAttributeName, //
                                                       new ValidOptionsFieldFilter( zSCD, pFilterValue ) );
                        reloadOptionsByAttributeReference( pToOneAttributeName );
                        return true;
                    }
                }
            }
            return false;
        }

        private Map<String, ValidOptionsFieldFilter> mValidOptionsFieldFilters =
                new HashMap<String, ValidOptionsFieldFilter>();
    }

    protected static class ValidOptionsFieldFilter
    {
        private SimpleColumnDefinition mSCDtoFilterOn; // !null
        private Object mFilterValue; // Null Allowed...

        public ValidOptionsFieldFilter( SimpleColumnDefinition pSCDtoFilterOn, Object pFilterValue )
        {
            mSCDtoFilterOn = pSCDtoFilterOn;
            mFilterValue = pFilterValue;
        }

        public SimpleColumnDefinition getSCDtoFilterOn()
        {
            return mSCDtoFilterOn;
        }

        public Object getFilterValue()
        {
            return mFilterValue;
        }
    }

    protected static class POAttributeMetaDataFactory implements FormAttributeMetaDataFactory
    {
        public static final FormAttributeMetaDataFactory INSTANCE = new POAttributeMetaDataFactory();

        public AMDconverterPair createAttributeMetaData( CreateAMDParamsPlus pParams )
        {
            return TextFieldFormAMD.INSTANCE.create( pParams );
        }
    }

    protected class POKeyValuePairConverter extends AbstractSendableKeyValuePairConverter
    {
        private String mRegisteredPOname;

        public POKeyValuePairConverter( String pRegisteredPOname )
        {
            mRegisteredPOname = pRegisteredPOname;
        }

        public String getRegisteredPOName()
        {
            return mRegisteredPOname;
        }

        public SimpleKeyValuePair createSimpleKeyValuePair( Object pOption )
        {
            if ( pOption == null )
            {
                return new StringKeyValuePair( "" );
            }
            if ( pOption instanceof SimpleKeyValuePair )
            {
                return (SimpleKeyValuePair) pOption;
            }
            if ( pOption instanceof ResourceKeyNameURLaccessor )
            {
                return ((ResourceKeyNameURLaccessor) pOption).getResourceKeyNameURL();
            }
            if ( pOption instanceof PersistentObject )
            {
                PersistentObject po = (PersistentObject) pOption;
                return new DataStoreKeyValuePair( po.getPersistentObjectUniqueKey().toString(),
                                                  po.getDisplayValue() );
            }
            String zOptionAsString = pOption.toString();
            return new StringKeyValuePair( zOptionAsString );
        }

        protected Object convertSimpleKeyValuePairKey( Object pKey )
        {
            if ( pKey instanceof String )
            {
                try
                {
                    return mFinder.createPersistentObjectUniqueKeyFrom( mRegisteredPOname, pKey.toString() );
                }
                catch ( IllegalArgumentException e )
                {
                    // Fall thru...
                }
            }
            return super.convertSimpleKeyValuePairKey( pKey );
        }
    }
}