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

import java.util.*;
import java.util.concurrent.atomic.*;

import org.litesoft.GWT.forms.server.*;
import org.litesoft.GWT.forms.server.support.converters.*;
import org.litesoft.GWT.forms.server.support.mdconstruction.*;
import org.litesoft.GWT.forms.server.support.nonpublic.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.core.simpletypes.currency.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.ui.def.nonpublic.support.*;
import org.litesoft.ui.support.*;
import org.litesoft.ui_1_5.*;
import org.litesoft.ui_1_5.def.*;

public abstract class TypeHelper implements UI.Hints
{
    private AtomicBoolean mDisposed = new AtomicBoolean( false );
    private FSPTypeHelperBackDoor mBackDoor;
    protected ExternalizationInterface mExternalization;
    protected FormAccessControl mAccessControl;
    protected TypeHelper mParent;
    protected String mRelativeType;
    private Integer mFormUniqueID;
    private boolean mBaseForm;
    protected String mRelToThisSubForm = null;
    private Set<ActionMetaData> mActions = new HashSet<ActionMetaData>();
    protected Map<Integer, AMDconverterPair> mAMDconvertPairsByAttributeID =
            new HashMap<Integer, AMDconverterPair>();
    protected AMDconverterPair[] mAMDconvertPairs;
    protected Map<String, TypeHelper[]> mRelSubFormRefToTypes = new HashMap<String, TypeHelper[]>();

    protected TypeHelper( FSPTypeHelperBackDoor pBackDoor, //
                          ExternalizationInterface pExternalization, //
                          FormAccessControl pAccessControl, //
                          TypeHelper pParent, String pRelativeType, FormUsage pUsage )
    {
        Objects.assertNotNull( "BackDoor", mBackDoor = pBackDoor );
        mExternalization = pExternalization.addContext( pRelativeType );
        mAccessControl = pAccessControl.addContext( pRelativeType );
        mParent = pParent;
        mRelativeType = pRelativeType;
        mFormUniqueID = pUsage.getUniqueID();
        if ( !(mBaseForm = pUsage.isBaseForm()) )
        {
            mRelToThisSubForm = pUsage.getRelAttributeRef();
        }
    }

    public ExternalizationInterface getExternalization()
    {
        return mExternalization;
    }

    public FormMetaData initializeAndCreateFormMetaData( FormUsage pUsage )
    {
        FormMetaData zFMD = new FormMetaData( pUsage );

        LLprocess( zFMD, pUsage );

        Collection<AMDconverterPair> pairs = mAMDconvertPairsByAttributeID.values();
        mAMDconvertPairs = pairs.toArray( new AMDconverterPair[pairs.size()] );

        return zFMD;
    }

    public TypeHelper getParent()
    {
        return mParent;
    }

    public String getRelativeType()
    {
        return mRelativeType;
    }

    public String getRelToThisSubForm()
    {
        return mRelToThisSubForm;
    }

    public boolean isBaseForm()
    {
        return mBaseForm;
    }

    public ServicePeerToFormDataProxy getCollectorProxy()
    {
        return mBackDoor.getCollectorProxy();
    }

    public AMDconverterPair[] getAMDconvertPairs()
    {
        return mAMDconvertPairs;
    }

    public Map<String, TypeHelper[]> getRelSubFormRefToTypes()
    {
        return mRelSubFormRefToTypes;
    }

    public Integer getFormUniqueID()
    {
        return mFormUniqueID;
    }

    public String resolveError( String pErrorID )
    {
        return mExternalization.resolveError( pErrorID );
    }

    public final boolean isDisposed()
    {
        return mDisposed.get();
    }

    public final void dispose()
    {
        if ( !mDisposed.getAndSet( true ) ) // set true and test for false
        {
            try
            {
                LLdispose();
            }
            catch ( RuntimeException e )
            {
                FormServicePeer.LOGGER.error.log( e );
            }
        }
    }

    protected void LLdispose()
    {
    }

    public AMDconverterPair findAttribute( Integer uniqueId )
    {
        return mAMDconvertPairsByAttributeID.get( uniqueId );
    }

