# hooks and their arguments
use strict;
use warnings;
use feature qw(state);
use Test::More 0.88;
use Test::NoWarnings;
use t::TestAM qw(chapter_3_train chapter_3_test);
use Algorithm::AM::Batch;
# Tests are run by the hooks passed into the classify() method.
# Each hook contains one test with several subtests. Each is called
# this many times:
my %hook_calls = (
        begin_hook => 1,
        begin_test_hook => 2,
        begin_repeat_hook => 4,
        end_repeat_hook => 4,
        training_item_hook => 20,
        end_test_hook => 2,
        end_hook => 1,
);
my $total_calls = 0;
$total_calls += $_ for values %hook_calls;
# +1 for test_defaults, run twice
# +2 for test_training_item_hook
# +1 for Test::NoWarnings
plan tests => $total_calls + 1*2 + 2 + 1;
# store number of tests run by each method so we
# can plan subtests
my %tests_per_sub = (
        test_beginning_vars => 5,
        test_item_vars => 4,
        test_iter_vars => 1,
        test_training_item_hook_vars => 2,
        test_end_iter_vars => 2,
        test_end_test_vars => 3,
        test_end_vars => 4
);
# store methods for choosing to what run in make_hook
my %test_subs = (
        test_beginning_vars => \&test_beginning_vars,
        test_item_vars => \&test_item_vars,
        test_iter_vars => \&test_iter_vars,
        test_training_item_hook_vars => \&test_training_item_hook_vars,
        test_end_iter_vars => \&test_end_iter_vars,
        test_end_test_vars => \&test_end_test_vars,
        test_end_vars => \&test_end_vars
);
my $train = chapter_3_train();
my $test = chapter_3_test();
$test->add_item(
        features => [qw(3 1 3)],
        comment => 'second test item',
        class => 'e',
);
my $batch = Algorithm::AM::Batch->new(
        training_set => $train,
        repeat => 2,
        max_training_items => 10,
        begin_hook => make_hook(
                'begin_hook',
                'test_beginning_vars'
        ),
        begin_test_hook => make_hook(
                'begin_test_hook',
                'test_beginning_vars',
                'test_item_vars'),
        begin_repeat_hook => make_hook(
                'begin_repeat_hook',
                'test_beginning_vars',
                'test_item_vars',
                'test_iter_vars'),
        training_item_hook => make_hook(
                'training_item_hook',
                'test_beginning_vars',
                'test_item_vars',
                'test_iter_vars',
                'test_training_item_hook_vars'),
        end_repeat_hook => make_hook(
                'end_repeat_hook',
                'test_beginning_vars',
                'test_item_vars',
                'test_iter_vars',
                'test_end_iter_vars'),
        end_test_hook => make_hook(
                'end_test_hook',
                'test_beginning_vars',
                'test_item_vars',
                'test_end_test_vars'
                ),
        end_hook => make_hook(
                'end_hook',
                'test_beginning_vars',
                'test_end_vars'
        ),
);
# test that defaults are set before and after classification
test_defaults($batch);
# most tests are run in classification hooks
$batch->classify_all($test);
test_defaults($batch);
# test item exclusion via data hook
test_training_item_hook();
# make a hook which runs the given test subs in a single subtest.
# Pass on the arguments passed to the hook at classification time.
sub make_hook {
        my ($name, @subs) = @_;
        return sub {
                my (@args) = @_;
                subtest $name => sub {
                        my $plan = 0;
                        $plan += $tests_per_sub{$_} for @subs;
                        plan tests => $plan;
                        $test_subs{$_}->(@args) for @subs;
                };
                # true return value is needed by training_item_hook to signal
                # that item should be included in training set
                return 1;
        };
}
#check vars available from beginning to end of classification
sub test_beginning_vars {
        my ($batch) = @_;
        isa_ok($batch, 'Algorithm::AM::Batch');
        is($batch->training_set->size, 5,
                'training set');
        is($batch->test_set->size, 2, 'test set');
        is($batch->probability, 1,
                'probability is 1 by default');
        is($batch->max_training_items, 10,
                'training set capped at 10 items');
        return;
}
# Check variables set before each test
# There are two items, 312 and 313, marked with
# different comments and class labels. Check each one.
sub test_item_vars {
        my ($batch, $test_item) = @_;
        isa_ok($test_item, 'Algorithm::AM::DataSet::Item');
        ok($test_item->class eq 'r' || $test_item->class eq 'e',
                'test class');
        if($test_item->class eq 'e'){
                like(
                        $test_item->comment,
                        qr/second test item$/,
                        'test comment'
                );
                is_deeply($test_item->features, [3,1,3], 'test item features')
                        or note explain $test_item->features;
        }else{
                like(
                        $test_item->comment,
                        qr/test item comment$/,
                        'test comment'
                );
                is_deeply($test_item->features, [3,1,2], 'test item features')
                        or note explain $test_item->features;
        }
        return;
}
# Test variables available for each iteration
sub test_iter_vars {
        my ($batch, $test_item, $iteration) = @_;
        ok(
                $iteration == 1 || $iteration == 2,
                'only do 2 iteration of classification');
        return;
}
sub test_training_item_hook_vars {
        my ($batch, $test_item, $iteration, $train_item) = @_;
        isa_ok($train_item, 'Algorithm::AM::DataSet::Item');
        ok($train_item->comment =~ /my.*CommentHere/,
                'item is from training set');
}
# Test variables provided after an iteration is finished
sub test_end_iter_vars {
        my ($batch, $test_item, $iteration, $excluded_items, $result) = @_;
        if($test_item->class eq 'e'){
                is_deeply($result->scores, {e => '4', r => '4'},
                        'class scores');
        }else{
                is_deeply($result->scores, {e => '4', r => '9'},
                        'classes scores');
        }
        is_deeply($excluded_items, [], 'no items excluded');
        return;
}
sub test_end_test_vars {
        my ($self, $test_item, @item_results) = @_;
        isa_ok($item_results[0], 'Algorithm::AM::Result');
        is(scalar @item_results, 2, '1 result for each iteration');
        is($item_results[0]->test_item, $item_results[0]->test_item,
                'results have the same test item');
}
# Test variables provided after all iterations are finished
sub test_end_vars {
        my ($batch, @results) = @_;
        is_deeply($results[0]->scores, {e => '4', r => '9'},
                'scores for first result');
        is_deeply($results[1]->scores, {e => '4', r => '9'},
                'scores for second result');
        is_deeply($results[2]->scores, {e => '4', r => '4'},
                'scores for third result');
        is_deeply($results[3]->scores, {e => '4', r => '4'},
                'scores for fourth result');
        return;
}
sub test_defaults {
        my ($batch) = @_;
        is($batch->test_set, undef, 'test_set is undef outside of hooks');
        return;
}
# test that training_item_hook excludes items via false return value
sub test_training_item_hook {
        my $batch = Algorithm::AM::Batch->new(
                training_set => chapter_3_train(),
                training_item_hook      => sub {
                        # false return value indicates that item should be excluded
                        return 0;
                },
                end_repeat_hook => sub {
                        my $excluded_items = $_[3];
                        is(scalar @$excluded_items, 5,
                                'training_item_hook excluded all items');
                        isa_ok($excluded_items->[0],
                                'Algorithm::AM::DataSet::Item');
                },
        );
        $batch->classify_all(chapter_3_test());
        return;
}