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

import java.io.*;

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

public abstract class CalendarSupport<T extends CalendarSupport> extends CompareSupport<T> implements Serializable
{
    public static final String JAN = "January";
    public static final String FEB = "Febuary";
    public static final String MAR = "March";
    public static final String APR = "April";
    public static final String MAY = "May";
    public static final String JUN = "June";
    public static final String JUL = "July";
    public static final String AUG = "August";
    public static final String SEP = "September";
    public static final String OCT = "October";
    public static final String NOV = "November";
    public static final String Dec = "December";

    protected static final String[] MONTH_NAMES = new String[] //
            { //
              "---", // 0 - Text required for Chunking (see below)
              JAN, //  1
              FEB, //  2
              MAR, //  3
              APR, //  4
              MAY, //  5
              JUN, //  6
              JUL, //  7
              AUG, //  8
              SEP, //  9
              OCT, // 10
              NOV, // 11
              Dec, // 12
            };

    protected static final int[] MONTH_DAYS = new int[] //
            { //
              0, //   0
              31, //  1 - Jan
              0, //   2 - Feb: 28/29
              31, //  3 - Mar
              30, //  4 - Apr
              31, //  5 - May
              30, //  6 - Jun
              31, //  7 - Jul
              31, //  8 - Aug
              30, //  9 - Sep
              31, // 10 - Oct
              30, // 11 - Nov
              31, // 12 - Dec
            };

    protected static final String[] MONTH_NAMES_ALL_CAPS = new String[] //
            { //
              "---", //              0 - Text required for Chunking (see below)
              JAN.toUpperCase(), //  1
              FEB.toUpperCase(), //  2
              MAR.toUpperCase(), //  3
              APR.toUpperCase(), //  4
              MAY.toUpperCase(), //  5
              JUN.toUpperCase(), //  6
              JUL.toUpperCase(), //  7
              AUG.toUpperCase(), //  8
              SEP.toUpperCase(), //  9
              OCT.toUpperCase(), // 10
              NOV.toUpperCase(), // 11
              Dec.toUpperCase(), // 12
            };

    public CalendarSupport()
    {
    }

    /**
     * True if pYear is thought to be a Leap Year (based on the rules that apply from 1800 thru 2100 in the "Gregorian" calendar).
     * <p/>
     * Note: if pYear is before 1800 or after 2010 or are not using a "Gregorian" calendar, then you may get incorrect results!
     * <p/>
     * Rules for 1800 - 2010:
     * <ul>
     * 1) Every 4 years is a Leap Year, except
     * 2) Every 100 years is NOT a Leap Year, except
     * 3) Every 400 years is a Leap year.
     * <ul/>
     * Hence:
     * The following are Leap Years: 1800, 1804, 1896, 1900, 1904, 1996, 2004, 2096, 2100, 2104
     * The following are NOT Leap Years: 1801, 1903, 1998, 2000, 2002
     */
    public static boolean isLeapYear( int pYear )
    {
        if ( 0 != (pYear & 3) ) // Every 4
        {
            return false;
        }
        //noinspection SimplifiableIfStatement
        if ( 0 != (pYear % 100) ) // ! Every 100
        {
            return true;
        }
        return (0 == (pYear % 400)); // Every 400
    }

    /**
     * Days in specified Year & Month (or 0 if the month is invalid).
     * <p/>
     * Only guaranteed to produce valid results in the "Gregorian" calendar from 1800 thru 2010.
     * <p/>
     * Note: if pYear is before 1800 or after 2010, then you may get incorrect results!
     */
    public static int daysInMonth( int pYear, int pMonth )
    {
        if ( (pMonth < 1) || (12 < pMonth) )
        {
            return 0;
        }
        return (pMonth != 2) ? MONTH_DAYS[pMonth] : isLeapYear( pYear ) ? 29 : 28;
    }

    /**
     * Returns null if a valid date, or error text if not!
     */
    public static String validDate( int pYear, int pMonth, int pDay )
    {
        int maxDaysInMonth = daysInMonth( pYear, pMonth );
        if ( maxDaysInMonth == 0 )
        {
            return "Invalid month: " + pMonth;
        }
        if ( pDay < 1 )
        {
            return "Invalid day: " + pDay;
        }
        if ( maxDaysInMonth < pDay )
        {
            return MONTH_NAMES[pMonth] + " " + pYear + " only has " + maxDaysInMonth + ", attempted to set days to: " + pDay;
        }
        return null;
    }

    public static int parseInt( String pToParse, String pWhat, String pFrom )
            throws IllegalArgumentException
    {
        pToParse = pToParse.trim();
        if ( pToParse.length() == 0 )
        {
            throw new IllegalArgumentException( "No " + pWhat + " in '" + pFrom + "'" );
        }
        try
        {
            return Integer.parseInt( pToParse );
        }
        catch ( NumberFormatException e )
        {
            throw new IllegalArgumentException( "Invalid " + pWhat + " '" + pToParse + "' in '" + pFrom + "': " + e.getMessage() );
        }
    }

    public static int parseMonth( String pToParse, String pFrom )
            throws IllegalArgumentException
    {
        pToParse = pToParse.trim().toUpperCase();
        if ( pToParse.length() == 0 )
        {
            throw new IllegalArgumentException( "No Month in '" + pFrom + "'" );
        }
        int zLastMatch = 0;
        int zMatchedCount = 0;
        String zMatches = "";
        for ( int i = 1; i < MONTH_NAMES_ALL_CAPS.length; i++ )
        {
            String monthName = MONTH_NAMES_ALL_CAPS[i];
            if ( monthName.startsWith( pToParse ) )
            {
                zMatches += ", " + MONTH_NAMES[zLastMatch = i];
                zMatchedCount++;
            }
        }
        String zMessage;
        switch ( zMatchedCount )
        {
            case 1:
                return zLastMatch;
            case 0:
                zMessage = "";
                break;
            default:
                zMessage = ": Matched-" + zMatches.substring( 2 );
                break;
        }
        throw new IllegalArgumentException( "Invalid Month '" + pToParse + "' in '" + pFrom + "'" + zMessage );
    }

