File Coverage

blib/lib/Games/Sudoku/Component/Controller.pm

Criterion	Covered	Total	%
statement	98	111	88.2
branch	25	32	78.1
condition	7	15	46.6
subroutine	19	21	90.4
pod	14	14	100.0
total	163	193	84.4

package Games::Sudoku::Component::Controller;
{
  use strict;
  use warnings;
  use Carp;

  our $VERSION = '0.02';

  use Games::Sudoku::Component::Table;
  use Games::Sudoku::Component::Table::Item;
  use Games::Sudoku::Component::Controller::History;
  use Games::Sudoku::Component::Controller::Status;

  sub new {
    my $class = shift;
    my $this  = bless {}, (ref $class || $class);

    my %options = ref $_[0] ? %{ $_[0] } : @_;

    $this->{table} = Games::Sudoku::Component::Table->new(
      size         => $options{size},
      block_width  => $options{block_width},
      block_height => $options{block_height},
    );

    my $size = $this->{table}->size;

    $this->{status}  = Games::Sudoku::Component::Controller::Status->new(
      rewind_max => $options{rewind_max} || $size,
      retry_max  => $options{retry_max}  || int(sqrt($size)),
    );
    $this->{history} = Games::Sudoku::Component::Controller::History->new;

    $this;
  }

  sub table   { $_[0]->{table}; }
  sub history { $_[0]->{history}; }
  sub status  { $_[0]->{status}; }

  sub clear {
    my $this = shift;

    $this->{table}->clear;
    $this->{history}->clear;
    $this->{status}->clear;
  }

  sub load {
    my $this = shift;

    require Games::Sudoku::Component::Controller::Loader;
    my @cells = Games::Sudoku::Component::Controller::Loader->load(@_);

    my $table = $this->{table};
    foreach my $item (@cells) {
      $table->cell($item->row,$item->col)->value($item->value);
      $table->cell($item->row,$item->col)->lock if $item->value;
    }
    $this->{history}->clear;
  }

  sub set {
    my ($this, $row, $col, $value) = @_;

    my $table   = $this->{table};
    my @allowed = $table->cell($row,$col)->allowed;

    $table->cell($row,$col)->value($value);

    $table->check_tmpvalue($row,$col);

    my $item = Games::Sudoku::Component::Table::Item->new(
      row     => $row,
      col     => $col,
      allowed => \@allowed,
      value   => $value,
    );

    $this->{history}->push($item);
  }

  sub find_and_set {
    my ($this, $item) = @_;

    my $table = $this->{table};

    $item ||= $table->find_next;

    return 0 unless defined $item;

    $table->cell($item->row,$item->col)->value($item->random_value);

    $this->{history}->push($item);

    return $item;
  }

  sub find_hints { $_[0]->{table}->find_all; }

  sub next {
    my $this = shift;

    my $status = $this->{status};

    $status->turn_to_ok if $status->is_null;

    my $result;
    if ($status->is_ok) {
      $result = $this->find_and_set;

      unless ($result) {
        if ($this->{table}->is_finished) {
          $status->turn_to_solved;
        }
        else {
          if ($status->can_rewind) {
            $status->turn_to_rewind;
          }
          else {
            if ($status->can_retry) {
              $this->rewind_all;
              $status->turn_to_ok;
            }
            else {
              $status->turn_to_giveup;
            }
          }
        }
      }
    }
    if ($status->is_rewind) {
      $result = $this->rewind;

      if ($result) {
        if ($result->allowed) {
          $this->find_and_set($result);
          $status->turn_to_ok;
        }
      }
      else {
        if ($status->can_retry) {
          $status->turn_to_ok;
        }
        else {
          $status->turn_to_giveup;
        }
      }
    }
    return $result;
  }

  sub solve {
    my $this = shift;

    $this->{status}->clear;

    until($this->{status}->is_finished) {
      $this->next;
    }
  }

  sub make_blank {
    my ($this, $count) = @_;

    my $table = $this->{table};
    my $size  = $table->size;

    croak "Invalid count: $count"
      if $count > ($size ** 2) || $count < 1;

    $table->lock_all;

    foreach my $id (1..$count) {
      my $row = int(rand($size)) + 1;
      my $col = int(rand($size)) + 1;
      redo unless $table->cell($row,$col)->value;
      $table->cell($row,$col)->unlock;
      my $prev = $table->cell($row,$col)->value;
      $table->cell($row,$col)->value(0);
    }

    $this->{status}->clear;
    $this->{history}->clear;
  }

  sub rewind {
    my $this = shift;

    my $table = $this->{table};
    my $item  = $this->{history}->pop;

    $table->cell($item->row,$item->col)->value(0) if defined $item;

    $item;
  }

  sub rewind_all {
    my $this = shift;

    foreach (1..$this->{history}->count) {
      $this->rewind;
    }
  }
}

1;
__END__