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

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.commonfoundation.typeutils.*;

public class ToLinesObjectsParseStream
{
    private static final Line NULL = new Line( -1, null );

    private String[] mLines;
    private int mNextIndex = 0;
    private Line mCurrent, mNext;

    public ToLinesObjectsParseStream( String... pLines )
    {
        mLines = (pLines != null) ? pLines : Strings.EMPTY_ARRAY;
        mCurrent = NULL;
        readNext();
    }

    public boolean readLine()
    {
        mCurrent = mNext;
        readNext();
        return mCurrent.isNotIgnorable();
    }

    private boolean isAnotherLine()
    {
        return (mNextIndex < mLines.length);
    }

    private void readNext()
    {
        while ( isAnotherLine() )
        {
            mNext = new Line( mNextIndex, mLines[mNextIndex] );
            mNextIndex++;
            if ( mNext.isNotIgnorable() )
            {
                return;
            }
        }
        mNext = NULL;
    }

    public ParseException error( String pError )
    {
        return mCurrent.error( pError );
    }

    public boolean isNextDeeper()
    {
        return (mNext.getDepth() > mCurrent.getDepth());
    }

    public boolean isNextDepth( int pDepth )
    {
        return (mNext.getDepth() == pDepth);
    }

    public void validateDepth( int pDepth )
    {
        mCurrent.validateDepth( pDepth );
    }

    public int getDepth()
    {
        return mCurrent.getDepth();
    }

    public String getWhat()
    {
        return mCurrent.getWhat();
    }

    public String getData()
    {
        return mCurrent.getData();
    }

    public boolean isNextWhat( String pWhat )
    {
        return mNext.isWhat( pWhat );
    }

    public String[] parseData( char pSeperator )
    {
        String data = mCurrent.getData();
        int zParts = 1;
        for ( int i = 0; i < data.length(); i++ )
        {
            if ( data.charAt( i ) == pSeperator )
            {
                zParts++;
            }
        }
        String[] parts = new String[zParts];
        int part = 0;
        int from = 0;
        for ( int at; -1 != (at = data.indexOf( pSeperator, from )); from = at + 1 )
        {
            parts[part++] = data.substring( from, at ).trim();
        }
        parts[part] = data.substring( from ).trim();
        return parts;
    }

    public String[] parseData( int pExpectedParts, char pSeperator )
    {
        if ( pExpectedParts < 1 )
        {
            throw new IllegalArgumentException( "? ExpectedParts: " + pExpectedParts );
        }
        String[] zParts = parseData( pSeperator );
        if ( zParts.length == pExpectedParts )
        {
            return zParts;
        }
        if ( zParts.length > pExpectedParts )
        {
            throw error( "Expected (" + pExpectedParts + ") Data Parts (seperated by '" + pSeperator + "'), but was (" + zParts.length + ") Parts" );
        }
        String[] rv = new String[pExpectedParts];
        System.arraycopy( zParts, 0, rv, 0, zParts.length );
        return rv;
    }

    //  "vs:Simple|Name",
    //  "Object:A1|",
    //  ".ID:ID|Persisted|Simple",
    //  "Object:B1|A1",
    //  "..Active:true",
    //  ".ID:ID|Persisted|Simple",
    //  "...ObjectDisplayValueOrder:1",
    //  "...ColumnName:ID",

    private static class Line
    {
        private int mIndex;
        private String mOrigLine;
        private boolean mIgnore = false;
        private boolean mBadFormat = true;
        private int mDepth = -1;
        private String mWhat = "";
        private String mData = "";

        public Line( int pIndex, String pOrigLine )
        {
            mIndex = pIndex;
            mOrigLine = (pOrigLine == null) ? null : pOrigLine.trim();
            if ( (mOrigLine == null) || (mOrigLine.length() == 0) || mOrigLine.startsWith( "#" ) || mOrigLine.startsWith( "//" ) )
            {
                mBadFormat = false;
                mIgnore = true;
                return;
            }
            int colonAt = mOrigLine.indexOf( ':' );
            if ( colonAt == -1 )
            {
                return;
            }
            int depth = 0;
            while ( mOrigLine.charAt( depth ) == '.' )
            {
                depth++;
            }
            mWhat = mOrigLine.substring( depth, colonAt ).trim();
            if ( mWhat.length() == 0 )
            {
                return;
            }
            mData = mOrigLine.substring( colonAt + 1 ).trim();
            mDepth = depth;
            mBadFormat = false;
        }

        public int getIndex()
        {
            return mIndex;
        }

        public String getOrigLine()
        {
            return mOrigLine;
        }

        public boolean isNotIgnorable()
        {
            return !mIgnore;
        }

        public int getDepth()
        {
            return mDepth;
        }

        public String getWhat()
        {
            return mWhat;
        }

        public String getData()
        {
            return mData;
        }

        public boolean isWhat( String pWhat )
        {
            return mWhat.equals( pWhat );
        }

        public void validateWhat( String pWhat )
        {
            if ( !isWhat( pWhat ) )
            {
                throw badWhat( pWhat );
            }
        }

        public int validateWhat( String[] pWhats )
        {
            for ( int i = 0; i < pWhats.length; i++ )
            {
                if ( isWhat( pWhats[i] ) )
                {
                    return i;
                }
            }
            StringBuilder sb = new StringBuilder();
            for ( int i = pWhats.length; --i > 0; )
            {
                sb.append( pWhats[i] );
                sb.append( ", " );
            }
            sb.append( "or " );
            sb.append( pWhats[0] );
            throw badWhat( sb.toString() );
        }

        public void validateDepth( int pDepth )
        {
            if ( mDepth != pDepth )
            {
                throw error( "Expected (" + pDepth + ") Depth, but was (" + mDepth + ")" );
            }
        }

        private ParseException badWhat( String pExpected )
        {
            return error( "Expected (" + pExpected + "), but was (" + mWhat + ")" );
        }

        public void rejectBadFormat()
        {
            if ( mBadFormat )
            {
                throw error( "Unacceptable Format" );
            }
        }

        public ParseException error( String pError )
        {
            return new ParseException( pError + ", line (" + mIndex + ") was: " + mOrigLine );
        }
    }
}