/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.cassandra.metrics;

import java.util.Arrays;
import java.util.Collection;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
import java.util.function.Function;

import com.google.common.collect.ImmutableList;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import com.codahale.metrics.Snapshot;
import org.apache.cassandra.utils.EstimatedHistogram;
import org.apache.cassandra.utils.MonotonicClock;
import org.apache.cassandra.utils.MonotonicClockTranslation;
import org.apache.cassandra.utils.Pair;
import org.quicktheories.core.Gen;

import static org.apache.cassandra.utils.Clock.Global.nanoTime;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.quicktheories.QuickTheory.qt;
import static org.quicktheories.generators.SourceDSL.*;

@RunWith(Enclosed.class)
public class DecayingEstimatedHistogramReservoirTest
{
    public static class NonParameterizedTests
    {
        public static final int numExamples = 1000000;

        public static final Gen<long[]> offsets = integers().from(DecayingEstimatedHistogramReservoir.DEFAULT_BUCKET_COUNT)
                                                            .upToAndIncluding(DecayingEstimatedHistogramReservoir.MAX_BUCKET_COUNT - 10)
                                                            .zip(booleans().all(), EstimatedHistogram::newOffsets);
        
        @Test
        public void testFindIndex()
        {
            qt().withExamples(numExamples)
                .forAll(booleans().all()
                                  .flatMap(b -> offsets.flatMap(offs -> this.offsetsAndValue(offs, b, 0))))
                .check(this::checkFindIndex);
        }

        @Test
        public void showEstimationWorks()
        {
            qt().withExamples(numExamples)
                .forAll(offsets.flatMap(offs -> this.offsetsAndValue(offs, false, 9)))
                .check(this::checkEstimation);
        }

        //shows that the max before overflow is 238 buckets regardless of consider zeros
        @Test
        @Ignore
        public void showHistogramOffsetOverflow()
        {
            qt().forAll(integers().from(DecayingEstimatedHistogramReservoir.DEFAULT_BUCKET_COUNT).upToAndIncluding(1000))
                .check(count -> {
                    long[] offsets = EstimatedHistogram.newOffsets(count, false);
                    for (long offset : offsets)
                        if (offset < 0)
                            return false;

                    return true;
                });
        }

        private boolean checkFindIndex(Pair<long[], Long> offsetsAndValue)
        {
            long[] offsets = offsetsAndValue.left;
            long value = offsetsAndValue.right;

            int model = findIndexModel(offsets, value);
            int actual = DecayingEstimatedHistogramReservoir.findIndex(offsets, value);

            return model == actual;
        }

        private int findIndexModel(long[] offsets, long value)
        {
            int modelIndex = Arrays.binarySearch(offsets, value);
            if (modelIndex < 0)
                modelIndex = -modelIndex - 1;

            return modelIndex;
        }

        private Gen<Pair<long[], Long>> offsetsAndValue(long[] offsets, boolean useMaxLong, long minValue)
        {
            return longs().between(minValue, useMaxLong ? Long.MAX_VALUE : offsets[offsets.length - 1] + 100)
                          .mix(longs().between(minValue, minValue + 10),50)
                          .map(value -> Pair.create(offsets, value));
        }

        public boolean checkEstimation(Pair<long[], Long> offsetsAndValue)
        {
            long[] offsets = offsetsAndValue.left;
            long value = offsetsAndValue.right;
            boolean considerZeros = offsets[0] == 0;

            int modelIndex = Arrays.binarySearch(offsets, value);
            if (modelIndex < 0)
                modelIndex = -modelIndex - 1;

            int estimate = (int) DecayingEstimatedHistogramReservoir.fastLog12(value);

            if (considerZeros)
                return estimate - 3 == modelIndex || estimate - 2 == modelIndex;
            else
                return estimate - 4 == modelIndex || estimate - 3 == modelIndex;
        }
    }

    @RunWith(Parameterized.class)
    public static class ParameterizedTests
    {
        private static final double DOUBLE_ASSERT_DELTA = 0;

        @Parameterized.Parameter
        public String description;
        
        @Parameterized.Parameter(1)
        public Function<DecayingEstimatedHistogramReservoir, Snapshot> toSnapshot;

        @Parameterized.Parameters(name="{0}")
        public static Collection<Object[]> suppliers()
        {
            Function<DecayingEstimatedHistogramReservoir, Snapshot> snapshot = DecayingEstimatedHistogramReservoir::getSnapshot;
            Function<DecayingEstimatedHistogramReservoir, Snapshot> decayingOnly = DecayingEstimatedHistogramReservoir::getPercentileSnapshot;
            return ImmutableList.of(new Object[] { "normal", snapshot }, new Object[] { "decaying buckets", decayingOnly });
        }

