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

import java.util.*;

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

public class TemporalParser implements TemporalParsingSupport
{
    public static TemporalParser YMD = new TemporalParser( "yMd" );

    private String mFieldOrder = null;

    public TemporalParser( String pFieldOrder )
    {
        mFieldOrder = pFieldOrder;
    }

    public String getFieldOrder()
    {
        return mFieldOrder;
    }

    public CalendarYMD parseDate( String pText, DateRes pDateRes, UtilDateAdaptor pInadequatePartsSource ) throws IllegalArgumentException
    {
        String zWhat = "Date";
        List<PartCollector> zParts = LLparseToParts( pText, true );
        LLpadPartsForDate( zParts, pInadequatePartsSource );
        AbstractRealPC[] realPCs = LLinitialPartsValidate( pText, zParts, zWhat, 3 );
        LLpartsValidateForDate( realPCs, zWhat );
        return LLparseDate( realPCs, pDateRes, zWhat );
    }

    public SimpleTimestamp parseTimestamp( String pText, int pTimeFields, UtilDateAdaptor pInadequatePartsSource ) throws IllegalArgumentException
    {
        String zWhat = "Timestamp";
        List<PartCollector> zParts = LLparseToParts( pText, true );
        LLpadPartsForTimestamp( zParts, pTimeFields, pInadequatePartsSource );
        AbstractRealPC[] realPCs = LLinitialPartsValidate( pText, zParts, zWhat, 3 + pTimeFields );
        LLpartsValidateForDate( realPCs, zWhat );
        LLpartsValidateForTime( pText, realPCs, 3, pTimeFields );
        CalendarYMD date = LLparseDate( realPCs, DateRes.ToDAY, zWhat );
        SimpleTime time = LLparseTime( realPCs, 3, pTimeFields );
        return new SimpleTimestamp( date, time );
    }

    public SimpleTime parseTime( String pText, int pTimeFields, UtilDateAdaptor pInadequatePartsSource ) throws IllegalArgumentException
    {
        String zWhat = "Time";
        List<PartCollector> zParts = LLparseToParts( pText, false );
        LLpadPartsForTime( zParts, 0, pTimeFields, pInadequatePartsSource );
        AbstractRealPC[] realPCs = LLinitialPartsValidate( pText, zParts, zWhat, pTimeFields );
        LLpartsValidateForTime( pText, realPCs, 0, pTimeFields );
        return LLparseTime( realPCs, 0, pTimeFields );
    }

    private PartCollector getNewCollector( char pChar, boolean pTextMonthAnOption )
    {
        if ( Characters.isNumeric( pChar ) )
        {
            return new NumericPC( pChar );
        }
        if ( Characters.isAlpha( pChar ) )
        {
            return pTextMonthAnOption ? new MonthAsTextPC( pChar ) : new StringPC( pChar );
        }
        return SeparatorPC.INSTANCE;
    }

    private UtilDateAdaptor ensurePartsSource( UtilDateAdaptor pInadequatePartsSource )
    {
        if ( pInadequatePartsSource == null )
        {
            pInadequatePartsSource = new UtilDateAdaptor();
        }
        return pInadequatePartsSource;
    }

    private List<PartCollector> LLparseToParts( String pCurrentText, boolean pTextMonthAnOption )
    {
        List<PartCollector> zParts = new ArrayList<PartCollector>();
        PartCollector zPC = SeparatorPC.INSTANCE;

        for ( int i = 0; i < pCurrentText.length(); i++ )
        {
            char c = pCurrentText.charAt( i );
            if ( !zPC.accept( c ) )
            {
                if ( zPC.isReal() )
                {
                    zParts.add( zPC );
                }
                zPC = getNewCollector( c, pTextMonthAnOption );
            }
        }
        if ( zPC.isReal() )
        {
            zParts.add( zPC );
        }
        return zParts;
    }

