public class TARRamRobot extends TeamRobot {

    private ArrayList<Robot> enemyRobots = new ArrayList<Robot>();
    private int turnDirection = 1;
    private boolean left = false;
    private Robot closestRobot;

    public void run() {
        while (true) {
            // Fast scanning
            if (getRadarTurnRemaining() == 0.0) {
                setTurnRadarRight(Double.POSITIVE_INFINITY);
            }
//            setTurnRight(5 * turnDirection);
            execute();

            if (enemyRobots.size() > 0) {
                if (closestRobot == null) {
                    closestRobot = getClosestRobot();
                } else if (!closestRobot.isAlive()) {
                    enemyRobots.remove(closestRobot);
                } else {
                    runAlgorithm(closestRobot);
                }
            }
//            while (getDistanceRemaining() > 0 && getTurnRemaining() > 0) {
//                execute();
//            }
        }
    }

    private void zigzagRun(double distance) {
        setAhead(distance);
        if (left) {
            left = false;
            turnLeft(60);
        } else {
            left = true;
            turnRight(60);
        }
    }

    private Robot getClosestRobot() {
        if (enemyRobots.isEmpty()) {
            return null;
        }

        Robot returnRobot = enemyRobots.get(0);

        for (Robot robot : enemyRobots) {
            if (robot.getDistance() < returnRobot.getDistance()) ;
            {
                returnRobot = robot;
            }
        }
        return returnRobot;
    }

    /**
     * This robot will scan every robot and decides on the distance between him and the enemy
     * how hard he will shoot.
     *
     * @param event
     */
    public void onScannedRobot(ScannedRobotEvent event) {
        if (!isTeammate(event.getName())) {
            System.out.println(event.getName());
            Robot enemyRobot = new Robot(event.getName(), event.getEnergy(), event.getDistance(), event.getBearing());
            addEnemyRobot(enemyRobot);
        }
    }

    public void dodgeWall() {
        if (getX() < 20 || getX() > getBattleFieldWidth() - 20 || getY() < 20 || getY() > getBattleFieldHeight() - 20) {
            turnRight(normalRelativeAngleDegrees(0 - getHeading()));
        }

    }

    @Override
    public void onHitRobot(HitRobotEvent event) {
        setBack(10);
    }

    private void runAlgorithm(Robot toTargetRobot) {
        dodgeWall();
        if (toTargetRobot.getDistance() > 300) {
            fire(0.5);
            System.out.println("Shooting 0.5 bullets");
        } else if (toTargetRobot.getDistance() < 300 || toTargetRobot.getDistance() > 100) {
            fire(1);
            System.out.println("Shooting 1 bullets");
        } else {
            fire(Rules.MAX_BULLET_POWER);
            System.out.println("Shooting 3 bullets");
        }
        turnRight(toTargetRobot.getBearing());
        double distanceToRobot = toTargetRobot.getDistance();

        if (distanceToRobot > 200) {
            for (int i = 0; i < 3; i++) {
                if (checkWallNearby(distanceToRobot / 3 + 20)) {
                    setBack(100);
                    turnLeft(90);
                } else {

                    zigzagRun(distanceToRobot / 3);
                }
            }
        } else {
            if (checkWallNearby(distanceToRobot + 20)) {
                setBack(100);
                turnLeft(90);
            } else {
                setAhead(distanceToRobot);
            }
        }
        execute();

        while (getDistanceRemaining() > 0 && getTurnRemaining() > 0) {
            execute();
        }
    }

    private boolean checkWallNearby(double distanceToRobot) {
        boolean wallnearby = false;
        if (getX() <= distanceToRobot) {
            wallnearby = true;
        } else if (getX() >= getBattleFieldWidth() - 75) {
            wallnearby = true;
        }

        if (getY() < distanceToRobot) {
            wallnearby = true;
        } else if (getY() >= getBattleFieldHeight() - distanceToRobot) {
            wallnearby = true;
        }

        return wallnearby;
    }

    private void addEnemyRobot(Robot newEnemyRobot) {
        if (enemyRobots.isEmpty()) {
            enemyRobots.add(newEnemyRobot);
        } else {
            for (Robot iterationRobot : enemyRobots) {
                // If the robot does not exist
                if (!iterationRobot.getName().equals(newEnemyRobot.getName())) {
                    System.out.println("enemy added " + newEnemyRobot.getName());
                    enemyRobots.add(newEnemyRobot);
                    for (int i = 0; i < enemyRobots.size(); i++) {
                        System.out.println(enemyRobots.get(i));
                    }
                } else {
                    Robot robot = getRobotByName(newEnemyRobot.getName());
                    robot.setBearing(newEnemyRobot.getBearing());
                    robot.setEnergy(newEnemyRobot.getEnergy());
                    robot.setDistance(newEnemyRobot.getDistance());
                }
            }
        }
    }

    private Robot getRobotByName(String name) {
        for (Robot robot : enemyRobots) {
            if (robot.getName().equals(name)) {
                return robot;
            }
        }
        return null;
    }
}