# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.

package Bugzilla::Attachment::PatchReader;

use 5.10.1;
use strict;
use warnings;

use Config;
use IO::Select;
use IPC::Open3;
use Symbol 'gensym';

use Bugzilla::Error;
use Bugzilla::Attachment;
use Bugzilla::Util;

use constant PERLIO_IS_ENABLED => $Config{useperlio};

sub process_diff {
  my ($attachment, $format) = @_;
  my $dbh  = Bugzilla->dbh;
  my $cgi  = Bugzilla->cgi;
  my $lc   = Bugzilla->localconfig;
  my $vars = {};

  require PatchReader::Raw;
  my $reader = new PatchReader::Raw;

  if ($format eq 'raw') {
    require PatchReader::DiffPrinter::raw;
    $reader->sends_data_to(new PatchReader::DiffPrinter::raw());

    # Actually print out the patch.
    print $cgi->header(-type => 'text/plain');
    disable_utf8();
    $reader->iterate_string('Attachment ' . $attachment->id, $attachment->data);
  }
  else {
    my @other_patches = ();
    if ($lc->{interdiffbin} && $lc->{diffpath}) {

      # Get the list of attachments that the user can view in this bug.
      my @attachments
        = @{Bugzilla::Attachment->get_attachments_by_bug($attachment->bug)};

      # Extract patches only.
      @attachments = grep { $_->ispatch == 1 } @attachments;

      # We want them sorted from newer to older.
      @attachments = sort { $b->id <=> $a->id } @attachments;

      # Ignore the current patch, but select the one right before it
      # chronologically.
      my $select_next_patch = 0;
      foreach my $attach (@attachments) {
        if ($attach->id == $attachment->id) {
          $select_next_patch = 1;
        }
        else {
          push(
            @other_patches,
            {
              'id'       => $attach->id,
              'desc'     => $attach->description,
              'selected' => $select_next_patch
            }
          );
          $select_next_patch = 0;
        }
      }
    }

    $vars->{'bugid'}         = $attachment->bug_id;
    $vars->{'attachid'}      = $attachment->id;
    $vars->{'description'}   = $attachment->description;
    $vars->{'other_patches'} = \@other_patches;

    setup_template_patch_reader($reader, $vars);

    # The patch is going to be displayed in a HTML page and if the utf8
    # param is enabled, we have to encode attachment data as utf8.
    if (Bugzilla->params->{'utf8'}) {
      $attachment->data;    # Populate ->{data}
      utf8::decode($attachment->{data});
    }
    $reader->iterate_string('Attachment ' . $attachment->id, $attachment->data);
  }
}

sub process_interdiff {
  my ($old_attachment, $new_attachment, $format) = @_;
  my $cgi  = Bugzilla->cgi;
  my $lc   = Bugzilla->localconfig;
  my $vars = {};

  require PatchReader::Raw;

  # Encode attachment data as utf8 if it's going to be displayed in a HTML
  # page using the UTF-8 encoding.
  if ($format ne 'raw' && Bugzilla->params->{'utf8'}) {
    $old_attachment->data;    # Populate ->{data}
    utf8::decode($old_attachment->{data});
    $new_attachment->data;    # Populate ->{data}
    utf8::decode($new_attachment->{data});
  }

  # Get old patch data.
  my ($old_filename, $old_file_list) = get_unified_diff($old_attachment, $format);

  # Get new patch data.
  my ($new_filename, $new_file_list) = get_unified_diff($new_attachment, $format);

  my $warning = warn_if_interdiff_might_fail($old_file_list, $new_file_list);

  # Send through interdiff, send output directly to template.
  # Must hack path so that interdiff will work.
  local $ENV{'PATH'} = $lc->{diffpath};

  # Open the interdiff pipe, reading from both STDOUT and STDERR
  # To avoid deadlocks, we have to read the entire output from all handles
  my ($stdout, $stderr) = ('', '');
  my ($pid, $interdiff_stdout, $interdiff_stderr, $use_select);
  if ($ENV{MOD_PERL}) {
    require Apache2::RequestUtil;
    require Apache2::SubProcess;
    my $request = Apache2::RequestUtil->request;
    (undef, $interdiff_stdout, $interdiff_stderr)
      = $request->spawn_proc_prog($lc->{interdiffbin},
      [$old_filename, $new_filename]);
    $use_select = !PERLIO_IS_ENABLED;
  }
  else {
    $interdiff_stderr = gensym;
    $pid = open3(gensym, $interdiff_stdout, $interdiff_stderr, $lc->{interdiffbin},
      $old_filename, $new_filename);
    $use_select = 1;
  }

  if ($format ne 'raw' && Bugzilla->params->{'utf8'}) {
    binmode $interdiff_stdout, ':utf8';
    binmode $interdiff_stderr, ':utf8';
  }
  else {
    binmode $interdiff_stdout;
    binmode $interdiff_stderr;
  }

  if ($use_select) {
    my $select = IO::Select->new();
    $select->add($interdiff_stdout, $interdiff_stderr);
    while (my @handles = $select->can_read) {
      foreach my $handle (@handles) {
        my $line = <$handle>;
        if (!defined $line) {
          $select->remove($handle);
          next;
        }
        if ($handle == $interdiff_stdout) {
          $stdout .= $line;
        }
        else {
          $stderr .= $line;
        }
      }
    }
    waitpid($pid, 0) if $pid;

  }
  else {
    local $/ = undef;
    $stdout = <$interdiff_stdout>;
    $stdout //= '';
    $stderr = <$interdiff_stderr>;
    $stderr //= '';
  }

  close($interdiff_stdout), close($interdiff_stderr);

  # Tidy up
  unlink($old_filename) or warn "Could not unlink $old_filename: $!";
  unlink($new_filename) or warn "Could not unlink $new_filename: $!";

  # Any output on STDERR means interdiff failed to full process the patches.
  # Interdiff's error messages are generic and not useful to end users, so we
  # show a generic failure message.
  if ($stderr) {
    warn($stderr);
    $warning = 'interdiff3';
  }

  my $reader = new PatchReader::Raw;

  if ($format eq 'raw') {
    require PatchReader::DiffPrinter::raw;
    $reader->sends_data_to(new PatchReader::DiffPrinter::raw());

    # Actually print out the patch.
    print $cgi->header(-type => 'text/plain');
    disable_utf8();
  }
  else {
    $vars->{'warning'}  = $warning if $warning;
    $vars->{'bugid'}    = $new_attachment->bug_id;
    $vars->{'oldid'}    = $old_attachment->id;
    $vars->{'old_desc'} = $old_attachment->description;
    $vars->{'newid'}    = $new_attachment->id;
    $vars->{'new_desc'} = $new_attachment->description;

    setup_template_patch_reader($reader, $vars);
  }
  $reader->iterate_string(
    'interdiff #' . $old_attachment->id . ' #' . $new_attachment->id, $stdout);
}