    public List<AttributeUpdateFormData> findAttributeUpdateFormDataByName( String pName )
    {
        List<AttributeUpdateFormData> zLocalList = new ArrayList<AttributeUpdateFormData>();
        for ( AMDconverterPair pair : mAMDconvertPairs )
        {
            AttributeMetaData meta = pair.getAttributeMetaData();
            if ( pName.toLowerCase().equals(
                    meta.getAttributeReference().toLowerCase() ) ) // todo: Use Case Insensitive Compare
            {
                zLocalList.add( new AttributeUpdateFormData( null, meta ) );
            }
        }

        return zLocalList;
    }

    public List<ActionMetaData> findActionUpdateFormDataByName( String pName )
    {
        List<ActionMetaData> zLocalList = new ArrayList<ActionMetaData>();
        for ( ActionMetaData data : mActions )
        {
            if ( data.getActionID().equals( pName ) )
            {
                zLocalList.add( data );
            }
        }

        return zLocalList;
    }

    public List<String> getActionIDs() {
        List<String> result = new ArrayList<String>();
        for ( ActionMetaData data : mActions ) {
            result.add( data.getActionID() );
        }
        return result;
    }

    public List<String> getAttributeNames() {
        List<String> result = new ArrayList<String>();
        for( AMDconverterPair ap : getAMDconvertPairs() ) {
            AttributeMetaData meta = ap.getAttributeMetaData();
            if( meta != null ) {
                result.add(meta.getAttributeReference());
            }
        }
        return result;
    }

    public boolean actionRequest( String pActionID, boolean pInputAction,
                                  InstanceHelper pParentInstanceHelper )
    {
        return !mBaseForm && "AddRow".equals( pActionID ) && createNewRow( pParentInstanceHelper );
    }

    /**
     * Only called for Non-BaseForms
     *
     * @param pParentInstanceHelper
     *
     * @return true if successful
     */
    protected boolean createNewRow( InstanceHelper pParentInstanceHelper )
    {
        return false;
    }

    private void LLprocess( FormMetaData pFMD, FormUsage pUsage )
    {
        process( pFMD, pUsage.getLabels() );
        process( pFMD, pUsage.getActions() );
        process( pFMD, pUsage.getAttributes() );
        process( pFMD, pUsage.getRelSubForms() );
    }

    protected void process( FormMetaData pFMD, FormUsage[] pRelSubFormUsages )
    {
        for ( FormUsage usage : pRelSubFormUsages )
        {
            String zRelAttributeRef = usage.getRelAttributeRef();
            String zRelRootType = determineRelSubFormRootType( zRelAttributeRef );
            TypeHelper typeHelper = mBackDoor.createTypeHelper( mBackDoor, mExternalization, mAccessControl,
                                                                this, zRelRootType, usage );
            mBackDoor.add( typeHelper );
            pFMD.addRelSubForm( typeHelper.initializeAndCreateFormMetaData( usage ) );
            TypeHelper[] zTypeHelpers = mRelSubFormRefToTypes.get( zRelAttributeRef );
            if ( zTypeHelpers == null )
            {
                zTypeHelpers = new TypeHelper[]{typeHelper};
            }
            else
            {
                TypeHelper[] newHelpers = new TypeHelper[zTypeHelpers.length + 1];
                System.arraycopy( zTypeHelpers, 0, newHelpers, 0, zTypeHelpers.length );
                newHelpers[zTypeHelpers.length] = typeHelper;
                zTypeHelpers = newHelpers;
            }
            mRelSubFormRefToTypes.put( zRelAttributeRef, zTypeHelpers );
        }
    }

    abstract protected String determineRelSubFormRootType( String pRelAttributeRef );

    protected void process( FormMetaData pFMD, LabelUsage[] pUsages )
    {
        for ( LabelUsage usage : pUsages )
        {
            String zLabelID = usage.getLabelID();
            pFMD.addLabel( new LabelMetaData( usage, resolveLabel( zLabelID ) ) );
        }
    }

