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

import org.litesoft.commonfoundation.typeutils.*;

public class DottedReference
{
    public static final String SEPERATOR = ".";
    public static final String TO_SELF = ".";

    public static final char SELECTOR_START = '[';
    public static final char SELECTOR_END = ']';
    public static final char SELECTOR_BY_VALUE_SEPERATOR = '=';

    public static Parts parse( String pReference )
            throws IllegalArgumentException
    {
        return new Parts( pReference );
    }

    public interface Selector
    {
    }

    public static class SelectorIndexed implements Selector
    {
        private int mIndex;

        private SelectorIndexed( int pIndex )
        {
            mIndex = pIndex;
        }

        public int getIndex()
        {
            return mIndex;
        }

        @Override
        public String toString()
        {
            return Integer.toString( mIndex );
        }
    }

    public static class SelectorByValue implements Selector
    {
        private String mValue;
        private Parts mParts;

        private SelectorByValue( String pValue, Parts pParts )
        {
            mValue = pValue;
            mParts = pParts;
        }

        public Object getValue()
        {
            return mValue;
        }

        public Parts getParts()
        {
            return mParts;
        }

        @Override
        public String toString()
        {
            return mValue + SELECTOR_BY_VALUE_SEPERATOR + mParts;
        }
    }

    public static class Parts
    {
        private String mLocalReference;
        private Selector mSelector = null;
        private String mRestOfReference = null;

        public String getLocalReference()
        {
            return mLocalReference;
        }

        public Selector getSelector()
        {
            return mSelector;
        }

        public String getRestOfReference()
        {
            return mRestOfReference;
        }

        @Override
        public String toString()
        {
            StringBuilder sb = new StringBuilder( mLocalReference );
            if ( mSelector != null )
            {
                sb.append( SELECTOR_START ).append( mSelector ).append( SELECTOR_END );
            }
            if ( mRestOfReference != null )
            {
                sb.append( SEPERATOR ).append( mRestOfReference );
            }
            return sb.toString();
        }

        private void setLocalReference( String pReference, String pLocalReference )
        {
            if ( null == (mLocalReference = Strings.noEmpty( pLocalReference )) )
            {
                throw new IllegalArgumentException( "No Local Reference in '" + pReference + "'" );
            }
        }

        private void setRestOfReference( String pReference, String pRestOfReference )
        {
            if ( null == (mRestOfReference = Strings.noEmpty( pRestOfReference )) )
            {
                throw new IllegalArgumentException( "Nothing after '" + SEPERATOR + "' in '" + pReference + "'" );
            }
        }

        private IllegalArgumentException badSelector( String pReference, String pWhy )
        {
            return new IllegalArgumentException( "Invalid formated Selector in '" + pReference + "': " + pWhy );
        }

        private Parts( String pReference )
        {
            pReference = Strings.deNull( pReference ).trim();
            int sepAt = pReference.indexOf( SEPERATOR );
            int selectorStartsAt = pReference.indexOf( SELECTOR_START );
            if ( sepAt == -1 )
            {
                if ( selectorStartsAt == -1 )
                {
                    // neither a Sep or a Selector
                    setLocalReference( pReference, pReference );
                    return;
                }
                int lastCharAt = pReference.length() - 1;
                if ( SELECTOR_END == pReference.charAt( lastCharAt ) )
                {
                    // Just a Local Ref & Selector
                    setLocalReference( pReference, pReference.substring( 0, selectorStartsAt ) );
                    mSelector = parseSelector( pReference, pReference.substring( selectorStartsAt + 1, lastCharAt ) );
                    return;
                }
                throw badSelector( pReference, "End Not at End" );
            }
            if ( (selectorStartsAt == -1) || (sepAt < selectorStartsAt) )
            {
                // Is a Sep & Either No Selector or the Selector is in the Rest
                setLocalReference( pReference, pReference.substring( 0, sepAt ) );
                setRestOfReference( pReference, pReference.substring( sepAt + 1 ) );
                return;
            }
            // Selector and Sep are all mixed up - so isolate the 'whole' selector
            int selectorEndsAt = locateSelectorEnd( pReference, selectorStartsAt );
            setLocalReference( pReference, pReference.substring( 0, selectorStartsAt ) );
            mSelector = parseSelector( pReference, pReference.substring( selectorStartsAt + 1, selectorEndsAt ) );
            String zRest = pReference.substring( selectorEndsAt + 1 ).trim();
            if ( zRest.length() != 0 )
            {
                if ( zRest.startsWith( SEPERATOR ) )
                {
                    setRestOfReference( pReference, zRest.substring( 1 ) );
                    return;
                }
            }
            throw new IllegalArgumentException( "Invalid format after '" + SELECTOR_END + "' in '" + pReference + "'" );
        }

        private int locateSelectorEnd( String pReference, int pSelectorStartsAt )
        {
            int possibleEnd = pReference.indexOf( SELECTOR_END, pSelectorStartsAt + 1 );
            if ( possibleEnd == -1 )
            {
                throw badSelector( pReference, "No End" );
            }
            int matchingStartAt = pReference.lastIndexOf( SELECTOR_START, possibleEnd );
            while ( pSelectorStartsAt != matchingStartAt )
            {
                int backFrom = matchingStartAt - 1;
                matchingStartAt = pReference.lastIndexOf( SELECTOR_START, backFrom );
                int endFrom = possibleEnd + 1;
                possibleEnd = pReference.indexOf( SELECTOR_END, endFrom );
                if ( (possibleEnd == -1) || (matchingStartAt == -1) )
                {
                    throw badSelector( pReference, "No matching End" );
                }
            }
            return possibleEnd;
        }

        private Selector parseSelector( String pReference, String pSelector )
        {
            if ( null == (pSelector = Strings.noEmpty( pSelector )) )
            {
                throw badSelector( pReference, "No Selector text" );
            }
            int byValueAt = pSelector.indexOf( SELECTOR_BY_VALUE_SEPERATOR );
            if ( byValueAt == -1 )
            {
                int index;
                try
                {
                    index = Integer.parseInt( pSelector );
                }
                catch ( NumberFormatException e )
                {
                    throw badSelector( pReference, "No '" + SELECTOR_BY_VALUE_SEPERATOR + "', expected index" );
                }
                return new SelectorIndexed( index );
            }
            String value = pSelector.substring( 0, byValueAt ).trim();
            String rest = pSelector.substring( byValueAt + 1 ).trim();
            if ( rest.length() == 0 )
            {
                throw badSelector( pReference, "Nothing after '" + SELECTOR_BY_VALUE_SEPERATOR + "'" );
            }
            return new SelectorByValue( value, new Parts( rest ) );
        }
    }
}