package org.litesoft.core.simpletypes.temporal;

import org.litesoft.core.typeutils.*;

/**
 * A Timestamp with resolution only to the Hour ("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!
 */
@SuppressWarnings("UnusedDeclaration")
public class TimestampH extends AbstractTimestampH<TimestampH, AbstractTimestampH.Mutable>
{
    private static final long serialVersionUID = 1L;

    @SuppressWarnings({"deprecation", "UnusedDeclaration"}) @Deprecated /** for Serialization */
    protected TimestampH()
    {
        super( 0, 0 );
    }

    private TimestampH( int pOriginalZuluOffsetMins, long pUTC )
    {
        super( pOriginalZuluOffsetMins, pUTC );
    }

    private TimestampH( int pOriginalZuluOffsetMins, UtilDateAdaptor pDateAdaptor )
    {
        super( pOriginalZuluOffsetMins, pDateAdaptor );
    }

    public TimestampH( UtilDateAdaptor pDateAdaptor )
    {
        super( pDateAdaptor.force( TemporalResolution.ToHour ) );
    }

    @Override
    protected UtilDateAdaptor createWall()
    {
        return new UtilDateAdaptor( getUTClong(), TemporalResolution.ToHour );
    }

    public static TimestampH fromWallTime( int pYear, int pMonth, int pDay, int pHour )
    {
        return new TimestampH( UtilDateAdaptor.wall( pYear,
                                                     validateMonth( pYear, pMonth ),
                                                     validateDay( pYear, pMonth, pDay ),
                                                     validateHour( pHour ) ) );
    }

    public static TimestampH fromISO8601( int pYear, int pMonth, int pDay, int pHour, boolean pZulu, Integer pUTC_offsetMinutes )
    {
        validateMonth( pYear, pMonth );
        validateDay( pYear, pMonth, pDay );
        validateHour( pHour );
        int zZuluOffsetMins = Integers.deNull( pUTC_offsetMinutes );
        if ( pZulu )
        {
            return new TimestampH( zZuluOffsetMins, UtilDateAdaptor.zulu( pYear, pMonth, pDay, pHour ) );
        }
        Mutable zMutable = new Mutable( pYear, pMonth, pDay, false, pHour ); // Original Wall Time
        zMutable.adjustOrigWallToZulu( zZuluOffsetMins );
        return new TimestampH( zZuluOffsetMins,
                               UtilDateAdaptor.zulu( zMutable.getYear(), zMutable.getMonth(), zMutable.getDay(), zMutable.getHour() ) );
    }

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

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

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

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

    public String toYMDH()
    {
        return formatSortableDisplayFormYMDH( this, new StringBuilder() ).toString();
    }

    public static TimestampH fromYMDH( String pToYMDH )
            throws IllegalArgumentException
    {
        String[] parts = parseSimple( pToYMDH, "// " );
        return (parts == null) ? null : //
               fromWallTime( parseYear( pToYMDH, parts ), //
                             parseMonth( pToYMDH, parts ), //
                             parseDay( pToYMDH, parts ), //
                             parseHour( pToYMDH, parts ) );
    }

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

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

    @Override
    public UtilDateAdaptor toUtilDateAdaptor()
    {
        return getWall();
    }

    // vvvvvvvvvvvvvvvvvv Non-common Public methods vvvvvvvvvvvvvvvvv

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

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    @Override
    protected TimestampH createTypeFrom( Mutable pMutable )
    {
        return null; // TODO: new TimestampH( pMutable.getYear(), pMutable.getMonth(), pMutable.getDay(), pMutable.getZuluOffsetMins(), pMutable.getHour() );
    }

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

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

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