// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.aokeyhole.objects;

import org.litesoft.aokeyhole.objects.attributes.*;
import org.litesoft.aokeyhole.objects.support.*;
import org.litesoft.aokeyhole.toolkit.*;

public class AttributeMetaDataRelatedPersisted extends AttributeMetaDataRelated {
    private String mBackAttrib = null;

    public AttributeMetaDataRelatedPersisted( AttributeSet pAttributeSet, Mode pMode, boolean pEditable, PropertyMetaData[] pPropertyMetaDatas,
                                              IdentifierValidator pNameValidator, String pName ) {
        super( pAttributeSet, pMode, pEditable, false, pPropertyMetaDatas, pNameValidator, pName );
    }

    public boolean isVariableToOne() {
        return (getAttributeSet() instanceof VariableToOne);
    }

    public boolean isCommonPairedToOne() {
        return A_CommonPairedToOne.TYPE.equals( getAttributeSet().getType() );
    }

    @Override
    public String getRelatedTo() {
        String zRelatedTo = super.getRelatedTo();
        if ( zRelatedTo == null ) {
            if ( isVariableToOne() || isCommonPairedToOne() ) {
                return ObjectNames.VARIES_RELATED_TO;
            }
        }
        return zRelatedTo;
    }

    public String getBackAttrib() {
        return mBackAttrib;
    }

    public void unpersistBackAttrib( String pBackAttrib ) {
        chkUnhappyCase( updateBackAttrib( pBackAttrib ) );
    }

    /**
     * @return null or Error
     */
    public String setBackAttrib( String pBackAttrib ) {
        verifyEditability();
        return updateBackAttrib( pBackAttrib );
    }

    /**
     * @return null or Error
     */
    protected String updateBackAttrib( String pBackAttrib ) {
        pBackAttrib = trimEmptyToNull( pBackAttrib );
        if ( !areEqual( mBackAttrib, pBackAttrib ) ) {
            mBackAttrib = pBackAttrib;
            changed();
        }
        return null;
    }

    @Override
    protected String[] getAdditionalValues() {
        AttributeType zAttributeType = getAttributeSet().getType();
        if ( !(zAttributeType instanceof NoPeerAttribute) ) {
            return (mBackAttrib != null) ? new String[]{getAdditionalValueRelatedTo(), mBackAttrib} : super.getAdditionalValues();
        }
        return null;
    }

    @Override
    public void setUpView( NameValuesComponent pNameValuesComponent ) {
        super.setUpView( pNameValuesComponent );

        ObjectMetaData object = mRelatedTo.getObjectMetaData();
        String[] options = (object == null) ? new String[0] : object.getSortedRelatedPersistedAttributeNamesTo( !isToMany(), getOwner() );
        pNameValuesComponent.setOptions( AttribNamesRelatedPersisted.BACK_REF, options );

        pNameValuesComponent.setValue( AttribNamesRelatedPersisted.BACK_REF, getBackAttrib() );
    }

    @Override
    public void deleteExistingCollectChanges( ChangeHandler pChanges ) {
        if ( mBackAttrib != null ) {
            ObjectMetaData zCurRelToObject = mRelatedTo.getObjectMetaData();
            if ( zCurRelToObject != null ) {
                AttributeMetaData zCurBackAttribute = zCurRelToObject.getAttribute( mBackAttrib );
                if ( zCurBackAttribute == null ) {
                    throw new RuntimeException( "Unable to locate Current " + backRefString( mBackAttrib, null ) );
                }
                if ( !(zCurBackAttribute instanceof AttributeMetaDataRelatedPersisted) ) {
                    throw new RuntimeException( backRefString( mBackAttrib, zCurBackAttribute.getName() ) + " NOT a Persisted Relationship" );
                }
                pChanges.add( new ClearOldBackRef( (AttributeMetaDataRelatedPersisted) zCurBackAttribute ) );
            }
        }
        super.deleteExistingCollectChanges( pChanges );
    }

    @Override
    protected ChangeFragment checkNameChange( String pNewName ) {
        mNewName = null;
        return super.checkNameChange( pNewName );
    }

    @Override
    protected ChangeFragment createChangeNameFragment( String pNewName ) {
        return super.createChangeNameFragment( mNewName = pNewName );
    }

    private String mNewName = null;