    protected void process( FormMetaData pFMD, ActionUsage[] pUsages )
    {
        for ( ActionUsage usage : pUsages )
        {
            String zExtLabelID = usage.getExtLabelID();
            ActionMetaData actionMetaData = new ActionMetaData( usage, //
                                                                !allowAction( usage.getActionID() ), //
                                                                resolveAction( zExtLabelID ), //
                                                                resolveActionTooltip( zExtLabelID ) );
            mActions.add( actionMetaData );
            pFMD.addAction( actionMetaData );
        }
        if ( !mBaseForm )
        {
            addSubFormManagementImageAction( pFMD, "AddRow", "AddNew" );
            addSubFormManagementImageAction( pFMD, "RemoveRow", "RemoveThis" );
        }
    }

    private void addSubFormManagementImageAction( FormMetaData pFMD, String pActionID, String pWhat )
    {
        String zTooltip = resolveActionTooltip( pActionID );
        if ( Strings.isNullOrEmpty( zTooltip ) )
        {
            zTooltip = resolveLabel( pWhat + cleanUpRelativeTypeForToolTip( mRelativeType ) );
        }
        pFMD.addAction( new ActionMetaData( pActionID, !allowAction( pActionID ), //
                                            pActionID, // // No need to Resolve - won't use!
                                            zTooltip ) );
    }

    protected String cleanUpRelativeTypeForToolTip( String pRelativeType )
    {
        return pRelativeType;
    }

    protected boolean allowAction( String pActionID )
    {
        return mAccessControl.allowAction( pActionID );
    }

    protected String resolveAction( String pActionID )
    {
        return mExternalization.resolveAction( pActionID );
    }

    protected String resolveActionTooltip( String pActionID )
    {
        return mExternalization.resolveActionTooltip( pActionID );
    }

    public String resolveLabel( String pLabelID )
    {
        return mExternalization.resolveLabel( pLabelID );
    }

    protected void process( FormMetaData pFMD, AttributeUsage[] pUsages )
    {
        for ( AttributeUsage usage : pUsages )
        {
            process( pFMD, usage, usage.getAttributeReference() );
        }
    }

    protected void process( FormMetaData pFMD, AttributeUsage pUsage, String pReference )
    {
        DottedReference.Parts parts = DottedReference.parse( pReference );
        String localReference = parts.getLocalReference();
        if ( !validAttributeReference( localReference ) )
        {
            throw new IllegalArgumentException(
                    this + " does Not Support an Attribute reference of: '" + localReference + "'" );
        }
        if ( parts.getRestOfReference() != null )
        {
            throw new IllegalArgumentException(
                    this + " does Not Support dotted references yet like: '" + pReference + "'" );
        }
        AMDconverterPair zAMDcvtr = //
                createAttributeMetaData( new CreateAMDParams( mExternalization, //
                                                              localReference, //
                                                              pUsage, //
                                                              allowAttribute( localReference ) ) );
        mAMDconvertPairsByAttributeID.put( zAMDcvtr.getAttributeMetaData().getUniqueID(), zAMDcvtr );
        pFMD.addAttribute( zAMDcvtr.getAttributeMetaData() );
    }

    protected FormAccessControl.Field allowAttribute( String pAttributeLocalReference )
    {
        return mAccessControl.getFieldControl( pAttributeLocalReference );
    }

    abstract protected boolean validAttributeReference( String pLocalReference );

    abstract protected AMDconverterPair createAttributeMetaData( CreateAMDParams pParams );

    protected AMDconverterPair createInvalidAttributeRef( CreateAMDParams pParams, String pLabelSuffix,
                                                          String pTooltip )
    {
        return createAttributeMetaData( new BadAttributeParamsPlus( pParams, pLabelSuffix, pTooltip ), //
                                        null, false, // options
                                        String.class );  // type
    }

