package ch.zhaw.pm2.racetrack;

import ch.zhaw.pm2.racetrack.strategy.UserMoveStrategy;
import org.junit.Before;
import org.junit.jupiter.api.*;

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.*;

class GameTest {
    private UserInterface userInterface;
    private Game game;
    private Track track;

    @Nested
    @DisplayName("Test correct Setup")
    class Setup {
        @BeforeEach
        void setup() {
            userInterface = new UserInterface("Test");
            game = new Game(userInterface);
            track = game.selectTrack(new File(".\\tracks\\challenge.txt"));
            game.selectMoveStrategy(track.getCar(0), new UserMoveStrategy(new UserInterface("Testing"), 0, track.getCarId(0)));
            game.selectMoveStrategy(track.getCar(1), new UserMoveStrategy(new UserInterface("Testing"), 1, track.getCarId(1)));

        }


        @Test
        void getCurrentCarIndex() {
            Assertions.assertEquals(0, game.getCurrentCarIndex());
            game.switchToNextActiveCar();
            Assertions.assertEquals(1, 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());
        }
    }

    @Nested
    @DisplayName("Basic manipulation")
    class manipulation {
        @BeforeEach
        void setup() {
            userInterface = new UserInterface("Test");
            game = new Game(userInterface);
            track = game.selectTrack(new File(".\\tracks\\challenge.txt"));
            game.selectMoveStrategy(track.getCar(0), new UserMoveStrategy(new UserInterface("Testing"), 0, track.getCarId(0)));
            game.selectMoveStrategy(track.getCar(1), new UserMoveStrategy(new UserInterface("Testing"), 1, track.getCarId(1)));

        }

        @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();
            }
        }
    }

    @Nested
    @DisplayName("Playtrough")
    class Play {
        private Game game;

        @Test
        void winner() {
            game = new Game(new interFace("Test"));
            try {
                game.initPhase();
                Assertions.assertEquals('a',game.gamePhase());
            } catch (InvalidTrackFormatException | PositionVectorNotValid e) {
                e.printStackTrace();
            }
        }



    }

    private class interFace extends UserInterface {

        private static PositionVector.Direction[] directions = {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};

        private static int pointer = -1;

        public interFace(String welcometxt) {
            super(welcometxt);
        }

        @Override
        public int selectOption(String text, List<String> options) {
            if (text.equals("Select Track file")) {
                return 1;
            } else if (text.contains("Select Strategy for Car")) {
                return 2;
            }
            return 0;
        }

        public void printInformation(String text) {
        }

        public void printTrack(Track track) {
        }

        public void quit(String text) {
        }

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

    }
}