How to correctly calculate the side of a wall in Bresenham's algorithm?

Question

I'm currently working on a raycaster engine in Java with Lanterna for a college project. My engine was working, but now I would like to add different colors to different sides of walls.

I'm using the Bresenham's line algorithm:

private Pair<List<Position>, Integer> createLine(double angle, Position playerPosition, Map map) {
    // Creates a line using the Bresenham's line algorithm.
    List<Position> line = new ArrayList<>();

    // Get the starting coordinates
    int x1 = (int) playerPosition.getX();
    int y1 = (int) playerPosition.getY();

    // Set the maximum distance for the line
    int distance = 1000;

    // Calculate the ending coordinates based on the angle and distance
    int x2 = (int) (x1 + distance * Math.cos(Math.toRadians(angle)));
    int y2 = (int) -(y1 + distance * Math.sin(Math.toRadians(angle)));

    // Calculate the differences between coordinates
    int dx = Math.abs(x2 - x1);
    int dy = Math.abs(y2 - y1);

    // Determine the direction of movement (sx and sy are either 1 or -1)
    int sx = (x1 < x2) ? 1 : -1;
    int sy = (y1 < y2) ? 1 : -1;

    // Initialize variables for tracking errors and the current side of the line
    int side = 1; // 1 for top/bottom, 2 for left/right
    int err = dx - dy;

    // Bresenham's line algorithm
    while (x1 != x2 || y1 != y2) {
        // Check if the current position is occupied in the map
        if (map.getXY(x1 / map.getCellsize(), y1 / map.getCellsize()) == 1) {
            // Return the line and the side when an obstacle is encountered
            return new ImmutablePair<>(line, side);
        }

        // Add the current position to the line
        line.add(new Position(x1, y1, 0));

        // Calculate error and update coordinates based on the algorithm
        int e2 = 2 * err;
        if (e2 > -dy) {
            err -= dy;
            x1 += sx;
            side = 2; // Set side to left/right
        }
        if (e2 < dx) {
            err += dx;
            y1 += sy;
            side = 1; // Set side to top/bottom
        }
    }
    return new ImmutablePair<>(line, side);
}

The problem is that the side isn't being calculated correctly, and it's producing this output. As you can see, the left side is correct, but there are red stripes in the middle where everything should be green, and on the right side it should also be green.
I think that this behavior is caused when the angle between the player and the wall is very small, but I can't solve it.
Every help is welcome!