// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.orsup.nonpublic;

import java.sql.*;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.orsup.base.*;
import org.litesoft.orsup.transact.*;

public abstract class PersistentObjectImplMetaData<T extends PersistentObjectImpl> implements MetaDataForPOinternalExtension<T>
{
    private MetaDataStore mMetaDataStore = null;
    private String mIdentifierName;
    private String mTableName;
    private AttributeAccessorKeySet mKeySet; // null means that there is NO Unique Key for this Table
    private AttributeAccessorSCD[] mAccessorSCDs;
    private Map<String, AttributeAccessorSCD> mAccessorSCDsByName = new HashMap<String, AttributeAccessorSCD>();
    private Integer mPrimaryKeyPersistingAccessorSCDsIndex = null;
    private AttributeAccessorSCD[] mPersistingAccessorSCDs;
    private AbstractAttributeAccessorSCDtoOne[] mToOneAccessorSCDsThatFlagPeerChange;
    private AbstractAttributeAccessorSCDtoOne[] mToOneAccessorSCDsThatFlagPeerChangeNotification;
    private Index[] mIndexes = Index.EMPTY_ARRAY;

    protected PersistentObjectImplMetaData( AttributeAccessorSCD[] pAccessorSCDs, String pIdentifierName, String pTableName, AttributeAccessorKeySet pAttributeAccessorKeySet, AttributeAccessorSCD... pMoreAccessorSCDs )
    {
        pAccessorSCDs = join( pAccessorSCDs, pMoreAccessorSCDs );
        mIdentifierName = Strings.assertNotNullNotEmpty( "IdentifierName", pIdentifierName );
        mTableName = Strings.assertNotNullNotEmpty( "TableName", pTableName );
        mKeySet = pAttributeAccessorKeySet;
        mAccessorSCDs = (pAccessorSCDs != null) ? pAccessorSCDs : AttributeAccessorSCD.EMPTY_ARRAY;

        List<AttributeAccessorSCD> acdsPersisted = new ArrayList<AttributeAccessorSCD>( mAccessorSCDs.length );
        List<AbstractAttributeAccessorSCDtoOne> acdsToOnePeerChangers = new ArrayList<AbstractAttributeAccessorSCDtoOne>( mAccessorSCDs.length );
        List<AbstractAttributeAccessorSCDtoOne> acdsToOnePeerChangeNotifiers = new ArrayList<AbstractAttributeAccessorSCDtoOne>( mAccessorSCDs.length );

        for ( AttributeAccessorSCD accessorSCD : mAccessorSCDs )
        {
            LLaddAccessor( accessorSCD );
            if ( accessorSCD.isPersisted() )
            {
                acdsPersisted.add( accessorSCD );
                if ( accessorSCD instanceof AbstractAttributeAccessorSCDtoOne )
                {
                    AbstractAttributeAccessorSCDtoOne zToOne = (AbstractAttributeAccessorSCDtoOne) accessorSCD;
                    if ( zToOne.changedPOflagsPeerChanged() )
                    {
                        acdsToOnePeerChangers.add( zToOne );
                    }
                    if ( zToOne.changedPOflagsPeerChangeNotification() )
                    {
                        acdsToOnePeerChangeNotifiers.add( zToOne );
                    }
                }
            }
        }
        mPersistingAccessorSCDs = acdsPersisted.toArray( new AttributeAccessorSCD[acdsPersisted.size()] );
        mToOneAccessorSCDsThatFlagPeerChange = acdsToOnePeerChangers.toArray( new AbstractAttributeAccessorSCDtoOne[acdsToOnePeerChangers.size()] );
        mToOneAccessorSCDsThatFlagPeerChangeNotification = acdsToOnePeerChangeNotifiers.toArray( new AbstractAttributeAccessorSCDtoOne[acdsToOnePeerChangeNotifiers.size()] );
        if ( mKeySet != null )
        {
            AttributeAccessorSCD<PersistentObject<?>>[] zKeySCDs = mKeySet.getKeyAttributeAccessorSCDs();
            if ( zKeySCDs.length == 1 )
            {
                for ( int i = 0; i < mPersistingAccessorSCDs.length; i++ )
                {
                    if ( mPersistingAccessorSCDs[i] == zKeySCDs[0] )
                    {
                        mPrimaryKeyPersistingAccessorSCDsIndex = i;
                        break;
                    }
                }
            }
        }
    }

