package Koha::Exceptions::Item::Transfer;

use Modern::Perl;

use Exception::Class (

    'Koha::Exceptions::Item::Transfer' => {

        description => 'Something went wrong'

    },

    'Koha::Exceptions::Item::Transfer::Found' => {

        isa => 'Koha::Exceptions::Item::Transfer',

        description => "Active item transfer already exists",

        fields => ['transfer']

    },

    'Koha::Exceptions::Item::Transfer::Limit' => {

        isa => 'Koha::Exceptions::Item::Transfer',

        description => "Transfer not allowed"

    }

);

1;

use Koha::Exceptions::Item::Transfer;

=head3 request_transfer

  my $transfer = $item->request_transfer(

      { to => $to_library, reason => $reason, force => 0 } );

Add a transfer request for this item to the given branch for the given reason.

An exception will be thrown if the BranchTransferLimits would prevent the requested

transfer, unless 'force' is passed to override the limits.

Note: At this time, only one active transfer (i.e pending arrival date) may exist

at a time for any given item. An exception will be thrown should you attempt to

add a request when a transfer has already been queued, whether it is in transit

or just at the request stage.

=cut

sub request_transfer {

    my ( $self, $params ) = @_;

    # check for mandatory params

    my @mandatory = ( 'to', 'reason' );

    for my $param (@mandatory) {

        unless ( defined( $params->{$param} ) ) {

            Koha::Exceptions::MissingParameter->throw(

                error => "The $param parameter is mandatory" );

        }

    }

    my $request;

    Koha::Exceptions::Item::Transfer::Found->throw( transfer => $request )

      if ( $request = $self->get_transfer );

    # FIXME: Add override functionality to allow for queing transfers

    Koha::Exceptions::Item::Transfer::Limit->throw()

      unless ( $params->{force} || $self->can_be_transferred( { to => $params->{to} } ) );

    my $transfer = Koha::Item::Transfer->new(

        {

            itemnumber    => $self->itemnumber,

            daterequested => dt_from_string,

            frombranch    => $self->holdingbranch,

            tobranch      => $params->{to}->branchcode,

            reason        => $params->{reason},

            comments      => $params->{comment}

        }

    )->store();

    return $transfer;

}

use Koha::DateUtils;

subtest 'request_transfer' => sub {

    plan tests => 7;

    $schema->storage->txn_begin;

    my $library1 = $builder->build_object( { class => 'Koha::Libraries' } );

    my $library2 = $builder->build_object( { class => 'Koha::Libraries' } );

    my $item     = $builder->build_sample_item(

        {

            homebranch    => $library1->branchcode,

            holdingbranch => $library2->branchcode,

        }

    );

    # Mandatory fields tests

    throws_ok { $item->request_transfer( { to => $library1 } ) }

    'Koha::Exceptions::MissingParameter',

      'Exception thrown if `reason` parameter is missing';

    throws_ok { $item->request_transfer( { reason => 'Manual' } ) }

    'Koha::Exceptions::MissingParameter',

      'Exception thrown if `to` parameter is missing';

    # Successful request

    my $transfer = $item->request_transfer({ to => $library1, reason => 'Manual' });

    is( ref($transfer), 'Koha::Item::Transfer',

        'Koha::Item->request_transfer should return a Koha::Item::Transfer object'

    );

    # Transfer already in progress

    throws_ok { $item->request_transfer( { to => $library2, reason => 'Manual' } ) }

    'Koha::Exceptions::Item::Transfer::Found',

      'Exception thrown if transfer is already in progress';

    my $exception = $@;

    is( ref( $exception->transfer ),

        'Koha::Item::Transfer',

        'The exception contains the found Koha::Item::Transfer' );

    $transfer->datearrived(dt_from_string)->store();

    # BranchTransferLimits

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

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

    my $limit = Koha::Item::Transfer::Limit->new({

        fromBranch => $library2->branchcode,

        toBranch => $library1->branchcode,

        itemtype => $item->effective_itemtype,

    })->store;

    throws_ok { $item->request_transfer( { to => $library1, reason => 'Manual' } ) }

    'Koha::Exceptions::Item::Transfer::Limit',

      'Exception thrown if transfer is prevented by limits';

    my $forced_transfer = $item->request_transfer( { to => $library1, reason => 'Manual', force => 1 } );

    is( ref($forced_transfer), 'Koha::Item::Transfer',

        'Koha::Item->request_transfer allowed when forced'

    );

    $schema->storage->txn_rollback;

};