    private UtilDateAdaptor LLpadPartsForDate( List<PartCollector> pParts, UtilDateAdaptor pInadequatePartsSource )
    {
        switch ( pParts.size() )
        {
            case 1: // assume Day only, add month
                pInadequatePartsSource = ensurePartsSource( pInadequatePartsSource );
                pParts.add( new MonthAsTextPC( Month.nameFromMonthNumber( pInadequatePartsSource.getMonth() ) ) );
            case 2: // assume Month & Day, add Year
                pInadequatePartsSource = ensurePartsSource( pInadequatePartsSource );
                pParts.add( new NumericPC( "" + pInadequatePartsSource.getYear() ) );
            case 3: // assume Month, Day & Year
            default:
                break;
        }
        return pInadequatePartsSource;
    }

    private UtilDateAdaptor LLpadPartsForTimestamp( List<PartCollector> pParts, int pTimeFields, UtilDateAdaptor pInadequatePartsSource )
    {
        pInadequatePartsSource = LLpadPartsForDate( pParts, pInadequatePartsSource );
        if ( pParts.size() == 3 )
        {
            pInadequatePartsSource = ensurePartsSource( pInadequatePartsSource );
            pParts.add( new NumericPC( "" + pInadequatePartsSource.getHour() ) );
        }
        return LLpadPartsForTime( pParts, 3, pTimeFields, pInadequatePartsSource );
    }

    private UtilDateAdaptor LLpadPartsForTime( List<PartCollector> pParts, int pFrontParts, int pRequiredParts, UtilDateAdaptor pInadequatePartsSource )
    {
        switch ( pParts.size() - pFrontParts )
        {
            case 1: // assume Hour only, add Mins
                if ( pRequiredParts > 1 )
                {
                    pInadequatePartsSource = ensurePartsSource( pInadequatePartsSource );
                    pParts.add( new NumericPC( "" + pInadequatePartsSource.getMin() ) );
                }
            case 2: // assume Hour & Min, add Secs
                if ( pRequiredParts > 2 )
                {
                    pInadequatePartsSource = ensurePartsSource( pInadequatePartsSource );
                    pParts.add( new NumericPC( "" + pInadequatePartsSource.getSec() ) );
                }
            case 3: // assume Hour, Min, & Secs, add Millis
                if ( pRequiredParts > 3 )
                {
                    pInadequatePartsSource = ensurePartsSource( pInadequatePartsSource );
                    pParts.add( new NumericPC( "" + pInadequatePartsSource.getMilliSec() ) );
                }
            case 4: // assume Hour, Min, Secs, & Millis
            default:
                break;
        }
        return pInadequatePartsSource;
    }

    private AbstractRealPC[] LLinitialPartsValidate( String pCurrentText, List<PartCollector> pParts, String pWhat, int pMaxParts )
    {
        int zParts = pParts.size();
        if ( zParts == 0 )
        {
            throw badText( "No " + pWhat + " 'parts'" );
        }
        if ( zParts > pMaxParts )
        {
            throw badText( "More than " + pMaxParts + " " + pWhat + " 'parts'" );
        }
        if ( zParts != pMaxParts )
        {
            throw badText( "Expected " + pMaxParts + " " + pWhat + " 'parts', but only got " + zParts );
        }
        AbstractRealPC[] aParts = new AbstractRealPC[zParts];
        int zMonths = 0;
        for ( int i = 0; i < zParts; i++ )
        {
            AbstractRealPC realPC = aParts[i] = (AbstractRealPC) pParts.get( i );
            realPC.validate( pCurrentText );
            if ( realPC.isMonth() )
            {
                zMonths++;
            }
        }
        if ( zMonths > 1 )
        {
            throw badText( pWhat + " with " + zMonths + " Month 'parts'" );
        }
        return aParts;
    }

    private void LLpartsValidateForDate( AbstractRealPC[] pParts, String pWhat )
    {
        int zYears = 0;
        for ( int i = 0; i < 3; i++ )
        {
            int flags = pParts[i].getFlags();
            if ( flags == OPT_YEAR )
            {
                zYears++;
            }
        }
        if ( zYears > 1 )
        {
            throw badText( pWhat + " with " + zYears + " Year 'parts'" );
        }
    }

