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.objects.factories.*;
import org.litesoft.aokeyhole.objects.factories.mementobean.*;
import org.litesoft.commonfoundation.typeutils.Objects;

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;
    protected boolean mNullEmpties;
    protected boolean mNullZeros;
    protected boolean mNullFalses;
    protected boolean mRepeating;
    private String[] mNotes = Strings.EMPTY_ARRAY;

    private AttributeData()
    {
    }

    public AttributeData( int pID, BeanAttributeBuilder pAttribute )
    {
        mID = pID;
        mName = pAttribute.getName();
        mRepeating = pAttribute.isRepeating();
        mNotes = pAttribute.getNotes();
        mNullEmpties = pAttribute.isNullEmpties();
        mNullZeros = pAttribute.isNullZeros();
        mNullFalses = pAttribute.isNullFalses();
        mType = pAttribute.getType();
        mMementoableType = !Objects.isOneOf( mType, VALID_TYPES );
    }

    private AttributeData( AttributeData pCloneFrom )
    {
        this.mID = pCloneFrom.mID;
        this.mName = pCloneFrom.mName;
        this.mType = pCloneFrom.mType;
        this.mMementoableType = pCloneFrom.mMementoableType;
        this.mNullEmpties = pCloneFrom.mNullEmpties;
        this.mNullZeros = pCloneFrom.mNullZeros;
        this.mNullFalses = pCloneFrom.mNullFalses;
        this.mRepeating = pCloneFrom.mRepeating;
        this.mNotes = pCloneFrom.mNotes;
    }

    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 appendID( StringBuilder pSB ) // PART1
    {
        pSB.append( Integers.zeroPadIt( 2, mID ) );
    }

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

    private void appendType( StringBuilder pSB )
    {
        pSB.append( isMementoableType() ? MEMENTOABLE_ATTRIBUTE_PROXY_TYPE : getType() );
    }

    private void appendMementoTypeExtension1( StringBuilder pSB ) // PART5
    {
        if ( isMementoableType() )
        {
            pSB.append( '<' ).append( getType() ).append( '>' );
        }
    }

    /**
     * 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 ) // PART3 & PART5
    {
        // "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 );
    }

    private void appendMementoTypeExtension2( StringBuilder pSB ) // PART7b
    {
        if ( isMementoableType() )
        {
            pSB.append( ATTR_PART7b_PRE_TYPE ).append( mType ).append( ATTR_PART7b_POST_TYPE );
        }
    }

    private void appendName( StringBuilder pSB ) // PART7a
    {
        if ( mName == null )
        {
             pSB.append( ATTR_PART7a_NO_NAME );
        }
        else
        {
            pSB.append( DOUBLE_QUOTE ).append( mName ).append( DOUBLE_QUOTE );
        }
    }

    /**
     * Parse the name from the Attribute Proxy's Parameters.
     */
    private void parseName( String pAttributeProxyParameters ) // PART7
    {
        // 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 = ATTR_PART7b_PRE_TYPE + mType + ATTR_PART7b_POST_TYPE;
            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( ATTR_PART7a_NO_NAME ) )
        {
            if ( (zName.length() < 3) || !zName.startsWith( DOUBLE_QUOTE ) || !zName.endsWith( DOUBLE_QUOTE ) )
            {
                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;
        }
    }

    private void appendFlags( StringBuilder pSB ) // PART9
    {
        for ( BeanAttributeProperties zValue : BeanAttributeProperties.values() )
        {
            zValue.appendFlag( this, pSB );
        }
    }

    // /* 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 ) // PART9
    {
        StringBuilder zFlags = new StringBuilder( pFlags );
        for ( BeanAttributeProperties zValue : BeanAttributeProperties.values() )
        {
            zValue.parseFlag( this, zFlags );
        }
        if ( zFlags.length() != 0 )
        {
            throw new IllegalArgumentException( "Don't understand '" + zFlags + "' in: " + pFlags );
        }
    }

    public String toParseLine()
    {
        StringBuilder sb = new StringBuilder();
        sb.append( ATTR_PART0 );
        appendID( sb ); // PART1
        sb.append( ATTR_PART2 );
        appendType( sb ); // PART3
        sb.append( ATTR_PART4 );
        appendMementoTypeExtension1( sb ); // PART5
        sb.append( ATTR_PART6 );
        appendName( sb ); // PART7a
        appendMementoTypeExtension2( sb ); // PART7b
        sb.append( ATTR_PART8 );
        appendFlags( sb ); // PART9
        return sb.append( ATTR_PART10 ).toString();
    }

    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( ATTR_PART0.length(), atPart2 ) ); // PART1
                zAttribute.parseType( pLine.substring( atPart2 + ATTR_PART2.length(), atPart4 ), // PART3
                                      pLine.substring( atPart4 + ATTR_PART4.length(), atPart6 ) ); // PART5
                zAttribute.parseName( pLine.substring( atPart6 + ATTR_PART6.length(), atPart8 ) ); // PART7
                zAttribute.parseFlags( pLine.substring( atPart8 + ATTR_PART8.length(), pLine.length() - ATTR_PART10.length() ) ); // PART9
                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()] );
    }

    public AttributeData makePlaceHolder()
    {
        AttributeData zAttributeData = new AttributeData( this );
        zAttributeData.mName = null;
        zAttributeData.setNotes( null );
        if ( isMementoableType() )
        {
            zAttributeData.mNullEmpties = true;
            zAttributeData.mType = "String";
            zAttributeData.mMementoableType = false;
        }
        return zAttributeData;
    }

    public boolean isUpdatableFrom( BeanAttributeBuilder pAttribute )
    {
        return Objects.areNonArraysEqual( this.getName(), pAttribute.getName() ) && //
               Objects.areNonArraysEqual( this.getType(), pAttribute.getType() ) && //
               (this.isRepeating() == pAttribute.isRepeating());
    }

    /**
     * Either return <code>this</code> if nothing has changed or create a new instance from <code>this</code> with the changes
     * <p/>
     * Note: <code>pAttribute</code> must have already passed thru <code>isUpdatableFrom</code>
     */
    public AttributeData updateWith( BeanAttributeBuilder pAttribute )
    {
        if ( isUpdatableFromRestIsEquivalent( pAttribute ) )
        {
            return this;
        }
        AttributeData zAttributeData = new AttributeData( this );
        zAttributeData.setNotes( pAttribute.getNotes() );
        zAttributeData.mNullEmpties = pAttribute.isNullEmpties();
        zAttributeData.mNullZeros = pAttribute.isNullZeros();
        zAttributeData.mNullFalses = pAttribute.isNullFalses();
        return zAttributeData;
    }

    private boolean isUpdatableFromRestIsEquivalent( BeanAttributeBuilder pAttribute )
    {
        return Objects.areArraysEqual( this.getNotes(), pAttribute.getNotes() ) && //
               (this.isNullEmpties() == pAttribute.isNullEmpties()) && //
               (this.isNullZeros() == pAttribute.isNullZeros()) && //
               (this.isNullFalses() == pAttribute.isNullFalses());
    }
}