package org.litesoft.core.simpletypes.temporal;

import org.litesoft.commonfoundation.typeutils.*;

/**
 * A Timestamp with resolution to the Second ("Wall" relative) (with tracking for the Offset Minutes from Zulu).
 * <p/>
 * Note: This class supports Gregorian dates only.  As such when working with
 * Java Util Date(s) (or it's descendants) the local (or "Wall") date & time is all that is considered!
 */
public class TimestampHMS extends AbstractTimestampHMS<TimestampHMS, AbstractTimestampHMS.Mutable>
{
    private static final long serialVersionUID = 1L;

    @SuppressWarnings({"deprecation", "UnusedDeclaration"}) @Deprecated /** for Serialization */
    protected TimestampHMS()
    {
        this( 0, 1, 1, 0, 0, 0, 0 );
    }

    public TimestampHMS( int pYear, int pMonth, int pDay, int pZuluOffsetMins, int pHour, int pMin, int pSec )
    {
        super( pYear, pMonth, pDay, pZuluOffsetMins, pHour, pMin, pSec );
    }

    public TimestampHMS( TimestampAccessorHMS pAccessor )
    {
        this( pAccessor.getYear(), pAccessor.getMonth(), pAccessor.getDay(), //
              pAccessor.getZuluOffsetMins(), //
              pAccessor.getHour(), pAccessor.getMin(), pAccessor.getSec() );
    }

    public static TimestampHMS fromWallTime( int pYear, int pMonth, int pDay, int pHour, int pMin, int pSec )
    {
        return new TimestampHMS( UtilDateAdaptor.currentWall( pYear, pMonth, pDay, pHour, pMin, pSec ) );
    }

    public static TimestampHMS fromISO8601( int pYear, int pMonth, int pDay, int pHour, int pMin, String pFraction, boolean pZulu, Integer pUTC_offsetMinutes )
    {
        return fromISO8601( pYear, pMonth, pDay, pHour, pMin, fractionOf60( pFraction ), pZulu, pUTC_offsetMinutes );
    }

    public static TimestampHMS fromISO8601( int pYear, int pMonth, int pDay, int pHour, int pMin, int pSec, boolean pZulu, Integer pUTC_offsetMinutes )
    {
        int zZuluOffsetMins = Integers.deNull( pUTC_offsetMinutes );
        Mutable zMutable = new Mutable( pYear, pMonth, pDay, //
                                        false, zZuluOffsetMins, //
                                        pHour, pMin, pSec );
        if ( pZulu || (zZuluOffsetMins == 0) )
        {
            zMutable.fromZuluToWall();
        }
        else // !Zulu && zZuluOffsetMins != 0
        {
            zMutable.fromOriginalWallToWall();
        }
        return new TimestampHMS( zMutable );
    }

    @Override
    public TemporalResolution getResolution()
    {
        return TemporalResolution.ToSec;
    }

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

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

    public static String toYMDHMS( TimestampHMS pTimestamp )
    {
        return (pTimestamp != null) ? pTimestamp.toYMDHMS() : null;
    }

    public String toYMDHMS()
    {
        return formatSortableDisplayFormYMDHMS( this, new StringBuilder() ).toString();
    }

    public static TimestampHMS fromYMDHMS( String pToYMDHMS )
            throws IllegalArgumentException
    {
        String[] parts = parseSimple( pToYMDHMS, "// ::" );
        return (parts == null) ? null : //
               fromWallTime( parseYear( pToYMDHMS, parts ), //
                             parseMonth( pToYMDHMS, parts ), //
                             parseDay( pToYMDHMS, parts ), //
                             parseHour( pToYMDHMS, parts ), //
                             parseMin( pToYMDHMS, parts ), //
                             parseSec( pToYMDHMS, parts ) );
    }

    public final String toSQLvalue()
    {
        Mutable zMutable = new Mutable( getYear(), getMonth(), getDay(), false, getZuluOffsetMins(), getHour(), getMin(), getSec() );
        zMutable.fromWallToZulu();
        return formatSQLvalueYMDH( zMutable, true, new StringBuilder() ).toString();
    }

    public static TimestampHMS fromSQLvalue( String pToSQLvalue )
    {
        String[] parts = parseSimple( pToSQLvalue, "--TZ::" );
        return (parts == null) ? null : //
               fromISO8601( parseYear( pToSQLvalue, parts ), //
                            parseMonth( pToSQLvalue, parts ), //
                            parseDay( pToSQLvalue, parts ), //
                            parseHour( pToSQLvalue, parts ), //
                            parseMin( pToSQLvalue, parts ), //
                            parseSec( pToSQLvalue, parts ), //
                            true, parseOffset( pToSQLvalue, parts ) );
    }

    @Override
    public UtilDateAdaptor toUtilDateAdaptor()
    {
        return UtilDateAdaptor.offsetWallToSec( getZuluOffsetMins(), getYear(), getMonth(), getDay(), getHour(), getMin(), getSec() );
    }

    // vvvvvvvvvvvvvvvvvv Non-common Public methods vvvvvvvvvvvvvvvvv

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

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    @Override
    protected TimestampHMS createTypeFrom( Mutable pMutable )
    {
        return new TimestampHMS( pMutable.getYear(), pMutable.getMonth(), pMutable.getDay(), pMutable.getZuluOffsetMins(), pMutable.getHour(), pMutable.getMin(), pMutable.getSec() );
    }

    @Override
    protected Mutable createMutable( int pNewYear )
    {
        return new Mutable( pNewYear, getMonth(), getDay(), true, getZuluOffsetMins(), getHour(), getMin(), getSec() );
    }

    @Override
    protected Mutable createMutable( int pYear, int pNewMonth )
    {
        return new Mutable( pYear, pNewMonth, getDay(), true, getZuluOffsetMins(), getHour(), getMin(), getSec() );
    }

    @Override
    protected Mutable createMutable( int pYear, int pMonth, int pNewDay )
    {
        return new Mutable( pYear, pMonth, pNewDay, false, getZuluOffsetMins(), getHour(), getMin(), getSec() );
    }

    @Override
    protected Mutable createMutable( int pYear, int pMonth, int pDay, int pNewHour )
    {
        return new Mutable( pYear, pMonth, pDay, false, getZuluOffsetMins(), pNewHour, getMin(), getSec() );
    }

    @Override
    protected Mutable createMutable( int pYear, int pMonth, int pDay, int pHour, int pNewMin )
    {
        return new Mutable( pYear, pMonth, pDay, false, getZuluOffsetMins(), pHour, pNewMin, getSec() );
    }

    @Override
    protected Mutable createMutable( int pYear, int pMonth, int pDay, int pHour, int pMin, int pNewSec )
    {
        return new Mutable( pYear, pMonth, pDay, false, getZuluOffsetMins(), pHour, pMin, pNewSec );
    }
}