// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.simpletypes.temporal;

import java.util.*;

import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.simpletypes.temporal.nonpublic.*;
import org.litesoft.core.typeutils.*;

/**
 * Format Control for CalendarAccessorYMD which provides varying levels of resolution based on the Format String
 * (which supports formatting similar to SimpleDateFormat).
 * <p/>
 * <pre>
 *     y    Year    - YY (1996 becomes 96),
 *                    otherwise it is the complete Year, eg: 1996, 2001, 10050.
 *     M    Month   - M generates no leading 0 months as numbers,
 *                    MM produces 2 digit month numbers,
 *                    MMM produces 3 letter month abbreviated form,
 *                    MMMM (4 or more) produces the full form.
 *     d    Day     - d generates no leading 0 day of month as numbers,
 *                    dd produces 2 digit day of month numbers.
 * </pre>
 */
public class DateFormat extends CalendarSupport<DateFormat> implements TemporalParsingSupport,
                                                                       SimpleType
{
    private static final long serialVersionUID = 1L;

    public static final String DEFAULT_YMD_FORMAT = "dd MMM yyyy";
    public static final DateFormat DEFAULT_YMD = new DateFormat( DEFAULT_YMD_FORMAT );

    public static final String DEFAULT_YM_FORMAT = "MMM yyyy";
    public static final DateFormat DEFAULT_YM = new DateFormat( DEFAULT_YM_FORMAT );

    public static final String DEFAULT_Y_FORMAT = "yyyy";
    public static final DateFormat DEFAULT_Y = new DateFormat( DEFAULT_Y_FORMAT );

    private static final char[] ACCEPTABLE_INDICATORS = //
            { //
              DateRes.INDICATOR_YEAR, //
              DateRes.INDICATOR_MONTH, //
              DateRes.INDICATOR_DAY, //
            };

    private String mFormat = DEFAULT_YMD_FORMAT;

    private DateRes mDateRes = DateRes.ToDAY;

    // Late Bound:
    private transient String mFieldOrder = null;
    private transient Chunk[] mToStringChunks = null;

    @SuppressWarnings({"deprecation", "UnusedDeclaration"}) @Deprecated /** for Serialization */
    protected DateFormat()
    {
    }

    public DateFormat( String pFormat )
    {
        mFormat = Strings.noEmpty( pFormat, DEFAULT_YMD_FORMAT );
        int zIndicatorBits = indicatorBit( 1, DateRes.ToYEAR ) + //
                             indicatorBit( 2, DateRes.ToMONTH ) + //
                             indicatorBit( 4, DateRes.ToDAY );
        switch ( zIndicatorBits )
        {
            case 6: // Month & Day
                // fall thru *** Common format used when the Year is implicit (e.g. 4JAN means the next January 4th)
            case 7: // Year, Month, & Day
                mDateRes = DateRes.ToDAY;
                break;
            case 3: // Year & Month
                mDateRes = DateRes.ToMONTH;
                break;
            case 1: // Year Only
                mDateRes = DateRes.ToYEAR;
                break;
            case 5: // Year & Day ?
                throw doesNotContain( DateRes.ToMONTH, "" );
            case 2: // Month Only ?
                // Fall thru
            case 4: // Day Only ?
                // Fall thru
            case 0: // None!
                throw doesNotContain( DateRes.ToYEAR, "" );
        }
    }

    public String format( CalendarAccessorYMD pDate )
    {
        if ( pDate == null )
        {
            return null; // TODO: Should this be ""?
        }
        StringBuilder sb = new StringBuilder();
        for ( Chunk chunk : getToStringChunks() )
        {
            chunk.appendTo( sb, pDate );
        }
        return sb.toString();
    }

    public String getFormat()
    {
        return mFormat;
    }

    public DateRes getDateRes()
    {
        return mDateRes;
    }

    public boolean isValidToMonth()
    {
        return mDateRes.isValidToMonth();
    }

    public boolean isValidToDay()
    {
        return mDateRes.isValidToDay();
    }

    @Override
    public String toString()
    {
        return getFormat();
    }

    /**
     * The expected order of the expected fields of a CalendarYMD.
     * <p/>
     * E.g. "dd MMM yyyy" -> "dMy"
     * E.g. "MM/dd/yy" -> "Mdy"
     * E.g. "ddMMM" -> "dM"
     */
    public synchronized String getFieldOrder()
    {
        if ( mFieldOrder == null )
        {
            mFieldOrder = determineFieldOrder( ACCEPTABLE_INDICATORS );
        }
        return mFieldOrder;
    }

    protected synchronized Chunk[] getToStringChunks()
    {
        if ( mToStringChunks == null )
        {
            mToStringChunks = createChunks( ACCEPTABLE_INDICATORS );
        }
        return mToStringChunks;
    }

    protected void validateMonthAdjustable()
            throws IllegalArgumentException
    {
        if ( !isValidToMonth() )
        {
            throw doesNotContain( DateRes.ToMONTH, ", but Month adjustment attempted" );
        }
    }

    protected void validateDayAdjustable()
            throws IllegalArgumentException
    {
        if ( !isValidToDay() )
        {
            throw doesNotContain( DateRes.ToDAY, ", but Day adjustment attempted" );
        }
    }

    protected void validateValidToDay( String pWhat )
    {
        if ( !isValidToDay() )
        {
            throw doesNotContain( DateRes.ToDAY, ", but " + pWhat + " attempted" );
        }
    }

    protected IllegalArgumentException formatPlusIndicatorWhy( String pPlus, char pIndicator, String pWhy )
    {
        return new IllegalArgumentException( "Format '" + mFormat + "' " + pPlus + //
                                             " '" + pIndicator + "' indicator" + pWhy );
    }

    protected IllegalArgumentException doesNotContain( DateRes pDateRes, String pWhy )
    {
        return formatPlusIndicatorWhy( "does NOT contain a " + pDateRes.getFriendlyName(), //
                                       pDateRes.getIndicator(), //
                                       pWhy );
    }

    protected IllegalArgumentException doesContain( DateRes pDateRes )
    {
        return formatPlusIndicatorWhy( "contains a " + pDateRes.getFriendlyName(), //
                                       pDateRes.getIndicator(), //
                                       ", but no " + pDateRes.getFriendlyName() + " provided" );
    }

    protected void noMonthProvided()
            throws IllegalArgumentException
    {
        if ( isValidToMonth() )
        {
            throw doesContain( DateRes.ToMONTH );
        }
        noDayProvided();
    }

    protected void noDayProvided()
            throws IllegalArgumentException
    {
        if ( isValidToDay() )
        {
            throw doesContain( DateRes.ToDAY );
        }
    }

    private String determineFieldOrder( char[] pAcceptableIndicators )
    {
        List<FoundIndicator> zFounds = new ArrayList<FoundIndicator>();
        for ( char indicator : pAcceptableIndicators )
        {
            int at = mFormat.indexOf( indicator );
            if ( at != -1 )
            {
                zFounds.add( new FoundIndicator( at, indicator ) );
            }
        }
        if ( zFounds.size() > 1 )
        {
            Collections.sort( zFounds );
        }
        StringBuilder sb = new StringBuilder( zFounds.size() );
        for ( FoundIndicator zFound : zFounds )
        {
            sb.append( zFound );
        }
        return sb.toString();
    }

    private int indicatorBit( int pBit, DateRes pDateRes )
    {
        return (-1 != mFormat.indexOf( pDateRes.getIndicator() )) ? pBit : 0;
    }

    private static class FoundIndicator implements Comparable
    {
        private int mIndex;
        private char mIndicator;

        public FoundIndicator( int pIndex, char pIndicator )
        {
            mIndex = pIndex;
            mIndicator = pIndicator;
        }

        @Override
        public String toString()
        {
            return Character.toString( mIndicator );
        }

        @Override
        public boolean equals( Object o )
        {
            return (this == o) || //
                   ((o instanceof FoundIndicator) && equals( (FoundIndicator) o ));
        }

        public boolean equals( FoundIndicator them )
        {
            return (this == them) || //
                   ((them != null) //
                    && equal( this.mIndex, them.mIndex ) //
                    && equal( this.mIndicator, them.mIndicator ) //
                   );
        }

        @Override
        public int hashCode()
        {
            return hashCodeEm( calcHashCode( mIndex ), //
                               calcHashCode( (int) mIndicator ) );
        }

        @Override
        public int compareTo( Object pObject )
        {
            FoundIndicator them = (FoundIndicator) pObject;
            return compare( this.mIndex, them.mIndex );
        }
    }

    protected Chunk[] createChunks( char[] pAcceptableIndicators )
    {
        ChunkCollector zCC = new ChunkCollector( pAcceptableIndicators );
        int from = 0;
        char curChunkChar = 0;
        for ( int to = 0; to < mFormat.length(); to++ )
        {
            char c = mFormat.charAt( to );
            if ( curChunkChar == 0 )
            {
                if ( zCC.isAcceptableIndicators( c ) )
                {
                    zCC.addChunk( from, to, curChunkChar );
                    from = to;
                    curChunkChar = c;
                }
            }
            else if ( curChunkChar != c )
            {
                zCC.addChunk( from, to, curChunkChar );
                from = to;
                curChunkChar = zCC.isAcceptableIndicators( c ) ? c : 0;
            }
        }
        zCC.addChunk( from, curChunkChar );
        return zCC.getChunks();
    }

    private class ChunkCollector
    {
        List<Chunk> mChunks = new ArrayList<Chunk>();
        private char[] mAcceptableIndicators;

        public ChunkCollector( char[] pAcceptableIndicators )
        {
            mAcceptableIndicators = pAcceptableIndicators;
        }

        public boolean isAcceptableIndicators( char pChar )
        {
            for ( char zAcceptableIndicator : mAcceptableIndicators )
            {
                if ( pChar == zAcceptableIndicator )
                {
                    return true;
                }
            }
            return false;
        }

        public Chunk[] getChunks()
        {
            return mChunks.toArray( new Chunk[mChunks.size()] );
        }

        public void addChunk( int pFrom, char pCurChunkChar )
        {
            addChunk( pFrom, mFormat.length(), pCurChunkChar );
        }

        public void addChunk( int pFrom, int pTo, char pCurChunkChar )
        {
            Chunk chunk = getChunk( pFrom, pTo, pCurChunkChar );
            if ( chunk != null )
            {
                mChunks.add( chunk );
            }
        }

        public Chunk getChunk( int pFrom, int pTo, char pCurChunkChar )
        {
            if ( pFrom == pTo )
            {
                return null;
            }
            if ( pCurChunkChar != 0 )
            {
                int length = pTo - pFrom;
                switch ( pCurChunkChar )
                {
                    case DateRes.INDICATOR_YEAR:
                        return get_y_nChunk( length );
                    case DateRes.INDICATOR_MONTH:
                        return get_M_nChunk( length );
                    case DateRes.INDICATOR_DAY:
                        return get_d_nChunk( length );
                    default:
                        break;
                }
            }
            return getLiteralChunk( mFormat.substring( pFrom, pTo ) );
        }
    }

    protected static Chunk getLiteralChunk( String pLiteral )
    {
        if ( pLiteral.length() == 1 )
        {
            switch ( pLiteral.charAt( 0 ) )
            {
                case '/':
                    return SLASH;
                case ' ':
                    return SPACE;
                case ':':
                    return COLON;
                case ',':
                    return COMMA;
                case '-':
                    return DASH;
                default:
                    break;
            }
        }
        return literalChunk( pLiteral );
    }

    protected static Chunk get_M_nChunk( int pLength )
    {
        switch ( pLength )
        {
            case 1:
                return M_Chunk;
            case 2:
                return MM_Chunk;
            case 3:
                return MMM_Chunk;
            default:
                return MMMM_Chunk;
        }
    }

    protected static Chunk get_y_nChunk( int pLength )
    {
        switch ( pLength )
        {
            case 1:
                return y_Chunk;
            case 2:
                return yy_Chunk;
            case 4:
                return yyyy_Chunk;
            default:
                return yyy_Chunk( pLength );
        }
    }

    protected static Chunk get_d_nChunk( int pLength )
    {
        return (pLength == 2) ? dd_Chunk : d_Chunk;
    }

    @Override
    public boolean equals( Object o )
    {
        return (o instanceof DateFormat) && equals( (DateFormat) o );
    }

    public boolean equals( DateFormat them )
    {
        return (this == them) || //
               ((them != null) //
                && this.mFormat.equals( them.mFormat ) //
               );
    }

    @Override
    public int hashCode()
    {
        return mFormat.hashCode();
    }

    @Override
    public int compareTo( DateFormat them )
    {
        return this.mFormat.compareTo( them.mFormat );
    }
}