    protected PersistentObjectImplMetaData( String pIdentifierName, String pTableName, AttributeAccessorKeySet pAttributeAccessorKeySet, AttributeAccessorSCD... pAccessorSCDs )
    {
        this( null, pIdentifierName, pTableName, pAttributeAccessorKeySet, pAccessorSCDs );
    }

    protected static AttributeAccessorSCD[] join( AttributeAccessorSCD[] pArray1, AttributeAccessorSCD[] pArray2 )
    {
        if ( (pArray2 == null) || (pArray2.length == 0) )
        {
            return pArray1;
        }
        if ( (pArray1 == null) || (pArray1.length == 0) )
        {
            return pArray2;
        }
        AttributeAccessorSCD[] joined = new AttributeAccessorSCD[pArray1.length + pArray2.length];
        System.arraycopy( pArray1, 0, joined, 0, pArray1.length );
        System.arraycopy( pArray2, 0, joined, pArray1.length, pArray2.length );
        return joined;
    }

    private boolean LLaddAccessor( AttributeAccessorSCD pAccessor )
    {
        if ( pAccessor == null )
        {
            return false;
        }

        String zAttributeName = makeCaseInsensitive( pAccessor.getName() );
        if ( mAccessorSCDsByName.containsKey( zAttributeName ) )
        {
            throw new IllegalArgumentException( "Attempt to add an AttributeAccessorSCD (" + pAccessor.getName() + ") who's name already exists in: " + getIdentifierName() );
        }
        mAccessorSCDsByName.put( zAttributeName, pAccessor );
        return true;
    }

    @Override
    public void LLset( MetaDataStore pMetaDataStore )
    {
        mMetaDataStore = pMetaDataStore;
    }

    @Override
    public MetaDataStore getMetaDataStore()
    {
        return mMetaDataStore;
    }

    public final void addAccessor( AttributeAccessorSCD pAccessor )
    {
        if ( !LLaddAccessor( pAccessor ) )
        {
            return;
        }

        mAccessorSCDs = AttributeAccessorSCD.append( mAccessorSCDs, pAccessor );

        if ( pAccessor.isPersisted() )
        {
            mPersistingAccessorSCDs = AttributeAccessorSCD.append( mPersistingAccessorSCDs, pAccessor );
            if ( pAccessor instanceof AbstractAttributeAccessorSCDtoOne )
            {
                AbstractAttributeAccessorSCDtoOne zToOne = (AbstractAttributeAccessorSCDtoOne) pAccessor;
                if ( zToOne.changedPOflagsPeerChanged() )
                {
                    mToOneAccessorSCDsThatFlagPeerChange = //
                            AbstractAttributeAccessorSCDtoOne.append( //
                                                                      mToOneAccessorSCDsThatFlagPeerChange, zToOne );
                }
                if ( zToOne.changedPOflagsPeerChangeNotification() )
                {
                    mToOneAccessorSCDsThatFlagPeerChangeNotification = //
                            AbstractAttributeAccessorSCDtoOne.append( //
                                                                      mToOneAccessorSCDsThatFlagPeerChangeNotification, zToOne );
                }
            }
        }
    }

    /**
     * This api is intended mainly for cleanup after running junit tests that dynamically
     * add backpointers
     */
    public final void deleteAccessor( String pAttributeName )
    {
        AttributeAccessorSCD scd = getAccessorSCDoptional( pAttributeName );
        if ( scd != null )
        {
            if ( mPrimaryKeyPersistingAccessorSCDsIndex != null )
            {
                Integer zPersistingAt = findPersistingASCDindex( scd );
                if ( (zPersistingAt != null) && (zPersistingAt <= mPrimaryKeyPersistingAccessorSCDsIndex) )
                {
                    throw new IllegalStateException( "May not remove a column/attribute positioned at/before the Primay Key" );
                }
            }
            mAccessorSCDsByName.remove( makeCaseInsensitive( pAttributeName ) );
            mAccessorSCDs = AttributeAccessorSCD.remove( mAccessorSCDs, scd );
            mPersistingAccessorSCDs = AttributeAccessorSCD.remove( mPersistingAccessorSCDs, scd );
            mToOneAccessorSCDsThatFlagPeerChange = //
                    AbstractAttributeAccessorSCDtoOne.remove( //
                                                              mToOneAccessorSCDsThatFlagPeerChange, scd );
            mToOneAccessorSCDsThatFlagPeerChangeNotification = //
                    AbstractAttributeAccessorSCDtoOne.remove( //
                                                              mToOneAccessorSCDsThatFlagPeerChangeNotification, scd );
        }
    }

