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

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.logger.*;
import org.litesoft.orsup.base.*;

public abstract class AttributeAccessorSCDpath
{
    protected static final Logger LOGGER = LoggerFactory.getLogger( AttributeAccessorSCDpath.class );

    public static class Node
    {
        private MetaDataForPO mPOmd;
        private AttributeAccessorSCD mAttributeAccessor;

        public Node( MetaDataForPO pPOmd, AttributeAccessorSCD pAttributeAccessor )
        {
            mPOmd = pPOmd;
            mAttributeAccessor = pAttributeAccessor;
        }

        public MetaDataForPO getPOmd()
        {
            return mPOmd;
        }

        public AttributeAccessorSCD getAttributeAccessor()
        {
            return mAttributeAccessor;
        }
    }

    private Finder mFinder;
    private MetaDataForPO mPOmd;

    /**
     * @param pFinder Finder to support look-up and ...
     * @param pPOmd   Starting PO metadata
     */
    public AttributeAccessorSCDpath( Finder pFinder, MetaDataForPO pPOmd )
    {
        mFinder = pFinder;
        mPOmd = pPOmd;
    }

    /**
     * Create a path of AttributeAccessorSCDpathNode, where if any attribute reference(s) does not resolve, null is returned!
     *
     * @param pDottedAttributereference Attribute reference(s) (separated by dots ('.'))
     *
     * @return [0...n] nodes of the path.  [0] is the start (will have the pPOmd in it) and [n] will be the end. OR null if any attribute reference(s) do not resolve.
     */
    public Node[] createPath( String pDottedAttributereference )
    {
        MetaDataForPO zPOmd = mPOmd;
        String[] zReferences = parseDottedAttributeReference( pDottedAttributereference );
        Node[] rv = new Node[zReferences.length];
        AttributeAccessorSCD zSCD;
        int zLastIndex = zReferences.length - 1;
        for ( int i = 0; i < zLastIndex; i++ )
        {
            if ( null == (zSCD = getAccessorSCD( rv, i, pDottedAttributereference, zPOmd, zReferences[i] )) )
            {
                return null;
            }
            if ( null == (zPOmd = getAcceptableRelationship( zSCD )) )
            {
                unacceptableRelationship( rv, i, pDottedAttributereference );
                return null;
            }
        }
        if ( null == (zSCD = getAccessorSCD( rv, zLastIndex, pDottedAttributereference, zPOmd, zReferences[zLastIndex] )) )
        {
            return null;
        }
        if ( !isAcceptableLeaf( zSCD ) )
        {
            unacceptableLeaf( rv, zLastIndex, pDottedAttributereference );
            return null;
        }
        return rv;
    }

    protected static void unacceptableLeaf( Node[] pTarget, int pIndex, String pDottedAttributereference )
    {
        if ( pTarget.length == 1 )
        {
            LOGGER.error.log( "Unacceptable Attribute (", pTarget[pIndex].getAttributeAccessor().getName(), ") type on PO: ", pTarget[pIndex].getPOmd().getPOregistrationName() );
        }
        else
        {
            LOGGER.error.log( unacceptable( pTarget, pIndex, "Last" ), " type", tail( pTarget, pIndex, pDottedAttributereference ) );
        }
    }

    protected static void unacceptableRelationship( Node[] pTarget, int pIndex, String pDottedAttributereference )
    {
        LOGGER.error.log( unacceptable( pTarget, pIndex, Integers.toNth( pIndex + 1 ) + " 'pre-dot'" ), tail( pTarget, pIndex, pDottedAttributereference ) );
    }

    protected static String unacceptable( Node[] pTarget, int pIndex, String pWhat )
    {
        return "Unacceptable " + pWhat + " Attribute (" + pTarget[pIndex].getAttributeAccessor().getName() + " on PO: " + pTarget[pIndex].getPOmd().getPOregistrationName() + ")";
    }

    protected AttributeAccessorSCD getAccessorSCD( Node[] pTarget, int pIndex, String pDottedAttributereference, MetaDataForPO pPOmd, String pReference )
    {
        AttributeAccessorSCD zSCD = pPOmd.getAccessorSCDoptional( pReference );
        if ( zSCD != null )
        {
            pTarget[pIndex] = new Node( pPOmd, zSCD );
            return zSCD;
        }
        if ( pTarget.length == 1 )
        {
            LOGGER.error.log( "Unknown Attribute (", pReference, ") on PO: ", pPOmd.getPOregistrationName() );
        }
        else
        {
            LOGGER.error.log( "Unknown ", Integers.toNth( pIndex + 1 ), " Attribute (", pReference, " on PO: ", pPOmd.getPOregistrationName(), ")", tail( pTarget, pIndex, pDottedAttributereference ) );
        }
        return null;
    }

    protected static String tail( Node[] pTarget, int pIndex, String pDottedAttributereference )
    {
        return " from Reference '" + pDottedAttributereference + ((pIndex == 0) ? "'" : "' from PO: " + pTarget[0].getPOmd().getPOregistrationName());
    }

    protected static String[] parseDottedAttributeReference( String pDottedAttributereference )
    {
        pDottedAttributereference = Strings.assertNotNullNotEmpty( "DottedAttributereference", pDottedAttributereference );
        String[] zReferences = Strings.parseChar( pDottedAttributereference, '.' );
        for ( int i = 0; i < zReferences.length; i++ )
        {
            if ( null == (zReferences[i] = Strings.noEmpty( zReferences[i] )) )
            {
                throw new IllegalArgumentException( Integers.toNth( i + 1 ) + " Reference empty!" );
            }
        }
        return zReferences;
    }

    protected MetaDataForPO getAcceptableRelationship( AttributeAccessorSCD pSCD )
    {
        if ( pSCD instanceof AbstractAttributeAccessorSCDtoPO )
        {
            String zToThemName = ((AbstractAttributeAccessorSCDtoPO) pSCD).getToThemName();
            if ( zToThemName != null )
            {
                return mFinder.getOptionalMetaDataForPO( zToThemName );
            }
        }
        return null;
    }

    abstract protected boolean isAcceptableLeaf( AttributeAccessorSCD pSCD );
}