        @Test
        public void testStriping() throws InterruptedException
        {
            TestClock clock = new TestClock();
            int nStripes = 4;
            DecayingEstimatedHistogramReservoir model = new DecayingEstimatedHistogramReservoir(clock);
            DecayingEstimatedHistogramReservoir test = new DecayingEstimatedHistogramReservoir(DecayingEstimatedHistogramReservoir.DEFAULT_ZERO_CONSIDERATION,
                                                                                               DecayingEstimatedHistogramReservoir.DEFAULT_BUCKET_COUNT,
                                                                                               nStripes,
                                                                                               clock);

            long seed = nanoTime();
            System.out.println("DecayingEstimatedHistogramReservoirTest#testStriping.seed = " + seed);
            Random valGen = new Random(seed);
            ExecutorService executors = Executors.newFixedThreadPool(nStripes * 2);
            for (int i = 0; i < 1_000_000; i++)
            {
                long value = Math.abs(valGen.nextInt());
                executors.submit(() -> {
                    model.update(value);
                    LockSupport.parkNanos(2);
                    test.update(value);
                });
            }

            executors.shutdown();
            Assert.assertTrue(executors.awaitTermination(1, TimeUnit.MINUTES));

            Snapshot modelSnapshot = toSnapshot.apply(model);
            Snapshot testSnapshot = toSnapshot.apply(test);

            assertEquals(modelSnapshot.getMean(), testSnapshot.getMean(), DOUBLE_ASSERT_DELTA);
            assertEquals(modelSnapshot.getMin(), testSnapshot.getMin(), DOUBLE_ASSERT_DELTA);
            assertEquals(modelSnapshot.getMax(), testSnapshot.getMax(), DOUBLE_ASSERT_DELTA);
            assertEquals(modelSnapshot.getMedian(), testSnapshot.getMedian(), DOUBLE_ASSERT_DELTA);
            for (double i = 0.0; i < 1.0; i += 0.1)
                assertEquals(modelSnapshot.getValue(i), testSnapshot.getValue(i), DOUBLE_ASSERT_DELTA);


            int stripedValues = 0;
            for (int i = model.size(); i < model.size() * model.stripeCount(); i++)
            {
                stripedValues += model.stripedBucketValue(i, true);
            }
            assertTrue("no striping found", stripedValues > 0);
        }

        @Test
        public void testSimple()
        {
            {
                // 0 and 1 map to the same, first bucket
                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir();
                histogram.update(0);
                assertEquals(1, histogram.getSnapshot().getValues()[0]);
                histogram.update(1);
                assertEquals(2, histogram.getSnapshot().getValues()[0]);
            }
            {
                // 0 and 1 map to different buckets
                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(true);
                histogram.update(0);
                assertEquals(1, histogram.getSnapshot().getValues()[0]);
                histogram.update(1);
                Snapshot snapshot = histogram.getSnapshot();
                assertEquals(1, snapshot.getValues()[0]);
                assertEquals(1, snapshot.getValues()[1]);
            }
        }

        @Test
        public void testOverflow()
        {
            DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(DecayingEstimatedHistogramReservoir.DEFAULT_ZERO_CONSIDERATION, 1, 1);
            histogram.update(100);
            assert histogram.isOverflowed();
            assertEquals(Long.MAX_VALUE, toSnapshot.apply(histogram).getMax());
        }

        @Test
        public void testMinMax()
        {
            DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir();
            histogram.update(16);
            Snapshot snapshot = toSnapshot.apply(histogram);
            assertEquals(15, snapshot.getMin());
            assertEquals(17, snapshot.getMax());
        }

