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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

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

/**
 * A Simple Timestamp that acts as a proxy for a java.util.Date (burying the depricated method use) and variable
 * resolution from the Hour thru the Millisecond.
 */
public final class SimpleTimestamp extends AbstractWithTimeResAspects<SimpleTimestamp> implements TimestampWithResolutionAccessor,
                                                                                                  TemporalSimpleType,
                                                                                                  SQLtimestampable
{
    public static final String DEFAULT_TS_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS"; // Note this is representational - IT IS NOT USED!

    private int mYear, mMonth, mDay;
    private SimpleTime mTime;

    /**
     * @deprecated - for Serialization
     */
    protected SimpleTimestamp()
    {
    }

    private SimpleTimestamp( SimpleTime pTime )
            throws IllegalArgumentException
    {
        if ( null == (mTime = pTime) )
        {
            throw new IllegalArgumentException( "Time required for a Timestamp" );
        }
    }

    public SimpleTimestamp( int pYear, int pMonth, int pDay, SimpleTime pTime )
            throws IllegalArgumentException
    {
        this( pTime );
        setDate( pYear, pMonth, pDay );
    }

    public SimpleTimestamp( CalendarYMD pDate, SimpleTime pTime )
            throws IllegalArgumentException
    {
        this( pTime );
        if ( pDate == null )
        {
            throw new IllegalArgumentException( "Date may NOT be null" );
        }
        setDate( pDate );
    }

    public SimpleTimestamp( int pYear, int pMonth, int pDay, int pHour )
            throws IllegalArgumentException
    {
        this( pYear, pMonth, pDay, new SimpleTime( pHour ) );
    }

    public SimpleTimestamp( int pYear, int pMonth, int pDay, int pHour, int pMin )
            throws IllegalArgumentException
    {
        this( pYear, pMonth, pDay, new SimpleTime( pHour, pMin ) );
    }

    public SimpleTimestamp( int pYear, int pMonth, int pDay, int pHour, int pMin, int pSec )
            throws IllegalArgumentException
    {
        this( pYear, pMonth, pDay, new SimpleTime( pHour, pMin, pSec ) );
    }

    public SimpleTimestamp( int pYear, int pMonth, int pDay, int pHour, int pMin, int pSec, int pMilliSec )
            throws IllegalArgumentException
    {
        this( pYear, pMonth, pDay, new SimpleTime( pHour, pMin, pSec, pMilliSec ) );
    }

    public SimpleTimestamp( CalendarYMD pDate, int pHour )
            throws IllegalArgumentException
    {
        this( pDate, new SimpleTime( pHour ) );
    }

    public SimpleTimestamp( CalendarYMD pDate, int pHour, int pMin )
            throws IllegalArgumentException
    {
        this( pDate, new SimpleTime( pHour, pMin ) );
    }

    public SimpleTimestamp( CalendarYMD pDate, int pHour, int pMin, int pSec )
            throws IllegalArgumentException
    {
        this( pDate, new SimpleTime( pHour, pMin, pSec ) );
    }

    public SimpleTimestamp( CalendarYMD pDate, int pHour, int pMin, int pSec, int pMilliSec )
            throws IllegalArgumentException
    {
        this( pDate, new SimpleTime( pHour, pMin, pSec, pMilliSec ) );
    }

    public SimpleTimestamp( TimeRes pResolution, Date pDate )
            throws IllegalArgumentException
    {
        this( new CalendarYMD( pDate ), SimpleTime.timeComponents( pResolution, pDate ) );
    }

//    public SimpleTimestamp( TimeRes pResolution, UtilDateAdaptor pDate )
//            throws IllegalArgumentException
//    {
//        this( pDate.getYear(), pDate.getMonth(), pDate.getDay(), SimpleTime.timeComponents( pResolution, pDate ) );
//    }

    public SimpleTimestamp( UtilDateAdaptor pDate )
            throws IllegalArgumentException
    {
        this( pDate.getYear(), pDate.getMonth(), pDate.getDay(), SimpleTime.timeComponents( pDate ) );
    }

    public SimpleTimestamp( Date pDate )
            throws IllegalArgumentException
    {
        this( new CalendarYMD( pDate ), SimpleTime.timeComponents( pDate ) );
    }

    public static SimpleTimestamp now()
    {
        return new SimpleTimestamp( new UtilDateAdaptor() );
    }

    public SimpleTimestamp copy()
    {
        return new SimpleTimestamp( getYear(), getMonth(), getDay(), mTime.copy() );
    }

    public SimpleTimestamp copyWithUpdatedResolution( TimeRes pResolution )
            throws IllegalArgumentException
    {
        return new SimpleTimestamp( getYear(), getMonth(), getDay(), mTime.copyWithUpdatedResolution( pResolution ) );
    }

    /**
     * Delete this method...
     */
    public SimpleTimestamp copyWithExpandedResolution( TimeRes pResolution )
            throws IllegalArgumentException
    {
        return new SimpleTimestamp( getYear(), getMonth(), getDay(), mTime.copyWithExpandedResolution( pResolution ) );
    }

    /**
     * Delete this method...
     */
    public SimpleTimestamp copyWithReducedResolution( TimeRes pResolution )
            throws IllegalArgumentException
    {
        return new SimpleTimestamp( getYear(), getMonth(), getDay(), mTime.copyWithReducedResolution( pResolution ) );
    }

    @Override
    public int getResolutionIndex()
    {
        return mTime.getResolutionIndex();
    }

    @Override
    public TimeRes getTimeRes()
    {
        return mTime.getTimeRes();
    }

    public CalendarYMD getDateComponents()
    {
        return new CalendarYMD( mYear, mMonth, mDay );
    }

    public SimpleTime getTimeComponents()
    {
        return new SimpleTime( mTime );
    }

    @Override
    public int getYear()
    {
        return mYear;
    }

    @Override
    public int getMonth()
    {
        return mMonth;
    }

    @Override
    public int getDay()
    {
        return mDay;
    }

    @Override
    public int getHour()
    {
        return mTime.getHour();
    }

    @Override
    public int getMin()
    {
        return mTime.getMin();
    }

    @Override
    public int getSec()
    {
        return mTime.getSec();
    }

    @Override
    public int getMilliSec()
    {
        return mTime.getMilliSec();
    }

    public UtilDateAdaptor getUtilDateAdaptor()
    {
        switch ( mTime.getResolutionIndex() )
        {
            case TimeRes.HOURindex:
                return UtilDateAdaptor.currentWall( mYear, mMonth, mDay, //
                                                    mTime.getHour() );
            case TimeRes.MINindex:
                return UtilDateAdaptor.currentWall( mYear, mMonth, mDay, //
                                                    mTime.getHour(), //
                                                    mTime.getMin() );
            case TimeRes.SECindex:
                return UtilDateAdaptor.currentWall( mYear, mMonth, mDay, //
                                                    mTime.getHour(), //
                                                    mTime.getMin(), //
                                                    mTime.getSec() );
            case TimeRes.MSECindex:
            default:
                return UtilDateAdaptor.currentWall( mYear, mMonth, mDay, //
                                                    mTime.getHour(), //
                                                    mTime.getMin(), //
                                                    mTime.getSec(), //
                                                    mTime.getMilliSec() );
        }
    }

    public Date getDate()
    {
        return getUtilDateAdaptor().getWallDate();
    }

    public void setDate( Date pDate )
    {
        if ( pDate == null )
        {
            throw new IllegalArgumentException( "Date was null" );
        }
        setDateToResolution( new UtilDateAdaptor( pDate ) );
    }

    public void setDate( CalendarYMD pDate )
    {
        if ( pDate == null )
        {
            throw new IllegalArgumentException( "Date was null" );
        }
        setDateToResolution( pDate.toUtilDateAdaptor() );
    }

    public void setTimestamp( SimpleTimestamp pTimestamp )
            throws IllegalArgumentException
    {
        if ( pTimestamp == null )
        {
            throw new IllegalArgumentException( "Date was null" );
        }
        setDateToResolution( pTimestamp.getUtilDateAdaptor() );
    }

    private void setDateToResolution( UtilDateAdaptor pDateAdaptor )
            throws IllegalArgumentException
    {
        setDate( pDateAdaptor.getYear(), pDateAdaptor.getMonth(), pDateAdaptor.getDay() );
        switch ( pDateAdaptor.getTemporalResolution() )
        {
            case ToMilliSec:
                if ( isValidToMilliSec() )
                {
                    setMilliSec( pDateAdaptor.getMilliSec() );
                }
                // Fall Thru
            case ToSec:
                if ( isValidToSec() )
                {
                    setSec( pDateAdaptor.getSec() );
                }
                // Fall Thru
            case ToMin:
                if ( isValidToMin() )
                {
                    setMin( pDateAdaptor.getMin() );
                }
                // Fall Thru
            case ToHour:
                setHour( pDateAdaptor.getHour() );
                // Fall Thru
            default:
                break;
        }
    }

    public void setDate( int pYear, int pMonth, int pDay )
            throws IllegalArgumentException
    {
        validate( pYear, pMonth, pDay );
        mYear = pYear;
        mMonth = pMonth;
        mDay = pDay;
    }

    public void setYearAndMonth( int pYear, int pMonth )
            throws IllegalArgumentException
    {
        validate( pYear, pMonth, mDay );
        mYear = pYear;
        mMonth = pMonth;
    }

    public void setMonthAndDay( int pMonth, int pDay )
            throws IllegalArgumentException
    {
        validate( mYear, pMonth, pDay );
        mMonth = pMonth;
        mDay = pDay;
    }

    public void setYear( int pYear )
            throws IllegalArgumentException
    {
        validate( pYear, mMonth, mDay );
        mYear = pYear;
    }

    public void setMonth( int pMonth )
            throws IllegalArgumentException
    {
        validate( mYear, pMonth, mDay );
        mMonth = pMonth;
    }

    public void setDay( int pDay )
            throws IllegalArgumentException
    {
        validate( mYear, mMonth, pDay );
        mDay = pDay;
    }

    public void setHour( int pHour )
    {
        mTime.setHour( pHour );
    }

    public void setMin( int pMin )
    {
        mTime.setMin( pMin );
    }

    public void setSec( int pSec )
    {
        mTime.setSec( pSec );
    }

    public void setMilliSec( int pMilliSec )
    {
        mTime.setMilliSec( pMilliSec );
    }

    protected void validate( int pYear, int pMonth, int pDay )
            throws IllegalArgumentException
    {
        String error = Dates.checkValidity( pYear, pMonth, pDay );
        if ( error != null )
        {
            throw new IllegalArgumentException( error );
        }
    }

    /**
     * True if this is 'before' pThem.
     * <p/>
     * Note: Uses the lesser resolution of pThem or this.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean before( SimpleTimestamp pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "before", -1 );
    }

    /**
     * True if this is 'after' pThem.
     * <p/>
     * Note: Uses the lesser resolution of pThem or this.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean after( SimpleTimestamp pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "after", 1 );
    }

    private boolean LLbeforeOrAfter( SimpleTimestamp pThem, String pWhat, int pCompareRetValue )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( pWhat, pThem );
        int cv;
        if ( 0 == (cv = compare( this.getYear(), pThem.getYear() )) )
        {
            if ( 0 == (cv = compare( this.getMonth(), pThem.getMonth() )) )
            {
                if ( 0 == (cv = compare( this.getDay(), pThem.getDay() )) )
                {
                    if ( 0 == (cv = compare( this.getHour(), pThem.getHour() )) )
                    {
                        if ( this.isValidToMin() && pThem.isValidToMin() && //
                             0 == (cv = compare( this.getMin(), pThem.getMin() )) )
                        {
                            if ( this.isValidToSec() && pThem.isValidToSec() && //
                                 0 == (cv = compare( this.getSec(), pThem.getSec() )) )
                            {
                                if ( this.isValidToMilliSec() && pThem.isValidToMilliSec() )
                                {
                                    cv = compare( this.getMilliSec(), pThem.getMilliSec() );
                                }
                            }
                        }
                    }
                }
            }
        }
        return pCompareRetValue == cv;
    }

    /**
     * True if this is 'before' pThem.
     * <p/>
     * Note: Treats pThem as if its resolution is the same as this' resolution.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean before( Date pThem )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( "before", pThem );
        return before( new SimpleTimestamp( pThem ) );
    }

    /**
     * True if this is 'after' pThem.
     * <p/>
     * Note: Treats pThem as if its resolution is the same as this' resolution.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public boolean after( Date pThem )
            throws IllegalArgumentException
    {
        undefinedResultIfNull( "after", pThem );
        return after( new SimpleTimestamp( pThem ) );
    }

    /**
     * Determine the Number of Days, Hours, Mins, Secs, & MilliSecs between this and pThem.
     * <p/>
     * The Maximum resolution of the result is the minimum resolution of this and pThem.  However, the actual
     * resolution is dependant on the result.
     *
     * @param pThem !null
     *
     * @throws IllegalArgumentException if pThem is null
     */
    public SimpleTimespan difference( SimpleTimestamp pThem )
            throws IllegalArgumentException
    {
        return LLbeforeOrAfter( pThem, "difference", -1 ) ? // this < pThem ?
               this.LLtill( pThem ) : //
               pThem.LLtill( this );
    }

    public SimpleTimestamp add( SimpleTimespan pAdjustBy )
            throws IllegalArgumentException
    {
        SimpleTime time = getTimeComponents();
        int adjustByDays = time.add( pAdjustBy ); // Should be 0 / positive
        CalendarYMD date = getDateComponents();
        date.addDays( adjustByDays );
        setTimestamp( new SimpleTimestamp( date, time ) );
        return this; // TODO: XXX
    }

    public SimpleTimestamp subtract( SimpleTimespan pAdjustBy )
            throws IllegalArgumentException
    {
        SimpleTime time = getTimeComponents();
        int adjustByDays = time.subtract( pAdjustBy ); // Should be 0 / negative
        CalendarYMD date = getDateComponents();
        date.addDays( adjustByDays );
        setTimestamp( new SimpleTimestamp( date, time ) );
        return this; // TODO: XXX
    }

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

    public boolean equals( Date pDate )
    {
        return (pDate != null) && equals( new SimpleTimestamp( pDate ) );
    }

    public boolean equals( SimpleTimestamp them )
    {
        return (this == them) || //
               ((them != null) //
                && equal( this.mYear, them.mYear ) //
                && equal( this.mMonth, them.mMonth ) //
                && equal( this.mDay, them.mDay ) //
                && equal( this.mTime, them.mTime ) //
               );
    }

    @Override
    public int hashCode()
    {
        return hashCodeEm( calcHashCode( mYear ), //
                           calcHashCode( mMonth ), //
                           calcHashCode( mDay ) );
    }

    @Override
    public int compareTo( SimpleTimestamp them )
    {
        return compareEm( compare( this.mYear, them.mYear ), //
                          compare( this.mMonth, them.mMonth ), //
                          compare( this.mDay, them.mDay ), //
                          compare( this.mTime, them.mTime ) );
    }

    public static String toString( SimpleTimestamp pFromString )
    {
        return (pFromString != null) ? pFromString.toString() : null;
    }

    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        for ( Chunk chunk : getToStringChunks() )
        {
            chunk.appendTo( sb, this );
        }
        return sb.toString();
    }

    public static SimpleTimestamp fromString( String pToString )
            throws IllegalArgumentException
    {
        if ( pToString == null )
        {
            return null;
        }
        // yyyy-MM-dd HH:mm:ss.SSS
        String[] parts = SimpleParser.parse( pToString, "-- ::.", 4 );
        int zYear = parseInt( parts[0], "Year", pToString );
        int zMonth = parseInt( parts[1], "Month", pToString );
        int zDay = parseInt( parts[2], "Day", pToString );
        switch ( parts.length )
        {
            case 4:
                return new SimpleTimestamp( zYear, zMonth, zDay, //
                                            parseInt( parts[3], "Hour", pToString ) );
            case 5:
                return new SimpleTimestamp( zYear, zMonth, zDay, //
                                            parseInt( parts[3], "Hour", pToString ), //
                                            parseInt( parts[4], "Min", pToString ) );
            case 6:
                return new SimpleTimestamp( zYear, zMonth, zDay, //
                                            parseInt( parts[3], "Hour", pToString ), //
                                            parseInt( parts[4], "Min", pToString ), //
                                            parseInt( parts[5], "Sec", pToString ) );
            case 7:
                return new SimpleTimestamp( zYear, zMonth, zDay, //
                                            parseInt( parts[3], "Hour", pToString ), //
                                            parseInt( parts[4], "Min", pToString ), //
                                            parseInt( parts[5], "Sec", pToString ), //
                                            parseInt( parts[6], "MilliSec", pToString ) );
            default:
                throw new IllegalStateException( "parts.length = " + parts.length );
        }
    }

    private transient List<Chunk> mToStringChunks = null;

    private synchronized List<Chunk> getToStringChunks()
    {
        if ( mToStringChunks == null )
        {
            List<Chunk> chunks = Lists.newArrayList();
            chunks.add( y_Chunk );
            chunks.add( DASH );
            chunks.add( MM_Chunk );
            chunks.add( DASH );
            chunks.add( dd_Chunk );
            chunks.add( SPACE );
            chunks.add( new Chunk()
                {
                    @Override
                    public void appendTo( StringBuilder pSB, CalendarAccessorYMD pYMDsource )
                    {
                        pSB.append( mTime );
                    }
                } );
            mToStringChunks = chunks;
        }
        return mToStringChunks;
    }

    private SimpleTimespan LLtill( SimpleTimestamp them )
    {
        int days = this.getDateComponents().daysTill( them.getDateComponents() );

        SimpleTime thisTime = this.getTimeComponents();
        SimpleTime themTime = them.getTimeComponents();

        SimpleTimespan rv = thisTime.difference( themTime );
        rv.addDays( days );

        if ( thisTime.after( themTime ) ) // Unhappy Case: this > them
        {
            rv.addHours( -24 );
        }
        return rv;
    }

    @Override
    public java.sql.Timestamp toSQLvalue()
    {
        return new java.sql.Timestamp( getDate().getTime() );
    }
}