package net.time4j.range;

import net.time4j.Moment;
import net.time4j.SI;
import net.time4j.scale.TimeScale;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;


@RunWith(JUnit4.class)
public class MachineTimeTest {

    private static final int MRD = 1000000000;

    @Test
    public void isShorterThan() {
        assertThat(
            MachineTime.of(23, TimeUnit.HOURS).isShorterThan(MachineTime.of(1, TimeUnit.DAYS)),
            is(true));
        assertThat(
            MachineTime.of(24, TimeUnit.HOURS).isShorterThan(MachineTime.of(1, TimeUnit.DAYS)),
            is(false));
        assertThat(
            MachineTime.of(25, TimeUnit.HOURS).isShorterThan(MachineTime.of(1, TimeUnit.DAYS)),
            is(false));
        assertThat(
            MachineTime.of(-23, TimeUnit.HOURS).isShorterThan(MachineTime.of(-1, TimeUnit.DAYS)),
            is(true));
        assertThat(
            MachineTime.of(-25, TimeUnit.HOURS).isShorterThan(MachineTime.of(-1, TimeUnit.DAYS)),
            is(false));
    }

    @Test
    public void isLongerThan() {
        assertThat(
            MachineTime.ofSIUnits(3, 999999999).isLongerThan(MachineTime.ofSIUnits(4, 0)),
            is(false));
        assertThat(
            MachineTime.ofSIUnits(3, 999999999).isLongerThan(MachineTime.ofSIUnits(3, 999999999)),
            is(false));
        assertThat(
            MachineTime.ofSIUnits(3, 999999999).isLongerThan(MachineTime.ofSIUnits(3, 999999998)),
            is(true));
        assertThat(
            MachineTime.ofSIUnits(-3, -999999999).isLongerThan(MachineTime.ofSIUnits(-3, -999999998)),
            is(true));
        assertThat(
            MachineTime.ofSIUnits(-3, 999999999).isLongerThan(MachineTime.ofSIUnits(-3, 999999998)),
            is(false));
    }

    @Test(expected=ClassCastException.class)
    @SuppressWarnings("unchecked")
    public void comparisonOnDifferentTimescales() {
        MachineTime m1 = MachineTime.of(23, TimeUnit.HOURS);
        MachineTime m2 = MachineTime.ofSIUnits(3, 999999999);
        System.out.println(m1.isLongerThan(m2));
    }

    @Test
    public void ofDayUnit() {
        assertThat(
            MachineTime.of(1, TimeUnit.DAYS),
            is(MachineTime.ofPosixUnits(86400L, 0)));
    }

    @Test
    public void ofHourUnit() {
        assertThat(
            MachineTime.of(1, TimeUnit.HOURS),
            is(MachineTime.ofPosixUnits(3600L, 0)));
    }

    @Test
    public void ofMinuteUnit() {
        assertThat(
            MachineTime.of(1, TimeUnit.MINUTES),
            is(MachineTime.ofPosixUnits(60L, 0)));
    }

    @Test
    public void ofMillisecondUnit() {
        assertThat(
            MachineTime.of(1, TimeUnit.MILLISECONDS),
            is(MachineTime.ofPosixUnits(0L, 1000000)));
    }

    @Test
    public void ofMicrosecondUnit() {
        assertThat(
            MachineTime.of(1, TimeUnit.MICROSECONDS),
            is(MachineTime.ofPosixUnits(0L, 1000)));
    }

    @Test
    public void ofSIUnits() {
        MachineTime<?> mt = MachineTime.ofSIUnits(2, 123456789);
        assertThat(
            mt.getSeconds(),
            is(2L));
        assertThat(
            mt.getFraction(),
            is(123456789));
        assertThat(
            mt.getScale(),
            is(TimeScale.UTC));
    }

    @Test
    public void ofSIUnitsNegative() {
        MachineTime<?> mt = MachineTime.ofSIUnits(-2, -123456789);
        assertThat(
            mt.getSeconds(),
            is(-3L));
        assertThat(
            mt.getFraction(),
            is(MRD - 123456789));
        assertThat(
            mt.getScale(),
            is(TimeScale.UTC));
    }

    @Test
    public void ofPosixUnits() {
        MachineTime<?> mt = MachineTime.ofPosixUnits(2, 123456789);
        assertThat(
            mt.getSeconds(),
            is(2L));
        assertThat(
            mt.getFraction(),
            is(123456789));
        assertThat(
            mt.getScale(),
            is(TimeScale.POSIX));
    }

