package JCRListMarked;
# --------------------------------------------------------------------
#   The copyright and all other proprietary rights in this Database
#   (including software - SEE LICENSING AGREEMENT) are the sole and
#   exclusive property of the Institute for Scientific Information
#   (ISI).  This Database and source code, or any derivative works
#   thereof, are confidential and proprietary to ISI . Therefore,
#   duplication, reuse, redistribution, reverse assembling, reverse
#   compiling, or translation of the Database, source code, or any
#   portion thereof IS NOT PERMITTED.  Consult Licensing Agreement.
# --------------------------------------------------------------------
# $Id: JCRListMarked.pm,v 1.24 2006/07/31 18:31:44 jsims Exp $

use strict;
use Data::Dumper;
use ISIBench;
use JCRErrorList;
use JCRUtil;
use JCR::Journal;
use Log::Log4perl qw(get_logger);
use JCR::MarkedList;
use Toolbar;
use base qq(JCRList);

sub _save_params {
  ISIBench::start();
  my $logger  = get_logger("JCRListMarked");
  my $self    = shift;
  my $args    = (ref $_[0] eq 'HASH') ? shift : { @_ };
  my $session = $self->{session};
  my $request = $self->{request};

  if ((defined $request->{'MARKED.x'}) || (defined $request->{'MARKED.x'})) {
    $logger->debug("Erasing old markedlist parameters...");
    $session->remove(
        'name' => 'marked_sort',
        );
    $session->remove(
        'name' => 'marked_cursor',
        );
  }

# Get/Set the current page and sort order
  my $sort;
  if ($request->{cursor}) {
# Get the current page number
    $self->{summary_cursor} = $request->{cursor};

# Get the current sort order
    $sort = $session->get( 'value' => 'marked_sort' );
    $self->{summary_sort} = $request->{journal_sort_by} || $sort->{marked_sort} || 'title';
  } else {
# No cursor defined, so they must have clicked on the ML button,
# so set the default cursor and sort order.
    $self->{summary_cursor} = 1;
    $self->{summary_sort}   = 'title';
  }
# Save the sort order if needed
  if ($self->{summary_sort} ne $sort->{marked_sort}) {
    $session->set(
        'name'  => 'marked_sort',
        'value' => $self->{summary_sort},
        );
  }

  $logger->debug("Page Cursor is: ", $self->{summary_cursor});
  $logger->debug("Sort order is:  ", $self->{summary_sort});

  ISIBench::stop();
  return 0;
}

sub _get_query {
  ISIBench::start();
  my $logger  = get_logger("JCRListMarked");
  my $self    = shift;
  my $args    = (ref $_[0] eq 'HASH') ? shift : { @_ };
  my $session = $self->{session};
  my $request = $self->{request};
  my ($data, $type);

  ISIBench::stop();
  return { 'type' => 'MarkedList' }; 
}

sub _execute_query {
  ISIBench::start();
  my $logger = get_logger("JCRListMarked");
  my $self = shift;
  my $args = (ref $_[0] eq 'HASH') ? shift : { @_ };
  my $request = $self->{request};
  my $session = $self->{session};

  # Create the new MarkedList object
  my $edition = $session->get( 'value' => 'edition' );
  my $year    = $session->get( 'value' => 'year' );
  my $marked_list = JCR::MarkedList->new(
                                     'session'    => $session,
                                     'max_marked' => $CF::marked_list_max,
                                     'db'         => $self->{db},  
                                     'edition'    => $edition->{edition},
                                     'year'       => $year->{year},
                                   );
  unless (defined($marked_list) && (ref($marked_list) =~ /markedlist/i)) { 
    $logger->debug("Could not create Marked List Object");
    ISIBench::stop();
    return $marked_list;
  }
  # Get the marked list from the DB 
  my $marked = $marked_list->get_marked_list( 'return' => 'array' );
  $logger->debug("Retrieved Marked Journal List: ", sub{Dumper($marked)});

  # Now look up the j20s in the database 
  my $journal = JCR::Journal->new(
                              'db'      => $self->{db},
                              'edition' => $edition->{edition},
                              'year'    => $year->{year},
                            );
  unless (defined($journal) && (ref($journal) =~ /journal/i)) {
    $logger->error("Could not create journal object (#$journal)!");
    ISIBench::stop();
    return $journal;
  }

  my $jlist;
  if ($self->{mode} =~ /save/i && $self->{DISPLAY_ML_ERROR_MSG} != 1) {
    $logger->debug("Getting save marked list selection");
    my $records = $self->_remove_unmarked('marked' => $marked);
    $jlist = $journal->get_journals_by_selection(
                                                   'data'     => $records,
                                                   'mode'     => 'j20', 
                                                   'limit'    => $CF::marked_list_max,
                                                   'order_by' => $self->{summary_sort},
                                                   'page_recs'=> $CF::marked_list_max,
                                                 );
  } elsif ($self->{mode} =~ /print/i && $self->{DISPLAY_ML_ERROR_MSG} != 1) {
    $logger->debug("Getting print marked list selection");
    my $records = $self->_remove_unmarked('marked' => $marked);
    $jlist = $journal->get_journals_by_selection(
                                                   'data'     => $records,
                                                   'mode'     => 'j20', 
                                                   'limit'    => $CF::marked_list_max,
                                                   'order_by' => $self->{summary_sort},
                                                   'page_recs'=> $CF::marked_list_max,
                                                 );
  } else {
    $logger->debug("Getting normal marked list selection");
    $jlist = $journal->get_journals_by_selection(
                                                   'data'     => $marked,
                                                   'mode'     => 'j20', 
                                                   'order_by' => $self->{summary_sort},
                                                   'limit'    => ($self->{summary_cursor}-1) + $CF::recs_per_summary,
                                                   'page_recs'=> $CF::recs_per_summary,
                                                 );
  }
  unless (defined($jlist) && (ref($jlist) =~ /array/i)) {
    $logger->error("Could not retrieve journal list! (#$jlist)");
    ISIBench::stop();
    return $jlist;
  }
  ISIBench::stop();
  return $jlist;
}

