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;
            try {
                car.setPosition(positionVector);
            } catch (IllegalArgumentException e) {
                exception = true;
            }
            assertTrue(exception);

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


    /**
     * Checks if the methods accelerate and move 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) {

            //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;

            car.accelerate(direction1);
            ExpectedNextPosX += direction1.vector.getX();
            ExpectedNextPosY += direction1.vector.getY();
            CheckNextPosition(ExpectedNextPosX, ExpectedNextPosY);

            car.move();
            ExpectedNextPosX += direction1.vector.getX();
            ExpectedNextPosY += direction1.vector.getY();
            CheckNextPosition(ExpectedNextPosX, ExpectedNextPosY);

            for (PositionVector.Direction direction2 : directions) {
                car.accelerate(direction2);
                ExpectedNextPosX += direction2.vector.getX();
                ExpectedNextPosY += direction2.vector.getY();
                CheckNextPosition(ExpectedNextPosX, ExpectedNextPosY);

                car.move();
                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());
    }
}