    @Test
    public void ofPosixUnitsNegative() {
        MachineTime<?> mt = MachineTime.ofPosixUnits(-2, -123456789);
        assertThat(
            mt.getSeconds(),
            is(-3L));
        assertThat(
            mt.getFraction(),
            is(MRD - 123456789));
        assertThat(
            mt.getScale(),
            is(TimeScale.POSIX));
    }

    @Test
    public void ofPosixSecondsBigDecimal() {
        BigDecimal value = new BigDecimal("2.1");
        assertThat(
            MachineTime.ofPosixSeconds(value),
            is(MachineTime.ofPosixUnits(2, 100000000)));
    }

    @Test
    public void ofSISecondsBigDecimal() {
        BigDecimal value = new BigDecimal("-2.1234567899");
        assertThat(
            MachineTime.ofSISeconds(value),
            is(MachineTime.ofSIUnits(-2, -123456790)));
    }

    @Test
    public void ofPosixSecondsDouble() {
        double value = 1.5;
        assertThat(
            MachineTime.ofPosixSeconds(value),
            is(MachineTime.ofPosixUnits(1, 500000000)));
    }

    @Test
    public void ofSISecondsDouble() {
        double value = -2.123456789;
        assertThat(
            MachineTime.ofSISeconds(value),
            is(MachineTime.ofSIUnits(-2, -123456789)));
    }

    @Test
    public void plusMachineTime() {
        MachineTime<SI> mt = MachineTime.ofSIUnits(-2, -123456789);
        assertThat(
            mt.plus(MachineTime.ofSIUnits(3, 1)),
            is(MachineTime.ofSIUnits(0, 876543212)));
    }

    @Test
    public void minusMachineTime() {
        MachineTime<SI> mt = MachineTime.ofSIUnits(3, 1);
        assertThat(
            mt.minus(MachineTime.ofSIUnits(2, 123456789)),
            is(MachineTime.ofSIUnits(0, 876543212)));
    }

    @Test
    public void plusSeconds() {
        MachineTime<SI> mt = MachineTime.ofSIUnits(3, 1);
        assertThat(
            mt.plus(4, SI.SECONDS),
            is(MachineTime.ofSIUnits(7, 1)));
    }

    @Test
    public void minusSeconds() {
        MachineTime<SI> mt = MachineTime.ofSIUnits(3, 1);
        assertThat(
            mt.minus(4, SI.SECONDS),
            is(MachineTime.ofSIUnits(-1, 1)));
    }

    @Test
    public void plusNanoseconds() {
        MachineTime<SI> mt = MachineTime.ofSIUnits(3, 1);
        assertThat(
            mt.plus(999999999, SI.NANOSECONDS),
            is(MachineTime.ofSIUnits(4, 0)));
    }

    @Test
    public void minusNanoseconds() {
        MachineTime<SI> mt = MachineTime.ofSIUnits(3, 1);
        assertThat(
            mt.minus(4, SI.NANOSECONDS),
            is(MachineTime.ofSIUnits(2, 999999997)));
    }

    @Test
    public void toStringPOSIX() {
        MachineTime<?> mt = MachineTime.ofPosixUnits(-2, -123456789);
        assertThat(mt.toString(), is("-2.123456789s [POSIX]"));
    }

    @Test
    public void toStringSI() {
        MachineTime<?> mt = MachineTime.ofSIUnits(2, 123456789);
        assertThat(mt.toString(), is("2.123456789s [UTC]"));
    }

    @Test
    public void toBigDecimal() {
        MachineTime<?> mt = MachineTime.ofPosixUnits(-2, -123456789);
        assertThat(mt.toBigDecimal(), is(new BigDecimal("-2.123456789")));
    }

    @Test
    public void isEmpty() {
        assertThat(MachineTime.of(0, SI.SECONDS).isEmpty(), is(true));
        assertThat(MachineTime.of(1, SI.SECONDS).isEmpty(), is(false));
        assertThat(MachineTime.of(-1, SI.SECONDS).isEmpty(), is(false));

        assertThat(
            MachineTime.ofSIUnits(1, -MRD).isEmpty(),
            is(true));
    }

    @Test
    public void isPositive() {
        assertThat(MachineTime.of(0, SI.SECONDS).isPositive(), is(false));
        assertThat(MachineTime.of(1, SI.SECONDS).isPositive(), is(true));
        assertThat(MachineTime.of(-1, SI.SECONDS).isPositive(), is(false));

        assertThat(
            MachineTime.ofSIUnits(-1, 1000000001).isPositive(),
            is(true));
    }

