package org.litesoft.core.simpletypes.temporal;

import org.litesoft.core.typeutils.*;

/**
 * A Timestamp with resolution to the Minute ("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 TimestampHM extends AbstractTimestampHM<TimestampHM, AbstractTimestampHM.Mutable>
{
    private static final long serialVersionUID = 1L;

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

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

    public TimestampHM( TimestampAccessorHM pAccessor )
    {
        this( pAccessor.getYear(), pAccessor.getMonth(), pAccessor.getDay(), //
              pAccessor.getZuluOffsetMins(), //
              pAccessor.getHour(), pAccessor.getMin() );
    }

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

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

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

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

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

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

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

    public String toYMDHM()
    {
        return formatSortableDisplayFormYMDHM( this, new StringBuilder() ).toString();
    }

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

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

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

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

    // vvvvvvvvvvvvvvvvvv Non-common Public methods vvvvvvvvvvvvvvvvv

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

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

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

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

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

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

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

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