package LIMS::Controller::PrintRun;

use base 'LIMS::Base';
use LIMS::Local::Utils;
use File::Find::Rule; # find()
use Data::Dumper;

use Moose;
with (
    'LIMS::Controller::Roles::PDF',
    'LIMS::Controller::Roles::DataMap',
    'LIMS::Controller::Roles::DataFile', # get_destination_dir()
    'LIMS::Controller::Roles::RecordHandler',
	'LIMS::Controller::Roles::ResultHandler',
);

has reports => (
    is      => 'ro',
    isa     => 'ArrayRef[HashRef]',
    default => sub { [] },
    lazy    => 1,
	traits  => ['Array'],
	handles => {
		add_to_reports => 'push',
        clear_all_reports => 'clear',
	},
);
__PACKAGE__->meta->make_immutable(inline_constructor => 0);

#-------------------------------------------------------------------------------
sub default : StartRunmode {
    my $self = shift; $self->_debug_path($self->get_current_runmode);

	return $self->forbidden() unless $self->user_can('print_all');

    my $cfg = $self->cfg; # warn Dumper $cfg;
    { # load url if pre-formatted pdf (from print_run.pl cron) present:
        my $local_path = sprintf 'docs/%s/print_run/printrun_%s.pdf',
            $cfg->{settings}->{'_centre'},
            LIMS::Local::Utils::today->ymd; # warn $local_path;
        my $full_path = $cfg->{path_to_www_docs} . $local_path; # warn $full_path;
        $self->tt_params( printrun_pdf => $local_path ) if -e $full_path;
    }
    my $last_working_day = $self->_get_last_working_day();
    return $self->tt_process({ auth_date => $last_working_day });
}

#-------------------------------------------------------------------------------
sub do : Runmode {
    my $self = shift; $self->_debug_path($self->get_current_runmode);

    # get start & end datetime objects:
    my $start_date = $self->_get_start_date; # warn Dumper $start_date->datetime;
    my $end_date   = $self->_get_end_date;   # warn Dumper $end_date->datetime;

    # first find out how many have been requested:
    my $count = do {
        my %args = (
            start_date => $start_date,
            end_date   => $end_date,
            type       => 'non-trial', # only skips trial cases if configured in yml
        );
        $self->model('PrintRun')->get_print_run_size(\%args);
    }; # warn $count;
    if (! $count) {
        $self->flash( info => $self->messages('search')->{no_records_found} );
        return $self->redirect( $self->query->url . '/printrun' );
    }
    # if more than max print_run size (defined in settings), split load:
    elsif ($count > $self->cfg('settings')->{print_run_max}) {
        my %args = (
            count => $count,
            start_date => $start_date,
            # $end defaults to 00:00:00 on current_date (unless use_today selected)
            end_date => $end_date->subtract(seconds => 1), # so subtract 1 sec for .tt param
        );
        return $self->tt_process(\%args);
    }
    else {
		$self->stash( date_span => { start => $start_date, end => $end_date } );
        return $self->forward('_do_print'); # forward so tt picks up 'print' in runmode
    }
}

#-------------------------------------------------------------------------------
# converts form start & end date strings back to DT objects, forwards to _do_print():
sub do_offset : Runmode {
    my $self = shift; $self->_debug_path($self->get_current_runmode);

    my $p = $self->query->Vars();

    # to_datetime_using_parsedate() seems to work:
#    my $start = LIMS::Local::Utils::to_datetime_using_parsedate($p->{start});
#    my $end   = LIMS::Local::Utils::to_datetime_using_parsedate($p->{end});

    # to_datetime_using_strptime() config'd to use supplied pattern:
	my $dt = sub { # datetime string eg 2010-01-01T00:00:00
		LIMS::Local::Utils::to_datetime_using_strptime(@_, '%FT%T');
	};
	my $start = &$dt($p->{start}); # warn $start->datetime;
	my $end   = &$dt($p->{end});   # warn $end->datetime;
	$self->stash( date_span => { start => $start, end => $end } );

    my $content = $self->forward('_do_print'); # forward so tt picks up 'print' in runmode
    return $content;
}