    @Override
    protected void augmentSaveFromView( ChangeHandler pChanges, NameValuesComponent pNameValuesComponent, String pCurRelatedTo, ObjectMetaData pNewRelToObject ) {
        String zNewRelatedTo = pNewRelToObject.getName();

        String zCurBackRef = deNull( getBackAttrib() );
        String zNewBackRef = deNull( pNameValuesComponent.getValue( AttribNamesRelatedPersisted.BACK_REF ) );

        FundamentalAttributeType zOurFAT = this.getAttributeSet().getType().getFAT();
        FundamentalAttributeType zRequiredBackReferenceType = zOurFAT.getCompatibleBackReferenceType();

        AttributeMetaData zNewBackAttribute = null;
        if ( (zNewBackRef.length() != 0) && !zNewBackRef.startsWith( "!" ) ) {
            zNewBackAttribute = pNewRelToObject.getAttribute( zNewBackRef );
            if ( (null == zNewBackAttribute) ) {
                throw new RuntimeException( "No " + backRefString( zNewBackRef, zNewRelatedTo ) );
            }
            if ( zNewBackAttribute.isVirtual() ) {
                throw new RuntimeException( "Virtual " + backRefString( zNewBackRef, zNewRelatedTo ) + " are NOT allowed" );
            }
            if ( !zRequiredBackReferenceType.equals( zNewBackAttribute.getAttributeSet().getType().getFAT() ) ) {
                throw new RuntimeException( backRefString( zNewBackRef, zNewRelatedTo ) + " NOT a " + zRequiredBackReferenceType + " type" );
            }
        }

        String zNewName;
        if ( ((zNewName = mNewName) == null) ) {
            if ( areEqual( pCurRelatedTo, zNewRelatedTo ) && areEqual( zCurBackRef, zNewBackRef ) ) {
                return;
            }
            zNewName = getName();
        }

        if ( zCurBackRef.length() != 0 ) {
            ObjectMetaData zCurRelToObject = getObjectMetaData( pCurRelatedTo );
            AttributeMetaData zCurBackAttribute = zCurRelToObject.getAttribute( zCurBackRef );
            if ( zCurBackAttribute != null ) {
                if ( !(zCurBackAttribute instanceof AttributeMetaDataRelatedPersisted) ) {
                    throw new RuntimeException( backRefString( zCurBackRef, pCurRelatedTo ) + " NOT a Persisted Relationship" );
                }
                pChanges.add( new ClearOldBackRef( (AttributeMetaDataRelatedPersisted) zCurBackAttribute ) );
            }
        }

        if ( zNewBackRef.startsWith( "!" ) ) {
            zNewBackRef = zNewBackRef.substring( 1 );

            String zError = getNameValidator().validateIdentifier( zNewBackRef, "Back Reference Attribute Name" );
            if ( zError != null ) {
                throw new RuntimeException( zError );
            }
            if ( pNewRelToObject.isUsedOwnedName( zNewBackRef ) ) {
                throw new RuntimeException( "New " + backRefString( zNewBackRef, zNewRelatedTo ) + " Already exists" );
            }
            switch ( zRequiredBackReferenceType ) {
                default: // Can't Happen!
                case ToMany:
                    pChanges.add( new CreateNewToManyAttribute( pNewRelToObject, zNewBackRef, getObjectMetaData(), zNewName ) );
                    break;
                case ToOne:
                    pChanges.add( new CreateNewToOneAttribute( pNewRelToObject, zNewBackRef, getObjectMetaData(), zNewName ) );
                    break;
            }
        } else if ( zNewBackRef.length() != 0 ) {
            if ( !(zNewBackAttribute instanceof AttributeMetaDataRelatedPersisted) ) {
                throw new RuntimeException( backRefString( zNewBackRef, zNewRelatedTo ) + " NOT a Persisted Relationship" );
            }
            pChanges.add( new ChangeBackRefOnTo( (AttributeMetaDataRelatedPersisted) zNewBackAttribute, zNewName ) );
        }

        if ( !areEqual( zCurBackRef, zNewBackRef ) ) {
            pChanges.add( new ChangeBackRef( zNewBackRef ) );
        }

        pChanges.add( checkRelatedToChange( pCurRelatedTo, pNewRelToObject.getName() ) );

        //RelatedPersisted.ChangeRelated (null->DBV2) from '|' to: |
        //RelatedPersisted.ChangeRelated (DbVersion) from 'DbVersion|DbTables' to: DbVersion|
        //RelatedPersisted.ChangeRelated (DBV2) from '|' to: |!Xyzzy2
        //RelatedPersisted.ChangeRelated (DbVersion) from 'DbVersion|DbTables' to: DbVersion|!xyZZy
        //RelatedPersisted.ChangeRelated (DbVersion) from 'DbVersion|DbTables' to: DbVersion|!.
        //RelatedPersisted.ChangeRelated (DbVersion) from 'DbVersion|DbTables' to: Device|
        //RelatedPersisted.ChangeRelated (DbVersion) from 'DbVersion|DbTables' to: DbTable|DbTables
        //RelatedPersisted.ChangeRelated (DbVersion) from 'DbVersion|DbTables' to: DbVersion|!Xyzzy
        //RelatedPersisted.ChangeRelated (DbVersion->DatabaseVersion) from 'DbVersion|DbTables' to: DbVersion|DbTables
        //RelatedPersisted.ChangeRelated (DatabaseVersion->DbaseVersion) from 'DbVersion|DbTables' to: DbVersion|!Xyzzy

        //System.out.println( "RelatedPersisted.ChangeRelated (" +
        //                    ((mNewName == null) ? getName() : getName() + "->" + mNewName) + ") " + "from '" +
        //                    pCurRelatedTo + "|" + zCurBackRef + "' " + "to: " + zNewRelatedTo + "|" +
        //                    zNewBackRef );
    }

