package com.epam.rd.autotasks;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.params.provider.Arguments.arguments;

class GraduallyDecreasingCarouselRunRandomTest {

    private static String variant = "gradual";


    @ParameterizedTest(name = "[1] {0} {1}")
    @MethodSource({"fullCases", "halfEmptyCases", "overflowCases"})
    void testCarouselRunWhileNotFinished(String collection, int seed) {
        Random random = new Random(seed);

        GraduallyDecreasingCarousel carousel = generateCarousel(random, collection);
        CarouselRun run = carousel.run();

        List<Integer> runResult = new ArrayList<>();

        while (!run.isFinished()) {
            runResult.add(run.next());
        }

        List<Boolean> isFinishedResult = new ArrayList<>();
        for (int i = 0; i < runResult.size(); i++) {
            isFinishedResult.add(false);
        }
        isFinishedResult.add(true);

        assertEquals(getExpectedRunResult(collection, seed), runResult);
        assertEquals(getExpectedIsFinishedResult(collection, seed), isFinishedResult);
    }

    @ParameterizedTest(name = "[{index}] {1}")
    @MethodSource({"fullCases", "halfEmptyCases", "overflowCases"})
    void testCarouselRunWhileNotNegative(String collection, int seed) {
        Random random = new Random(seed);

        GraduallyDecreasingCarousel carousel = generateCarousel(random, collection);
        CarouselRun run = carousel.run();

        List<Integer> runResult = new ArrayList<>();
        List<Boolean> isFinishedResult = new ArrayList<>();

        isFinishedResult.add(run.isFinished());
        int nextVal;
        while ((nextVal = run.next()) != -1) {
            runResult.add(nextVal);
            isFinishedResult.add(run.isFinished());
        }

        assertEquals(getExpectedRunResult(collection, seed), runResult);
        assertEquals(getExpectedIsFinishedResult(collection, seed), isFinishedResult);
    }

    public static Stream<Arguments> fullCases() {
        return IntStream.of(
                        1,
                        56,
                        133976,
                        8513884,
                        322368,
                        6854)
                .mapToObj(i -> arguments("full", i));
    }

    public static Stream<Arguments> halfEmptyCases() {
        return IntStream.of(
                        1,
                        56,
                        133976,
                        3678,
                        264807,
                        1238732)
                .mapToObj(i -> arguments("half", i));
    }

    public static Stream<Arguments> overflowCases() {
        return IntStream.of(
                        1,
                        56,
                        133976,
                        8526458,
                        9656836,
                        98512357)
                .mapToObj(i -> arguments("over", i));
    }

    private static GraduallyDecreasingCarousel generateCarousel(final Random random, final String collection) {
        int elements = 10 + random.nextInt(10);
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(elements);

        if (collection.equals("half")) {
            elements -= (random.nextInt(7) + 1);
        } else if (collection.equals("over")) {
            elements += (random.nextInt(7) + 1);
        }
        for (int i = 0; i < elements; i++) {
            carousel.addElement(1 + random.nextInt(10));
        }
        return carousel;
    }