#-------------------------------------------------------------------------------
sub _do_print : Runmode { # rm so template picks up 'print' in get_current_runmode
    my $self = shift; $self->_debug_path($self->get_current_runmode);

    my @sort_by = qw(referrers.name requests.year requests.request_number);
	my $dates   = $self->stash->{date_span};

    my %args = (
        start_date => $dates->{start},
        end_date   => $dates->{end},
        sort_by    => \@sort_by,
        type       => 'non-trial', # only skips trial requests if configured to do so in yml
    );
    #  offset supplied if total > max print_run size:
    $args{offset} = $self->query->param('offset') || 0; # default to beginning
    $args{limit}  = $self->cfg('settings')->{print_run_max} || 50; # sensible default

    # get request id's & cc's for records amended between start & end datetimes:
    my ( $request_ids, $ccs ) # = [298446, 298961]; # outreach & imatinib charts + 1 copy_to
        = $self->model('PrintRun')->get_print_run_request_ids(\%args);
    unless (@$request_ids) { # should never get here - count checked in do()
        $self->flash( info => $self->messages('search')->{no_records_found} );
        return $self->redirect( $self->query->url . '/printrun' );
    }
    # do we want to append supplimentary pdf's:
    my $supplimentary_filenames
        = $self->get_yaml_file('supplimentary_report_files');
    # warn Dumper $supplimentary_filenames;
    for my $request_id (@$request_ids) {
        # format request data for template:
        my $request_data = $self->get_single_request_data($request_id);
		# add processed lab test data to $request_data:
		$self->process_raw_lab_test_data($request_data);
        $self->add_to_reports($request_data); # warn Dumper $request_data;
        # add any supplimentary pdf's to args:
        if ( $supplimentary_filenames ) { # warn Dumper $filenames;
            my $request = $request_data->{data}->as_tree;
            my $pdf_dir = $self->_get_destination_dir($request); # warn $pdf_dir;
            my $regex = join '|', map quotemeta, @$supplimentary_filenames;
            # use File::Find::Rule procedural interface to find files matching pattern:
            my @files = find( 'file', name => qr{$regex}i, in => $pdf_dir );
            # check supplimentary files are pdf's:
            push @{ $args{supplimentary_files}{$request_id} },
                grep { lc io($_)->ext eq 'pdf' } @files;
        }
    } # warn Dumper $args{supplimentary_files};
    # copy-tos:
    for my $request_id (@$ccs) {
        my $request_data = $self->get_single_request_data($request_id);
        $self->process_raw_lab_test_data($request_data);
        my $copy = $self->_generate_copy($request_data);
        $self->add_to_reports($copy);
    }

    $ENV{REPORT_HTML} = undef if $ENV{PDF_REPORT}; # PDF_REPORT env overrides REPORT_HTML env
	if ($ENV{REPORT_HTML}) { # for lims_server and/or no PDF reader
        my $tmpl = 'record/default.tt';
        return $self->render_view($tmpl, { reports => $self->reports });
    }
    # combine pdfs into single:
    my $content = $self->combine_pdfs($self->reports, \%args);
    $self->clear_all_reports; # maybe free some memory ??
    # return single pdf:
    $self->header_add(-type => 'application/pdf', -expires => 'now');
    return $content;
}