    @SuppressWarnings({"PointlessArithmeticExpression"})
    private void LLpartsValidateForTime( String pCurrentText, AbstractRealPC[] pParts, int pFrontParts, int pRequiredParts )
    {
        pParts[pFrontParts + 0].validate( pCurrentText, "Hour", 23 );
        if ( pRequiredParts > 1 )
        {
            pParts[pFrontParts + 1].validate( pCurrentText, "Min", 59 );
            if ( pRequiredParts > 2 )
            {
                pParts[pFrontParts + 2].validate( pCurrentText, "Sec", 59 );
                if ( pRequiredParts > 3 )
                {
                    pParts[pFrontParts + 3].validate( pCurrentText, "MilliSec", 999 );
                }
            }
        }
    }

    @SuppressWarnings({"PointlessArithmeticExpression"})
    private SimpleTime LLparseTime( AbstractRealPC[] pParts, int pFrontParts, int pRequiredParts )
    {
        switch ( pRequiredParts )
        {
            default:
            case 4:
                return new SimpleTime( pParts[pFrontParts + 0].getNumericValue(), // Hour
                                       pParts[pFrontParts + 1].getNumericValue(), // Min
                                       pParts[pFrontParts + 2].getNumericValue(), // Sec
                                       pParts[pFrontParts + 3].getNumericValue() ); // MilliSec
            case 3:
                return new SimpleTime( pParts[pFrontParts + 0].getNumericValue(), // Hour
                                       pParts[pFrontParts + 1].getNumericValue(), // Min
                                       pParts[pFrontParts + 2].getNumericValue() ); // Sec
            case 2:
                return new SimpleTime( pParts[pFrontParts + 0].getNumericValue(), // Hour
                                       pParts[pFrontParts + 1].getNumericValue() ); // Min
            case 1:
                return new SimpleTime( pParts[pFrontParts + 0].getNumericValue() ); // Hour
        }
    }