        @Test
        public void testMean()
        {
            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);
                for (int i = 0; i < 40; i++)
                    histogram.update(0);
                for (int i = 0; i < 20; i++)
                    histogram.update(1);
                for (int i = 0; i < 10; i++)
                    histogram.update(2);
                assertEquals(1.14D, toSnapshot.apply(histogram).getMean(), 0.1D);
            }
            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(true,
                                                                                                        DecayingEstimatedHistogramReservoir.DEFAULT_BUCKET_COUNT,
                                                                                                        DecayingEstimatedHistogramReservoir.DEFAULT_STRIPE_COUNT,
                                                                                                        clock);
                for (int i = 0; i < 40; i++)
                    histogram.update(0);
                for (int i = 0; i < 20; i++)
                    histogram.update(1);
                for (int i = 0; i < 10; i++)
                    histogram.update(2);
                assertEquals(0.57D, toSnapshot.apply(histogram).getMean(), 0.1D);
            }
        }

        @Test
        public void testStdDev()
        {
            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);
                for (int i = 0; i < 20; i++)
                    histogram.update(10);
                for (int i = 0; i < 40; i++)
                    histogram.update(20);
                for (int i = 0; i < 20; i++)
                    histogram.update(30);

                Snapshot snapshot = toSnapshot.apply(histogram);
                assertEquals(20.0D, snapshot.getMean(), 2.0D);
                assertEquals(7.07D, snapshot.getStdDev(), 2.0D);
            }
        }

        @Test
        public void testFindingCorrectBuckets()
        {
            TestClock clock = new TestClock();

            DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(DecayingEstimatedHistogramReservoir.DEFAULT_ZERO_CONSIDERATION, 90, 1, clock);
            histogram.update(23282687);
            assertFalse(histogram.isOverflowed());
            assertEquals(1, histogram.getSnapshot().getValues()[89]);

            histogram.update(9);
            assertEquals(1, histogram.getSnapshot().getValues()[8]);

            histogram.update(21);
            histogram.update(22);
            Snapshot snapshot = histogram.getSnapshot();
            assertEquals(2, snapshot.getValues()[13]);
            assertEquals(6277304.5D, snapshot.getMean(), DOUBLE_ASSERT_DELTA);
        }

        @Test
        public void testPercentile()
        {
            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);
                // percentile of empty histogram is 0
                assertEquals(0D, toSnapshot.apply(histogram).getValue(0.99), DOUBLE_ASSERT_DELTA);

                histogram.update(1);
                // percentile of a histogram with one element should be that element
                assertEquals(1D, toSnapshot.apply(histogram).getValue(0.99), DOUBLE_ASSERT_DELTA);

                histogram.update(10);
                assertEquals(10D, toSnapshot.apply(histogram).getValue(0.99), DOUBLE_ASSERT_DELTA);
            }

            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);

                histogram.update(1);
                histogram.update(2);
                histogram.update(3);
                histogram.update(4);
                histogram.update(5);

                Snapshot snapshot = toSnapshot.apply(histogram);
                assertEquals(0, snapshot.getValue(0.00), DOUBLE_ASSERT_DELTA);
                assertEquals(3, snapshot.getValue(0.50), DOUBLE_ASSERT_DELTA);
                assertEquals(3, snapshot.getValue(0.60), DOUBLE_ASSERT_DELTA);
                assertEquals(5, snapshot.getValue(1.00), DOUBLE_ASSERT_DELTA);
            }

            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);

                for (int i = 11; i <= 20; i++)
                    histogram.update(i);

                // Right now the histogram looks like:
                //    10   12   14   17   20
                //     0    2    2    3    3
                // %:  0   20   40   70  100
                Snapshot snapshot = toSnapshot.apply(histogram);
                assertEquals(12, snapshot.getValue(0.01), DOUBLE_ASSERT_DELTA);
                assertEquals(14, snapshot.getValue(0.30), DOUBLE_ASSERT_DELTA);
                assertEquals(17, snapshot.getValue(0.50), DOUBLE_ASSERT_DELTA);
                assertEquals(17, snapshot.getValue(0.60), DOUBLE_ASSERT_DELTA);
                assertEquals(20, snapshot.getValue(0.80), DOUBLE_ASSERT_DELTA);
            }
            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(true,
                                                                                                        DecayingEstimatedHistogramReservoir.DEFAULT_BUCKET_COUNT,
                                                                                                        DecayingEstimatedHistogramReservoir.DEFAULT_STRIPE_COUNT,
                                                                                                        clock);
                histogram.update(0);
                histogram.update(0);
                histogram.update(1);

                Snapshot snapshot = toSnapshot.apply(histogram);
                assertEquals(0, snapshot.getValue(0.5), DOUBLE_ASSERT_DELTA);
                assertEquals(1, snapshot.getValue(0.99), DOUBLE_ASSERT_DELTA);
            }
        }

        @Test
        public void testDecayingPercentile()
        {
            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);
                // percentile of empty histogram is 0
                assertEquals(0, toSnapshot.apply(histogram).getValue(1.0), DOUBLE_ASSERT_DELTA);

                for (int v = 1; v <= 100; v++)
                {
                    for (int i = 0; i < 10_000; i++)
                    {
                        histogram.update(v);
                    }
                }

                Snapshot snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(5, snapshot.getValue(0.05));
                assertEstimatedQuantile(20, snapshot.getValue(0.20));
                assertEstimatedQuantile(40, snapshot.getValue(0.40));
                assertEstimatedQuantile(99, snapshot.getValue(0.99));

                clock.addSeconds(DecayingEstimatedHistogramReservoir.HALF_TIME_IN_S);
                snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(5, snapshot.getValue(0.05));
                assertEstimatedQuantile(20, snapshot.getValue(0.20));
                assertEstimatedQuantile(40, snapshot.getValue(0.40));
                assertEstimatedQuantile(99, snapshot.getValue(0.99));

                for (int v = 1; v <= 50; v++)
                {
                    for (int i = 0; i < 10_000; i++)
                    {
                        histogram.update(v);
                    }
                }

                snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(4, snapshot.getValue(0.05));
                assertEstimatedQuantile(14, snapshot.getValue(0.20));
                assertEstimatedQuantile(27, snapshot.getValue(0.40));
                assertEstimatedQuantile(98, snapshot.getValue(0.99));

                clock.addSeconds(DecayingEstimatedHistogramReservoir.HALF_TIME_IN_S);
                snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(4, snapshot.getValue(0.05));
                assertEstimatedQuantile(14, snapshot.getValue(0.20));
                assertEstimatedQuantile(27, snapshot.getValue(0.40));
                assertEstimatedQuantile(98, snapshot.getValue(0.99));

                for (int v = 1; v <= 50; v++)
                {
                    for (int i = 0; i < 10_000; i++)
                    {
                        histogram.update(v);
                    }
                }

                snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(3, snapshot.getValue(0.05));
                assertEstimatedQuantile(12, snapshot.getValue(0.20));
                assertEstimatedQuantile(23, snapshot.getValue(0.40));
                assertEstimatedQuantile(96, snapshot.getValue(0.99));

                clock.addSeconds(DecayingEstimatedHistogramReservoir.HALF_TIME_IN_S);
                snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(3, snapshot.getValue(0.05));
                assertEstimatedQuantile(12, snapshot.getValue(0.20));
                assertEstimatedQuantile(23, snapshot.getValue(0.40));
                assertEstimatedQuantile(96, snapshot.getValue(0.99));

                for (int v = 11; v <= 20; v++)
                {
                    for (int i = 0; i < 5_000; i++)
                    {
                        histogram.update(v);
                    }
                }

                snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(4, snapshot.getValue(0.05));
                assertEstimatedQuantile(12, snapshot.getValue(0.20));
                assertEstimatedQuantile(20, snapshot.getValue(0.40));
                assertEstimatedQuantile(95, snapshot.getValue(0.99));

                clock.addSeconds(DecayingEstimatedHistogramReservoir.HALF_TIME_IN_S);
                snapshot = toSnapshot.apply(histogram);
                assertEstimatedQuantile(4, snapshot.getValue(0.05));
                assertEstimatedQuantile(12, snapshot.getValue(0.20));
                assertEstimatedQuantile(20, snapshot.getValue(0.40));
                assertEstimatedQuantile(95, snapshot.getValue(0.99));

            }

            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);
                // percentile of empty histogram is 0
                assertEquals(0, toSnapshot.apply(histogram).getValue(0.99), DOUBLE_ASSERT_DELTA);

                for (int m = 0; m < 40; m++)
                {
                    for (int i = 0; i < 1_000_000; i++)
                    {
                        histogram.update(2);
                    }
                    // percentile of a histogram with one element should be that element
                    clock.addSeconds(DecayingEstimatedHistogramReservoir.HALF_TIME_IN_S);
                    assertEquals(2, toSnapshot.apply(histogram).getValue(0.99), DOUBLE_ASSERT_DELTA);
                }

                clock.addSeconds(DecayingEstimatedHistogramReservoir.HALF_TIME_IN_S * 100);
                assertEquals(0, toSnapshot.apply(histogram).getValue(0.99), DOUBLE_ASSERT_DELTA);
            }

            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);

                histogram.update(20);
                histogram.update(21);
                histogram.update(22);
                Snapshot snapshot = histogram.getSnapshot();
                assertEquals(1, snapshot.getValues()[12]);
                assertEquals(2, snapshot.getValues()[13]);

                clock.addSeconds(DecayingEstimatedHistogramReservoir.HALF_TIME_IN_S);

                histogram.update(20);
                histogram.update(21);
                histogram.update(22);
                snapshot = histogram.getSnapshot();
                assertEquals(2, snapshot.getValues()[12]);
                assertEquals(4, snapshot.getValues()[13]);
            }
        }

        @Test
        public void testDecayingMean()
        {
            {
                TestClock clock = new TestClock();

                DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);

                clock.addNanos(DecayingEstimatedHistogramReservoir.LANDMARK_RESET_INTERVAL_IN_NS - TimeUnit.SECONDS.toNanos(1L));

                while (clock.now() < DecayingEstimatedHistogramReservoir.LANDMARK_RESET_INTERVAL_IN_NS + TimeUnit.SECONDS.toNanos(1L))
                {
                    clock.addNanos(TimeUnit.MILLISECONDS.toNanos(900));
                    for (int i = 0; i < 1_000_000; i++)
                    {
                        histogram.update(1000);
                        histogram.update(2000);
                        histogram.update(3000);
                        histogram.update(4000);
                        histogram.update(5000);
                    }
                    assertEquals(3000D, toSnapshot.apply(histogram).getMean(), 500D);
                }
            }
        }

        @Test
        public void testAggregation()
        {
            TestClock clock = new TestClock();

            DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);
            DecayingEstimatedHistogramReservoir another = new DecayingEstimatedHistogramReservoir(clock);

            clock.addNanos(DecayingEstimatedHistogramReservoir.LANDMARK_RESET_INTERVAL_IN_NS - TimeUnit.SECONDS.toNanos(1L));

            histogram.update(1000);
            clock.addMillis(100);
            another.update(2000);
            clock.addMillis(100);
            histogram.update(2000);
            clock.addMillis(100);
            another.update(3000);
            clock.addMillis(100);
            histogram.update(3000);
            clock.addMillis(100);
            another.update(4000);

            DecayingEstimatedHistogramReservoir.EstimatedHistogramReservoirSnapshot snapshot = (DecayingEstimatedHistogramReservoir.EstimatedHistogramReservoirSnapshot) histogram.getSnapshot();
            DecayingEstimatedHistogramReservoir.EstimatedHistogramReservoirSnapshot anotherSnapshot = (DecayingEstimatedHistogramReservoir.EstimatedHistogramReservoirSnapshot) another.getSnapshot();

            assertEquals(2000, snapshot.getMean(), 500D);
            assertEquals(3000, anotherSnapshot.getMean(), 500D);

            snapshot.add(anotherSnapshot);

            // Another had newer decayLandmark, the aggregated snapshot should use it
            assertEquals(anotherSnapshot.getSnapshotLandmark(), snapshot.getSnapshotLandmark());
            assertEquals(2500, snapshot.getMean(), 500D);
        }

        @Test
        public void testSize()
        {
            TestClock clock = new TestClock();

            DecayingEstimatedHistogramReservoir histogram = new DecayingEstimatedHistogramReservoir(clock);
            histogram.update(42);
            histogram.update(42);
            assertEquals(2, toSnapshot.apply(histogram).size());
        }

        private void assertEstimatedQuantile(long expectedValue, double actualValue)
        {
            assertTrue("Expected at least [" + expectedValue + "] but actual is [" + actualValue + ']', actualValue >= expectedValue);
            assertTrue("Expected less than [" + Math.round(expectedValue * 1.2) + "] but actual is [" + actualValue + ']', actualValue < Math.round(expectedValue * 1.2));
        }

        public static class TestClock implements MonotonicClock
        {
            private long tick = 0;

            public void addNanos(long nanos)
            {
                tick += nanos;
            }

            public void addMillis(long millis)
            {
                tick += TimeUnit.MILLISECONDS.toNanos(millis);
            }

            public void addSeconds(long seconds)
            {
                tick += TimeUnit.SECONDS.toNanos(seconds);
            }

            public long now()
            {
                return tick;
            }

            @Override
            public long error()
            {
                return 0;
            }

            @Override
            public MonotonicClockTranslation translate()
            {
                throw new UnsupportedOperationException();
            }

            @Override
            public boolean isAfter(long instant)
            {
                throw new UnsupportedOperationException();
            }

            @Override
            public boolean isAfter(long now, long instant)
            {
                throw new UnsupportedOperationException();
            }
        }
    }
}