package org.litesoft.core.simpletypes.temporal.nonpublic;

import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.simpletypes.temporal.*;

public abstract class AbstractWithTimeResAspects<T extends AbstractWithTimeResAspects> extends CalendarSupport<T> implements SimpleType
{
    abstract public int getResolutionIndex();

    abstract public TimeRes getTimeRes();

    public boolean isValidToMin()
    {
        return TimeRes.MINindex <= getResolutionIndex();
    }

    public boolean isValidToSec()
    {
        return TimeRes.SECindex <= getResolutionIndex();
    }

    public boolean isValidToMilliSec()
    {
        return TimeRes.MSECindex <= getResolutionIndex();
    }

    protected boolean chkCopyWithExpandedResolution( TimeRes pResolution )
    {
        if ( pResolution == null )
        {
            throw new IllegalArgumentException( "Resolution required" );
        }
        int zResolutionIndex = pResolution.getIndex();
        if ( zResolutionIndex < getResolutionIndex() )
        {
            throw new IllegalArgumentException( "May NOT reduce Resolution" );
        }
        return (zResolutionIndex == getResolutionIndex());
    }

    protected boolean chkCopyWithReducedResolution( TimeRes pResolution )
    {
        if ( pResolution == null )
        {
            throw new IllegalArgumentException( "Resolution required" );
        }
        int zResolutionIndex = pResolution.getIndex();
        if ( zResolutionIndex > getResolutionIndex() )
        {
            throw new IllegalArgumentException( "May NOT increase Resolution" );
        }
        return (zResolutionIndex == getResolutionIndex());
    }

    protected void validateMinAdjustable()
            throws IllegalArgumentException
    {
        validateAdjustable( "Min", isValidToMin() );
    }

    protected void validateSecAdjustable()
            throws IllegalArgumentException
    {
        validateAdjustable( "Sec", isValidToSec() );
    }

    protected void validateMilliSecAdjustable()
            throws IllegalArgumentException
    {
        validateAdjustable( "MilliSec", isValidToMilliSec() );
    }

    protected void validateAdjustable( String pWhat, boolean pValidToWhat )
            throws IllegalArgumentException
    {
        if ( !pValidToWhat )
        {
            throw new IllegalArgumentException(
                    "Insufficient Time Resolution supported when attempting to adjust '" + pWhat +
                    "', current value is: " + this );
        }
    }

    protected int validate( int pMinResIndex, String pWhat, int pNewValue, int pMaxValue )
            throws IllegalArgumentException
    {
        if ( getResolutionIndex() < pMinResIndex )
        {
            throw new IllegalArgumentException(
                    "Insufficient Time Resolution supported when attempting to set '" + pWhat + "' to '" +
                    pNewValue + "', current value is: " + this );
        }
        return validate( pWhat, pNewValue, pMaxValue );
    }
}