    private CalendarYMD LLparseDate( AbstractRealPC[] pParts, DateRes pDateRes, String pWhat )
    {
        int zSwitchValue = 0;
        int bucketFactor = 1;
        int zMonthAt = -1;
        for ( int i = 0; i < 3; i++ )
        {
            AbstractRealPC realPC = pParts[i];
            if ( realPC.isMonth() )
            {
                zMonthAt = i;
            }
            int flags = realPC.getFlags();
            zSwitchValue += bucketFactor * flags;
            bucketFactor *= BUCKET_FACTOR;
        }

        switch ( zMonthAt )
        {
            case 0:
                switch ( zSwitchValue )
                {
                    case B0_IS_MONTH + B1_OPT_YEAR + B2_OPT_YEARorMONTHorDAY:
                    case B0_IS_MONTH + B1_OPT_YEAR + B2_OPT_YEARorDAY:
                        return toDate( pDateRes, pParts, 1, 0, 2 );

                    case B0_IS_MONTH + B1_OPT_YEARorMONTHorDAY + B2_OPT_YEAR:
                    case B0_IS_MONTH + B1_OPT_YEARorDAY + B2_OPT_YEAR:
                        return toDate( pDateRes, pParts, 2, 0, 1 );

                    case B0_IS_MONTH + B1_OPT_YEARorMONTHorDAY + B2_OPT_YEARorDAY:
                    case B0_IS_MONTH + B1_OPT_YEARorMONTHorDAY + B2_OPT_YEARorMONTHorDAY:
                    case B0_IS_MONTH + B1_OPT_YEARorDAY + B2_OPT_YEARorMONTHorDAY:
                    case B0_IS_MONTH + B1_OPT_YEARorDAY + B2_OPT_YEARorDAY:
                    default:
                        return isYearBeforeDay() ? toDate( pDateRes, pParts, 1, 0, 2 ) : toDate( pDateRes, pParts, 2, 0, 1 );
                }
            case 1:
                switch ( zSwitchValue )
                {
                    case B0_OPT_YEAR + B1_IS_MONTH + B2_OPT_YEARorMONTHorDAY:
                    case B0_OPT_YEAR + B1_IS_MONTH + B2_OPT_YEARorDAY:
                        return toDate( pDateRes, pParts, 0, 1, 2 );

                    case B0_OPT_YEARorMONTHorDAY + B1_IS_MONTH + B2_OPT_YEAR:
                    case B0_OPT_YEARorDAY + B1_IS_MONTH + B2_OPT_YEAR:
                        return toDate( pDateRes, pParts, 2, 1, 0 );

                    case B0_OPT_YEARorMONTHorDAY + B1_IS_MONTH + B2_OPT_YEARorDAY:
                    case B0_OPT_YEARorMONTHorDAY + B1_IS_MONTH + B2_OPT_YEARorMONTHorDAY:
                    case B0_OPT_YEARorDAY + B1_IS_MONTH + B2_OPT_YEARorMONTHorDAY:
                    case B0_OPT_YEARorDAY + B1_IS_MONTH + B2_OPT_YEARorDAY:
                    default:
                        return isYearBeforeMonth() ? toDate( pDateRes, pParts, 0, 1, 2 ) : toDate( pDateRes, pParts, 2, 1, 0 );
                }
            case 2:
                switch ( zSwitchValue )
                {
                    case B0_OPT_YEARorMONTHorDAY + B1_OPT_YEAR + B2_IS_MONTH:
                    case B0_OPT_YEARorDAY + B1_OPT_YEAR + B2_IS_MONTH:
                        return toDate( pDateRes, pParts, 1, 2, 0 );

                    case B0_OPT_YEAR + B1_OPT_YEARorMONTHorDAY + B2_IS_MONTH:
                    case B0_OPT_YEAR + B1_OPT_YEARorDAY + B2_IS_MONTH:
                        return toDate( pDateRes, pParts, 0, 2, 1 );

                    case B0_OPT_YEARorDAY + B1_OPT_YEARorMONTHorDAY + B2_IS_MONTH:
                    case B0_OPT_YEARorMONTHorDAY + B1_OPT_YEARorMONTHorDAY + B2_IS_MONTH:
                    case B0_OPT_YEARorMONTHorDAY + B1_OPT_YEARorDAY + B2_IS_MONTH:
                    case B0_OPT_YEARorDAY + B1_OPT_YEARorDAY + B2_IS_MONTH:
                    default:
                        return isYearBeforeDay() ? toDate( pDateRes, pParts, 0, 2, 1 ) : toDate( pDateRes, pParts, 1, 0, 2 );
                }
            default:
                switch ( zSwitchValue )
                {
                    case B0_OPT_YEAR + B1_OPT_YEARorDAY + B2_OPT_YEARorDAY:
                        break;
                    case B0_OPT_YEAR + B1_OPT_YEARorDAY + B2_OPT_YEARorMONTHorDAY:
                        return toDate( pDateRes, pParts, 0, 2, 1 );
                    case B0_OPT_YEAR + B1_OPT_YEARorMONTHorDAY + B2_OPT_YEARorDAY:
                        return toDate( pDateRes, pParts, 0, 1, 2 );
                    case B0_OPT_YEAR + B1_OPT_YEARorMONTHorDAY + B2_OPT_YEARorMONTHorDAY:
                        return isDayBeforeMonth() ? toDate( pDateRes, pParts, 0, 2, 1 ) : toDate( pDateRes, pParts, 0, 1, 2 );

                    case B0_OPT_YEARorDAY + B1_OPT_YEAR + B2_OPT_YEARorDAY:
                        break;
                    case B0_OPT_YEARorDAY + B1_OPT_YEAR + B2_OPT_YEARorMONTHorDAY:
                        return toDate( pDateRes, pParts, 1, 2, 0 );
                    case B0_OPT_YEARorMONTHorDAY + B1_OPT_YEAR + B2_OPT_YEARorDAY:
                        return toDate( pDateRes, pParts, 1, 0, 2 );
                    case B0_OPT_YEARorMONTHorDAY + B1_OPT_YEAR + B2_OPT_YEARorMONTHorDAY:
                        return isDayBeforeMonth() ? toDate( pDateRes, pParts, 1, 2, 0 ) : toDate( pDateRes, pParts, 1, 0, 2 );

                    case B0_OPT_YEARorDAY + B1_OPT_YEARorDAY + B2_OPT_YEAR:
                        break;
                    case B0_OPT_YEARorDAY + B1_OPT_YEARorMONTHorDAY + B2_OPT_YEAR:
                        return toDate( pDateRes, pParts, 2, 1, 0 );
                    case B0_OPT_YEARorMONTHorDAY + B1_OPT_YEARorDAY + B2_OPT_YEAR:
                        return toDate( pDateRes, pParts, 2, 0, 1 );
                    case B0_OPT_YEARorMONTHorDAY + B1_OPT_YEARorMONTHorDAY + B2_OPT_YEAR:
                        return isDayBeforeMonth() ? toDate( pDateRes, pParts, 2, 1, 0 ) : toDate( pDateRes, pParts, 2, 0, 1 );
                    default:
                        break;
                }
                throw badText( "No " + pWhat + " 'part' that could be a Month" );
        }
    }

