package pl.put.poznan.sqc.scenario;

import io.vavr.collection.List;
import org.junit.Test;
import pl.put.poznan.sqc.scenario.api.ScenarioDTO;
import pl.put.poznan.sqc.scenario.api.StepDTO;
import pl.put.poznan.sqc.scenario.api.output.FlatStep;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class ScenarioTest {

    @Test
    public void shouldReturnZeroForEmptyScenario() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder().build();

        int stepsAmount = Scenario
                .fromDTO(scenarioDTO)
                .getStepsAmount();

        assertEquals(0, stepsAmount);
    }

    @Test
    public void shouldCountAllSubSteps() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .addSteps(
                        step("",
                                step(""),
                                step(""),
                                step("",
                                        step(""))),
                        step("")
                )
                .build();

        int stepsAmount = Scenario
                .fromDTO(scenarioDTO)
                .getStepsAmount();

        assertEquals(6, stepsAmount);
    }

    @Test
    public void shouldCountAllSteps() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .addSteps(
                        step(""),
                        step(""),
                        step(""),
                        step(""),
                        step("")
                )
                .build();

        int stepsAmount = Scenario
                .fromDTO(scenarioDTO)
                .getStepsAmount();

        assertEquals(5, stepsAmount);
    }

    @Test
    public void shouldReturnEmptyListForScenarioWithAllStepsStartingWithActor() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .addActor("test")
                .addSystemActors("sysTest")
                .addSteps(
                        step("test fo"),
                        step("test not fo"),
                        step("sysTest whololo"),
                        step("test sleep"),
                        step("sysTest uber")
                )
                .build();

        List<FlatStep> invalidSteps = Scenario
                .fromDTO(scenarioDTO)
                .getAllInvalidSteps();

        assertTrue(invalidSteps.isEmpty());
    }


    @Test
    public void shouldReturnListWithInvalidSteps() {
        List<StepDTO> invalidSteps = List.of(step("not"), step("hehehe"), step("kek"));
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .addActor("test")
                .addSystemActors("sysTest")
                .addSteps(
                        invalidSteps,
                        step("test not fo"),
                        step("test sleep"),
                        step("sysTest uber")
                )
                .build();

        List<FlatStep> listOfInvalid = Scenario
                .fromDTO(scenarioDTO)
                .getAllInvalidSteps();

        assertEquals(3, listOfInvalid.length());
    }

    @Test
    public void shouldReturnListWithInvalidStepsAndSubSteps() {
        List<StepDTO> invalidSteps = List.of(step("not"), step("hehehe"), step("kek"));
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .addActor("test")
                .addSystemActors("sysTest")
                .addSteps(
                        invalidSteps,
                        step("test not fo"),
                        step("test sleep"),
                        step("sysTest uber",
                                invalidSteps
                        )
                )
                .build();

        List<FlatStep> listOfInvalid = Scenario
                .fromDTO(scenarioDTO)
                .getAllInvalidSteps();

        assertEquals(6, listOfInvalid.length());
    }

    @Test
    public void shouldReturnScenarioWithCorrectNumberedSteps() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("step1",
                                step("step1-1",
                                        step("step1-1-1"),
                                        step("step1-1-2")
                                )
                        ),
                        step("step2")
                )
                .build();

        String scenarioAsText = Scenario
                .fromDTO(scenarioDTO)
                .asTextWithNumbers();

        String expectedScenario =
                "Tytuł: title\n" +
                        "Aktorzy: actor\n" +
                        "Aktor systemowy: sysAct\n" +
                        "\n" +
                        "1. step1\n" +
                        "1.1. step1-1\n" +
                        "1.1.1. step1-1-1\n" +
                        "1.1.2. step1-1-2\n" +
                        "2. step2\n";
        assertEquals(expectedScenario, scenarioAsText);
    }

    @Test
    public void shouldReturnScenarioWithCorrectNumberedSteps2() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("test1"),
                        step("test2",
                                step("test2.2",
                                        step("test2.1.1")
                                )
                        ),
                        step("test3")
                )
                .build();

        String scenarioAsText = Scenario
                .fromDTO(scenarioDTO)
                .asTextWithNumbers();

        String expectedScenario =
                "Tytuł: title\n" +
                        "Aktorzy: actor\n" +
                        "Aktor systemowy: sysAct\n" +
                        "\n" +
                        "1. test1\n" +
                        "2. test2\n" +
                        "2.1. test2.2\n" +
                        "2.1.1. test2.1.1\n" +
                        "3. test3\n";
        assertEquals(expectedScenario, scenarioAsText);
    }

    @Test
    public void shouldReturnFlatScenarioAsListOfSteps() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("step1"),
                        step("step2"),
                        step("step3")
                )
                .build();

        String scenarioAsText = Scenario
                .fromDTO(scenarioDTO)
                .asTextWithNumbers();

        String expectedScenario =
                "Tytuł: title\n" +
                        "Aktorzy: actor\n" +
                        "Aktor systemowy: sysAct\n" +
                        "\n" +
                        "1. step1\n" +
                        "2. step2\n" +
                        "3. step3\n";
        assertEquals(expectedScenario, scenarioAsText);
    }

    @Test
    public void shouldReturnEmptyScenarioWithScenarioMetadataAsText() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .build();

        String scenarioAsText = Scenario
                .fromDTO(scenarioDTO)
                .asTextWithNumbers();

        String expectedScenario =
                "Tytuł: title\n" +
                        "Aktorzy: actor\n" +
                        "Aktor systemowy: sysAct";
        assertEquals(expectedScenario, scenarioAsText);
    }


    @Test
    public void shouldReturnFlattedToTopLevelScenario() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("jakis",
                                step("zagniezdzony")
                        ),
                        step("kolejny")

                )
                .build();

        ScenarioDTO flatted = Scenario
                .fromDTO(scenarioDTO)
                .flatScenario(1);

        assertEquals(2, flatted.getSteps().size());
        assertEquals("jakis", flatted.getSteps().get(0).getDescription());
        assertEquals("kolejny", flatted.getSteps().get(1).getDescription());
        assertEquals(0, flatted.getSteps().get(0).getSubSteps().size());
    }

    @Test
    public void shouldReturnFlattedGivenLevelScenario() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("jakis",
                                step("zagniezdzony",
                                        step("glebiej")
                                )
                        ),
                        step("kolejny")

                )
                .build();

        ScenarioDTO flatted = Scenario
                .fromDTO(scenarioDTO)
                .flatScenario(2);

        assertEquals(2, flatted.getSteps().size());
        assertEquals("jakis", flatted.getSteps().get(0).getDescription());
        assertEquals("kolejny", flatted.getSteps().get(1).getDescription());
        assertEquals(1, flatted.getSteps().get(0).getSubSteps().size());
        assertEquals("zagniezdzony", flatted.getSteps().get(0).getSubSteps().get(0).getDescription());
    }

    @Test
    public void checkKeywordsInStepsNumberTestOne() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("IF",
                                step("FOR EACH",
                                        step("glebiej, oh, aj")
                                )
                        ),
                        step("ELSE",
                                step("dusge"))

                )
                .build();

        Integer keywords = Scenario.fromDTO(scenarioDTO)
                                    .getKeywordsNumberInSteps();

        assertEquals(Integer.valueOf(3), keywords);
    }

    @Test
    public void checkKeywordsInStepsNumberTestTwo() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("IF",
                                step("FOR EACH",
                                        step("glebiej, oh, aj")
                                )
                        ),
                        step("ELSE",
                                step("FOR EACH",
                                        step("IF pupa",
                                                step("czajnik")),
                                        step("ELSE",
                                                step("czapka"))
                                )
                        )
                )
                .build();

        Integer keywords = Scenario.fromDTO(scenarioDTO)
                .getKeywordsNumberInSteps();

        assertEquals(Integer.valueOf(6), keywords);
    }

    @Test
    public void checkKeywordsInStepsNumberTestThree() {
        ScenarioDTO scenarioDTO = new ScenarioBuilder()
                .withTitle("title")
                .addActor("actor")
                .addSystemActors("sysAct")
                .addSteps(
                        step("IF",
                                step("FOREACH",
                                        step("glebiej, oh, aj")
                                )
                        ),
                        step(" ELSE",
                                step("dusge"),
                                step(" FOREACH")
                                )

                )
                .build();

        Integer keywords = Scenario.fromDTO(scenarioDTO)
                .getKeywordsNumberInSteps();

        assertEquals(Integer.valueOf(1), keywords);
    }

    private StepDTO step(String description) {
        return step(description, new StepDTO[0]);
    }

    private StepDTO step(String description, StepDTO... steps) {
        return new StepDTO(description, List.of(steps));
    }

    private StepDTO step(String description, List<StepDTO> steps) {
        return new StepDTO(description, steps);
    }


    private class ScenarioBuilder {
        private String title = "";
        private List<String> actors = List.empty();
        private List<String> systemActors = List.empty();
        private List<StepDTO> steps = List.empty();

        ScenarioBuilder withTitle(String title) {
            this.title = title;
            return this;
        }

        ScenarioBuilder addActor(String actor) {
            this.actors = actors.append(actor);
            return this;
        }

        ScenarioBuilder addSystemActors(String systemActor) {
            this.systemActors = systemActors.append(systemActor);
            return this;
        }

        ScenarioBuilder addSteps(StepDTO... stepDTO) {
            this.steps = steps.appendAll(List.of(stepDTO));
            return this;
        }

        ScenarioBuilder addSteps(List<StepDTO> stepsDTOList, StepDTO... stepDTO) {
            this.steps = steps.appendAll(List.of(stepDTO)).appendAll(stepsDTOList);
            return this;
        }

        public ScenarioBuilder addSteps(List<StepDTO> stepsDTO) {
            this.steps = steps.appendAll(stepsDTO);
            return this;
        }

        ScenarioDTO build() {
            return new ScenarioDTO(title, actors, systemActors, steps);
        }
    }


}