#!/usr/bin/env perl

use strict;
use warnings;
use Test::More;
use Test::Exception;
use Role::Tiny;
use Catmandu::ArrayIterator;

my $pkg;
BEGIN {
    $pkg = 'Catmandu::Validator';
    use_ok $pkg;
}
require_ok $pkg;

{
    package T::ValidatorWithoutValidateHash;
    use Moo;

    package T::Validator;
    use Moo;
    with $pkg;

    sub validate_data {
        $_[1]->{field} =~ /^1|7$/  ? undef : ["Value is not 1"] }

}

throws_ok { Role::Tiny->apply_role_to_package('T::ValidatorWithoutValidateOne', $pkg) } qr/missing validate_data/;

my $e = T::Validator->new;

can_ok $e, 'is_valid';
can_ok $e, 'validate';

# throw:: TODO make sure it is a hash for single one.
throws_ok { $e->validate(1) } qr/Cannot validate data of this type/;

#
my $href0 = { field => 0 };
my $href1 = { field => 1 };

is $e->validate($href1), $href1, 'validate() - success';
is $e->validate($href0), undef, 'validate() - fails';

is_deeply($e->last_errors, ['Value is not 1'], 'last_errors returns errors');

is $e->is_valid($href1), 1, 'is_valid returns 1';
is $e->is_valid($href0), 0, 'is_valid returns 0';

my $after_callback_called =0;
$e = T::Validator->new(after_callback => sub { $after_callback_called = 1, $_[0]} );
is $e->validate($href1), $href1, 'validate, after_callback - success';
is $after_callback_called, 1, 'validate, after_callback - called';

my $arr =
  $e->validate([{field => 2},{field => 1}, {field => 0},{field => 3} ]);


is $e->valid_count, 1, 'valid_count';
is $e->invalid_count, 3, 'invalid_count';

my $error_field = '_validation_errors';
my $validation_error_message = "Value is not 1";
my $e_efield = T::Validator->new( error_field =>1 );
is_deeply $e_efield->validate([{field => 5},{field => 3}, {field => 1}]),
    [
        {field => 5, $error_field => [$validation_error_message]},
        {field => 3, $error_field => [$validation_error_message]},
        {field => 1}
    ], 'validate, error_field 1';

my $error_field_new = 'my_error';

$e_efield = T::Validator->new( error_field => $error_field_new);

is_deeply $e_efield->validate(
    [{field => 6},{field => 3}, {field => 1}]
),
    [
        {field => 6, $error_field_new => [$validation_error_message]},
        {field => 3, $error_field_new => [$validation_error_message]},
        {field => 1}
    ], 'validate, error_field 2';

my @invalid_array;

my $validator = T::Validator->new(
    after_callback => sub {
        my ($hashref, $errors) = @_;
        if ($errors) {
            $hashref->{errors} = $errors;
            push @invalid_array, $hashref;
            return;
        } else {
            $hashref->{valid} = 1;
        }
        $hashref;        
    } );
    
my $passed_array = $validator->validate(
    [{field => 3},{field => 1}, {field => 2}]
);

is_deeply $passed_array, [{field => 1, valid=>1}], 'validate, after_callback - valid';
is_deeply \@invalid_array, [
    {field => 3, errors => [$validation_error_message]},
    {field => 2, errors => [$validation_error_message]}, 
     ], 'validate, after_callback - invalid';

my $x=0;
@invalid_array =();
$validator = T::Validator->new( error_callback => sub { push @invalid_array, $_[0] } );
$passed_array = $validator->validate(
    [{field => 1},{field => 8}, {field => 9}]
);
is_deeply $passed_array, [{field => 1}], 'validate (array) - valid records returned';
is_deeply \@invalid_array, [{field => 8}, {field => 9}], 'validate - invalid records returned';

# test iterator

my $it = Catmandu::ArrayIterator->new([{field => 1},{field=>8},{field=>7}]);
$validator = T::Validator->new;
my $new_it = $validator->validate($it);
is_deeply $new_it->to_array, [{field => 1}, {field=>7}], 'validate (iterator) - iterator returned';

done_testing 22;