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

import java.util.*;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.objects.factories.*;
import org.litesoft.aokeyhole.objects.factories.mementobean.*;
import org.litesoft.core.typeutils.*;

public class AttributeData implements BeanMagicStrings
{
    private static final String[] VALID_TYPES = extractValidTypes( MementoBeanPropertyMetaDataDefinitionAccessor.INSTANCE );

    private int mID;
    private String mName;
    private String mType;
    private boolean mMementoableType;
    private boolean mNullEmpties;
    private boolean mNullZeros;
    private boolean mNullFalses;
    private boolean mRepeating;
    private String[] mNotes = Strings.EMPTY_ARRAY;

    public int getID()
    {
        return mID;
    }

    public String getName()
    {
        return mName;
    }

    public String getType()
    {
        return mType;
    }

    public boolean isMementoableType()
    {
        return mMementoableType;
    }

    public boolean isNullEmpties()
    {
        return mNullEmpties;
    }

    public boolean isNullZeros()
    {
        return mNullZeros;
    }

    public boolean isNullFalses()
    {
        return mNullFalses;
    }

    public boolean isRepeating()
    {
        return mRepeating;
    }

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

    public void setNotes( String[] pNotes )
    {
        mNotes = Strings.deNull( pNotes );
    }

    /**
     * An ID is a 2 digit value (with leading zeros) between 0 & 99
     */
    private void parseID( String pID )
    {
        mID = Integer.parseInt( pID );
    }

    /**
     * Parse the Pre & Post type indicators.
     *
     * @param pPreType           an AttributeProxy type: Mementoable, String, Integer, ...
     * @param pBracketedPostType Either an empty String of the class name of the Mementoable surrounded by generic type indicators ('<' & '>').
     */
    private void parseType( String pPreType, String pBracketedPostType )
    {
        // "String" & "" || "Mementoable" & "<DetailBean>"
        if ( !MEMENTOABLE_ATTRIBUTE_PROXY_TYPE.equals( pPreType ) )
        {
            Strings.assertNullOrEmpty( "BracketedPostType", pBracketedPostType );
            mType = Objects.assertOneOf( pPreType, VALID_TYPES );
            return;
        }
        mMementoableType = true;
        if ( pBracketedPostType.startsWith( "<" ) && pBracketedPostType.endsWith( ">" ) )
        {
            mType = pBracketedPostType.substring( 1, pBracketedPostType.length() - 1 );
            if ( Strings.isValidAttributeIdentifier( mType ) )
            {
                return;
            }
        }
        throw new IllegalArgumentException( "Unacceptable BracketedPostType: " + pBracketedPostType );
    }

    /**
     * Parse the name from the Attribute Proxy's Parameters.
     */
    private void parseName( String pAttributeProxyParameters )
    {
        // A string of 'null' which indicates that this is a legacy place holder
        // Single (double quoted) Names, e.g.: "FirstName", "Name", "Description"
        // or the above followed by a default instance, like:
        // "SpecialDetail", DetailBean.DEFAULT_INSTANCE
        // "Details", DetailBean.DEFAULT_INSTANCE
        String zName = pAttributeProxyParameters;
        if ( mMementoableType )
        {
            String zDefaultInstanceTail = ", " + mType + ".DEFAULT_INSTANCE";
            if ( !pAttributeProxyParameters.endsWith( zDefaultInstanceTail ) )
            {
                throw new IllegalArgumentException(
                        "Mementoable attribute proxy, but not default instance in the parameter section: " + pAttributeProxyParameters );
            }
            zName = pAttributeProxyParameters.substring( 0, pAttributeProxyParameters.length() - zDefaultInstanceTail.length() );
        }
        if ( !zName.equals( "null" ) )
        {
            if ( (zName.length() < 3) || !zName.startsWith( "\"" ) || !zName.endsWith( "\"" ) )
            {
                throw new IllegalArgumentException( "Malformed name '" + zName + "' in: " + pAttributeProxyParameters );
            }
            zName = zName.substring( 1, zName.length() - 1 );
            if ( !Strings.isAsciiIdentifier( zName ) )
            {
                throw new IllegalArgumentException( "Name '" + zName + "' not an Ascii Identifier in: " + pAttributeProxyParameters );
            }
            mName = zName;
        }
    }