    protected static void undefinedResultIfNull( String pWhat, Object pToCheck )
            throws IllegalArgumentException
    {
        if ( pToCheck == null )
        {
            throw new IllegalArgumentException( "Result is undefined for: " + pWhat + "( null )" );
        }
    }

    protected static void LLcheckMonth( int pMonth )
    {
        if ( (pMonth < 1) || (12 < pMonth) )
        {
            throw new IllegalArgumentException( "Invalid Month provided: " + pMonth );
        }
    }

    protected static void LLcheckDay( int pDay )
    {
        if ( (pDay < 1) || (31 < pDay) )
        {
            throw new IllegalArgumentException( "Invalid Day provided: " + pDay );
        }
    }

    protected int validate( String pWhat, int pNewValue, int pMaxValue )
            throws IllegalArgumentException
    {
        if ( (pNewValue < 0) || (pMaxValue < pNewValue) )
        {
            throw new IllegalArgumentException( "The Time '" + pWhat + "' field only accepts values between 0 and " + pMaxValue + " inclusive, attemted to set it to '" + pNewValue + "', current value is: " + this );
        }
        return pNewValue;
    }

    protected static String minLength( int pMinLength, String pValue )
    {
        while ( pValue.length() < pMinLength )
        {
            pValue = "0" + pValue;
        }
        return pValue;
    }

    public interface Chunk // Marker
    {
    }

    protected static class ProxyLeadZeroMinLengthChunk implements Chunk
    {
        private Chunk mChunk;
        private int mMinLength;

        public ProxyLeadZeroMinLengthChunk( Chunk pChunk, int pMinLength )
        {
            mChunk = pChunk;
            mMinLength = pMinLength;
        }

        public String toString()
        {
            return minLength( mMinLength, mChunk.toString() );
        }
    }

    protected static class LiteralChunk implements Chunk
    {
        private String mLiteral;

        public LiteralChunk( String pLiteral )
        {
            mLiteral = pLiteral;
        }

        public String toString()
        {
            return mLiteral;
        }
    }

    protected static abstract class YMDaccessorChunk implements Chunk
    {
        protected YMDaccessor mYMDaccessor;

        protected YMDaccessorChunk( YMDaccessor pYMDaccessor )
        {
            mYMDaccessor = pYMDaccessor;
        }
    }

    protected static class M_Chunk extends YMDaccessorChunk
    {
        public M_Chunk( YMDaccessor pYMDaccessor )
        {
            super( pYMDaccessor );
        }

        public String toString()
        {
            return Integer.toString( mYMDaccessor.getMonth() );
        }
    }

    protected static class MM_Chunk extends ProxyLeadZeroMinLengthChunk
    {
        public MM_Chunk( YMDaccessor pYMDaccessor )
        {
            super( new M_Chunk( pYMDaccessor ), 2 );
        }
    }

    protected static class MMMM_Chunk extends YMDaccessorChunk
    {
        public MMMM_Chunk( YMDaccessor pYMDaccessor )
        {
            super( pYMDaccessor );
        }

        public String toString()
        {
            return MONTH_NAMES[mYMDaccessor.getMonth()];
        }
    }

    protected static class MMM_Chunk extends MMMM_Chunk
    {
        public MMM_Chunk( YMDaccessor pYMDaccessor )
        {
            super( pYMDaccessor );
        }

        public String toString()
        {
            return super.toString().substring( 0, 3 );
        }
    }

    protected static class y_Chunk extends YMDaccessorChunk
    {
        public y_Chunk( YMDaccessor pYMDaccessor )
        {
            super( pYMDaccessor );
        }

        public String toString()
        {
            return Integer.toString( mYMDaccessor.getYear() );
        }
    }

    protected static class yy_Chunk extends y_Chunk
    {
        public yy_Chunk( YMDaccessor pYMDaccessor )
        {
            super( pYMDaccessor );
        }

        public String toString()
        {
            String s = super.toString();
            return (s.length() == 1) ? "0" + s : s.substring( s.length() - 2 );
        }
    }

    protected static class yyy_Chunk extends y_Chunk
    {
        private int mMinLength;

        public yyy_Chunk( YMDaccessor pYMDaccessor, int pMinLength )
        {
            super( pYMDaccessor );
            mMinLength = pMinLength;
        }

        public String toString()
        {
            return minLength( mMinLength, super.toString() );
        }
    }

    protected static class d_Chunk extends YMDaccessorChunk
    {
        public d_Chunk( YMDaccessor pYMDaccessor )
        {
            super( pYMDaccessor );
        }

        public String toString()
        {
            return Integer.toString( mYMDaccessor.getDay() );
        }
    }

    protected static class dd_Chunk extends ProxyLeadZeroMinLengthChunk
    {
        public dd_Chunk( YMDaccessor pYMDaccessor )
        {
            super( new d_Chunk( pYMDaccessor ), 2 );
        }
    }

    protected static LiteralChunk SLASH = new LiteralChunk( "/" );
    protected static LiteralChunk SPACE = new LiteralChunk( " " );
    protected static LiteralChunk COLON = new LiteralChunk( ":" );
    protected static LiteralChunk COMMA = new LiteralChunk( "," );
    protected static LiteralChunk DASH = new LiteralChunk( "-" );
}