package org.litesoft.orsup.base;

import java.util.*;

import org.litesoft.core.util.*;
import org.litesoft.orsup.nonpublic.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.util.*;

/**
 * Limited Class due to inability to convert to/from String for any type - currently limited to Long & String
 */
public final class UniqueKeyMulti extends AbstractUniqueKeyObject
{
    private static final char SEP_CHAR = ',';
    private static final char ESC_CHAR = '\\';

    private Object[] mIDs;
    transient private AttributeAccessorSCD[] mAASCDs;

    public UniqueKeyMulti( PersistentObject<?> pPO, AttributeAccessorSCD<PersistentObject<?>>... pAASCDs )
    {
        IllegalArgument.ifNull( "PersistentObject", pPO );
        Utils.assertNotNullNotEmpty( "Must provide some AttributeAccessorSCDs", mAASCDs = pAASCDs );
        mIDs = new Object[mAASCDs.length];
        for ( int i = 0; i < mAASCDs.length; i++ )
        {
            mIDs[i] = mAASCDs[i].db_getValueOnPO( pPO );
        }
    }

    public UniqueKeyMulti( String pFromString, AttributeAccessorSCD<PersistentObject<?>>... pAASCDs )
            throws IllegalArgumentException
    {
        String[] parts = parseString( pFromString, (mAASCDs = pAASCDs).length );
        mIDs = new Object[pAASCDs.length];
        for ( int i = 0; i < pAASCDs.length; i++ )
        {
            mIDs[i] = convertIDfrom( parts[i], pAASCDs[i] );
        }
    }

    protected int calcHashCode()
    {
        int rv = 0;
        for ( Object o : mIDs )
        {
            rv += Utils.calcHashCode( o );
        }
        return rv;
    }

    protected boolean equalsNotNullNotUs( PersistentObjectUniqueKey pThem )
    {
        if ( pThem instanceof UniqueKeyMulti )
        {
            UniqueKeyMulti them = (UniqueKeyMulti) pThem;
            if ( this.mIDs.length == them.mIDs.length )
            {
                for ( int i = 0; i < mIDs.length; i++ )
                {
                    if ( !Utils.equal( this.mIDs[i], them.mIDs[i] ) )
                    {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }

    protected String generateToStringForConstructor()
    {
        StringBuilder sb = new StringBuilder();
        for ( Object o : mIDs )
        {
            sb.append( SEP_CHAR );
            if ( o == null )
            {
                sb.append( NULL_CHAR );
            }
            else
            {
                sb.append( DATA_CHAR );
                String s = o.toString();
                for ( int k = 0; k < s.length(); ++k )
                {
                    char c = s.charAt( k );
                    if ( c == SEP_CHAR || c == ESC_CHAR )
                    {
                        sb.append( ESC_CHAR );
                    }
                    sb.append( c );
                }
            }
        }
        return sb.toString().substring( 1 );
    }

    private String[] parseString( String pFromString, int pParts )
            throws IllegalArgumentException
    {
        if ( pParts < 1 )
        {
            throw new IllegalArgumentException( "Need at least 1 part" );
        }
        List<String> parts = new ArrayList<String>();
        StringBuilder sb = new StringBuilder();
        int stridx = 0;
        while ( stridx < pFromString.length() )
        {
            char c = pFromString.charAt( stridx++ );
            if ( c == ESC_CHAR )
            {
                if ( stridx >= pFromString.length() )
                {
                    throw new IllegalArgumentException( "Key malformed - too short" );
                }
                c = pFromString.charAt( stridx++ );
                sb.append( c );
            }
            else if ( c == SEP_CHAR )
            {
                parts.add( nullifyfromString( sb.toString() ) );
                sb = new StringBuilder();
            }
            else
            {
                sb.append( c );
            }
        }
        parts.add( nullifyfromString( sb.toString() ) );
        if ( pParts < parts.size() )
        {
            throw new IllegalArgumentException( "Key has too few entries" );
        }
        if ( pParts > parts.size() )
        {
            throw new IllegalArgumentException( "Key has too many entries" );
        }
        return parts.toArray( new String[parts.size()] );
    }

    public WhereClause convertToWC()
    {
        if ( mAASCDs == null )
        {
            throw new IllegalStateException( "convertToWC not allowed for transferred UniqueKeys" );
        }
        WhereClauseFactory f = WhereClauseFactory.INSTANCE;
        WhereClause wc = f.isEqual( mAASCDs[0], mIDs[0] );
        for ( int i = 1; i < mIDs.length; i++ )
        {
            wc = f.and( wc, f.isEqual( mAASCDs[i], mIDs[i] ) );
        }
        return wc;
    }
}