    private String backRefString( String pNewBackRef, String pNewRelatedTo ) {
        return "Back Reference Attribute '" + pNewBackRef + "' on Related To '" + pNewRelatedTo + "'";
    }

    protected class ChangeBackRef implements ChangeFragment {
        private String mNewBackRef;

        public ChangeBackRef( String pNewBackRef ) {
            mNewBackRef = pNewBackRef;
        }

        @Override
        public void commitChange() {
            setBackAttrib( mNewBackRef );
        }
    }

    protected static class ChangeBackRefOnTo implements ChangeFragment {
        private AttributeMetaDataRelatedPersisted mNewBackAttribute;
        private String mNewBackRef;

        public ChangeBackRefOnTo( AttributeMetaDataRelatedPersisted pNewBackAttribute, String pNewBackRef ) {
            mNewBackAttribute = pNewBackAttribute;
            mNewBackRef = pNewBackRef;
        }

        @Override
        public void commitChange() {
            mNewBackAttribute.setBackAttrib( mNewBackRef );
        }
    }

    protected static class ClearOldBackRef implements ChangeFragment {
        private AttributeMetaDataRelatedPersisted mCurBackAttribute;

        public ClearOldBackRef( AttributeMetaDataRelatedPersisted pCurBackAttribute ) {
            mCurBackAttribute = pCurBackAttribute;
        }

        @Override
        public void commitChange() {
            mCurBackAttribute.setBackAttrib( null );
        }
    }

    protected abstract class CreateNewAttribute implements ChangeFragment {
        protected ObjectMetaData mNewAttributesObject;
        private ObjectMetaData mNewAttributesRelToObject;
        private String mNewAttributesName;
        private String mNewAttributesBackRef;

        public CreateNewAttribute( ObjectMetaData pNewAttributesObject, String pNewAttributesName, ObjectMetaData pNewAttributesRelToObject,
                                   String pNewAttributesBackRef ) {
            mNewAttributesObject = pNewAttributesObject;
            mNewAttributesName = pNewAttributesName;
            mNewAttributesRelToObject = pNewAttributesRelToObject;
            mNewAttributesBackRef = pNewAttributesBackRef;
        }

        @Override
        public void commitChange() {
            AttributeMetaDataRelatedPersisted zNewBackAttribute = createAttribute();
            zNewBackAttribute.setName( mNewAttributesName );
            zNewBackAttribute.setRelatedTo( mNewAttributesRelToObject.getName() );
            zNewBackAttribute.setBackAttrib( mNewAttributesBackRef );
        }

        abstract protected AttributeMetaDataRelatedPersisted createAttribute();
    }

    protected class CreateNewToOneAttribute extends CreateNewAttribute {
        public CreateNewToOneAttribute( ObjectMetaData pNewAttributesObject, String pNewAttributesName, ObjectMetaData pNewAttributesRelToObject,
                                        String pNewAttributesBackRef ) {
            super( pNewAttributesObject, pNewAttributesName, pNewAttributesRelToObject, pNewAttributesBackRef );
        }

        @Override
        protected AttributeMetaDataRelatedPersisted createAttribute() {
            return (AttributeMetaDataRelatedPersisted) mNewAttributesObject.createAttributeMetaData( A_ToOne.TYPE, false );
        }
    }

    protected class CreateNewToManyAttribute extends CreateNewAttribute {
        public CreateNewToManyAttribute( ObjectMetaData pNewAttributesObject, String pNewAttributesName, ObjectMetaData pNewAttributesRelToObject,
                                         String pNewAttributesBackRef ) {
            super( pNewAttributesObject, pNewAttributesName, pNewAttributesRelToObject, pNewAttributesBackRef );
        }

        @Override
        protected AttributeMetaDataRelatedPersisted createAttribute() {
            return (AttributeMetaDataRelatedPersisted) mNewAttributesObject.createAttributeMetaData( A_ToMany.TYPE, false );
        }
    }
}