package ch.zhaw.pm2.racetrack;

import ch.zhaw.pm2.racetrack.strategy.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

/**
 * Tests for Class Car
 */
class CarTest {

    Car car;

    // Default coordinates for tests
    int DEFAULT_X = 10;
    int DEFAULT_Y = 10;
    char DEFAULT_ID = 'f';

    /**
     * Create a new Car Object and set Position to a defined Default Position
     */
    @BeforeEach
    void setUp() {
        car = new Car(DEFAULT_ID, new PositionVector(DEFAULT_X, DEFAULT_Y));
    }

    @Test
    void getID() {
        assertEquals(DEFAULT_ID, car.getID());
    }

    /**
     * Method to check nextPosition with coordinates as int
     *
     * @param x the expected value for x coordinate
     * @param y the expected value for y coordinate
     */
    void checkNextPosition(int x, int y) {
        assertEquals(new PositionVector(x, y), car.nextPosition());
    }

    /**
     * - checks if the position of the car can be set and saved correctly with valid positions.
     * - checks if an exception is throwed and position keeps unchanged if invalid coordinates are entered.
     */
    @Test
    void setPosition() {
        checkNextPosition(DEFAULT_X, DEFAULT_Y);

        // List of valid Positions
        List<PositionVector> validPositions = new ArrayList<>();
        validPositions.add(new PositionVector(20, 20));
        validPositions.add(new PositionVector(0, 0));
        validPositions.add(new PositionVector(20, 0));
        validPositions.add(new PositionVector(0, 20));

        for (PositionVector positionVector : validPositions) {
            car.setPosition(positionVector);
            assertEquals(positionVector, car.nextPosition());
        }

        // List of invalid positions.
        List<PositionVector> invalidPositions = new ArrayList<>();
        invalidPositions.add(new PositionVector(0, -20));
        invalidPositions.add(new PositionVector(-20, 0));
        invalidPositions.add(new PositionVector(-20, -20));

        for (PositionVector positionVector : invalidPositions) {
            boolean exception = false;
            setUp();
            try {
                car.setPosition(positionVector);
            } catch (IllegalArgumentException e) {
                exception = true;
            }
            assertTrue(exception);

            // position should keep unchanged
            checkNextPosition(DEFAULT_X, DEFAULT_Y);
        }
    }

    void checkVelocity(int x, int y) {
        assertEquals(new PositionVector(x, y), car.getVelocity());
    }


    /**
     * Checks if the methods accelerate, move and getVelocity are working correctly with acceleration in all directions.
     * Checks also if velocity is calculated correctly if method accelerate is called a second time.
     */
    @Test
    void movement() {
        // add all possible directions in a List
        List<PositionVector.Direction> directions = Arrays.asList(PositionVector.Direction.values());

        //position shouldn't be changed because velocity should be 0.
        car.move();
        checkNextPosition(DEFAULT_X, DEFAULT_Y);



        for (PositionVector.Direction direction1 : directions) {
            for (PositionVector.Direction direction2 : directions) {

                //create a new instance of Car with default coordinates and velocity 0.
                setUp();

                //variables to save the actual expected result of method nextPosition
                int expectedNextPosX = DEFAULT_X;
                int expectedNextPosY = DEFAULT_Y;

                //variables to save the acutal expected result of method getVelocity
                int expectedVelocityX = 0;
                int expectedVelocityY = 0;

                car.accelerate(direction1);
                expectedVelocityX += direction1.vector.getX();
                expectedVelocityY += direction1.vector.getY();
                expectedNextPosX += direction1.vector.getX();
                expectedNextPosY += direction1.vector.getY();
                checkVelocity(expectedVelocityX, expectedVelocityY);
                checkNextPosition(expectedNextPosX, expectedNextPosY);

                car.move();
                expectedNextPosX += direction1.vector.getX();
                expectedNextPosY += direction1.vector.getY();
                checkVelocity(expectedVelocityX, expectedVelocityY);
                checkNextPosition(expectedNextPosX, expectedNextPosY);


                car.accelerate(direction2);
                expectedVelocityX += direction2.vector.getX();
                expectedVelocityY += direction2.vector.getY();
                expectedNextPosX += direction2.vector.getX();
                expectedNextPosY += direction2.vector.getY();
                checkVelocity(expectedVelocityX, expectedVelocityY);
                checkNextPosition(expectedNextPosX, expectedNextPosY);

                car.move();
                checkVelocity(expectedVelocityX, expectedVelocityY);
                expectedNextPosX += (direction1.vector.getX() + direction2.vector.getX());
                expectedNextPosY += (direction1.vector.getY() + direction2.vector.getY());
                checkNextPosition(expectedNextPosX, expectedNextPosY);
            }
        }
    }


    /**
     * test for methods crash and isCrashed. checks if state crashed is set and returned correctly.
     */
    @Test
    void crash() {
        assertFalse(car.isCrashed());
        car.crash();
        assertTrue(car.isCrashed());
    }

    /**
     * test for methods setMoveStrategy. Checks if the MoveStrategy Object is saved and returned correctly
     * with all Types of MoveStrategy.
     */
    @Test
    void MoveStrategy() {
        MoveStrategy moveStrategy;

        moveStrategy = new DoNotMoveStrategy();
        car.setMoveStrategy(moveStrategy);
        assertEquals(moveStrategy, car.getMoveStrategy());

        moveStrategy = new MoveListStrategy();
        car.setMoveStrategy(moveStrategy);
        assertEquals(moveStrategy, car.getMoveStrategy());

        moveStrategy = new PathFollowerMoveStrategy();
        car.setMoveStrategy(moveStrategy);
        assertEquals(moveStrategy, car.getMoveStrategy());

        moveStrategy = new UserMoveStrategy();
        car.setMoveStrategy(moveStrategy);
        assertEquals(moveStrategy, car.getMoveStrategy());
    }
}