/*
 * 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.skywalking.oap.meter.analyzer.dsl.counter;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import io.vavr.Tuple2;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.time.Duration;
import java.util.List;

import static java.time.Instant.parse;

public class CounterWindowTest {

    public static List<Tuple2<Long, Double>> parameters() {
        return Lists.newArrayList(
            new Tuple2<>(parse("2020-09-11T11:11:01.03Z").toEpochMilli(), 10d),
            new Tuple2<>(parse("2020-09-11T11:11:15.99Z").toEpochMilli(), 11d),
            new Tuple2<>(parse("2020-09-11T11:11:31.00Z").toEpochMilli(), 12d),
            new Tuple2<>(parse("2020-09-11T11:11:46.09Z").toEpochMilli(), 13d),
            new Tuple2<>(parse("2020-09-11T11:12:00.97Z").toEpochMilli(), 14d),
            new Tuple2<>(parse("2020-09-11T11:11:00.97Z").toEpochMilli(), 15d),
            new Tuple2<>(parse("2020-09-11T11:12:16.60Z").toEpochMilli(), 16d),
            new Tuple2<>(parse("2020-09-11T11:12:31.66Z").toEpochMilli(), 17d)
        );
    }

    @Test
    public void testPT15S() {
        double[] actuals = parameters().stream().mapToDouble(e -> {
            Tuple2<Long, Double> increase = CounterWindow.INSTANCE.increase(
                "test", ImmutableMap.<String, String>builder().build(), e._2,
                Duration.parse("PT15S").getSeconds() * 1000, e._1
            );
            return e._2 - increase._2;
        }).toArray();

        Assertions.assertArrayEquals(new double[] {0, 1d, 1d, 1d, 1d, 0d, 2d, 1d}, actuals, 0.d);
    }

    @Test
    public void testPT35S() {
        double[] actuals = parameters().stream().mapToDouble(e -> {
            Tuple2<Long, Double> increase = CounterWindow.INSTANCE.increase(
                "test", ImmutableMap.<String, String>builder().build(), e._2,
                Duration.parse("PT35S").getSeconds() * 1000, e._1
            );
            return e._2 - increase._2;
        }).toArray();

        Assertions.assertArrayEquals(new double[] {0, 1d, 2d, 2d, 2d, 0d, 3d, 3d}, actuals, 0.d);
    }

    @Test
    public void testPT1M() {
        double[] actuals = parameters().stream().mapToDouble(e -> {
            Tuple2<Long, Double> increase = CounterWindow.INSTANCE.increase(
                "test", ImmutableMap.<String, String>builder().build(), e._2,
                Duration.parse("PT1M").getSeconds() * 1000, e._1
            );
            return e._2 - increase._2;
        }).toArray();

        Assertions.assertArrayEquals(new double[] {0, 1d, 2d, 3d, 4d, 0d, 5d, 5d}, actuals, 0.d);
    }

    @Test
    public void testPT2M() {
        double[] actuals = parameters().stream().mapToDouble(e -> {
            Tuple2<Long, Double> increase = CounterWindow.INSTANCE.increase(
                "test", ImmutableMap.<String, String>builder().build(), e._2,
                Duration.parse("PT2M").getSeconds() * 1000, e._1
            );
            return e._2 - increase._2;
        }).toArray();

        Assertions.assertArrayEquals(new double[] {0, 1d, 2d, 3d, 4d, 0d, 1d, 2d}, actuals, 0.d);
    }
}