    @Test
    public void isNegative() {
        assertThat(MachineTime.of(0, SI.SECONDS).isNegative(), is(false));
        assertThat(MachineTime.of(1, SI.SECONDS).isNegative(), is(false));
        assertThat(MachineTime.of(-1, SI.SECONDS).isNegative(), is(true));

        assertThat(
            MachineTime.ofSIUnits(1, -1000000001).isNegative(),
            is(true));
    }

    @Test
    public void abs() {
        assertThat(
            MachineTime.ofSIUnits(1, 123456789).abs(),
            is(MachineTime.ofSIUnits(1, 123456789)));
        assertThat(
            MachineTime.ofSIUnits(-1, -123456789).abs(),
            is(MachineTime.ofSIUnits(1, 123456789)));
    }

    @Test
    public void inverse() {
        assertThat(
            MachineTime.ofSIUnits(1, 123456789).inverse(),
            is(MachineTime.ofSIUnits(-1, -123456789)));
        assertThat(
            MachineTime.ofSIUnits(-1, -123456789).inverse(),
            is(MachineTime.ofSIUnits(1, 123456789)));
    }

    @Test
    public void getPartialAmount() {
        assertThat(
            MachineTime.ofSIUnits(-1, -123456789).getPartialAmount(SI.SECONDS),
            is(1L));
        assertThat(
            MachineTime.ofSIUnits(-2, MRD -123456789).getPartialAmount(SI.SECONDS),
            is(1L));
    }

    @Test
    public void getSeconds() {
        assertThat(
            MachineTime.ofSIUnits(1, 123456789).getSeconds(),
            is(1L));
        assertThat(
            MachineTime.ofSIUnits(-1, -123456789).getSeconds(),
            is(-2L));
    }

    @Test
    public void getFraction() {
        assertThat(
            MachineTime.ofSIUnits(1, 123456789).getFraction(),
            is(123456789));
        assertThat(
            MachineTime.ofSIUnits(-1, -123456789).getFraction(),
            is(MRD - 123456789));
    }

    @Test
    public void getScale() {
        assertThat(
            MachineTime.ofPosixUnits(1, 123456789).getScale(),
            is(TimeScale.POSIX));
        assertThat(
            MachineTime.ofSIUnits(1, 123456789).getScale(),
            is(TimeScale.UTC));
    }

    @Test
    public void contains() {
        assertThat(
            MachineTime.ofPosixUnits(86400, 1).contains(TimeUnit.DAYS),
            is(false));
        assertThat(
            MachineTime.ofPosixUnits(86400, 1).contains(TimeUnit.HOURS),
            is(false));
        assertThat(
            MachineTime.ofPosixUnits(86400, 1).contains(TimeUnit.MINUTES),
            is(false));
        assertThat(
            MachineTime.ofPosixUnits(1, 1).contains(TimeUnit.SECONDS),
            is(true));
        assertThat(
            MachineTime.ofPosixUnits(0, -1).contains(TimeUnit.SECONDS),
            is(false));
        assertThat(
            MachineTime.ofPosixUnits(0, -1000000000).contains(TimeUnit.SECONDS),
            is(true));
        assertThat(
            MachineTime.ofPosixUnits(0, -1000000000).contains(TimeUnit.NANOSECONDS),
            is(false));
        assertThat(
            MachineTime.of(1, TimeUnit.MILLISECONDS).contains(TimeUnit.MILLISECONDS),
            is(false));
        assertThat(
            MachineTime.of(1, TimeUnit.MICROSECONDS).contains(TimeUnit.MICROSECONDS),
            is(false));
        assertThat(
            MachineTime.ofPosixUnits(1, 1).contains(TimeUnit.NANOSECONDS),
            is(true));
    }

    @Test
    public void multipliedBy() {
        assertThat(
            MachineTime.ofSIUnits(2, 500000000).multipliedBy(3),
            is(MachineTime.ofSIUnits(7, 500000000)));
    }

    @Test
    public void dividedByHalfUp() {
        assertThat(
            MachineTime.ofSIUnits(7, 500000001).dividedBy(3, RoundingMode.HALF_UP),
            is(MachineTime.ofSIUnits(2, 500000000)));
        assertThat(
            MachineTime.ofSIUnits(7, 500000002).dividedBy(3, RoundingMode.HALF_UP),
            is(MachineTime.ofSIUnits(2, 500000001)));
    }

