LocalDateTimeValue.java

/*
 * Copyright (c) 2002-2018 "Neo Technology,"
 * Network Engine for Objects in Lund AB [http://neotechnology.com]
 *
 * This file is part of Neo4j.
 *
 * Neo4j is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.neo4j.values.storable;

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.IsoFields;
import java.time.temporal.TemporalUnit;
import java.util.Map;
import java.util.function.Supplier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.neo4j.helpers.collection.Pair;
import org.neo4j.values.AnyValue;
import org.neo4j.values.StructureBuilder;
import org.neo4j.values.ValueMapper;
import org.neo4j.values.virtual.MapValue;
import org.neo4j.values.virtual.VirtualValues;

import static java.time.Instant.ofEpochSecond;
import static java.time.LocalDateTime.ofInstant;
import static java.time.ZoneOffset.UTC;
import static java.util.Objects.requireNonNull;
import static org.neo4j.values.storable.DateTimeValue.parseZoneName;
import static org.neo4j.values.storable.DateValue.DATE_PATTERN;
import static org.neo4j.values.storable.DateValue.parseDate;
import static org.neo4j.values.storable.IntegralValue.safeCastIntegral;
import static org.neo4j.values.storable.LocalTimeValue.TIME_PATTERN;
import static org.neo4j.values.storable.LocalTimeValue.parseTime;

public final class LocalDateTimeValue extends TemporalValue<LocalDateTime,LocalDateTimeValue>
{
    public static LocalDateTimeValue localDateTime( DateValue date, LocalTimeValue time )
    {
        return new LocalDateTimeValue( LocalDateTime.of( date.temporal(), time.temporal() ) );
    }

    public static LocalDateTimeValue localDateTime(
            int year, int month, int day, int hour, int minute, int second, int nanoOfSecond )
    {
        return new LocalDateTimeValue( LocalDateTime.of( year, month, day, hour, minute, second, nanoOfSecond ) );
    }

    public static LocalDateTimeValue localDateTime( LocalDateTime value )
    {
        return new LocalDateTimeValue( requireNonNull( value, "LocalDateTime" ) );
    }

    public static LocalDateTimeValue localDateTime( long epochSecond, long nano )
    {
        return new LocalDateTimeValue( ofInstant( ofEpochSecond( epochSecond, nano ), UTC ) );
    }

    public static LocalDateTimeValue inUTC( DateTimeValue datetime )
    {
        return new LocalDateTimeValue( datetime.temporal().withZoneSameInstant( UTC ).toLocalDateTime() );
    }

    public static LocalDateTimeValue parse( CharSequence text )
    {
        return parse( LocalDateTimeValue.class, PATTERN, LocalDateTimeValue::parse, text );
    }

    public static LocalDateTimeValue parse( TextValue text )
    {
        return parse( LocalDateTimeValue.class, PATTERN, LocalDateTimeValue::parse, text );
    }

    public static LocalDateTimeValue now( Clock clock )
    {
        return new LocalDateTimeValue( LocalDateTime.now( clock ) );
    }

    public static LocalDateTimeValue now( Clock clock, String timezone )
    {
        return now( clock.withZone( parseZoneName( timezone ) ) );
    }

    public static LocalDateTimeValue build( MapValue map, Supplier<ZoneId> defaultZone )
    {
        return StructureBuilder.build( builder( defaultZone ), map );
    }

    public static LocalDateTimeValue select( AnyValue from, Supplier<ZoneId> defaultZone )
    {
        return builder( defaultZone ).selectDateTime( from );
    }

    public static LocalDateTimeValue truncate(
            TemporalUnit unit,
            TemporalValue input,
            MapValue fields,
            Supplier<ZoneId> defaultZone )
    {
        if ( unit.isTimeBased() && !(input instanceof DateTimeValue || input instanceof LocalDateTimeValue) )
        {
            throw new IllegalArgumentException( "Cannot truncate " + input + " to local date time with a time based unit." );
        }
        LocalTime localTime = input.hasTime() ? input.getLocalTimePart() : LocalTimeValue.DEFAULT_LOCAL_TIME;
        LocalDate localDate = input.getDatePart();

        LocalTime truncatedTime;
        LocalDate truncatedDate;
        if ( unit.isDateBased() )
        {
            truncatedDate = DateValue.truncateTo( localDate, unit );
            truncatedTime = LocalTimeValue.DEFAULT_LOCAL_TIME;
        }
        else
        {
            truncatedDate = localDate;
            truncatedTime = localTime.truncatedTo( unit );
        }

        LocalDateTime truncatedLDT = LocalDateTime.of( truncatedDate, truncatedTime );
        if ( fields.size() == 0 )
        {
            return localDateTime( truncatedLDT );
        }
        else
        {
            Map<String,AnyValue> updatedFields = fields.getMapCopy();
            truncatedLDT = updateFieldMapWithConflictingSubseconds( updatedFields, unit, truncatedLDT );
            if ( updatedFields.size() == 0 )
            {
                return localDateTime( truncatedLDT );
            }
            updatedFields.put( "datetime", localDateTime( truncatedLDT ) );
            return build( VirtualValues.map( updatedFields ), defaultZone );
        }
    }

    static final LocalDateTime DEFAULT_LOCAL_DATE_TIME =
            LocalDateTime.of( Field.year.defaultValue, Field.month.defaultValue, Field.day.defaultValue, Field.hour.defaultValue,
                    Field.minute.defaultValue );

    static DateTimeValue.DateTimeBuilder<LocalDateTimeValue> builder( Supplier<ZoneId> defaultZone )
    {
        return new DateTimeValue.DateTimeBuilder<LocalDateTimeValue>( defaultZone )
        {
            @Override
            protected boolean supportsTimeZone()
            {
                return false;
            }

            @Override
            protected boolean supportsEpoch()
            {
                return false;
            }

            @Override
            public LocalDateTimeValue buildInternal()
            {
                boolean selectingDate = fields.containsKey( Field.date );
                boolean selectingTime = fields.containsKey( Field.time );
                boolean selectingDateTime = fields.containsKey( Field.datetime );
                LocalDateTime result;
                if ( selectingDateTime )
                {
                    AnyValue dtField = fields.get( Field.datetime );
                    if ( !(dtField instanceof TemporalValue) )
                    {
                        throw new IllegalArgumentException( String.format( "Cannot construct local date time from: %s", dtField ) );
                    }
                    TemporalValue dt = (TemporalValue) dtField;
                    result = LocalDateTime.of( dt.getDatePart(), dt.getLocalTimePart() );
                }
                else if ( selectingTime || selectingDate )
                {
                    LocalTime time;
                    if ( selectingTime )
                    {
                        AnyValue timeField = fields.get( Field.time );
                        if ( !(timeField instanceof TemporalValue) )
                        {
                            throw new IllegalArgumentException( String.format( "Cannot construct local time from: %s", timeField ) );
                        }
                        TemporalValue t = (TemporalValue) timeField;
                        time = t.getLocalTimePart();
                    }
                    else
                    {
                        time = LocalTimeValue.DEFAULT_LOCAL_TIME;
                    }
                    LocalDate date;
                    if ( selectingDate )
                    {
                        AnyValue dateField = fields.get( Field.date );
                        if ( !(dateField instanceof TemporalValue) )
                        {
                            throw new IllegalArgumentException( String.format( "Cannot construct date from: %s", dateField ) );
                        }
                        TemporalValue t = (TemporalValue) dateField;
                        date = t.getDatePart();
                    }
                    else
                    {
                        date = DateValue.DEFAULT_CALENDER_DATE;
                    }

                    result = LocalDateTime.of( date, time );
                }
                else
                {
                    result = DEFAULT_LOCAL_DATE_TIME;
                }

                if ( fields.containsKey( Field.week ) && !selectingDate && !selectingDateTime )
                {
                    // Be sure to be in the start of the week based year (which can be later than 1st Jan)
                    result = result
                            .with( IsoFields.WEEK_BASED_YEAR, safeCastIntegral( Field.year.name(), fields.get( Field.year ),
                                    Field.year.defaultValue ) )
                            .with( IsoFields.WEEK_OF_WEEK_BASED_YEAR, 1 )
                            .with( ChronoField.DAY_OF_WEEK, 1 );
                }

                result = assignAllFields( result );
                return localDateTime( result );
            }

            private LocalDateTime getLocalDateTimeOf( AnyValue temporal )
            {
                if ( temporal instanceof TemporalValue )
                {
                    TemporalValue v = (TemporalValue) temporal;
                    LocalDate datePart = v.getDatePart();
                    LocalTime timePart = v.getLocalTimePart();
                    return LocalDateTime.of( datePart, timePart );
                }
                throw new IllegalArgumentException( String.format( "Cannot construct date from: %s", temporal ) );
            }

            @Override
            protected LocalDateTimeValue selectDateTime( AnyValue datetime )
            {
                if ( datetime instanceof LocalDateTimeValue )
                {
                    return (LocalDateTimeValue) datetime;
                }
                return localDateTime( getLocalDateTimeOf( datetime ) );
            }
        };
    }

    private final LocalDateTime value;

    private LocalDateTimeValue( LocalDateTime value )
    {
        this.value = value;
    }

    @Override
    int unsafeCompareTo( Value otherValue )
    {
        LocalDateTimeValue other = (LocalDateTimeValue) otherValue;
        return value.compareTo( other.value );
    }

    @Override
    LocalDateTime temporal()
    {
        return value;
    }

    @Override
    LocalDate getDatePart()
    {
        return value.toLocalDate();
    }

    @Override
    LocalTime getLocalTimePart()
    {
        return value.toLocalTime();
    }

    @Override
    OffsetTime getTimePart( Supplier<ZoneId> defaultZone )
    {
        ZoneOffset currentOffset = ZonedDateTime.ofInstant( Instant.now(), defaultZone.get() ).getOffset();
        return OffsetTime.of(value.toLocalTime(), currentOffset);
    }

    @Override
    ZoneId getZoneId( Supplier<ZoneId> defaultZone )
    {
        return defaultZone.get();
    }

    @Override
    public boolean hasTimeZone()
    {
        return false;
    }

    @Override
    boolean hasTime()
    {
        return true;
    }

    @Override
    public boolean equals( Value other )
    {
        return other instanceof LocalDateTimeValue && value.equals( ((LocalDateTimeValue) other).value );
    }

    @Override
    public <E extends Exception> void writeTo( ValueWriter<E> writer ) throws E
    {
        writer.writeLocalDateTime( value.toEpochSecond( UTC ), value.getNano() );
    }

    @Override
    public String prettyPrint()
    {
        return value.format( DateTimeFormatter.ISO_LOCAL_DATE_TIME );
    }

    @Override
    public ValueGroup valueGroup()
    {
        return ValueGroup.LOCAL_DATE_TIME;
    }

    @Override
    protected int computeHash()
    {
        return value.toInstant( UTC ).hashCode();
    }

    @Override
    public <T> T map( ValueMapper<T> mapper )
    {
        return mapper.mapLocalDateTime( this );
    }

    @Override
    public LocalDateTimeValue add( DurationValue duration )
    {
        return replacement( value.plus( duration ) );
    }

    @Override
    public LocalDateTimeValue sub( DurationValue duration )
    {
        return replacement( value.minus( duration ) );
    }

    @Override
    LocalDateTimeValue replacement( LocalDateTime dateTime )
    {
        return dateTime == value ? this : new LocalDateTimeValue( dateTime );
    }

    private static final Pattern PATTERN = Pattern.compile(
            DATE_PATTERN + "(?<time>T" + TIME_PATTERN + ")?",
            Pattern.CASE_INSENSITIVE );

    private static LocalDateTimeValue parse( Matcher matcher )
    {
        return localDateTime( LocalDateTime.of( parseDate( matcher ), optTime( matcher ) ) );
    }

    static LocalTime optTime( Matcher matcher )
    {
        return matcher.group( "time" ) != null ? parseTime( matcher ) : LocalTime.MIN;
    }
}