package org.litesoft.core.simpletypes.temporal;

import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.commonfoundation.typeutils.gregorian.*;

/**
 * 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 TimestampHMSM extends AbstractTimestampHMSM<TimestampHMSM, AbstractTimestampHMSM.Mutable>
{
    private static final long serialVersionUID = 1L;

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

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

    public TimestampHMSM( TimestampAccessorHMSM pAccessor )
    {
        this( pAccessor.getYear(), pAccessor.getMonth(), pAccessor.getDay(), //
              pAccessor.getZuluOffsetMins(), //
              pAccessor.getHour(), pAccessor.getMin(), pAccessor.getSec(), pAccessor.getMilliSec() );
    }

    public static TimestampHMSM fromWallTime( int pYear, int pMonth, int pDay, int pHour, int pMin, int pSec, String pFraction )
    {
        return fromWallTime( pYear, pMonth, pDay, pHour, pMin, pSec, fractionOf1000( pFraction ) );
    }

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

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

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

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

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

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

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

    public String toYMDHMSM()
    {
        return formatSortableDisplayFormYMDHMSM( this, new StringBuilder() ).toString();
    }

    public static TimestampHMSM fromYMDHMSM( String pToYMDHMSM )
            throws IllegalArgumentException
    {
        String[] parts = parseSimple( pToYMDHMSM, "// ::." );
        return (parts == null) ? null : //
               fromWallTime( parseYear( pToYMDHMSM, parts ), //
                             parseMonth( pToYMDHMSM, parts ), //
                             parseDay( pToYMDHMSM, parts ), //
                             parseHour( pToYMDHMSM, parts ), //
                             parseMin( pToYMDHMSM, parts ), //
                             parseSec( pToYMDHMSM, parts ), //
                             parseMilliSec( pToYMDHMSM, parts ) );
    }

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

    public static TimestampHMSM 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 ), //
                            parseMilliSec( pToSQLvalue, parts ), //
                            true, parseOffset( pToSQLvalue, parts ) );
    }

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

    // vvvvvvvvvvvvvvvvvv Non-common Public methods vvvvvvvvvvvvvvvvv

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

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

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

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

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

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

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

    @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(), getMilliSec() );
    }

    @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, getMilliSec() );
    }

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