package ch.zhaw.pm2.racetrack;

import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Assertions;
import java.io.File;
import java.util.List;
import static ch.zhaw.pm2.racetrack.Game.NO_WINNER;
import static ch.zhaw.pm2.racetrack.PositionVector.Direction.*;


/**
 * Test for Class Game
 */
class GameTest {
    private UserInterface userInterface;
    private Game game;
    private Track track;

    private final String TRACK_FILE_PATH = ".\\tracks\\challenge.txt";
    private final int CAR_INDEX_ONE = 0;
    private final int CAR_INDEX_TWO = 1;

    /**
     * This nested Class tests if the game gets initiatet correctly
     */
    @Nested
    @DisplayName("Test correct Setup")
    class Setup {

        @BeforeEach
        void setup() {
            userInterface = new UserInterface("Test");
            game = new Game(userInterface);
            track = game.selectTrack(new File(TRACK_FILE_PATH));
            game.selectMoveStrategy(track.getCar(CAR_INDEX_ONE), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_ONE, track.getCarId(CAR_INDEX_ONE)));
            game.selectMoveStrategy(track.getCar(CAR_INDEX_TWO), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_TWO, track.getCarId(CAR_INDEX_TWO)));

        }

        @Test
        void getCurrentCarIndex() {
            Assertions.assertEquals(CAR_INDEX_ONE, game.getCurrentCarIndex());
            game.switchToNextActiveCar();
            Assertions.assertEquals(CAR_INDEX_TWO, game.getCurrentCarIndex());
        }

        @Test
        void getCarId() {
            Assertions.assertEquals('a', game.getCarId(0));
            Assertions.assertEquals('b', game.getCarId(1));
        }

        @Test
        void getCarPosition() {
            Assertions.assertEquals(new PositionVector(24, 22), game.getCarPosition(0));
            Assertions.assertEquals(new PositionVector(24, 24), game.getCarPosition(1));
        }

        @Test
        void getCarVelocity() {
            Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(0));
            Assertions.assertEquals(new PositionVector(0, 0), game.getCarVelocity(1));
        }

        @Test
        void getWinner() {
            Assertions.assertEquals(NO_WINNER, game.getWinner());
        }

        @Test
        void onlyOneCarLeft() {
            Assertions.assertFalse(game.onlyOneCarLeft());
        }

        @Test
        void carsMoving() {
            Assertions.assertTrue(game.carsMoving());
        }
    }

    /**
     * This nested Class makes basic manipulation after Game init.
     */
    @Nested
    @DisplayName("Basic manipulation")
    class Manipulation {

        @BeforeEach
        void setup() {
            userInterface = new UserInterface("Test");
            game = new Game(userInterface);
            track = game.selectTrack(new File(TRACK_FILE_PATH));
            game.selectMoveStrategy(track.getCar(CAR_INDEX_ONE), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_ONE, track.getCarId(CAR_INDEX_ONE)));
            game.selectMoveStrategy(track.getCar(CAR_INDEX_TWO), new UserMoveStrategy(new UserInterface("Testing"), CAR_INDEX_TWO, track.getCarId(CAR_INDEX_TWO)));

        }

        @Test
        void carTurnCorrect() {
            try {
                game.doCarTurn(RIGHT);
                Assertions.assertEquals(new PositionVector(1, 0), game.getCarVelocity(0));
            } catch (PositionVectorNotValid positionVectorNotValid) {
                positionVectorNotValid.printStackTrace();
            }
        }

        @Test
        void carCrash() {
            try {
                game.doCarTurn(PositionVector.Direction.UP);
                Assertions.assertTrue(game.onlyOneCarLeft());
            } catch (PositionVectorNotValid positionVectorNotValid) {
                positionVectorNotValid.printStackTrace();
            }
        }
    }

    /**
     * This nested Class tests a Playtrough. And implements a UserInterface interagtion to pretend a real player
     */
    @Nested
    @DisplayName("Playtrough")
    class Play {
        private Game game;

        @Test
        void winner() {
            game = new Game(new interFace("Test",new Integer[]{0,2,1},new PositionVector.Direction[]{RIGHT,
                RIGHT,
                RIGHT,
                NONE,
                NONE,
                NONE,
                NONE,
                UP,
                LEFT,
                LEFT,
                LEFT,
                LEFT,
                UP_LEFT,
                NONE,
                RIGHT,
                RIGHT,
                RIGHT,
                NONE,
                LEFT,
                DOWN_LEFT,
                DOWN_LEFT,
                LEFT,
                LEFT,
                NONE,
                RIGHT,
                NONE,
                DOWN,
                DOWN,
                RIGHT,
                NONE,
                RIGHT,
                DOWN,
                NONE,
                UP_RIGHT,
                RIGHT,
                UP_RIGHT,
                UP_RIGHT,
                RIGHT,
                RIGHT}));
            try {
                game.initPhase();
                Assertions.assertEquals("a",game.gamePhase());
            } catch (InvalidTrackFormatException | PositionVectorNotValid e) {
                e.printStackTrace();
            }
        }

        @Test
        void crashA() {
            game = new Game(new interFace("Test",new Integer[]{0,2,2},new PositionVector.Direction[]{UP}));
            try {
                game.initPhase();
                Assertions.assertEquals("b",game.gamePhase());
            } catch (InvalidTrackFormatException | PositionVectorNotValid e) {
                e.printStackTrace();
            }
        }

    }

    private class interFace extends UserInterface {

        private final PositionVector.Direction[] directions;
        private final Integer[] instructions;
        private int pointerDir,pointerInstruction;


        public interFace(String welcometxt, Integer[] instructions, PositionVector.Direction[] directions) {
            super(welcometxt);
            pointerDir = -1;
            pointerInstruction = -1;
            this.instructions = instructions;
            this.directions = directions;
        }

        @Override
        public int selectOption(String text, List<String> options) {
            pointerInstruction++;
            return instructions[pointerInstruction];

        }

        public void printInformation(String text) {
        }

        public void printTrack(Track track) {
        }

        public void quit(String text) {
        }

        public PositionVector.Direction selectDirection(int playingCarIndex, char playingCarID) {
            pointerDir += 1;
            if(pointerDir < directions.length) {
                return directions[pointerDir];
            }
            return NONE;
        }

    }
}