use Test::More tests => 18;

use Test::More tests => 3;

use Test::MockModule;

my $schema = Koha::Database->schema;

my $schema  = Koha::Database->schema;

$schema->storage->txn_begin;

my $library = $builder->build({

    source => 'Branch',

subtest 'all() tests' => sub {

    value => {

        branchcode => 'MYLIBRARY',

    plan tests => 16;

    }

});

    $schema->storage->txn_begin;

my $another_library = $builder->build({

    source => 'Branch',

    my $library = $builder->build({

    value => {

        source => 'Branch',

        branchcode => 'ANOTHERLIB',

        value => {

    }

            branchcode => 'MYLIBRARY',

});

        }

    });

my $plugin = Koha::Template::Plugin::Branches->new();

    my $another_library = $builder->build({

ok($plugin, "initialized Branches plugin");

        source => 'Branch',

        value => {

my $name = $plugin->GetName($library->{branchcode});

            branchcode => 'ANOTHERLIB',

is($name, $library->{branchname}, 'retrieved expected name for library');

        }

    });

$name = $plugin->GetName('__ANY__');

is($name, '', 'received empty string as name of the "__ANY__" placeholder library code');

    my $plugin = Koha::Template::Plugin::Branches->new();

    ok($plugin, "initialized Branches plugin");

$name = $plugin->GetName(undef);

is($name, '', 'received empty string as name of NULL/undefined library code');

    my $name = $plugin->GetName($library->{branchcode});

    is($name, $library->{branchname}, 'retrieved expected name for library');

$library = $plugin->GetLoggedInBranchcode();

is($library, '', 'no active library if there is no active user session');

    $name = $plugin->GetName('__ANY__');

    is($name, '', 'received empty string as name of the "__ANY__" placeholder library code');

t::lib::Mocks::mock_userenv({ branchcode => 'MYLIBRARY' });

$library = $plugin->GetLoggedInBranchcode();

    $name = $plugin->GetName(undef);

is($library, 'MYLIBRARY', 'GetLoggedInBranchcode() returns active library');

    is($name, '', 'received empty string as name of NULL/undefined library code');

t::lib::Mocks::mock_preference( 'IndependentBranches', 0 );

    $library = $plugin->GetLoggedInBranchcode();

my $libraries = $plugin->all();

    is($library, '', 'no active library if there is no active user session');

ok( scalar(@$libraries) > 1, 'If IndependentBranches is not set, all libraries should be returned' );

is( grep ( { $_->{branchcode} eq 'MYLIBRARY'  and $_->{selected} == 1 } @$libraries ),       1, 'Without selected parameter, my library should be preselected' );

    t::lib::Mocks::mock_userenv({ branchcode => 'MYLIBRARY' });

is( grep ( { $_->{branchcode} eq 'ANOTHERLIB' and not exists $_->{selected} } @$libraries ), 1, 'Without selected parameter, other library should not be preselected' );

    $library = $plugin->GetLoggedInBranchcode();

$libraries = $plugin->all( { selected => 'ANOTHERLIB' } );

    is($library, 'MYLIBRARY', 'GetLoggedInBranchcode() returns active library');

is( grep ( { $_->{branchcode} eq 'MYLIBRARY'  and not exists $_->{selected} } @$libraries ), 1, 'With selected parameter, my library should not be preselected' );

is( grep ( { $_->{branchcode} eq 'ANOTHERLIB' and $_->{selected} == 1 } @$libraries ),       1, 'With selected parameter, other library should be preselected' );

    t::lib::Mocks::mock_preference( 'IndependentBranches', 0 );

$libraries = $plugin->all( { selected => '' } );

    my $libraries = $plugin->all();

is( grep ( { exists $_->{selected} } @$libraries ), 0, 'With selected parameter set to an empty string, no library should be preselected' );

    ok( scalar(@$libraries) > 1, 'If IndependentBranches is not set, all libraries should be returned' );

    is( grep ( { $_->{branchcode} eq 'MYLIBRARY'  and $_->{selected} == 1 } @$libraries ),       1, 'Without selected parameter, my library should be preselected' );

my $total = @{$plugin->all};

    is( grep ( { $_->{branchcode} eq 'ANOTHERLIB' and not exists $_->{selected} } @$libraries ), 1, 'Without selected parameter, other library should not be preselected' );

my $pickupable = @{$plugin->all( { search_params => { pickup_location => 1 } }) };

    $libraries = $plugin->all( { selected => 'ANOTHERLIB' } );

my $yet_another_library = $builder->build({

    is( grep ( { $_->{branchcode} eq 'MYLIBRARY'  and not exists $_->{selected} } @$libraries ), 1, 'With selected parameter, my library should not be preselected' );

    source => 'Branch',

    is( grep ( { $_->{branchcode} eq 'ANOTHERLIB' and $_->{selected} == 1 } @$libraries ),       1, 'With selected parameter, other library should be preselected' );

    value => {

    $libraries = $plugin->all( { selected => '' } );

        branchcode => 'CANTPICKUP',

    is( grep ( { exists $_->{selected} } @$libraries ), 0, 'With selected parameter set to an empty string, no library should be preselected' );

        pickup_location => 0,

    }

    my $total = @{$plugin->all};

});

    my $pickupable = @{$plugin->all( { search_params => { pickup_location => 1 } }) };

is(@{$plugin->all( { search_params => { pickup_location => 1 } }) }, $pickupable,

    my $yet_another_library = $builder->build({

   'Adding a new library with pickups'

        source => 'Branch',

   .' disabled does not increase the amount returned by ->pickup_locations');

        value => {

is(@{$plugin->all}, $total+1, 'However, adding a new library increases'

            branchcode => 'CANTPICKUP',

   .' the total amount gotten with ->all');

            pickup_location => 0,

        }

t::lib::Mocks::mock_preference( 'IndependentBranches', 1 );

    });

$libraries = $plugin->all();

    is(@{$plugin->all( { search_params => { pickup_location => 1 } }) }, $pickupable,

is( scalar(@$libraries), 1, 'If IndependentBranches is set, only 1 library should be returned' );

       'Adding a new library with pickups'

$libraries = $plugin->all( { unfiltered => 1 } );

       .' disabled does not increase the amount returned by ->pickup_locations');

ok( scalar(@$libraries) > 1, 'If IndependentBranches is set, all libraries should be returned if the unfiltered flag is set' );

    is(@{$plugin->all}, $total+1, 'However, adding a new library increases'

       .' the total amount gotten with ->all');

subtest 'UseBranchTransferLimits = OFF' => sub {

    plan tests => 5;

    t::lib::Mocks::mock_preference( 'IndependentBranches', 1 );

    $libraries = $plugin->all();

    my $from = Koha::Library->new({

    is( scalar(@$libraries), 1, 'If IndependentBranches is set, only 1 library should be returned' );

        branchcode => 'zzzfrom',

    $libraries = $plugin->all( { unfiltered => 1 } );

        branchname => 'zzzfrom',

    ok( scalar(@$libraries) > 1, 'If IndependentBranches is set, all libraries should be returned if the unfiltered flag is set' );

        branchnotes => 'zzzfrom',

    })->store;

    $schema->storage->txn_rollback;

    my $to = Koha::Library->new({

        branchcode => 'zzzto',

        branchname => 'zzzto',

        branchnotes => 'zzzto',

    })->store;

    my ($bibnum, $title, $bibitemnum) = create_helper_biblio('DUMMY');

    # Create item instance for testing.

    my ($item_bibnum1, $item_bibitemnum1, $itemnumber1)

    = AddItem({ homebranch => $from->branchcode,

                holdingbranch => $from->branchcode } , $bibnum);

    my ($item_bibnum2, $item_bibitemnum2, $itemnumber2)

    = AddItem({ homebranch => $from->branchcode,

                holdingbranch => $from->branchcode } , $bibnum);

    my ($item_bibnum3, $item_bibitemnum3, $itemnumber3)

    = AddItem({ homebranch => $from->branchcode,

                holdingbranch => $from->branchcode } , $bibnum);

    my $biblio = Koha::Biblios->find($bibnum);

    t::lib::Mocks::mock_preference('UseBranchTransferLimits', 0);

    t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');

    t::lib::Mocks::mock_preference('item-level_itypes', 1);

    Koha::Item::Transfer::Limits->delete;

    Koha::Item::Transfer::Limit->new({

        fromBranch => $from->branchcode,

        toBranch => $to->branchcode,

        itemtype => $biblio->itemtype,

    })->store;

    my $total_pickup = Koha::Libraries->search({

        pickup_location => 1

    })->count;

    # Test TT plugin

    my $pickup = Koha::Template::Plugin::Branches::pickup_locations({ biblio => $bibnum });

    is(C4::Context->preference('UseBranchTransferLimits'), 0, 'Given system '

       .'preference UseBranchTransferLimits is switched OFF,');

    is(@{$pickup}, $total_pickup, 'Then the total number of pickup locations '

       .'equal number of libraries with pickup_location => 1');

    t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');

    t::lib::Mocks::mock_preference('item-level_itypes', 1);

    $pickup = Koha::Template::Plugin::Branches::pickup_locations({ biblio => $bibnum });

    is(@{$pickup}, $total_pickup, '...when '

       .'BranchTransferLimitsType = itemtype and item-level_itypes = 1');

    t::lib::Mocks::mock_preference('item-level_itypes', 0);

    $pickup = Koha::Template::Plugin::Branches::pickup_locations({ biblio => $bibnum });

    is(@{$pickup}, $total_pickup, '...as well as when '

       .'BranchTransferLimitsType = itemtype and item-level_itypes = 0');

    t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'ccode');

    $pickup = Koha::Template::Plugin::Branches::pickup_locations({ biblio => $bibnum });

    is(@{$pickup}, $total_pickup, '...as well as when '

       .'BranchTransferLimitsType = ccode');

    t::lib::Mocks::mock_preference('item-level_itypes', 1);

sub create_helper_biblio {

subtest 'pickup_locations() tests' => sub {

    my $itemtype = shift;

    my ($bibnum, $title, $bibitemnum);

    plan tests => 8;

    my $bib = MARC::Record->new();

    $title = 'Silence in the library';

    my $library_1 = { branchcode => 'A' };

    $bib->append_fields(

    my $library_2 = { branchcode => 'B' };

        MARC::Field->new('100', ' ', ' ', a => 'Moffat, Steven'),

    my $library_3 = { branchcode => 'C' };

        MARC::Field->new('245', ' ', ' ', a => $title),

    my @library_array = ( $library_1, $library_2, $library_3 );

        MARC::Field->new('942', ' ', ' ', c => $itemtype),

    my $libraries = Test::MockModule->new('Koha::Libraries');

    $libraries->mock(

        'pickup_locations',

        sub {

            my $result = clone(\@library_array);

            return $result;

        }

    return ($bibnum, $title, $bibitemnum) = AddBiblio($bib, '');

}

    my $plugin           = Koha::Template::Plugin::Branches->new();

    my $pickup_locations = $plugin->pickup_locations();

    is( scalar @{$pickup_locations}, 3, 'Libraries count is correct' );

    for my $library ( @{$pickup_locations} ) {

        ok( ( any { $_->{branchcode} eq $library->{branchcode} } @library_array ),

            'Library ' . $library->{branchcode} . ' in results' );

    }

    $pickup_locations = $plugin->pickup_locations({ selected => $library_2->{branchcode} });

    my @selected = grep { exists $_->{selected} } @{ $pickup_locations };

    is( scalar @selected, 1, '(param) Only one is selected' );

    is( $selected[0]->{branchcode}, $library_2->{branchcode}, '(param) The selected one is the right one' );

    t::lib::Mocks::mock_userenv({ branchcode => $library_3->{branchcode} });

    $pickup_locations = $plugin->pickup_locations();

    @selected = grep { exists $_->{selected} } @{ $pickup_locations };

    is( scalar @selected, 1, '(userenv) Only one is selected' );

    is( $selected[0]->{branchcode}, $library_3->{branchcode}, '(userenv) The selected one is the right one' );

};