use Koha::MessageAttributes;

use Koha::MessageAttribute;

use Koha::Notice::Templates;

    $backend->mock(

        'metadata',

        sub {

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

            return {

                title => 'mytitle',

                author => 'myauthor'

            }

        }

    );

    # Create a mocked branch with no email addressed defined

    my $illbrn = $builder->build({

        source => 'Branch',

        value => {

            branchcode => 'HDE',

            branchemail => "",

            branchillemail => "",

            branchreplyto => ""

        }

    });

    #send_patron_notice

    my $attr = Koha::MessageAttributes->find({ message_name => 'Ill_ready' });

    C4::Members::Messaging::SetMessagingPreference({

        borrowernumber => $patron->{borrowernumber},

        message_attribute_id => $attr->message_attribute_id,

        message_transport_types => ['email']

    });

    my $return_patron = $illrq_obj->send_patron_notice('ILL_PICKUP_READY');

    my $notice = $schema->resultset('MessageQueue')->search({

            letter_code => 'ILL_PICKUP_READY',

            message_transport_type => 'email',

            borrowernumber => $illrq_obj->borrowernumber

        })->next()->letter_code;

    is_deeply(

        $return_patron,

        { result => { success => ['email'], fail => [] } },

        "Correct return when notice created"

    );

    is($notice, 'ILL_PICKUP_READY' ,"Notice is correctly created");

    my $return_patron_fail = $illrq_obj->send_patron_notice();

    is_deeply(

        $return_patron_fail,

        { error => 'notice_no_type' },

        "Correct error when missing type"

    );

    #get_staff_to_address

    # Mock a KohaAdminEmailAddress syspref

    t::lib::Mocks::mock_preference(

        'KohaAdminEmailAddress',

        'kohaadmin@nowhere.com'

    );

    # No branch addresses defined and no ILLDefaultStaffEmail, so should

    # fall back to Koha admin address

    my $email_kohaadmin = $illrq_obj->get_staff_to_address;

    ok(

        $email_kohaadmin eq 'kohaadmin@nowhere.com',

        'get_staff_to_address falls back to Koha admin in the absence of other alternatives'

    );

    # General branch address defined, should fall back to that

    $builder->delete({ source => 'Branch', records => $illbrn });

    $illbrn = $builder->build({

        source => 'Branch',

        value => {

            branchcode => 'HDE',

            branchemail => 'branch@nowhere.com',

            branchillemail => "",

            branchreplyto => ""

        }

    });

    my $email_gen_branch = $illrq_obj->get_staff_to_address;

    ok(

        $email_gen_branch eq 'branch@nowhere.com',

        'get_staff_to_address falls back to general branch address when defined'

    );

    # ILL staff syspref address defined, should fall back to that

    t::lib::Mocks::mock_preference(

        'ILLDefaultStaffEmail',

        'illstaff@nowhere.com'

    );

    my $email_syspref = $illrq_obj->get_staff_to_address;

    ok(

        $email_syspref eq 'illstaff@nowhere.com',

        'get_staff_to_address falls back to ILLDefaultStaffEmail when defined'

    );

    # Branch ILL address defined, should use that

    $builder->delete({ source => 'Branch', records => $illbrn });

    $illbrn = $builder->build({

        source => 'Branch',

        value => {

            branchcode => 'HDE',

            branchemail => 'branch@nowhere.com',

            branchillemail => 'branchill@nowhere.com',

            branchreplyto => ""

        }

    });

    my $email_branch = $illrq_obj->get_staff_to_address;

    ok(

        $email_branch eq 'branchill@nowhere.com',

        'get_staff_to_address uses branch ILL address when defined'

    );

    #send_staff_notice

    # Specify that no staff notices should be send

    t::lib::Mocks::mock_preference('ILLSendStaffNotices', '');

    my $return_staff_cancel_fail =

        $illrq_obj->send_staff_notice('ILL_REQUEST_CANCEL');

    is_deeply(

        $return_staff_cancel_fail,

        { error => 'notice_not_enabled' },

        "Does not send notices that are not enabled"

    );

    # Specify that the cancel notice can be sent

    t::lib::Mocks::mock_preference('ILLSendStaffNotices', 'ILL_REQUEST_CANCEL');

    my $return_staff_cancel = $illrq_obj->send_staff_notice(

        'ILL_REQUEST_CANCEL'

    );

    my $cancel = $schema->resultset('MessageQueue')->search({

            letter_code => 'ILL_REQUEST_CANCEL',

            message_transport_type => 'email',

            to_address => 'branchill@nowhere.com'

        })->next()->letter_code;

    is_deeply(

        $return_staff_cancel,

        { success => 'notice_queued' },

        "Correct return when staff notice created"

    );

    my $return_staff_fail = $illrq_obj->send_staff_notice();

    is_deeply(

        $return_staff_fail,

        { error => 'notice_no_type' },

        "Correct error when missing type"

    );

    #get_notice

    my $not = $illrq_obj->get_notice({

        notice_code => 'ILL_REQUEST_CANCEL',

        transport   => 'email'

    });

    # We test the properties of the hashref separately because the random

    # hash ordering of the metadata means we can't test the entire thing

    # with is_deeply

    ok(

        $not->{module} eq 'ill',

        'Correct module return from get_notice'

    );

    ok(

        $not->{name} eq 'ILL request cancelled',

        'Correct name return from get_notice'

    );

    ok(

        $not->{message_transport_type} eq 'email',

        'Correct message_transport_type return from get_notice'

    );

    ok(

        $not->{title} eq 'Interlibrary loan request cancelled',

        'Correct title return from get_notice'

    );