    // /* 00 */ new StringAttributeProxy( "FirstName" ), //
    // /* 00 */ new StringAttributeProxy( "Name" ).nullEmpties(), //
    // /* 01 */ new StringAttributeProxy( null ), //
    // /* 02 */ new StringAttributeProxy( "Description" ).nullEmpties().repeating(), //
    // /* 03 */ new MementoableAttributeProxy<DetailBean>( "SpecialDetail", DetailBean.DEFAULT_INSTANCE ).nullEmpties(), //
    // 01234567-10123
    // /* 04 */ new MementoableAttributeProxy<DetailBean>( "Details", DetailBean.DEFAULT_INSTANCE ).nullEmpties().repeating(), //
    // 123  12345678           12345678901234            12                                      12                          1234
    // 0  1 2       3          4             5           6 7                                     8 9                         10
    private void parseFlags( String pFlags )
    {
        StringBuilder zFlags = new StringBuilder( pFlags );
        mNullEmpties = checkFor( ".nullEmpties()", zFlags );
        mNullZeros = checkFor( ".nullZeros()", zFlags );
        mNullFalses = checkFor( ".nullFalses()", zFlags );
        mRepeating = checkFor( ".repeating()", zFlags );
        if ( zFlags.length() != 0 )
        {
            throw new IllegalArgumentException( "Don't understand '" + zFlags + "' in: " + pFlags );
        }
    }

    private boolean checkFor( String pStringToFind, StringBuilder pFlags )
    {
        int zAt = pFlags.indexOf( pStringToFind );
        if ( zAt == -1 )
        {
            return false;
        }
        pFlags.delete( zAt, zAt + pStringToFind.length() );
        return true;
    }

    public static AttributeData parseLine( String pLine )
    {
        // /* 00 */ new StringAttributeProxy( "FirstName" ), //
        // /* 00 */ new StringAttributeProxy( "Name" ).nullEmpties(), //
        // /* 01 */ new StringAttributeProxy( null ), //
        // /* 02 */ new StringAttributeProxy( "Description" ).nullEmpties().repeating(), //
        // /* 03 */ new MementoableAttributeProxy<DetailBean>( "SpecialDetail", DetailBean.DEFAULT_INSTANCE ).nullEmpties(), //
        // 01234567-10123
        // /* 04 */ new MementoableAttributeProxy<DetailBean>( "Details", DetailBean.DEFAULT_INSTANCE ).nullEmpties().repeating(), //
        // 123  12345678           12345678901234            12                                      12                          1234
        // 0  1 2       3          4             5           6 7                                     8 9                         10
        int atPart2 = pLine.indexOf( ATTR_PART2 );
        int atPart4 = pLine.indexOf( ATTR_PART4, atPart2 + 1 );
        int atPart6 = pLine.indexOf( ATTR_PART6, atPart4 + 1 );
        int atPart8 = pLine.indexOf( ATTR_PART8, atPart6 + 1 );
        if ( pLine.startsWith( ATTR_PART0 ) && //
             (atPart2 != -1) && (atPart4 != -1) && (atPart6 != -1) && (atPart8 != -1) && //
             pLine.endsWith( ATTR_PART10 ) )
        {
            AttributeData zAttribute = new AttributeData();
            try
            {
                zAttribute.parseID( pLine.substring( 3, atPart2 ) );
                zAttribute.parseType( pLine.substring( 13, atPart4 ), pLine.substring( atPart4 + 14, atPart6 ) );
                zAttribute.parseName( pLine.substring( atPart6 + 2, atPart8 ) );
                zAttribute.parseFlags( pLine.substring( atPart8 + 2, pLine.length() - 4 ) );
                return zAttribute;
            }
            catch ( IllegalArgumentException e )
            {
                System.out.println( e.getMessage() );
                // Fall thru...
            }
        }
        return null;
    }

    private static String[] extractValidTypes( PropertyMetaDataDefinitionAccessor pAccessor )
    {
        List<String> zTypes = Lists.newArrayList();
        for ( AttributeSet zAttribute : pAccessor.getAttributeSets() )
        {
            AttributeType zType = zAttribute.getType();
            if ( zType.getFAT().isSimple() )
            {
                zTypes.add( zType.toString() );
            }
        }
        return zTypes.toArray( new String[zTypes.size()] );
    }
}