=begin
sub _do_print_old {
    my ($self, $start, $end) = @_; $self->_debug_path();

    my @sort_by = qw(referrers.name requests.year requests.request_number);

    my %args = (
        start_date => $start,
        end_date   => $end,
        sort_by    => \@sort_by,
    );

    # exclude any locations which don't require paper copies:
    if ( my $cfg = $self->get_yaml_file('skip_paper_reports') ) {
        $args{skip_reports} = $cfg;
    } # warn Dumper \%args;

    #  offset supplied if total > max print_run size (maybe '0' so use defined):
    # if ( defined $self->query->param('offset') ) { # always submitted now
        $args{offset} = $self->query->param('offset') || 0; # default to beginning
        $args{limit}  = $self->cfg('settings')->{print_run_max} || 50; # sensible default
    # }

    # get request id's for records amended between start & end datetimes:
    my $request_ids
        = $self->model('PrintRun')->get_print_run_request_ids(\%args);

    unless (@$request_ids) { # should never get here - count checked in do()
        $self->flash( info => $self->messages('search')->{no_records_found} );
        return $self->redirect( $self->query->url . '/printrun' );
    }

	# allowed report error_codes:
	my $report_error_codes = $self->report_error_codes_map;

    # diagnosis_context_warnings:
	my $context_warning = $self->diagnosis_context_warning_map;

    # categories exempt from 'use NHS number':
    my $nhs_number_exempt = $self->nhs_number_exempt;

	# preserve 'app_url' & 'active_link' tt_params for use in loop:
	my %required_tt_params = map {
		$_ => $self->tt_params->{$_};
	} qw(app_url active_link);

	# my $i;
    foreach my $request_id (@$request_ids) { # last if $i++ > 1; # for testing
        # format request data for template:
        my $request_data = $self->format_print_record_request_data($request_id); # warn Dumper $request_id;
        # add data maps for template:
		$self->tt_params(
            context_warning_map => $context_warning,
            nhs_number_exempt   => $nhs_number_exempt,
            report_error_codes  => $report_error_codes,
            request             => $request_data,
        );
        # template depends on whether it's outreach data:
        my $tmpl = $request_data->{outreach}
            ? 'outreach/report_body.tt'
            : 'record/body.tt'; # warn $tmpl;

        # render template & add to 'reports' attr:
        my $html = $self->render_view($tmpl);
        $self->add_to_reports($$html); # dereference first

        { # has copy_to been requested?
            my $request_options = $request_data->{request_options};
            # warn Dumper $request_options;
            if ( $request_options->{copy_to}->{is_selected} ) {
                my $cc = $self->_generate_copy($html);
                $self->add_to_reports($cc); # already deref'ed
            }
        }
        $self->tt_clear_params; # clear all template params for next loop
		$self->tt_params(\%required_tt_params); # add required ones back
    }

    return $self->tt_process('printrun/wrapper.tt', { reports => $self->reports });
}
=cut
#-------------------------------------------------------------------------------
sub _generate_copy {
    my ($self, $ref) = @_; $self->_debug_path();

	# clone() of $ref generates thousands of warning msgs in Devel::Cycle
    # (ie dev server), caused by presence of a LIMS::DB object (OK if as_tree'd):
#	my $clone = LIMS::Local::Utils::clone($ref); $self->debug($clone);

    # take hash copy of $ref so original unaffected:
    my %h = %$ref;

    # take %h LIMS::DB::Request 'data' object into a hashref and clone it:
    my $data = $h{data}; # warn ref $data; # LIMS::DB::Request object
    # clone hashref NOT object - vital to prevent Devel::Cycle warnings:
    my $cloned = LIMS::Local::Utils::clone( $data->as_tree(deflate => 0) );

    # replace referrer name with 'cc' flag for template:
    $cloned->{referrer_department}->{referrer}->{name} = 'cc'; # warn Dumper $clone;
    # replace original $h{data} DB::Request object with cloned hashref (OK for tt):
    $h{data} = $cloned;
    # return %h as hashref, same as original $ref, but with referrer name changed:
    return \%h;
}

#-------------------------------------------------------------------------------
sub _get_start_date {
    my $self = shift; $self->_debug_path();

    my $q = $self->query;

    my $datetime;

    # expect params 'last_working_day' OR 'date', and optional 'today':
    if ( $q->param('last_working_day') ) {
        $datetime = $self->_get_last_working_day();
    }
    elsif ( my $date = $q->param('date') ) {
        $datetime = LIMS::Local::Utils::to_datetime_using_datecalc($date)
        || return $self->error("cannot decode date-string $date");
    } # warn Dumper $datetime;

    # in case start date not supplied (beginning of day 00:00:00):
    $datetime ||= LIMS::Local::Utils::time_now->truncate( to => 'day' );
    return $datetime;
}

#-------------------------------------------------------------------------------
sub _get_end_date {
    my $self = shift; $self->_debug_path();

    my $datetime = LIMS::Local::Utils::time_now(); # up to current time (BST-aware)
    # end date is today - 1 day, unless 'today' selected (query uses ymd so
    # includes full day to midnight):
    return $self->query->param('today')
        ? $datetime
        : $datetime->subtract( days => 1 );
}

#-------------------------------------------------------------------------------
sub _get_last_working_day { # considers public holidays
    my $self = shift; $self->_debug_path();

    # function moved to LLU (returns DT object):
    return LIMS::Local::Utils::last_working_date(); # considers public hols
=begin
    my $dt = DateTime->today->subtract( days => 1 ); # yesterday at 00:00:00

    # day 6 is Saturday, day 7 is Sunday
    while ( $dt->day_of_week >= 6 ) {
        $dt->subtract( days => 1 );
    } # warn Dumper $dt;
    return $dt;
=cut
}

1;