sub _execute_count {
  ISIBench::start();
  my $logger  = get_logger("JCRListMarked");
  my $self    = shift;
  my $args    = (ref $_[0] eq 'HASH') ? shift : { @_ };
  my $query   = $args->{query};
  my $session = $self->{session};
  my $edition = $session->get( 'value' => 'edition' );
  my $year    = $session->get( 'value' => 'year' );
  my $count;

  my $marked_list = JCR::MarkedList->new(
                                     'session'    => $session,
                                     'max_marked' => $CF::marked_list_max,
                                     'db'         => $self->{db},  
                                     'edition'    => $edition->{edition},
                                     'year'       => $year->{year},
                                   );
  if (defined($marked_list) && (ref($marked_list) =~ /markedlist/i)) { 
    $count = $marked_list->get_marked_list_count();
  }

  $logger->debug("Execute Count Returned: ", sub{Dumper($count);});
  ISIBench::stop();
  return $count;
}

sub _get_buttons {
  ISIBench::start();
  my $logger = get_logger("JCRListMarked");
  my $self = shift;
  my $args = (ref $_[0] eq 'HASH') ? shift : { @_ };

  # These buttons are in the template due to javascript needs

  ISIBench::stop();
  return {'html' => ''};   
}

sub _process_button_clicks {
  ISIBench::start();
  my $logger  = get_logger("JCRListMarked");
  my $self    = shift;
  my $args    = (ref $_[0] eq 'HASH') ? shift : { @_ };
  my $request = $self->{request};

  my $count = $self->_execute_count($request->{query});

  my $marked = (ref($request->{mark}) =~ /array/i) ? $request->{mark} : [$request->{mark}];
  $logger->debug("Marked Records on Page are: ", sub{Dumper($marked)});
  my $num_marked_recs = scalar(@{$marked});
  if ( $num_marked_recs == 1 ) {
    if ( !defined($marked->[0]) && $count->{count} <= $CF::recs_per_summary ) {
      $num_marked_recs=0;
      $self->{DISPLAY_ML_ERROR_MSG} = 1;
    }
  }

  if (($request->{'CLEAR.x'}>0) || ($request->{'CLEAR.y'}>0)) {
    JCRUtil::purge_marked_list(
                                'session' => $self->{session},
                                'db'      => $self->{db},
                              );
    $self->{mark_template} = 'jcr_marked_list.html';
    $self->{mode} = 'normal';
  } elsif ( $request->{'updateme'} eq "yes" ) {
    $self->_update_marked_list(); 
    $self->{mark_template} = 'jcr_marked_list.html';
    $self->{mode} = 'normal';
  } elsif (($request->{'SAVE.x'}>0) || ($request->{'SAVE.y'}>0)) {
    $self->{mode} = 'save';
    if ( $num_marked_recs == 0 && $count->{count} <= $CF::recs_per_summary ) {
      $self->{mark_template} = 'jcr_marked_list.html';
    } else {
      $self->{mark_template} = 'jcr_marked_save.txt';

      $self->set_header(
                         'name'  => 'Content-type',
                         'value' => 'application/octet-stream',
                       );
      $self->set_header(
                         'name'  => 'Content-disposition',
                         'value' => "attachment; filename=$CF::marked_save_file",
                       );
    }
  } elsif (($request->{'PRINT.x'}>0) || ($request->{'PRINT.y'}>0)) {
    if ( $num_marked_recs == 0 && $count->{count} <= $CF::recs_per_summary ) {
      $self->{mark_template} = 'jcr_marked_list.html';
    } else {
      $self->{mark_template} = 'jcr_marked_print.html';
    }
    $self->{mode} = 'print';
  } else {
    $self->{mark_template} = 'jcr_marked_list.html';
    $self->{mode} = 'normal';
  }
  ISIBench::stop();
}

sub _set_template {
  ISIBench::start();
  my $logger  = get_logger("JCRListMarked");
  my $self    = shift;
  my $args    = (ref $_[0] eq 'HASH') ? shift : { @_ };

  ISIBench::stop();
  return $self->set_template( 'template' => $self->{mark_template} );
}

# Sub to figure out all marked records, excluding any 'unmarked' ones on the current page
sub _remove_unmarked {
  ISIBench::start();
  my $logger  = get_logger("JCRListMarked");
  my $self    = shift;
  my $args    = (ref $_[0] eq 'HASH') ? shift : { @_ };
  my $marked  = $args->{marked};
  my $request = $self->{request};

  # Get a list of all the records on the current page 
  my @page_records = split /,/, $request->{page_records};

  # Now get a list of only the ones that are marked
  my $page_marked  = (ref($request->{mark}) =~ /array/i) ? $request->{mark} : [$request->{mark}];

  # Now build a list of the unmarked records on the current page
  my %dups;
  @dups{@$page_marked} = ();
  my @unmarked = grep { not exists $dups{$_} } @page_records;

  # Now remove the unmarked records from all of the marked records
  %dups = {};
  @dups{@unmarked} = ();
  my @temp_marked = grep { not exists $dups{$_} } @$marked;

  ISIBench::stop();
  return \@temp_marked;
}
1;