public class Point {
    private int x;
    private int y;

    /**
     * initialises a point using X and Y coordinates starting at 0
     * @param x the x coordinate of the point starting at 0
     * @param y the y coordinate of the point starting at 0
     * @author Peer Ole Wachtel
     */
    public Point (int x, int y) {
        this.setX(x);
        this.setY(y);
    }

    /**
     * initialises a Point using a coordinate provided in the format of a letter followed by a number
     * this coordinate is checked using `isValidSyntax`
     * If the coordinate is not in a valid syntax, an `IllegalArgumentException` will be thrown, stating as such
     * The number part of the coordinate starts at 1 instead of 0 so for example, the
     * string A1 will result in the X and Y coordinates of (0, 0)
     * @param str the coordinate in alphanumeric format
     * @throws IllegalArgumentException if the coordinate is invalid according to `isValidSyntax`
     * @author Peer Ole Wachtel, Luca Conte
     */
    public Point (String str) {
        if (Point.isValidSyntax(str)) {
            this.setX(str.charAt(0));
            this.setY(Integer.parseInt(str.substring(1)) - 1);
        } else {
            throw new IllegalArgumentException("String ist keine gültige Koordinate");
        }
    }

    /**
     * returns this point as a string in its alphanumeric format
     * @return this point as a string in its alphanumeric format
     * @author Luca Conte, Peer Ole Wachtel
     */
    @Override
    public String toString() {
        return (char) ('A' + this.x) + String.valueOf(this.y + 1);
    }

    /**
     * returns the X coordinate of the point starting at 0
     * @return the X coordinate of the point starting at 0
     * @author Peer Ole Wachtel
     */
    public int getX() {
        return x;
    }

    /**
     * returns the Y coordinate of the point starting at 0
     * @return the Y coordinate of the point starting at 0
     * @author Peer Ole Wachtel
     */
    public int getY() {
        return y;
    }

    /**
     * sets the X coordinate of the point starting at 0
     * @param x the X coordinate of the point starting at 0
     * @author Peer Ole Wachtel
     */
    public void setX(int x) {
        this.x = x;
    }

    /**
     * sets the Y coordinate of the point starting at 0
     * @param y the Y coordinate of the point starting at 0
     * @author Peer Ole Wachtel
     */
    public void setY(int y) {
        this.y = y;
    }

    /**
     * sets the X coordinate of the from its character value in alphanumeric form
     * @param c the character to be transformed into 
     * @author Peer Ole Wachtel
     */
    public void setX(char c) {
        this.x = c - 'A';
    }

    /**
     * checks whether a string is a valid alphanumeric point coordinate
     * @param str the string to be tested
     * @return whether the string is valid according to the regular expression `^[A-Z]\\d+$`
     * @author Peer Ole Wachtel
     */
    public static boolean isValidSyntax(String str) {
        return str.matches("^[A-Z]\\d+$");
    }

    /**
     * returns whether two points are equal
     * two points with equivalent coordinates are considered equal
     * @param o the other object/Point to compare this one to
     * @return whether the objects are equal
     * @author Luca Conte
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || this.getClass() != o.getClass()) return false;

        Point p = (Point)o;
        return p.getX() == this.getX() && p.getY() == this.getY();
    }

    /**
     * determines whether two points are neighbours
     * points are considered neighbours if their positions are equal or within a difference of 1 on both X and Y axis
     * @param other the point to check for neighbourship
     * @return whether the points are neighbours
     * @author Luca Conte
     */
    public boolean neighbours(Point other) {
        if (other == null) return false;
        return (int)Math.abs(this.getX() - other.getX()) <= 1 && (int)Math.abs(this.getY() - other.getY()) <= 1;
    }
}