    private List<Boolean> getExpectedIsFinishedResult(final String collection, final int seed) {
        int size = getExpectedRunResult(collection, seed).size();
        List<Boolean> result = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            result.add(false);
        }
        result.add(true);
        return result;
    }

    private List<Integer> getExpectedRunResult(final String collection, final int seed) {
        return readExpectedList(collection, seed);
    }

    private static List<Integer> readExpectedList(String collection, int seed) {
        try {
            return Pattern.compile("\\D+").splitAsStream(
                            Files.readString(
                                    Path.of("src", "test", "resources", variant, collection, seed + ".txt")))
                    .filter(token -> !token.isBlank())
                    .map(Integer::parseInt)
                    .collect(Collectors.toList());
        } catch (IOException e) {
            e.printStackTrace();
            return List.of();
        }
    }

    private void writeFile(String collection, int seed, String actual) {
        try {
            Files.writeString(
                    Path.of("src", "test", "resources", variant, collection, seed + ".txt"),
                    actual + "\n", StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
package com.epam.rd.autotasks;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

class GraduallyDecreasingCarouselRunTest {

    @Test
    void testEmptyCase() {
        CarouselRun run = new GraduallyDecreasingCarousel(7).run();

        assertTrue(run.isFinished());
        assertEquals(-1, run.next());
        assertEquals(-1, run.next());

        assertTrue(run.isFinished());
        assertEquals(-1, run.next());
        assertEquals(-1, run.next());
    }

    @Test
    void testHalfEmptyCase1() {
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(7);

        carousel.addElement(3);
        carousel.addElement(7);
        carousel.addElement(4);
        CarouselRun run = carousel.run();

        assertEquals(3, run.next());
        assertEquals(7, run.next());
        assertEquals(4, run.next());

        assertEquals(2, run.next());
        assertEquals(6, run.next());
        assertEquals(3, run.next());

        assertEquals(4, run.next());
        assertEquals(1, run.next());

        assertEquals(1, run.next());

        assertEquals(-1, run.next());
        assertTrue(run.isFinished());
    }

    @Test
    void testHalfEmptyCase2() {
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(7);

        carousel.addElement(7);
        carousel.addElement(3);
        carousel.addElement(4);
        CarouselRun run = carousel.run();

        assertEquals(7, run.next());
        assertEquals(3, run.next());
        assertEquals(4, run.next());

        assertEquals(6, run.next());
        assertEquals(2, run.next());
        assertEquals(3, run.next());

        assertEquals(4, run.next());
        assertEquals(1, run.next());

        assertEquals(1, run.next());

        assertEquals(-1, run.next());
        assertTrue(run.isFinished());
    }

    @Test
    void testFullCase1() {
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(5);

        carousel.addElement(7);
        carousel.addElement(2);
        carousel.addElement(3);
        carousel.addElement(1);
        carousel.addElement(4);
        CarouselRun run = carousel.run();

        assertEquals(7, run.next());
        assertEquals(2, run.next());
        assertEquals(3, run.next());
        assertEquals(1, run.next());
        assertEquals(4, run.next());

        assertEquals(6, run.next());
        assertEquals(1, run.next());
        assertEquals(2, run.next());
        assertEquals(3, run.next());

        assertEquals(4, run.next());
        assertEquals(1, run.next());

        assertEquals(1, run.next());

        assertEquals(-1, run.next());
        assertTrue(run.isFinished());
    }

    @Test
    void testFullCase2() {
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(6);

        carousel.addElement(7);
        carousel.addElement(2);
        carousel.addElement(100);
        carousel.addElement(3);
        carousel.addElement(1);
        carousel.addElement(4);
        CarouselRun run = carousel.run();

        assertEquals(7, run.next());
        assertEquals(2, run.next());
        assertEquals(100, run.next());
        assertEquals(3, run.next());
        assertEquals(1, run.next());
        assertEquals(4, run.next());

        assertEquals(6, run.next());
        assertEquals(1, run.next());
        assertEquals(99, run.next());
        assertEquals(2, run.next());
        assertEquals(3, run.next());

        assertEquals(4, run.next());
        assertEquals(97, run.next());
        assertEquals(1, run.next());

        assertEquals(1, run.next());
        assertEquals(94, run.next());

        assertEquals(90, run.next());
        assertEquals(85, run.next());
        assertEquals(79, run.next());
        assertEquals(72, run.next());
        assertEquals(64, run.next());
        assertEquals(55, run.next());
        assertEquals(45, run.next());
        assertEquals(34, run.next());
        assertEquals(22, run.next());
        assertEquals(9, run.next());

        assertEquals(-1, run.next());
        assertTrue(run.isFinished());
    }
}package com.epam.rd.autotasks;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

class GraduallyDecreasingCarouselTest {

    @Test
    void checkAddElement() {
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(5);
        assertFalse(carousel.addElement(0));
        assertFalse(carousel.addElement(-1));
        assertFalse(carousel.addElement(-123456));
        assertFalse(carousel.addElement(0));

        assertTrue(carousel.addElement(1));
        assertTrue(carousel.addElement(2));

        assertFalse(carousel.addElement(0));
        assertFalse(carousel.addElement(-123));

        assertTrue(carousel.addElement(1234));
        assertTrue(carousel.addElement(1234));

        assertFalse(carousel.addElement(0));
        assertFalse(carousel.addElement(-456));

        assertTrue(carousel.addElement(22));

        assertFalse(carousel.addElement(22));

        assertFalse(carousel.addElement(-856));
        assertFalse(carousel.addElement(0));

        assertFalse(carousel.addElement(357));
        assertFalse(carousel.addElement(159));
        assertFalse(carousel.addElement(1));
    }

    @Test
    void checkAddElementAfterRun() {
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(5);

        assertTrue(carousel.addElement(1));
        assertTrue(carousel.addElement(2));
        assertTrue(carousel.addElement(3));

        carousel.run();

        assertFalse(carousel.addElement(4));
        assertFalse(carousel.addElement(5));
        assertFalse(carousel.addElement(6));

        assertFalse(carousel.addElement(0));
        assertFalse(carousel.addElement(-123));
        assertFalse(carousel.addElement(-4568));
    }

    @Test
    void testCarouselRunsSingleTimeOnly() {
        GraduallyDecreasingCarousel carousel = new GraduallyDecreasingCarousel(4);
        carousel.addElement(4);

        assertNotNull(carousel.run());
        assertNull(carousel.run());
        assertNull(carousel.run());
    }


}