package org.litesoft.aokeyhole.swing.mains.mementobeans.support;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.persist.*;

public class BeanReader implements ObjectReader,
                                   BeanMagicStrings
{
    private final String mName;
    private final String[] mNotes;
    private final List<AttributeData> mAttributeDatas;
    private int mNextAttibute = 0;

    public BeanReader( String pName, String[] pNotes, List<AttributeData> pAttributeDatas )
    {
        mName = pName;
        mNotes = pNotes;
        mAttributeDatas = Lists.deNullMutable( pAttributeDatas );
    }

    private BeanReader( String pName, String[] pNotes )
    {
        this( pName, pNotes, null );
    }

    public List<AttributeData> getAttributeDatas()
    {
        return mAttributeDatas;
    }

    @Override
    public String getType()
    {
        return "Bean";
    }

    @Override
    public String getName()
    {
        return mName;
    }

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

    @Override
    public String[] getNotes()
    {
        return mNotes;
    }

    @Override
    public ParseException unrecognizedType( String pMessage )
    {
        return new ParseException( "Bean (" + getName() + ") - " + pMessage );
    }

    @Override
    public PropertyReader nextProperty()
    {
        return null;  // No Properties.
    }

    @Override
    public AttributeReader nextAttribute()
    {
        while ( mNextAttibute < mAttributeDatas.size() )
        {
            AttributeData zAttribute = mAttributeDatas.get( mNextAttibute++ );
            if ( zAttribute.getName() != null )
            {
                return new OurAttributeReader( zAttribute );
            }
        }
        return null;
    }

    /**
     * Parse the lines for a "possible" java MementoBean and create a BeanReader if appropriate.
     *
     * @param pLines from a "possible" java MementoBean extending file.
     *
     * @return a BeanReader or null if the lines passed in do not represent a MementoBean.
     */
    public static BeanReader createFor( String... pLines )
    {
        if ( pLines.length < 30 )
        {
            return null;
        }
        int extendsLine = findLine( pLines, EXTENDS_ABSTRACT_MEMO_BEAN );
        if ( extendsLine == -1 )
        {
            return null;
        }
        String zDeclarationLine = pLines[extendsLine].trim();
        String zName = getBeanName( zDeclarationLine );
        if ( zName == null )
        {
            return null;
        }
        String[] zNotes = getJavaDocBefore( pLines, extendsLine );
        int attributesAt = findLine( pLines, "private static final AbstractAttributeProxy[] ATTRIBUTES = //" );
        if ( attributesAt == -1 || (attributesAt > (pLines.length - 32)) || !"{ //".equals( pLines[attributesAt + 1].trim() ) )
        {
            return null;
        }
        BeanReader zBR = new BeanReader( zName, zNotes );
        String zLine;
        for ( int i = 0; !"};".equals( zLine = getLine( pLines, attributesAt + 2 + i ) ); i++ )
        {
            AttributeData zAttributeData = parseAttributeData( i, zLine, pLines );
            if ( zAttributeData == null )
            {
                System.err.println( "Expected AttributeProxy Line (" + i + ") at " + (attributesAt + 2 + i) + ", but saw: " + zLine );
                return null;
            }
            zBR.mAttributeDatas.add( zAttributeData );
        }
        return zBR;
    }

    private static String getBeanName( String pLine )
    {
        return !pLine.endsWith( ">" ) ? //
               null : //
               Strings.noEmpty( pLine.substring( pLine.indexOf( EXTENDS_ABSTRACT_MEMO_BEAN ) + //
                                                 EXTENDS_ABSTRACT_MEMO_BEAN.length(), pLine.length() - 1 ) );
    }

    private static int findLine( String[] pLines, String pContainsText )
    {
        for ( int i = 0; i < pLines.length; i++ )
        {
            if ( pLines[i].contains( pContainsText ) )
            {
                return i;
            }
        }
        return -1;
    }

    private static String[] getJavaDocBefore( String[] pLines, int pLine )
    {
        int jdocStart = findJdocStart( pLines, pLine );
        if ( jdocStart != -1 )
        {
            List<String> noteLines = new ArrayList<String>();
            String zLine;
            for ( int i = jdocStart + 1; (i < pLine) && (zLine = getLine( pLines, i )).startsWith( "*" ); i++ )
            {
                if ( "*/".equals( zLine ) )
                {
                    break;
                }
                noteLines.add( zLine.startsWith( "* " ) ? zLine.substring( 2 ) : "" );
            }
            if ( !noteLines.isEmpty() )
            {
                return noteLines.toArray( new String[noteLines.size()] );
            }
        }
        return Strings.EMPTY_ARRAY;
    }

    private static int findJdocStart( String[] pLines, int pFrom )
    {
        for ( String zLine; (zLine = getLine( pLines, --pFrom )).length() != 0; )
        {
            if ( "/**".equals( zLine ) )
            {
                return pFrom;
            }
        }
        return -1;
    }

    private static String getLine( String[] pLines, int pLine )
    {
        if ( (0 <= pLine) && (pLine < pLines.length) )
        {
            return pLines[pLine].trim();
        }
        return "";
    }

    private static AttributeData parseAttributeData( int pExpectedId, String pLine, String[] pLines )
    {
        AttributeData zAttribute = AttributeData.parseLine( pLine );
        if ( (zAttribute == null) || (zAttribute.getID() != pExpectedId) )
        {
            return null; // Unable to Parse OR ID wrong!
        }
        if ( zAttribute.getName() == null )
        {
            return zAttribute; // No name means that this is a legacy reference space holder
        }
        String zType = zAttribute.getType();
        if ( zAttribute.isRepeating() )
        {
            zType = "List<" + zType + ">";
        }
        int getterAt = findLine( pLines, "public " + zType + " get" + zAttribute.getName() + "()" );
        if ( getterAt == -1 )
        {
            return null; // "Real" attribute, but no getter?
        }
        zAttribute.setNotes( getJavaDocBefore( pLines, getterAt ) );
        return zAttribute;
    }

    private ParseException error( String pMessage )
    {
        return unrecognizedType( pMessage );
    }

    private class OurAttributeReader implements AttributeReader
    {
        private final AttributeData mAttribute;
        private final String mType;
        private final String[] mAdditionalValues;
        private BeanAttributeProperties nextProperty = BeanAttributeProperties.Notes;

        private OurAttributeReader( AttributeData pAttribute )
        {
            mAttribute = pAttribute;
            if ( mAttribute.isMementoableType() )
            {
                mType = (mAttribute.isRepeating() ? FundamentalAttributeType.ToMany : FundamentalAttributeType.ToOne).toString();
                mAdditionalValues = new String[]{mAttribute.getType()};
                return;
            }
            mType = mAttribute.getType();
            mAdditionalValues = Strings.EMPTY_ARRAY; // TODO: Valid Options!
        }

        @Override
        public String getType()
        {
            return mType;
        }

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

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

        @Override
        public String[] getAdditionalValues( Integer pExpected )
        {
            if ( pExpected == null )
            {
                return mAdditionalValues;
            }
            int zExpected = Integers.assertNonNegative( "Expected", pExpected );
            if ( mAdditionalValues.length > zExpected )
            {
                throw error( "Expected (" + pExpected + ") Additional Parts (seperated by '|'), but was (" + mAdditionalValues.length + ") Parts" );
            }
            return Strings.expectArray( pExpected, mAdditionalValues );
        }

        @Override
        public ParseException unrecognizedType( String pMessage )
        {
            return error( pMessage );
        }

        @Override
        public PropertyReader nextProperty()
        {
            while ( nextProperty != null )
            {
                final String zData = nextProperty.getData( mAttribute );
                final String zWhat = nextProperty.toString();
                nextProperty = nextProperty.next();
                if ( zData != null )
                {
                    return new PropertyReader()
                    {
                        @Override
                        public String getWhat()
                        {
                            return zWhat;
                        }

                        @Override
                        public String getData()
                        {
                            return zData;
                        }
                    };
                }
            }
            return null;
        }
    }
}