    private Integer findPersistingASCDindex( AttributeAccessorSCD pSCD )
    {
        for ( int i = mPersistingAccessorSCDs.length; --i >= 0; )
        {
            if ( pSCD == mPersistingAccessorSCDs[i] )
            {
                return i;
            }
        }
        return null;
    }

    @Override
    public final Integer getPrimaryKeyPersistingAccessorSCDsIndex()
    {
        return mPrimaryKeyPersistingAccessorSCDsIndex;
    }

    @Override
    public Index[] getIndexes()
    {
        return mIndexes;
    }

    public void setIndexes( Index... pIndexes )
    {
        mIndexes = pIndexes;
    }

    @Override
    public T createNew( Map<String, ?> pInitialAttributeNameValues, Transaction pTransaction )
    {
        T po = createNew( pTransaction );
        if ( pInitialAttributeNameValues != null )
        {
            for ( Map.Entry<String, ?> entry : pInitialAttributeNameValues.entrySet() )
            {
                po.setAttributeValue( entry.getKey(), entry.getValue() );
            }
        }
        return po;
    }

    @Override
    public T createPO( Finder pFinder, Object[] pRow )
    {
        AttributeAccessorSCD[] paCDs = getPersistingAccessorSCDs();
        if ( paCDs.length != pRow.length )
        {
            throw new IllegalStateException( "On '" + getPOregistrationName() + "', " + //
                                             "Expected Row with " + paCDs.length + " entries, " + //
                                             "but got " + pRow.length );
        }
        T po = createPOfromFinder();
        for ( int i = 0; i < paCDs.length; i++ )
        {
            AttributeAccessorSCD acd = paCDs[i];
            //noinspection unchecked
            acd.db_setValueOnPO( po, pRow[i] );
        }
        return PersistentObjectImpl.BackDoor.rehydrationComplete( po, pFinder );
    }

    @Override
    public final String getIdentifierName()
    {
        return mIdentifierName;
    }

    @Override
    public final String getTableName()
    {
        return mTableName;
    }

    @Override
    public boolean isReferencePO()
    {
        return false;
    }

    @Override
    public boolean isORMetaDataMutating()
    {
        Class zPOclass = getPOclass();
        return ORMetaDataMutating.class.isAssignableFrom( zPOclass );
    }

    @Override
    public boolean isImportable()
    {
        Class zPOclass = getPOclass();
        return !NonImportableFeature.class.isAssignableFrom( zPOclass ); // Note the '!' (not)
    }

    @Override
    public final boolean isPotentiallyImmortallyInActive()
    {
        return !getMortality().equals( Mortality.Mortal ); // Force NPE if not implemented correctly!
    }

    @Override
    public Mortality getMortality()
    {
        return Mortality.Mortal;
    }

    @Override
    public String getImmortalInactiveAttributeName()
    {
        return null;
    }

    @Override
    public String getInstanceImmortalImmortalAttributeName()
    {
        return null;
    }

    @Override
    public boolean isUpdatable()
    {
        return true;
    }

    @Override
    public String getInstanceManagedUpdatabilityLockedAttributeName()
    {
        return null;
    }

    @Override
    public boolean isCreationTimestampable()
    {
        return getCreationTimestampAttributeName() != null;
    }

    @Override
    public String getCreationTimestampAttributeName()
    {
        return null;
    }

    @Override
    public final boolean isTransactionTimestampable()
    {
        return getTransactionTimestampAttributeName() != null;
    }

    @Override
    public String getTransactionTimestampAttributeName()
    {
        return null;
    }

    @Override
    public final boolean isRecordVersionable()
    {
        return getRecordVersionAttributeName() != null;
    }

