package Shape;


#=============#
## Libraries ##
#=============#
use strict;
use warnings;
use feature qw( say );
use Data::Dumper::Concise;
use Function::Parameters;


#===============#
## Constructor ##
#===============#
method new($proto: $a_points = [ ]) {
    my $self = { points => $a_points };
    bless $self, $proto;
    return $self;
}


#==================#
## Public methods ##
#==================#
#
#  points()
#
#  Returns the underlying points data
#
method points() { return $self->{points} }


#
#  add_point($a_point)
#
#  Adds a point to the shape, in the format [ $x, $y ].
#  
#
method add_point($a_point) {
    my $a_points = $self->points;
    push @$a_points, $a_point;
}


#  prune_interior_points()
#
#  Removes points within the interior of the shape.
#
#  Such points are defined as being bordered on all 4 sides
#  (excluding diagonals) by other points in the shape.
#
#  For example, the points '#' in the shape on the left would be
#  pruned to produce the shape on the right (where 'o' stands for
#  a point which has been pruned, so is actually no longer present
#  in the shape):
#
#      . . . . . . . . . . . .        . . . . . . . . . . . .
#      . . . # . . . . . . . .        . . . # . . . . . . . .
#      . . # # # . . . . . . .        . . # o # . . . . . . .
#      . . . # # # # # # # # .        . . . # o # # # # # # .
#      . . # # # # # # # # . .        . . # o o o o o o # . .
#      . # # # # # # # # . . .        . # # o o o o o # . . .
#      . . . # # # # # # # # .        . . . # o o o o o # # .
#      . . . . # # # # # . . .        . . . . # # # # # . . .
#      . . . . . . . . # # . .        . . . . . . . . # # . .
#      . . . . . . . . . . . .        . . . . . . . . . . . .
#
method prune_interior_points() {
    my $a_pruned = [ ];

    my $a_points = $self->points;

    for (my $i = 0; $i < @$a_points; $i++) {
        my $a_pt = $a_points->[$i];
        my ($x, $y) = @$a_pt;
        if (!$self->_point_is_surrounded($x, $y, $a_points)) {
            push @$a_pruned, [ $x, $y ];
        }
    }

    return $self->{points} = $a_pruned;
}


#
#  show_points()
#
#  Creates a simple ascii display of the points in the shape
#
method show_points($label = "Shape") {
    my $a_points = $self->points;
    my ($minx, $miny, $maxx, $maxy) = $self->_find_extrema();
    my $width  = $maxx - $minx + 1;
    my $height = $maxy - $miny + 1;
    my $N      = @$a_points;

    say "\n[$label: $N points]";

    # Create a blank shape
    my $shape = [ ];
    for (my $y = 0; $y < $height + 2; $y++) {
        my $row = $shape->[$y] = [ ];
        for (my $x = 0; $x < $width + 2; $x++) {
            $row->[$x] = 0;
        }
    }

    # Fill in the points for the current shape
    for (my $i = 0; $i < @$a_points; $i++) {
        my $a_point = $a_points->[$i];
        my ($x, $y) = @$a_point;
        $y = $y - $miny + 1;
        $x = $x - $minx + 1;
        my $row    = $shape->[$y];
        $row->[$x] = 1;
    }

    # Display the resulting shape
    for (my $y = 0; $y < $height + 2; $y++) {
        my $row  = $shape->[$y];
        my $line = join("", map { $_? '#': '.' } @$row);
        say $line;
    }
}


#===================#
## Private methods ##
#===================#
method _fatal($msg) {
    my $lnum = (caller)[2];
    die "(Shape.pm) FATAL[$lnum]:  $msg\n";
}


#  
#  _point_is_surrounded($x, $y, $a_points)
#  
#  Given a point ($x, $y), returns nonzero iff that point is bounded
#  on all 4 sides (excluding diagonals) by other points.
#  
method _point_is_surrounded($x, $y, $a_points = $self->points) {
    my $nneighbors = 0;

    for (my $i = 0; $i < @$a_points; $i++) {
        my $a_pt = $a_points->[$i];
        my ($x1, $y1) = @$a_pt;
        my $dx = abs($x1 - $x);
        my $dy = abs($y1 - $y);
        if ((1 == $dx and 0 == $dy) or (0 == $dx and 1 == $dy)) {
            ++$nneighbors;
        }
    }

    return (4 == $nneighbors)? 1: 0;
}


#  
#  _find_extrema
#
#  Returns the bounding box, represented by the MIN (X, Y) and MAX (X, Y)
#  points for the shape.
#  
method _find_extrema() {
    my $a_points = $self->points;
    my ($minx, $miny, $maxx, $maxy);

    for (my $i = 0; $i < @$a_points; $i++) {
        my ($x, $y) = @{$a_points->[$i]};
        defined($x) or $self->_fatal("Undefined X");
        defined($y) or $self->_fatal("Undefined Y");

        if (0 == $i) {
            $minx = $maxx = $x;
            $miny = $maxy = $y;
        }

        ($x < $minx) and $minx = $x;
        ($y < $miny) and $miny = $y;
        ($x > $maxx) and $maxx = $x;
        ($y > $maxy) and $maxy = $y;
    }

    return ( $minx, $miny, $maxx, $maxy );
}