if ( defined $csvfilename && $csvfilename =~ /^-/ ) {

sub VERBOSE{

    warn qq(using "$csvfilename" as filename, that seems odd);

    if ($verbose){

        printf STDERR "%s\n", shift;

    }

my @overduebranches    = C4::Overdues::GetBranchcodesWithOverdueRules();	# Branches with overdue rules

if ( defined $csvfilename && $csvfilename =~ /^-/ ) {

my @branches;									# Branches passed as parameter with overdue rules

    warn qq(using "$csvfilename" as filename, that seems odd);

my $branchcount = scalar(@overduebranches);

my $overduebranch_word = scalar @overduebranches > 1 ? 'branches' : 'branch';

my $branchcodes_word = scalar @branchcodes > 1 ? 'branches' : 'branch';

my $PrintNoticesMaxLines = C4::Context->preference('PrintNoticesMaxLines');

if ($branchcount) {

    $verbose and warn "Found $branchcount $overduebranch_word with first message enabled: " . join( ', ', map { "'$_'" } @overduebranches ), "\n";

} else {

    die 'No branches with active overduerules';

        $date_to_run = dt_from_string( $date_input, 'iso' );

        $date_to_run = dt_from_string( $date_input );

    die "$date_input is not a valid date, aborting! Use a date in format YYYY-MM-DD."

    die "$date_input is not a valid date, aborting!"

    if ( $csv->combine(qw(name surname address1 address2 zipcode city country email phone cardnumber itemcount itemsinfo branchname letternumber)) ) {

    if ( $csv->combine(qw(name surname address1 address2 zipcode city country email itemcount itemsinfo)) ) {

        $verbose and warn 'combine failed on argument: ' . $csv->error_input;

        VERBOSE( 'combine failed on argument: ' . $csv->error_input);

    open $fh, ">:encoding(UTF-8)",File::Spec->catdir ($htmlfilename,"notices-".$today->ymd().".html");

    open $fh, ">",File::Spec->catdir ($htmlfilename,"notices-".$today->ymd().".html");

foreach my $branchcode (@branches) {

##

    if ( C4::Context->preference('OverdueNoticeCalendar') ) {

## sql queries

        my $calendar = Koha::Calendar->new( branchcode => $branchcode );

##

        if ( $calendar->is_holiday($date_to_run) ) {

my $sqlIssues = "SELECT biblio.*, items.*, issues.*, biblioitems.itemtype, TO_DAYS($date)-TO_DAYS(date_due) AS days_overdue

            next;

    FROM issues,items,biblio, biblioitems

        }

    WHERE items.itemnumber=issues.itemnumber

    }

    my $branch_details      = C4::Branch::GetBranchDetail($branchcode);

    my $admin_email_address = $branch_details->{'branchemail'}

      || C4::Context->preference('KohaAdminEmailAddress');

    my @output_chunks;    # may be sent to mail or stdout or csv file.

    $verbose and warn sprintf "branchcode : '%s' using %s\n", $branchcode, $admin_email_address;

    my $sth2 = $dbh->prepare( <<"END_SQL" );

SELECT biblio.*, items.*, issues.*, biblioitems.itemtype, TO_DAYS($date)-TO_DAYS(date_due) AS days_overdue, branchname

  FROM issues,items,biblio, biblioitems, branches b

  WHERE items.itemnumber=issues.itemnumber

    AND issues.borrowernumber = ?

    AND TO_DAYS($date)-TO_DAYS(date_due) BETWEEN 1 AND $MAX ";

END_SQL

my $sqlBorrowers = "SELECT issues.borrowernumber, firstname, surname, address, address2, city, zipcode,

    my $query = "SELECT * FROM overduerules WHERE delay1 IS NOT NULL AND branchcode = ? ";

                           country, email, emailpro, B_email, smsalertnumber, borrowers.categorycode

    $query .= " AND categorycode IN (".join( ',' , ('?') x @myborcat ).") " if (@myborcat);

    FROM issues,borrowers,categories

    $query .= " AND categorycode NOT IN (".join( ',' , ('?') x @myborcatout ).") " if (@myborcatout);

    WHERE issues.borrowernumber=borrowers.borrowernumber

    AND borrowers.categorycode=categories.categorycode

    my $rqoverduerules =  $dbh->prepare($query);

    AND TO_DAYS($date)-TO_DAYS(date_due) BETWEEN 1 AND $MAX

    $rqoverduerules->execute($branchcode, @myborcat, @myborcatout);

    AND categories.overduenoticerequired=1 ";

    # We get default rules is there is no rule for this branch

my $sqlRules = "SELECT *

    if($rqoverduerules->rows == 0){

    FROM overduerules

        $query = "SELECT * FROM overduerules WHERE delay1 IS NOT NULL AND branchcode = '' ";

    WHERE delay != 0

        $query .= " AND categorycode IN (".join( ',' , ('?') x @myborcat ).") " if (@myborcat);

    AND letter <> ''

        $query .= " AND categorycode NOT IN (".join( ',' , ('?') x @myborcatout ).") " if (@myborcatout);

    ORDER BY branchcode desc, categorycode desc, itemtype desc, onhold desc, delay desc";

        $rqoverduerules = $dbh->prepare($query);

my $sqlMTT = "SELECT message_transport_type from overduerules_transport_types where overduerules_id = ?";

        $rqoverduerules->execute(@myborcat, @myborcatout);

    }

my $sqlReserves = "SELECT distinct(biblionumber) FROM reserves";

    # my $outfile = 'overdues_' . ( $mybranch || $branchcode || 'default' );

##

    while ( my $overdue_rules = $rqoverduerules->fetchrow_hashref ) {

## customized depending on parameters

      PERIOD: foreach my $i ( 1 .. 3 ) {

##

if(@branchcodes){

            $verbose and warn "branch '$branchcode', categorycode = $overdue_rules->{categorycode} pass $i\n";

    $sqlIssues .= " AND issues.branchcode IN ('" . join ("','", @branchcodes) . "')";

}

if(@myborcat){

    $sqlBorrowers .= " AND borrower.categorycode IN ('" . join ("','", @myborcat) . "')";

}

if(@myborcatout){

    $sqlBorrowers .= " AND borrower.categorycode NOT IN ('" . join ("','", @myborcatout) . "')";

}

            my $mindays = $overdue_rules->{"delay$i"};    # the notice will be sent after mindays days (grace period)

##

            my $maxdays = (

## collect everything in meaningful hashes

                  $overdue_rules->{ "delay" . ( $i + 1 ) }

##

                ? $overdue_rules->{ "delay" . ( $i + 1 ) } - 1

my $hrBorrowers = $dbh->selectall_hashref($sqlBorrowers, 'borrowernumber');

                : ($MAX)

VERBOSE("$sqlBorrowers\nReturned " . (scalar keys $hrBorrowers) . " borrowers with issues.");

            );                                            # issues being more than maxdays late are managed somewhere else. (borrower probably suspended)

my $hrOverdueIssues = $dbh->selectall_hashref($sqlIssues, 'itemnumber' );

VERBOSE("$sqlIssues\nReturned " . (scalar keys $hrOverdueIssues) . " overdue issues.");

my $arRules = $dbh->selectall_arrayref($sqlRules, { Slice => {} } );

VERBOSE("\nRule order:\nId\tBranch\tCat\tItem\tHold\tDelay\tDebarred\tLetter");

foreach my $rule (@$arRules){

    $rule->{mtt} = $dbh->selectcol_arrayref($sqlMTT, undef, $rule->{overduerules_id});

    VERBOSE("$rule->{id}\t$rule->{branchcode}\t$rule->{categorycode}\t$rule->{itemtype}\t$rule->{onhold}\t$rule->{delay}\t$rule->{debarred}\t$rule->{letter}");

}

my $hrReserves = $dbh->selectall_hashref($sqlReserves, 'biblionumber');

VERBOSE("$sqlReserves\nReturned " . (scalar keys $hrReserves) . " unique reserves.");

my %hBranches;

my %hChunks; # messages to send once per branch to the administrator

##

## For each issue, determine the most meaningful rule that applies

## and associate it to the borrower

##

my $whichItemType = C4::Context->preference('item-level_itypes') ? 'itype' : 'itemtype';

foreach my $in (keys $hrOverdueIssues){

    my $issue = $hrOverdueIssues->{$in};

    VERBOSE("Processing issue $in.  branchcode: $issue->{branchcode}, borrower: $issue->{borrowernumber}.");

    foreach my $rule(@$arRules){

        if( ($rule->{branchcode} eq '' || $rule->{branchcode} eq $issue->{branchcode}) &&

            ($rule->{categorycode} eq '' || $rule->{categorycode} eq $hrBorrowers->{$issue->{borrowernumber}}->{categorycode}) &&

            ($rule->{itemtype} eq '' || $rule->{itemtype} eq $issue->{$whichItemType}) &&

            (!$rule->{onhold} || defined $hrReserves->{$issue->{biblionumber}})

          )

        {

            # limit the creation of calendar objects

            if(!defined $hBranches{$issue->{branchcode}}){

                $hBranches{$issue->{branchcode}} = C4::Branch::GetBranchDetail($issue->{branchcode});

                $hBranches{$issue->{branchcode}}{CALENDAR} = Koha::Calendar->new( branchcode => $issue->{branchcode} );

            }

            next unless defined $mindays;

            # validate number of days overdue vs delay

            if ( C4::Context->preference('OverdueNoticeCalendar') ){

                my $days_between = $hBranches{$issue->{branchcode}}{CALENDAR}->days_between( dt_from_string($issue->{date_due}), $date_to_run );

                $issue->{days_overdue} = $days_between->in_units('days');

            }

            next if ( $triggered && $rule->{delay} != $issue->{days_overdue}); # on "triggered". we only look for exact matches

            next if (!$triggered && $rule->{delay} >  $issue->{days_overdue});

            if ( !$overdue_rules->{"letter$i"} ) {

            # validate the letter

                $verbose and warn "No letter$i code for branch '$branchcode'";

            unless(C4::Letters::getletter( 'circulation', $rule->{letter}, $issue->{branchcode} )){

                next PERIOD;

                VERBOSE("Message '$rule->{letter}' content not found");

                last; # if no letter

            # $letter->{'content'} is the text of the mail that is sent.

            # we found the best rule to apply, let's store the branchcode/lettter combo into the borrower

            # this text contains fields that are replaced by their value. Those fields must be written between brackets

            my $arItems = $hrBorrowers->{$issue->{borrowernumber}}{NOTICES}{$issue->{branchcode}}{$rule->{letter}}{ITEMS} ||= [];

            # The following fields are available :

            push $arItems, $issue->{itemnumber};

	    # itemcount is interpreted here as the number of items in the overdue range defined by the current notice or all overdues < max if(-list-all).

            # And note that we union the transport types, so IF the user set two similar alerts (except for delay and mtt), then

            # <date> <itemcount> <firstname> <lastname> <address1> <address2> <address3> <city> <postcode> <country>

            # only one message will be sent to each of the transport specified by both rules together

            my $hrMtts = $hrBorrowers->{$issue->{borrowernumber}}{NOTICES}{$issue->{branchcode}}{$rule->{letter}}{MTTS} ||= {};

            my $borrower_sql = <<'END_SQL';

            foreach my $mtt(@{$rule->{mtt}}){

SELECT issues.borrowernumber, firstname, surname, address, address2, city, zipcode, country, email, emailpro, B_email, smsalertnumber, phone, cardnumber,

                $hrMtts->{$mtt} = 1;

TO_DAYS(?)-TO_DAYS(date_due) as difference, date_due

FROM   issues,borrowers,categories

WHERE  issues.borrowernumber=borrowers.borrowernumber

AND    borrowers.categorycode=categories.categorycode

END_SQL

            my @borrower_parameters;

            push @borrower_parameters, $date_to_run->datetime();

            if ($branchcode) {

                $borrower_sql .= ' AND issues.branchcode=? ';

                push @borrower_parameters, $branchcode;

            if ( $overdue_rules->{categorycode} ) {

            VERBOSE("User $hrBorrowers->{$issue->{borrowernumber}}{surname}, Branch $issue->{branchcode}, Letter $rule->{letter} : Item $issue->{itemnumber}");

                $borrower_sql .= ' AND borrowers.categorycode=? ';

                push @borrower_parameters, $overdue_rules->{categorycode};

            # block the user if needed

            if ( $rule->{"debarred"} ) {

                AddUniqueDebarment({

                    borrowernumber => $issue->{borrowernumber},

                    type           => 'OVERDUES',

                    comment => "Restriction added by overdues process " . output_pref( dt_from_string() ),

                });

                VERBOSE("debarring user $issue->{borrowernumber} (" . $hrBorrowers->{$issue->{borrowernumber}}{surname} . ")");

            $borrower_sql .= '  AND categories.overduenoticerequired=1 ORDER BY issues.borrowernumber';

            last; # we found a rule, let's move to the next issue

        }

            # $sth gets borrower info iff at least one overdue item has triggered the overdue action.

    }

	        my $sth = $dbh->prepare($borrower_sql);

}

            $sth->execute(@borrower_parameters);

            $verbose and warn $borrower_sql . "\n $branchcode | " . $overdue_rules->{'categorycode'} . "\n ($mindays, $maxdays, ".  $date_to_run->datetime() .")\nreturns " . $sth->rows . " rows";

            my $borrowernumber;

            while ( my $data = $sth->fetchrow_hashref ) {

                next unless ( DateTime->compare( $date_to_run,  dt_from_string($data->{date_due})) ) == 1;

                # check the borrower has at least one item that matches

                my $days_between;

                if ( C4::Context->preference('OverdueNoticeCalendar') )

                {

                    my $calendar =

                      Koha::Calendar->new( branchcode => $branchcode );

                    $days_between =

                      $calendar->days_between(  dt_from_string($data->{date_due}),

                        $date_to_run );

                }

                else {

                    $days_between =

                      $date_to_run->delta_days(  dt_from_string($data->{date_due}) );

                }

                $days_between = $days_between->in_units('days');

                if ($triggered) {

                    if ( $mindays != $days_between ) {

                        next;

                    }

                }

                else {

                    unless (   $days_between >= $mindays

                        && $days_between <= $maxdays )

                    {

                        next;

                    }

                }

                if (defined $borrowernumber && $borrowernumber eq $data->{'borrowernumber'}){

# we have already dealt with this borrower

                    $verbose and warn "already dealt with this borrower $borrowernumber";

                    next;

                }

                $borrowernumber = $data->{'borrowernumber'};

                my $borr =

                    $data->{'firstname'} . ', '

                  . $data->{'surname'} . ' ('

                  . $borrowernumber . ')';

                $verbose

                  and warn "borrower $borr has items triggering level $i.";

                @emails_to_use = ();

                my $notice_email =

                    C4::Members::GetNoticeEmailAddress($borrowernumber);

                unless ($nomail) {

                    if (@emails) {

                        foreach (@emails) {

                            push @emails_to_use, $data->{$_} if ( $data->{$_} );

                        }

                    }

                    else {

                        push @emails_to_use, $notice_email if ($notice_email);

                    }

                }

                unless ($letter) {

##

                    $verbose and warn qq|Message '$overdue_rules->{"letter$i"}' content not found|;

## Main loop

##

VERBOSE("Main loop.");

foreach my $borrowernumber(keys $hrBorrowers){

    if(!defined $hrBorrowers->{$borrowernumber}{NOTICES}){

        VERBOSE("User $hrBorrowers->{$borrowernumber}{surname} has no notice.");

        next;

    }

    # for each branch

    foreach my $branchcode (keys $hrBorrowers->{$borrowernumber}{NOTICES}){

        my $admin_email_address = $hBranches{$branchcode}{'branchemail'} || C4::Context->preference('KohaAdminEmailAddress');

        if($hBranches{$branchcode}{CALENDAR}->is_holiday($date_to_run)){

            VERBOSE("$date_to_run is a holiday at branch $branchcode");

            next;

        }

                    # might as well skip while PERIOD, no other borrowers are going to work.

        # for each letter

                    # FIXME : Does this mean a letter must be defined in order to trigger a debar ?

        foreach my $lettercode (keys $hrBorrowers->{$borrowernumber}{NOTICES}{$branchcode}){

                    next PERIOD;

            @emails_to_use = ();

            my $notice_email = C4::Members::GetNoticeEmailAddress($borrowernumber);

            unless ($nomail) {

                if (@emails) {

                    @emails_to_use = @emails;

  #              foreach (@emails) {

#                    push @emails_to_use, $data->{$_} if ( $data->{$_} );

 #               }

                }else{

                    push @emails_to_use, $notice_email if ($notice_email);

            }

                if ( $overdue_rules->{"debarred$i"} ) {

            # finally, the items

                    #action taken is debarring

            my $arItems = $hrBorrowers->{$borrowernumber}{NOTICES}{$branchcode}{$lettercode}{ITEMS};

                    AddUniqueDebarment(

            if(!defined $arItems){

                        {

                VERBOSE("No item for borrower $borrowernumber");

                            borrowernumber => $borrowernumber,

                next;

                            type           => 'OVERDUES',

            }

                            comment => "Restriction added by overdues process "

            my $itemcount = 0;

                              . output_pref( dt_from_string() ),

            my $titles = "";

                        }

            my @items = ();

                    );

                    $verbose and warn "debarring $borr\n";

            my $j = 0;

            my $exceededPrintNoticesMaxLines = 0;

            foreach my $itemnumber(@{$arItems}){

                if ( ( scalar(@emails_to_use) == 0 || $nomail ) && $printNoticesMaxLines && $j >= $printNoticesMaxLines ) {

                    $exceededPrintNoticesMaxLines = 1;

                    last;

                my @params = ($borrowernumber);

                $j++;

                $verbose and warn "STH2 PARAMS: borrowernumber = $borrowernumber";

                my $item = $hrOverdueIssues->{$itemnumber};

                my @item_info = map { $_ =~ /^date|date$/ ? format_date( $item->{$_} ) : $item->{$_} || '' } @item_content_fields;

                $sth2->execute(@params);

                $titles .= join("\t", @item_info) . "\n";

                my $itemcount = 0;

                $itemcount++;

                my $titles = "";

                push @items, $item;

                my @items = ();

            }

                my $j = 0;

                my $exceededPrintNoticesMaxLines = 0;

                while ( my $item_info = $sth2->fetchrow_hashref() ) {

                    next unless ( DateTime->compare( $date_to_run,  dt_from_string($item_info->{date_due})) ) == 1;

                    if ( C4::Context->preference('OverdueNoticeCalendar') ) {

                        my $calendar =

                          Koha::Calendar->new( branchcode => $branchcode );

                        $days_between =

                          $calendar->days_between(

                            dt_from_string( $item_info->{date_due} ), $date_to_run );

                    }

                    else {

                        $days_between =

                          $date_to_run->delta_days(

                            dt_from_string( $item_info->{date_due} ) );

                    }

                    $days_between = $days_between->in_units('days');

                    if ($listall){

                        unless ($days_between >= 1 and $days_between <= $MAX){

                            next;

                        }

                    }

                    else {

                        if ($triggered) {

                            if ( $mindays != $days_between ) {

                                next;

                            }

                        }

                        else {

                            unless ( $days_between >= $mindays

                                && $days_between <= $maxdays )

                            {

                                next;

                            }

                        }

                    }

                    if ( ( scalar(@emails_to_use) == 0 || $nomail ) && $PrintNoticesMaxLines && $j >= $PrintNoticesMaxLines ) {

            # the transport types (email, sms...)

                      $exceededPrintNoticesMaxLines = 1;

            my @message_transport_types = keys $hrBorrowers->{$borrowernumber}{NOTICES}{$branchcode}{$lettercode}{MTTS};

                      last;

            my $print_sent = 0; # A print notice is not yet sent for this patron

                    }

            for my $mtt ( @message_transport_types ) {

                    $j++;

                my $letter = parse_letter( {

                    my @item_info = map { $_ =~ /^date|date$/ ? format_date( $item_info->{$_} ) : $item_info->{$_} || '' } @item_content_fields;

                    letter_code     => $lettercode,

                    $titles .= join("\t", @item_info) . "\n";

                    borrowernumber  => $borrowernumber,

                    $itemcount++;

                    branchcode      => $branchcode,

                    push @items, $item_info;

                    items           => \@items,

                    substitute      => {    # this appears to be a hack to overcome incomplete features in this code.

                                        bib             => $hBranches{$branchcode}{'branchname'}, # maybe 'bib' is a typo for 'lib<rary>'?

                                        'items.content' => $titles,

                                        'count'         => $itemcount,

                                       },

                    message_transport_type => $mtt,

                } );

                unless ($letter) {

                    VERBOSE("Message '$lettercode' content not found (transport $mtt, branch $branchcode)");

                    next;

                    if ( $exceededPrintNoticesMaxLines ) {

                if ( $exceededPrintNoticesMaxLines ) {

                      $letter->{'content'} .= "List too long for form; please check your account online for a complete list of your overdue items.";

                    $letter->{'content'} .= "List too long for form; please check your account online for a complete list of your overdue items.";

                    }

                }

                    my @misses = grep { /./ } map { /^([^>]*)[>]+/; ( $1 || '' ); } split /\</, $letter->{'content'};

                my @misses = grep { /./ } map { /^([^>]*)[>]+/; ( $1 || '' ); } split /\</, $letter->{'content'};

                    if (@misses) {

                if (@misses) {

                        $verbose and warn "The following terms were not matched and replaced: \n\t" . join "\n\t", @misses;

                    VERBOSE( "The following terms were not matched and replaced: \n\t" . join "\n\t", @misses );

                    }

                }

                    if ($nomail) {

                if ($nomail) {

                        push @output_chunks,

                    $hChunks{$admin_email_address} ||= [];

                          prepare_letter_for_printing(

                    push $hChunks{$admin_email_address}, prepare_letter_for_printing( {

                          {   letter         => $letter,

                        letter         => $letter,

                              borrowernumber => $borrowernumber,

                        borrowernumber => $borrowernumber,

                              firstname      => $data->{'firstname'},

                        firstname      => $hrBorrowers->{$borrowernumber}->{'firstname'},

                              lastname       => $data->{'surname'},

                        lastname       => $hrBorrowers->{$borrowernumber}->{'surname'},

                              address1       => $data->{'address'},

                        address1       => $hrBorrowers->{$borrowernumber}->{'address'},

                              address2       => $data->{'address2'},

                        address2       => $hrBorrowers->{$borrowernumber}->{'address2'},

                              city           => $data->{'city'},

                        city           => $hrBorrowers->{$borrowernumber}->{'city'},

                              phone          => $data->{'phone'},

                        postcode       => $hrBorrowers->{$borrowernumber}->{'zipcode'},

                              cardnumber     => $data->{'cardnumber'},

                        country        => $hrBorrowers->{$borrowernumber}->{'country'},

                              branchname     => $branch_details->{'branchname'},

                        email          => $notice_email,

                              letternumber   => $i,

                        itemcount      => $itemcount,

                              postcode       => $data->{'zipcode'},

                        titles         => $titles,

                              country        => $data->{'country'},

                        outputformat   => defined $csvfilename ? 'csv' : defined $htmlfilename ? 'html' : defined $text_filename ? 'text' : '',

                              email          => $notice_email,

                    } );

                              itemcount      => $itemcount,

                } else {

                              titles         => $titles,

                    if ( ($mtt eq 'email' and not scalar @emails_to_use) or ($mtt eq 'sms' and not $hrBorrowers->{$borrowernumber}->{smsalertnumber}) ) {

                              outputformat   => defined $csvfilename ? 'csv' : defined $htmlfilename ? 'html' : defined $text_filename ? 'text' : '',

                        # email or sms is requested but not exist, do a print.

                        $mtt = 'print';

                    }

                    unless ( $mtt eq 'print' and $print_sent == 1 ) {

                        # Just sent a print if not already done.

                        C4::Letters::EnqueueLetter(

                            {   letter                 => $letter,

                                borrowernumber         => $borrowernumber,

                                message_transport_type => $mtt,

                                from_address           => $admin_email_address,

                                to_address             => join(',', @emails_to_use),

                          );

                        );

                    } else {

                        # A print notice should be sent only once per overdue level.

                        if ( ($mtt eq 'email' and not scalar @emails_to_use) or ($mtt eq 'sms' and not $data->{smsalertnumber}) ) {

                        # Without this check, a print could be sent twice or more if the library checks sms and email and print and the patron has no email or sms number.

                            # email or sms is requested but not exist, do a print.

                        $print_sent = 1 if $mtt eq 'print';

                            $mtt = 'print';

                            push @output_chunks,

                              prepare_letter_for_printing(

                              {   letter         => $letter,

                                  borrowernumber => $borrowernumber,

                                  firstname      => $data->{'firstname'},

                                  lastname       => $data->{'surname'},

                                  address1       => $data->{'address'},

                                  address2       => $data->{'address2'},

                                  city           => $data->{'city'},

                                  postcode       => $data->{'zipcode'},

                                  country        => $data->{'country'},

                                  email          => $notice_email,

                                  itemcount      => $itemcount,

                                  titles         => $titles,

                                  outputformat   => defined $csvfilename ? 'csv' : defined $htmlfilename ? 'html' : defined $text_filename ? 'text' : '',

                                }

                              );

                        }

                        unless ( $mtt eq 'print' and $print_sent == 1 ) {

                            # Just sent a print if not already done.

                            C4::Letters::EnqueueLetter(

                                {   letter                 => $letter,

                                    borrowernumber         => $borrowernumber,

                                    message_transport_type => $mtt,

                                    from_address           => $admin_email_address,

                                    to_address             => join(',', @emails_to_use),

                                }

                            );

                            # A print notice should be sent only once per overdue level.

                            # Without this check, a print could be sent twice or more if the library checks sms and email and print and the patron has no email or sms number.

                            $print_sent = 1 if $mtt eq 'print';

                        }

    if (@output_chunks) {

foreach my $admin_email_address (keys %hChunks) {

        if ( defined $csvfilename ) {

    my @output_chunks = @{$hChunks{$admin_email_address}};

            print $csv_fh @output_chunks;        

    if ( defined $csvfilename ) {

        }

        print $csv_fh @output_chunks;

        elsif ( defined $htmlfilename ) {

    }

            print $fh @output_chunks;        

    elsif ( defined $htmlfilename ) {

        }

        print $fh @output_chunks;

        elsif ( defined $text_filename ) {

    }

            print $fh @output_chunks;        

    elsif ( defined $text_filename ) {

        }

        print $fh @output_chunks;

        elsif ($nomail){

    }

                local $, = "\f";    # pagebreak

    elsif ($nomail){

                print @output_chunks;

        local $, = "\f";    # pagebreak

        }

        print @output_chunks;

        # Generate the content of the csv with headers

    }

        my $content;

    # Generate the content of the csv with headers

        if ( defined $csvfilename ) {

    my $content;

            my $delimiter = C4::Context->preference('delimiter') || ';';

    if ( defined $csvfilename ) {

            $content = join($delimiter, qw(title name surname address1 address2 zipcode city country email itemcount itemsinfo due_date issue_date)) . "\n";

        my $delimiter = C4::Context->preference('delimiter') || ';';

        }

        $content = join($delimiter, qw(title name surname address1 address2 zipcode city country email itemcount itemsinfo due_date issue_date)) . "\n";

        else {

            $content = "";

        }

        $content .= join( "\n", @output_chunks );

        my $attachment = {

            filename => defined $csvfilename ? 'attachment.csv' : 'attachment.txt',

            type => 'text/plain',

            content => $content, 

        };

        my $letter = {

            title   => 'Overdue Notices',

            content => 'These messages were not sent directly to the patrons.',

        };

        C4::Letters::EnqueueLetter(

            {   letter                 => $letter,

                borrowernumber         => undef,

                message_transport_type => 'email',

                attachments            => [$attachment],

                to_address             => $admin_email_address,

            }

        );

  print $fh "</body>\n";

    print $fh "</body>\n";

  print $fh "</html>\n";

    print $fh "</html>\n";

  close $fh;

    close $fh;

  close $fh;

    close $fh;

                $params->{'city'}, $params->{'country'}, $params->{'email'}, $params->{'phone'}, $params->{'cardnumber'},

                $params->{'city'}, $params->{'country'}, $params->{'email'}, $params->{'itemcount'}, $params->{'titles'}

                $params->{'itemcount'}, $params->{'titles'}, $params->{'branchname'}, $params->{'letternumber'}