    private IllegalArgumentException badText( String pWhy )
    {
        String zWhy = "Could not interpret";
        if ( pWhy != null )
        {
            zWhy += ": " + pWhy;
        }
        return new IllegalArgumentException( zWhy );
    }

    private CalendarYMD toDate( DateRes pDateRes, //
                               AbstractRealPC[] pParts, int pYearNdx, int pMonthNdx, int pDayNdx )
    {
        int zYear = pParts[pYearNdx].getYear();
        int zMonth = pParts[pMonthNdx].getMonth();
        int zDay = pParts[pDayNdx].getDay();
        if ( pDateRes.isValidToDay() )
        {
            return new CalendarYMD( zYear, zMonth, zDay );
        }
        if ( pDateRes.isValidToMonth() )
        {
            return new CalendarYMD( zYear, zMonth );
        }
        return new CalendarYMD( zYear );
    }

    private transient LateBooleanFieldOrder mYearBeforeMonth = new LateBooleanFieldOrder();

    private boolean isYearBeforeMonth()
    {
        return mYearBeforeMonth.isBefore( mFieldOrder, DateRes.INDICATOR_YEAR, DateRes.INDICATOR_MONTH );
    }

    private transient LateBooleanFieldOrder mYearBeforeDay = new LateBooleanFieldOrder();

    private boolean isYearBeforeDay()
    {
        return mYearBeforeDay.isBefore( mFieldOrder, DateRes.INDICATOR_YEAR, DateRes.INDICATOR_DAY );
    }

    private transient LateBooleanFieldOrder mDayBeforeMonth = new LateBooleanFieldOrder();

    private boolean isDayBeforeMonth()
    {
        return mDayBeforeMonth.isBefore( mFieldOrder, DateRes.INDICATOR_DAY, DateRes.INDICATOR_MONTH );
    }

    private static class LateBooleanFieldOrder
    {
        private Boolean mFlag = null;

        public synchronized boolean isBefore( String pFieldOrder, char pIndicator1st, char pIndicator2nd )
        {
            if ( mFlag == null )
            {
                mFlag = Boolean.FALSE;
                int at1st = pFieldOrder.indexOf( pIndicator1st );
                if ( at1st != -1 )
                {
                    int at2nd = pFieldOrder.indexOf( pIndicator2nd );
                    if ( (at2nd != -1) && (at1st < at2nd) )
                    {
                        mFlag = Boolean.TRUE;
                    }
                }
            }
            return mFlag;
        }
    }
}