    protected AMDconverterPair createAttributeMetaData( CreateAMDParamsPlus pParams, //
                                                        // !Global & Not from Usage
                                                        Object[] pValidOptions, //
                                                        boolean pAssumeValidOptions, //
                                                        Class pFieldType )
    {
        FormAttributeMetaDataFactory zAMDFactory = mAMDFactoriesByFieldType.get( pFieldType );
        if ( (zAMDFactory == null) && !pFieldType.isEnum() )
        {
            return new AMDconverterPair( SendableUnknownDataTypeConverter.INSTANCE,
                                         new UnknownDataTypeMetaData( pParams.getUsage() ) );
        }
        return createAttributeMetaData( pParams, //
                                        // !Global & Not from Usage
                                        pValidOptions, pAssumeValidOptions, //
                                        zAMDFactory, null );
    }

    protected AMDconverterPair createAttributeMetaData( CreateAMDParamsPlus pParams, //
                                                        // !Global & Not from Usage
                                                        Object[] pValidOptions, //
                                                        boolean pAssumeValidOptions, //
                                                        FormAttributeMetaDataFactory pAMDFactory, //
                                                        FormSendableDataConverter pDataConverter )
    {
        IntendedUse zIntendedUse = pParams.getUsage().getIntendedUse();
        if ( zIntendedUse.isJustData() )
        {
            FormSendableDataConverter zFormSendableDataConverter = pParams.isHide() ?
                                                                   SendableHideDataStringConverter.INSTANCE :
                                                                   SendableStringConverter.INSTANCE;
            return new AMDconverterPair( zFormSendableDataConverter, //
                                         new ViewAsStringMetaData( pParams.getUsage() ) );
        }
        if ( pParams.isHide() )
        {
            return PasswordFieldFormAMD.INSTANCE.create( pParams );
        }
        String zFormHint = pParams.getHintValue( COMPONENT_FORM );
        if ( CF_TEXT_FIELD.equals( zFormHint ) || CF_TEXT_FIELD_RIGHT_ALIGNED.equals( zFormHint ) )
        {
            return TextFieldFormAMD.INSTANCE.create( pParams );
        }
        String[] zHintedValidOptions = parseHintValidOptions( pParams.getHintValue( VALID_OPTIONS ) );
        if ( pAssumeValidOptions || //
             Objects.isNotNullOrEmpty( pValidOptions ) || Objects.isNotNullOrEmpty( zHintedValidOptions ) )
        {
            AbstractSendableKeyValuePairConverter converter = //
                    (pDataConverter instanceof AbstractSendableKeyValuePairConverter) ? //
                    (AbstractSendableKeyValuePairConverter) pDataConverter :
                    new SendableExternalizedKeyValuePairConverter( mExternalization );
            SimpleKeyValuePair[] zMDoptions =
                    converter.createValidOptions( pValidOptions, zHintedValidOptions );

            if ( pParams.getUsage() instanceof InputImageAttributeUsage )
            {
                AttributeMetaData zMetaData;
                if ( Objects.isNullOrEmpty( zMDoptions ) )
                {
                    zMetaData = new InputImageMetaData( pParams.getUsage(), //
                                                        pParams.isDisabled(), //
                                                        pParams.getHints(), //
                                                        pParams.getFieldLabel(), //
                                                        pParams.getFieldTooltip(), //
                                                        pParams.isRequired(), //
                                                        pParams.getErrorTextForRequired() );
                }
                else
                {
                    zMetaData = new InputImageValidOptionsAttributeMetaData( pParams.getUsage(), //
                                                                             pParams.isDisabled(), //
                                                                             pParams.getFieldLabel(), //
                                                                             pParams.getFieldTooltip(), //
                                                                             pParams.isRequired(), //
                                                                             pParams.getErrorTextForRequired(),
                                                                             //
                                                                             zMDoptions );
                }
                return new AMDconverterPair( converter, zMetaData );
            }
            if ( pParams.isEditRequired() && CF_RADIO_GROUP.equals( zFormHint ) )
            {
                return RadioGroupFormAMD.INSTANCE.create( pParams, converter, zMDoptions );
            }
            return ComboBoxFormAMD.INSTANCE.create( pParams, converter, zMDoptions );
        }
        if ( pAMDFactory == null )
        {
            throw new IllegalStateException( "No Factory & No ValidOptions?" );
        }
        return pAMDFactory.createAttributeMetaData( pParams );
    }

