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

import java.util.*;

import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.otherattributeaccessors.*;

public class MetaDataRegistry implements MetaDataStore
{
    private Map<String, MetaDataForPO> mMetaDataByPOtablename = new HashMap<String, MetaDataForPO>();
    private Map<String, MetaDataForPO> mMetaDataByPOregistrationname = new HashMap<String, MetaDataForPO>();
    private Map<String, MetaDataForPO> mMetaDataByPOidentifierName = new HashMap<String, MetaDataForPO>();
    private MetaDataForPO[] mAllMetaDataForPOs;

    public MetaDataRegistry( MetaDataForPOinternalExtension... pMDs )
    {
        if ( pMDs != null )
        {
            for ( MetaDataForPOinternalExtension zMD : pMDs )
            {
                if ( zMD != null )
                {
                    add( zMD );
                }
            }
        }
        mAllMetaDataForPOs = mMetaDataByPOregistrationname.values().toArray( new MetaDataForPO[mMetaDataByPOregistrationname.size()] );
    }

    @Override
    public MetaDataForPO[] getAllMetaDataForPOs()
    {
        return mAllMetaDataForPOs;
    }

    @Override
    public MetaDataForPO getMetaDataOptionallyByIdentifier( String pIdentifierName )
    {
        return mMetaDataByPOidentifierName.get( pIdentifierName );
    }

    @Override
    public MetaDataForPO getMetaDataOptional( String pPersistedObjectRegistrationName )
    {
        return mMetaDataByPOregistrationname.get( pPersistedObjectRegistrationName );
    }

    @Override
    public MetaDataForPO getMetaDataOptional( Class<? extends PersistentObject> pPersistedObjectClass )
    {
        return getMetaDataOptional( pPersistedObjectClass.getName() );
    }

    @Override
    public MetaDataForPO getMetaDataRequired( String pPersistedObjectRegistrationName )
    {
        MetaDataForPO zMD = getMetaDataOptional( pPersistedObjectRegistrationName );
        if ( zMD != null )
        {
            return zMD;
        }
        throw new MetaDataNotFoundException( pPersistedObjectRegistrationName );
    }

    @Override
    public MetaDataForPO getMetaDataRequired( Class<? extends PersistentObject> pPersistedObjectClass )
    {
        return getMetaDataRequired( pPersistedObjectClass.getName() );
    }

    private void add( MetaDataForPOinternalExtension pMetaDataForPO )
    {
        String zRegistrationName = pMetaDataForPO.getPOregistrationName();
        if ( zRegistrationName.equals( Parts4Blobs.MyMetaData.INSTANCE.getPOregistrationName() ) )
        {
            throw new IllegalArgumentException( "Underlying Blob support PO (Parts4Blobs) Automatically added" );
        }
        addNonNull( pMetaDataForPO );
        if ( !mBlobSupportAdded )
        {
            if ( zRegistrationName.equals( Blob.MyMetaData.INSTANCE.getPOregistrationName() ) )
            {
                addBlobSupport();
            }
            else if ( usesBlobs( pMetaDataForPO ) )
            {
                addNonNull( Blob.MyMetaData.INSTANCE );
                addBlobSupport();
            }
        }
    }

    private boolean usesBlobs( MetaDataForPO pMetaDataForPO )
    {
        for ( AttributeAccessorSCD zSCD : pMetaDataForPO.getAccessorSCDs() )
        {
            if ( zSCD instanceof AttributeAccessorSCDtoBlob )
            {
                return true;
            }
        }
        return false;
    }

    private void addBlobSupport()
    {
        addNonNull( Parts4Blobs.MyMetaData.INSTANCE );
        mBlobSupportAdded = true;
    }

    private boolean mBlobSupportAdded = false;

    private void addNonNull( MetaDataForPOinternalExtension pMetaDataForPO )
    {
        String zIdentifierName = pMetaDataForPO.getIdentifierName();
        String zRegistrationName = pMetaDataForPO.getPOregistrationName();
        String zTableName = pMetaDataForPO.getTableName();
        if ( mMetaDataByPOtablename.containsKey( zTableName ) )
        {
            throw new IllegalArgumentException( "Duplicate Persistable PO Table " + zTableName );
        }
        if ( mMetaDataByPOregistrationname.containsKey( zRegistrationName ) )
        {
            throw new IllegalArgumentException( "Duplicate Persistable PO Registration Name " + zRegistrationName );
        }
        if ( mMetaDataByPOidentifierName.containsKey( zRegistrationName ) )
        {
            throw new IllegalArgumentException( "Duplicate Persistable PO Identifier Name " + zRegistrationName );
        }
        pMetaDataForPO.LLset( this );
        mMetaDataByPOtablename.put( zTableName, pMetaDataForPO );
        mMetaDataByPOregistrationname.put( zRegistrationName, pMetaDataForPO );
        mMetaDataByPOidentifierName.put( zIdentifierName, pMetaDataForPO );
    }

    public MetaDataForPO[] getInReducingDependancyOrderAllMetaDataForPO()
    {
        MetaDataForPO[] zAllMDs = getAllMetaDataForPOs();
        Map<String, RefsAndMDs> zRefs = new HashMap<String, RefsAndMDs>( zAllMDs.length );
        for ( MetaDataForPO md : zAllMDs )
        {
            zRefs.put( md.getPOregistrationName(), new RefsAndMDs( md ) );
        }
        for ( MetaDataForPO md : zAllMDs )
        {
            AttributeAccessorSCD[] aas = md.getPersistingAccessorSCDs();
            for ( AttributeAccessorSCD aa : aas )
            {
                if ( aa instanceof AbstractAttributeAccessorSCDtoOne )
                {
                    String zToThemName = ((AbstractAttributeAccessorSCDtoOne) aa).getToThemName();
                    if ( zToThemName != null )
                    {
                        RefsAndMDs zRefsAndMDs = zRefs.get( zToThemName );
                        if ( zRefsAndMDs == null )
                        {
                            throw new IllegalStateException( "No Refs for (" + aa.getName() + "): " + zToThemName );
                        }
                        zRefsAndMDs.incRef();
                    }
                }
            }
        }
        List<RefsAndMDs> zRefsAndMDs = new ArrayList<RefsAndMDs>( zRefs.values() );
        Collections.sort( zRefsAndMDs );
        MetaDataForPO[] rv = new MetaDataForPO[zRefsAndMDs.size()];
        for ( int i = 0; i < zRefsAndMDs.size(); i++ )
        {
            rv[i] = zRefsAndMDs.get( i ).getPMetaDataForPO();
        }
        return rv;
    }

    private static class RefsAndMDs implements Comparable<RefsAndMDs>
    {
        private int mRefs = 0;
        private MetaDataForPO mMetaDataForPO;

        public RefsAndMDs( MetaDataForPO pMetaDataForPO )
        {
            mMetaDataForPO = pMetaDataForPO;
        }

        public void incRef()
        {
            mRefs++;
        }

        public MetaDataForPO getPMetaDataForPO()
        {
            return mMetaDataForPO;
        }

        @Override
        public int compareTo( RefsAndMDs them )
        {
            return CompareSupport.compareEm( them.mRefs - this.mRefs, //
                                             them.mMetaDataForPO.getPOregistrationName().compareTo( this.mMetaDataForPO.getPOregistrationName() ) );
        }
    }
}