package Robot;
import robocode.*;
import robocode.DeathEvent;
import robocode.ScannedRobotEvent;
import robocode.util.Utils;

import java.awt.*;
import java.awt.geom.Point2D;

import static java.lang.Math.signum;
import static java.lang.Math.toRadians;

import java.util.Random;
public class MyFirstRobot extends AdvancedRobot{
private static final double RADIANS_5 = toRadians(5);
final Random random = new Random();
 private boolean isAlive = true;

 private double enemyX = -1;
 private double enemyY = -1;

 @Override
 public void run() {
 setTurnRadarRightRadians(Double.POSITIVE_INFINITY);
 while (isAlive) {

 if (enemyX > -1) {
 final double radarTurn = getRadarTurn();
 setTurnRadarRightRadians(radarTurn);
    final double bodyTurn = getBodyTurn();
  setTurnRightRadians(bodyTurn);

 if (getDistanceRemaining() == 0) {
 final double distance = getDistance();
 setAhead(distance);
      final double gunTurn = getGunTurn();
   setTurnGunRightRadians(gunTurn);
   setFire(2);

 }
 }

  }


 execute();
 }



 private double getRadarTurn() {

 final double alphaToEnemy = angleTo(getX(), getY(), enemyX, enemyY);

 final double sign = (alphaToEnemy != getRadarHeadingRadians())
 ? signum(Utils.normalRelativeAngle(alphaToEnemy - getRadarHeadingRadians()))
 : 1;


 return Utils.normalRelativeAngle(alphaToEnemy - getRadarHeadingRadians() + RADIANS_5 * sign);

 }

 @Override
 public void onScannedRobot(ScannedRobotEvent event) {


 final double alphaToEnemy = getHeadingRadians() + event.getBearingRadians();


 enemyX = getX() + Math.sin(alphaToEnemy) * event.getDistance();
 enemyY = getY() + Math.cos(alphaToEnemy) * event.getDistance();
 }

 @Override
 public void onDeath(DeathEvent event) {
 isAlive = false;
 }

 @Override
 public void onPaint(Graphics2D g) {


 if (enemyX > -1) {
 g.setColor(Color.WHITE);
 g.drawRect((int) (enemyX - getWidth() / 2), (int) (enemyY - getHeight() / 2), (int) getWidth(), (int) getHeight());
 }
 }

 private static double angleTo(double baseX, double baseY, double x, double y) {
 double theta = Math.asin((y - baseY) / Point2D.distance(x, y, baseX, baseY)) - Math.PI / 2;
 if (x >= baseX && theta < 0) {
 theta = -theta;
 }
 return (theta %= Math.PI * 2) >= 0 ? theta : (theta + Math.PI * 2);
 }
 private double getDistance() {

 return 200 - 400 * random.nextInt();
 }

 private double getBodyTurn() {

 final double alphaToMe = angleTo(enemyX, enemyY, getX(), getY());


 final double lateralDirection = signum((getVelocity() != 0 ? getVelocity() : 1) * Math.sin(Utils.normalRelativeAngle(getHeadingRadians() - alphaToMe)));

 final double desiredHeading = Utils.normalAbsoluteAngle(alphaToMe + Math.PI / 2 * lateralDirection);

 final double normalHeading = getVelocity() >= 0 ? getHeadingRadians() : Utils.normalAbsoluteAngle(getHeadingRadians() + Math.PI);

 return Utils.normalRelativeAngle(desiredHeading - normalHeading);
 }
 private double getGunTurn() {

 return Utils.normalRelativeAngle(angleTo(getX(), getY(), enemyX, enemyY) - getGunHeadingRadians());
 }

}