    protected String[] parseHintValidOptions( String pHintValue )
    {
        return Strings.parseOptions( pHintValue );
    }

    public void removeInstanceHelper( String pRowKey )
    {
        mBackDoor.removeInstanceHelper( new FormDataRowKey( getFormUniqueID(), pRowKey ) );
    }

    public InstanceHelper createRelSubInstanceHelper( InstanceHelper pParent, String pRowKey )
    {
        InstanceHelper rv = LLcreateRelSubInstanceHelper( pParent, pRowKey );
        mBackDoor.add( rv );
        return rv;
    }

    abstract protected InstanceHelper LLcreateRelSubInstanceHelper( InstanceHelper pParent, String pRowKey );

    public AttributeResourceOptionsResponseData getResourceOptions( String pAttributeReference,
                                                                    FormSendableDataConverter pDataConverter )
    {
        return new AttributeResourceOptionsResponseData( ResourceOptionsErrorType.ErrorNotImplemented );
    }

    private static class BadAttributeParamsPlus extends CreateAMDParamsPlus
    {
        private String mLabelSuffix;
        private String mTooltip;

        public BadAttributeParamsPlus( CreateAMDParams pParams, String pLabelSuffix, String pTooltip )
        {
            super( pParams, null, // HintManager
                   false, // Required
                   true, // Disabled
                   false, // Hide
                   null, // MaxChars
                   null, // DisplayLines
                   null ); // DisplayCharsWidth
            mLabelSuffix = pLabelSuffix;
            mTooltip = pTooltip;
        }

        public String getFieldLabel()
        {
            return super.getFieldLabel() + mLabelSuffix;
        }

        public String getFieldTooltip()
        {
            return mTooltip;
        }
    }

    private static final Map<Class, FormAttributeMetaDataFactory> mAMDFactoriesByFieldType =
            new HashMap<Class, FormAttributeMetaDataFactory>();

    private static void add( Class pClass, FormAttributeMetaDataFactory pFactory )
    {
        mAMDFactoriesByFieldType.put( pClass, pFactory );
    }

    static
    {
        add( String.class, FormAMDFactory_String.INSTANCE );

        add( FloatingPointLong.class, FormAMDFactory_SimpleFloatingPointLong.INSTANCE );

        add( FixedPointLong.class, FormAMDFactory_SimpleFixedPointLong.INSTANCE );

        add( Money.class, FormAMDFactory_SimpleMoney.INSTANCE );

        add( SimpleTime.class, FormAMDFactory_SimpleTime.INSTANCE );
        add( java.sql.Time.class, FormAMDFactory_SimpleTime.INSTANCE );

        add( SimpleTimestamp.class, FormAMDFactory_SimpleTimestamp.INSTANCE );
        add( java.sql.Timestamp.class, FormAMDFactory_SimpleTimestamp.INSTANCE );

        add( CalendarYMD.class, FormAMDFactory_SimpleDate.INSTANCE );
        add( java.sql.Date.class, FormAMDFactory_SimpleDate.INSTANCE );

        add( Boolean.class, FormAMDFactory_Boolean.INSTANCE );
        add( boolean.class, FormAMDFactory_Boolean.INSTANCE );

        add( double.class, FormAMDFactory_Double.INSTANCE );
        add( Double.class, FormAMDFactory_Double.INSTANCE );

        add( float.class, FormAMDFactory_Float.INSTANCE );
        add( Float.class, FormAMDFactory_Float.INSTANCE );

        add( short.class, FormAMDFactory_Long.SHORT );
        add( Short.class, FormAMDFactory_Long.SHORT );
        add( int.class, FormAMDFactory_Long.INTEGER );
        add( Integer.class, FormAMDFactory_Long.INTEGER );
        add( long.class, FormAMDFactory_Long.LONG );
        add( Long.class, FormAMDFactory_Long.LONG );
    }
}