package org.litesoft.core.simpletypes.temporal.nonpublic;

import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.util.*;

public interface TemporalParsingSupport
{
    public static final int BUCKET_FACTOR = 256;

    public static final int OPT_YEAR = 1;
    public static final int OPT_MONTH = 2;
    public static final int OPT_DAY = 4;
    public static final int IS_MONTH = 8;

    public static final int B0_OPT_YEAR = OPT_YEAR;
    public static final int B0_OPT_YEARorDAY = OPT_YEAR + OPT_DAY;
    public static final int B0_OPT_YEARorMONTHorDAY = OPT_YEAR + OPT_MONTH + OPT_DAY;
    public static final int B0_IS_MONTH = IS_MONTH;

    public static final int B1_OPT_YEAR = B0_OPT_YEAR << 8;
    public static final int B1_OPT_YEARorDAY = B0_OPT_YEARorDAY << 8;
    public static final int B1_OPT_YEARorMONTHorDAY = B0_OPT_YEARorMONTHorDAY << 8;
    public static final int B1_IS_MONTH = B0_IS_MONTH << 8;

    public static final int B2_OPT_YEAR = B1_OPT_YEAR << 8;
    public static final int B2_OPT_YEARorDAY = B1_OPT_YEARorDAY << 8;
    public static final int B2_OPT_YEARorMONTHorDAY = B1_OPT_YEARorMONTHorDAY << 8;
    public static final int B2_IS_MONTH = B1_IS_MONTH << 8;

    public interface PartCollector
    {
        public boolean accept( char pChar );

        public boolean isReal();

        public void validate( String pFromText );
    }

    public static class SeparatorPC implements PartCollector
    {
        public static final PartCollector INSTANCE = new SeparatorPC();

        public boolean accept( char pChar )
        {
            return !UtilsCommon.isAlphaNumeric( pChar );
        }

        public boolean isReal()
        {
            return false;
        }

        public void validate( String pFromText )
        {
        }

        public String toString()
        {
            return "'sep'";
        }
    }

    public static abstract class AbstractRealPC implements PartCollector
    {
        protected StringBuilder mSB = new StringBuilder();

        protected AbstractRealPC( char pChar )
        {
            mSB.append( pChar );
        }

        protected AbstractRealPC( String pText )
        {
            mSB.append( pText );
        }

        public boolean accept( char pChar )
        {
            boolean rv = isAcceptable( pChar );
            if ( rv )
            {
                mSB.append( pChar );
            }
            return rv;
        }

        public boolean isReal()
        {
            return true;
        }

        abstract protected boolean isAcceptable( char pChar );

        abstract public boolean isMonth();

        abstract public boolean isCouldBeDay();

        abstract public boolean isCouldBeMonth();

        abstract public int getDay();

        abstract public int getMonth();

        abstract public int getYear();

        abstract public int getNumericValue();

        abstract public int getFlags();

        abstract public void validate( String pFromText, String pWhat, int pMaxValue );

        public String toString()
        {
            return mSB.toString();
        }
    }

    public static class StringPC extends AbstractRealPC
    {
        public StringPC( String pText )
        {
            super( pText );
        }

        public StringPC( char pChar )
        {
            super( pChar );
        }

        protected boolean isAcceptable( char pChar )
        {
            return UtilsCommon.isAlpha( pChar );
        }

        public void validate( String pFromText )
        {
        }

        public void validate( String pFromText, String pWhat, int pMaxValue )
        {
            throw new IllegalArgumentException( pWhat + " from '" + pFromText + "' not numeric" );
        }

        public boolean isMonth()
        {
            return false;
        }

        public boolean isCouldBeDay()
        {
            return false;
        }

        public boolean isCouldBeMonth()
        {
            return false;
        }

        public int getDay()
        {
            return 0;
        }

        public int getMonth()
        {
            return 0;
        }

        public int getYear()
        {
            return 0;
        }

        public int getNumericValue()
        {
            return 0;
        }

        public int getFlags()
        {
            return 0;
        }

    }

    public static class MonthAsTextPC extends StringPC
    {
        protected int mValue;

        public MonthAsTextPC( String pText )
        {
            super( pText );
        }

        public MonthAsTextPC( char pChar )
        {
            super( pChar );
        }

        public void validate( String pFromText )
        {
            mValue = CalendarSupport.parseMonth( mSB.toString(), pFromText );
        }

        public int getNumericValue()
        {
            return mValue;
        }

        public int getMonth()
        {
            return mValue;
        }

        public boolean isMonth()
        {
            return true;
        }

        public boolean isCouldBeMonth()
        {
            return true;
        }

        public int getFlags()
        {
            return IS_MONTH;
        }
    }

    public static class NumericPC extends AbstractRealPC
    {
        protected boolean mCouldBeDay, mCouldBeMonth;
        protected int mDay, mMonth, mYear, mValue;

        public NumericPC( String pText )
        {
            super( pText );
        }

        public NumericPC( char pChar )
        {
            super( pChar );
        }

        protected boolean isAcceptable( char pChar )
        {
            return UtilsCommon.isNumeric( pChar );
        }

        public void validate( String pFromText )
        {
            String s = mSB.toString();
            int i = mYear = mValue = Integer.parseInt( s );
            if ( s.length() <= 2 )
            {
                window2digitYear();
                if ( i > 0 )
                {
                    if ( i <= 31 )
                    {
                        mDay = i;
                        mCouldBeDay = true;
                        if ( i <= 12 )
                        {
                            mMonth = i;
                            mCouldBeMonth = true;
                        }
                    }
                }
            }
        }

        private void window2digitYear()
        {
            int thisYear = new UtilDateAdaptor().getYear();
            mYear += (thisYear / 100) * 100;
            if ( mYear > (thisYear + 10) )
            {
                mYear -= 100;
            }
            else if ( mYear < (thisYear - 90) )
            {
                mYear += 100;
            }
        }

        public void validate( String pFromText, String pWhat, int pMaxValue )
        {
            if ( mValue > pMaxValue )
            {
                throw new IllegalArgumentException(
                        pWhat + "(" + mValue + ") from '" + pFromText + "' greater than " + pMaxValue );
            }
        }

        public boolean isMonth()
        {
            return false;
        }

        public boolean isCouldBeDay()
        {
            return mCouldBeDay;
        }

        public boolean isCouldBeMonth()
        {
            return mCouldBeMonth;
        }

        public int getDay()
        {
            return mDay;
        }

        public int getMonth()
        {
            return mMonth;
        }

        public int getYear()
        {
            return mYear;
        }

        public int getNumericValue()
        {
            return mValue;
        }

        public int getFlags()
        {
            int rv = OPT_YEAR;
            if ( isCouldBeMonth() )
            {
                rv += OPT_MONTH;
            }
            if ( isCouldBeDay() )
            {
                rv += OPT_DAY;
            }
            return rv;
        }
    }
}