######################
#  Internal routines
######################

sub get_unified_diff {
  my ($attachment, $format) = @_;

  # Bring in the modules we need.
  require PatchReader::Raw;
  require PatchReader::DiffPrinter::raw;
  require PatchReader::PatchInfoGrabber;
  require File::Temp;

  $attachment->ispatch
    || ThrowCodeError('must_be_patch', {'attach_id' => $attachment->id});

  # Reads in the patch, converting to unified diff in a temp file.
  my $reader      = new PatchReader::Raw;
  my $last_reader = $reader;

  # Grabs the patch file info.
  my $patch_info_grabber = new PatchReader::PatchInfoGrabber();
  $last_reader->sends_data_to($patch_info_grabber);
  $last_reader = $patch_info_grabber;

  # Prints out to temporary file.
  my ($fh, $filename) = File::Temp::tempfile();
  if ($format ne 'raw' && Bugzilla->params->{'utf8'}) {

    # The HTML page will be displayed with the UTF-8 encoding.
    binmode $fh, ':utf8';
  }
  my $raw_printer = new PatchReader::DiffPrinter::raw($fh);
  $last_reader->sends_data_to($raw_printer);
  $last_reader = $raw_printer;

  # Iterate!
  $reader->iterate_string($attachment->id, $attachment->data);

  return ($filename, $patch_info_grabber->patch_info()->{files});
}

sub warn_if_interdiff_might_fail {
  my ($old_file_list, $new_file_list) = @_;

  # Verify that the list of files diffed is the same.
  my @old_files = sort keys %{$old_file_list};
  my @new_files = sort keys %{$new_file_list};
  if (@old_files != @new_files || join(' ', @old_files) ne join(' ', @new_files))
  {
    return 'interdiff1';
  }

  # Verify that the revisions in the files are the same.
  foreach my $file (keys %{$old_file_list}) {
    if ( exists $old_file_list->{$file}{old_revision}
      && exists $new_file_list->{$file}{old_revision}
      && $old_file_list->{$file}{old_revision} ne
      $new_file_list->{$file}{old_revision})
    {
      return 'interdiff2';
    }
  }
  return undef;
}

sub setup_template_patch_reader {
  my ($last_reader, $vars) = @_;
  my $cgi      = Bugzilla->cgi;
  my $template = Bugzilla->template;

  require PatchReader::DiffPrinter::template;

  # Define the vars for templates.
  if (defined $cgi->param('headers')) {
    $vars->{'headers'} = $cgi->param('headers');
  }
  else {
    $vars->{'headers'} = 1;
  }

  $vars->{'collapsed'} = $cgi->param('collapsed');

  # Print everything out.
  print $cgi->header(-type => 'text/html');

  $last_reader->sends_data_to(new PatchReader::DiffPrinter::template(
    $template,                        'attachment/diff-header.html.tmpl',
    'attachment/diff-file.html.tmpl', 'attachment/diff-footer.html.tmpl',
    $vars
  ));
}

1;

__END__

=head1 B<Methods in need of POD>

=over

=item get_unified_diff

=item process_diff

=item warn_if_interdiff_might_fail

=item setup_template_patch_reader

=item process_interdiff

=back