    @Test
    public void dividedByDown() {
        assertThat(
            MachineTime.ofSIUnits(7, 500000001).dividedBy(3, RoundingMode.DOWN),
            is(MachineTime.ofSIUnits(2, 500000000)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).dividedBy(3, RoundingMode.DOWN),
            is(MachineTime.ofSIUnits(2, 499_999_999)));
        assertThat(
            MachineTime.ofSIUnits(7, 500_000_001).inverse().dividedBy(3, RoundingMode.DOWN),
            is(MachineTime.ofSIUnits(-2, -500_000_000)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).inverse().dividedBy(3, RoundingMode.DOWN),
            is(MachineTime.ofSIUnits(-2, -499_999_999)));
    }

    @Test
    public void dividedByUp() {
        assertThat(
            MachineTime.ofSIUnits(7, 500_000_001).dividedBy(3, RoundingMode.UP),
            is(MachineTime.ofSIUnits(2, 500_000_001)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).dividedBy(3, RoundingMode.UP),
            is(MachineTime.ofSIUnits(2, 500_000_000)));
        assertThat(
            MachineTime.ofSIUnits(7, 500_000_001).inverse().dividedBy(3, RoundingMode.UP),
            is(MachineTime.ofSIUnits(-2, -500_000_001)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).inverse().dividedBy(3, RoundingMode.UP),
            is(MachineTime.ofSIUnits(-2, -500_000_000)));
    }

    @Test
    public void dividedByFloor() {
        assertThat(
            MachineTime.ofSIUnits(7, 500000001).dividedBy(3, RoundingMode.FLOOR),
            is(MachineTime.ofSIUnits(2, 500000000)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).dividedBy(3, RoundingMode.FLOOR),
            is(MachineTime.ofSIUnits(2, 499_999_999)));
        assertThat(
            MachineTime.ofSIUnits(7, 500_000_001).inverse().dividedBy(3, RoundingMode.FLOOR),
            is(MachineTime.ofSIUnits(-2, -500_000_001)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).inverse().dividedBy(3, RoundingMode.FLOOR),
            is(MachineTime.ofSIUnits(-2, -500_000_000)));
    }

    @Test
    public void dividedByCeiling() {
        assertThat(
            MachineTime.ofSIUnits(7, 500_000_001).dividedBy(3, RoundingMode.CEILING),
            is(MachineTime.ofSIUnits(2, 500_000_001)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).dividedBy(3, RoundingMode.CEILING),
            is(MachineTime.ofSIUnits(2, 500_000_000)));
        assertThat(
            MachineTime.ofSIUnits(7, 500_000_001).inverse().dividedBy(3, RoundingMode.CEILING),
            is(MachineTime.ofSIUnits(-2, -500_000_000)));
        assertThat(
            MachineTime.ofSIUnits(7, 499_999_999).inverse().dividedBy(3, RoundingMode.CEILING),
            is(MachineTime.ofSIUnits(-2, -499_999_999)));
    }

    @Test
    public void plusMachineTimeUTC() {
        Moment m1 = Moment.of(1278028823, TimeScale.UTC);
        Moment m2 = Moment.of(1278028826, 1, TimeScale.UTC);
        MachineTime<SI> mt = MachineTime.ON_UTC_SCALE.between(m1, m2);
        assertThat(mt.getSeconds(), is(3L));
        assertThat(mt.getFraction(), is(1));
        assertThat(m1.plus(mt.getSeconds(), SI.SECONDS).plus(mt.getFraction(), SI.NANOSECONDS), is(m2));
        assertThat(m1.plus(mt), is(m2));
    }

    @Test
    public void plusMachineTimePOSIX() {
        Moment m1 = Moment.of(1278028823, TimeScale.UTC);
        Moment m2 = Moment.of(1278028826, 1, TimeScale.UTC);
        MachineTime<TimeUnit> mt = MachineTime.ON_POSIX_SCALE.between(m1, m2);
        assertThat(mt.getSeconds(), is(2L));
        assertThat(mt.getFraction(), is(1));
        assertThat(m1.plus(mt.getSeconds(), TimeUnit.SECONDS).plus(mt.getFraction(), TimeUnit.NANOSECONDS), is(m2));
        assertThat(m1.plus(mt), is(m2));
    }

}