package org.litesoft.core.simpletypes.temporal;

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

public abstract class AbstractTimestampH<T extends AbstractTimestampH, M extends AbstractTimestampH.Mutable> extends AbstractCalendarYMD<T, M>
        implements TimestampAccessorH
{
    private static final long serialVersionUID = 1L;

    private /* final */ int mHour;
    private /* final */ int mZuluOffsetMins;

    protected AbstractTimestampH( int pYear, int pMonth, int pDay, int pZuluOffsetMins, int pHour )
    {
        super( pYear, pMonth, pDay );
        mHour = validateHour( pHour );
        mZuluOffsetMins = pZuluOffsetMins;
    }

    @Override
    public final int getHour()
    {
        return mHour;
    }

    /**
     * Return a T with the Hour set to the parameter.
     */
    public final T hour( int pHour )
    {
        validateHour( pHour );
        return (mHour == pHour) ? us() : LLsetHour( pHour );
    }

    /**
     * Return T with the parameter pHour added.
     */
    public final T addHours( int pHours )
    {
        return (pHours == 0) ? us() : LLsetHour( mHour + pHours );
    }

    /**
     * Return T with the parameter pHour subtracted.
     */
    public final T minusHours( int pHours )
    {
        return (pHours == 0) ? us() : LLsetHour( mHour - pHours );
    }

    public int getZuluOffsetMins()
    {
        return mZuluOffsetMins;
    }

    // vvvvvvvvvvvvvvvvvv Support methods vvvvvvvvvvvvvvvvv

    protected static final int parseOffset( String pStringForm, String... pParts )
    {
        String zPart = Strings.noEmpty( pParts[pParts.length - 1] );
        if ( zPart == null )
        {
            return 0;
        }
        char zPlusOrMinus = zPart.charAt( 0 );
        if ( (zPlusOrMinus == '-') || (zPlusOrMinus == '+') )
        {
            zPart = zPart.substring( 1 );
            int zOffset = 0;
            switch ( zPart.length() )
            {
                case 5:
                    if ( zPart.charAt( 2 ) != ':' )
                    {
                        break;
                    }
                    zPart = zPart.substring( 0, 2 ) + zPart.substring( 3 );
                    // Fall Thru
                case 4:
                    zOffset += parseInt( zPart.substring( 3 ), "Offset Minutes", pStringForm );
                    zPart = zPart.substring( 0, 2 );
                    // Fall Thru
                case 2:
                    return zOffset + (60 * parseInt( zPart, "Offset Hours", pStringForm ));
                default:
                    break;
            }
        }
        throw new IllegalArgumentException( "Invalid Offset in: " + pStringForm );
    }

    protected static final StringBuilder tailSQLvalue( TimestampAccessorH pAccessorYMDH, boolean pAddTail, StringBuilder pSB )
    {
        if ( pAddTail )
        {
            pSB.append( 'Z' );
            int zOffset = pAccessorYMDH.getZuluOffsetMins();
            if ( zOffset != 0 )
            {
                if ( zOffset > 0 )
                {
                    pSB.append( '+' );
                }
                else
                {
                    pSB.append( '-' );
                    zOffset = -zOffset;
                }
                int zHours = zOffset / 60;
                int zMins = zOffset - (zHours * 60);
                pSB.append( Integers.zeroPadIt( 2, zHours ) );
                if ( zMins != 0 )
                {
                    pSB.append( ':' ).append( Integers.zeroPadIt( 2, zMins ) );
                }
            }
        }
        return pSB;
    }

    protected static final int parseHour( String pStringForm, String... pParts )
    {
        return parseInt( pParts[3], "Hour", pStringForm );
    }

    protected static final StringBuilder formatSQLvalueYMDH( TimestampAccessorH pAccessor, boolean pAddTail, StringBuilder pSB )
    {
        formatSQLvalueYMD( pAccessor, pSB ).append( 'T' );
        formatHour( pAccessor, pSB );
        return tailSQLvalue( pAccessor, pAddTail, pSB );
    }

    protected static final StringBuilder formatSortableDisplayFormYMDH( TimestampAccessorH pAccessor, StringBuilder pSB )
    {
        formatSortableDisplayFormYMD( pAccessor, pSB ).append( ' ' );
        return formatHour( pAccessor, pSB );
    }

    protected static final StringBuilder formatHour( TimestampAccessorH pAccessor, StringBuilder pSB )
    {
        pSB.append( Integers.zeroPadIt( 2, pAccessor.getHour() ) );
        return pSB;
    }

    protected static final int validateHour( int pHour )
            throws IllegalArgumentException
    {
        if ( (pHour < 0) || (23 < pHour) )
        {
            throw new IllegalArgumentException( "Invalid Hour provided: " + pHour );
        }
        return pHour;
    }

    protected int LL_hashCode()
    {
        return hashCodeEm( super.hashCode(), mHour );
    }

    /**
     * T is non-null and of the same class, so should check everything!
     */
    protected boolean LL_equalsNonNullStrict( T them )
    {
        return super.LL_equalsNonNullStrict( them ) && this.getHour() == them.getHour();
    }

    protected Compare LL_compareNonNullLoose( Object them )
    {
        Compare zCompare = super.LL_compareNonNullLoose( them );
        if ( (zCompare.result() == EQUAL) && (them instanceof TimestampAccessorH) )
        {
            zCompare = zCompare.then( this.getHour(), ((TimestampAccessorH) them).getHour() );
        }
        return zCompare;
    }

    /**
     * @param pNewMonth != current
     */
    protected final T LLsetHour( int pNewHour )
    {
        M zMutable = createMutable( getYear(), getMonth(), getDay(), pNewHour );
        zMutable.normalize();
        return createTypeFrom( zMutable );
    }

    protected abstract M createMutable( int pYear, int pMonth, int pDay, int pNewHour );

    protected static class Mutable extends AbstractCalendarYMD.Mutable implements TimestampAccessorH
    {
        private final int mZuluOffsetMins;
        protected int mHour;

        public Mutable( int pYear, int pMonth, int pDay, boolean pDayConstrained, int pZuluOffsetMins, int pHour )
        {
            super( pYear, pMonth, pDay, pDayConstrained );
            mZuluOffsetMins = pZuluOffsetMins;
            mHour = pHour;
        }

        @Override
        public int getZuluOffsetMins()
        {
            return mZuluOffsetMins;
        }

        public void fromWallToZulu()
        {
            adjustMinutesTo( -UtilDateAdaptor.calculateCurrentUTCtoWallOffsetMinutes() );
        }

        public void fromZuluToWall()
        {
            adjustMinutesTo( UtilDateAdaptor.calculateCurrentUTCtoWallOffsetMinutes() );
        }

        public void fromOriginalWallToWall()
        {
            adjustMinutesTo( UtilDateAdaptor.calculateCurrentUTCtoWallOffsetMinutes() - getZuluOffsetMins() );
        }

        public final int getHour()
        {
            return mHour;
        }

        public void normalize()
        {
            super.normalize();
            while ( mHour < 0 )
            {
                tooSmallHour();
            }
            while ( 23 < mHour )
            {
                tooLargeHour();
            }
        }

        protected final void decrementHour()
        {
            if ( --mHour < 0 )
            {
                tooSmallHour();
            }
        }

        protected final void incrementHour()
        {
            if ( 23 < ++mHour )
            {
                tooLargeHour();
            }
        }

        private void tooSmallHour()
        {
            decrementDay();
            mHour += 24;
        }

        private void tooLargeHour()
        {
            mHour -= 24;
            incrementDay();
        }

        protected void adjustMinutesTo( int pOffsetMinsAdjustment )
        {
            if ( pOffsetMinsAdjustment != 0 )
            {
                mHour += pOffsetMinsAdjustment / 60; // Hours Offset
                normalize();
            }
        }
    }
}