    @Override
    public String getRecordVersionAttributeName()
    {
        return null;
    }

    @Override
    public final boolean isSnagable()
    {
        return getSnagAttributeName() != null;
    }

    @Override
    public String getSnagAttributeName()
    {
        return null;
    }

    @Override
    public String getDefaultOrderByAttributeName()
    {
        return null;
    }

    @Override
    public String getPOregistrationName()
    {
        return getPOclass().getName();
    }

    @Override
    public AttributeAccessorKeySet getKeySet()
    {
        return mKeySet;
    }

    @Override
    public final AttributeAccessorSCD getAccessorSCDrequired( String pAttributeName )
    {
        AttributeAccessorSCD scd = getAccessorSCDoptional( pAttributeName );
        if ( scd != null )
        {
            return scd;
        }
        throw new NoSuchElementException( "'" + pAttributeName + "' on PO type: " + getIdentifierName() );
    }

    @Override
    public final AttributeAccessorSCD getAccessorSCDoptional( String pAttributeName )
    {
        return mAccessorSCDsByName.get( makeCaseInsensitive( pAttributeName ) );
    }

    @Override
    public final boolean hasAttribute( String pAttributeName )
    {
        return getAccessorSCDoptional( pAttributeName ) != null;
    }

    @Override
    public String[] getAttributeNames()
    {
        AttributeAccessorSCD[] zSCDs = getAccessorSCDs();
        String[] rv = new String[zSCDs.length];
        for ( int i = 0; i < zSCDs.length; i++ )
        {
            rv[i] = zSCDs[i].getName();
        }
        return rv;
    }

    @Override
    public final AttributeAccessorSCD[] getAccessorSCDs()
    {
        return mAccessorSCDs;
    }

    @Override
    public final AttributeAccessorSCD[] getPersistingAccessorSCDs()
    {
        return mPersistingAccessorSCDs;
    }

    @Override
    public final AbstractAttributeAccessorSCDtoOne[] getToOneAccessorSCDsThatFlagPeerChange()
    {
        return mToOneAccessorSCDsThatFlagPeerChange;
    }

    @Override
    public final AbstractAttributeAccessorSCDtoOne[] getToOneAccessorSCDsThatFlagPeerChangeNotification()
    {
        return mToOneAccessorSCDsThatFlagPeerChangeNotification;
    }

    @SuppressWarnings({"unchecked"}) @Override
    public final PersistentObjectUniqueKey createUniqueKeyFrom( String pKeyToString )
            throws IllegalArgumentException
    {
        if ( mKeySet == null )
        {
            throw new IllegalArgumentException( mIdentifierName + " does not have Uniqueness" );
        }
        AttributeAccessorSCD[] zAASCDs = mKeySet.getKeyAttributeAccessorSCDs();
        return (zAASCDs.length == 1) ? new UniqueKeySingle( pKeyToString, zAASCDs[0] ) : new UniqueKeyMulti( pKeyToString, zAASCDs );
    }

    @Override
    public void setCommitTimestamps( T pPersistentObject, Timestamp pTransactionTimeStamp )
    {
        if ( pPersistentObject.isNew() && isCreationTimestampable() )
        {
            setCreationTimestamp( pPersistentObject, pTransactionTimeStamp );
        }
        if ( isTransactionTimestampable() )
        {
            setTransactionTimestamp( pPersistentObject, pTransactionTimeStamp );
        }
    }

    @Override
    public final int compareTo( MetaDataForPO pThem )
    {
        return this.getTableName().compareTo( pThem.getTableName() );
    }

    @Override
    public String toString()
    {
        return "MetaData for " + getPOregistrationName();
    }

    protected void setCreationTimestamp( T pPersistentObject, Timestamp pTransactionTimeStamp )
    {
        throw new IllegalStateException( "Should have overriden setCreationTimestamp" );
    }

    protected void setTransactionTimestamp( T pPersistentObject, Timestamp pTransactionTimeStamp )
    {
        throw new IllegalStateException( "Should have overriden setTransactionTimestamp" );
    }

    protected String makeCaseInsensitive( String pString )
    {
        return (pString == null) ? pString : pString.toLowerCase();
    }
}