#!/usr/bin/perl -T
# 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.

##############################################################################
#
# enter_bug.cgi
# -------------
# Displays bug entry form. Bug fields are specified through popup menus,
# drop-down lists, or text fields. Default for these values can be
# passed in as parameters to the cgi.
#
##############################################################################

use 5.10.1;
use strict;
use warnings;

use lib qw(. lib);

use Bugzilla;
use Bugzilla::Constants;
use Bugzilla::Util;
use Bugzilla::Error;
use Bugzilla::Bug;
use Bugzilla::Hook;
use Bugzilla::Classification;
use Bugzilla::Token;
use Bugzilla::Field;
use Bugzilla::Status;
use Bugzilla::UserAgent;

use List::MoreUtils qw(none);

my $user = Bugzilla->login(LOGIN_REQUIRED);

my $cloned_bug;
my $cloned_bug_id;

my $cgi      = Bugzilla->cgi;
my $dbh      = Bugzilla->dbh;
my $template = Bugzilla->template;
my $vars     = {};

# All pages point to the same part of the documentation.
$vars->{'doc_section'} = 'using/filing.html';

my $product_name = trim($cgi->param('product') || '');

# Will contain the product object the bug is created in.
my $product;

if ($product_name eq '') {

  # If the user cannot enter bugs in any product, stop here.
  my @enterable_products = @{$user->get_enterable_products};
  ThrowUserError('no_products') unless scalar(@enterable_products);

  my $classification
    = Bugzilla->params->{'useclassification'}
    ? scalar($cgi->param('classification'))
    : '__all';

  # Unless a real classification name is given, we sort products
  # by classification.
  my @classifications;

  unless ($classification && $classification ne '__all') {
    @classifications = @{sort_products_by_classification(\@enterable_products)};
  }

  unless ($classification) {

    # We know there is at least one classification available,
    # else we would have stopped earlier.
    if (scalar(@classifications) > 1) {

      # We only need classification objects.
      $vars->{'classifications'} = [map { $_->{'object'} } @classifications];

      $vars->{'target'} = "enter_bug.cgi";

      print $cgi->header();
      $template->process("global/choose-classification.html.tmpl", $vars)
        || ThrowTemplateError($template->error());
      exit;
    }

    # If we come here, then there is only one classification available.
    $classification = $classifications[0]->{'object'}->name;
  }

  # Keep only enterable products which are in the specified classification.
  if ($classification ne "__all") {
    my $class = new Bugzilla::Classification({'name' => $classification});

    # If the classification doesn't exist, then there is no product in it.
    if ($class) {
      @enterable_products
        = grep { $_->classification_id == $class->id } @enterable_products;
      @classifications = ({object => $class, products => \@enterable_products});
    }
    else {
      @enterable_products = ();
    }
  }

  if (scalar(@enterable_products) == 0) {
    ThrowUserError('no_products');
  }
  elsif (scalar(@enterable_products) > 1) {
    $vars->{'classifications'} = \@classifications;
    $vars->{'target'}          = "enter_bug.cgi";

    print $cgi->header();
    $template->process("global/choose-product.html.tmpl", $vars)
      || ThrowTemplateError($template->error());
    exit;
  }
  else {
    # Only one product exists.
    $product = $enterable_products[0];
  }
}

# We need to check and make sure that the user has permission
# to enter a bug against this product.
$product = $user->can_enter_product($product || $product_name, THROW_ERROR);

##############################################################################
# Useful Subroutines
##############################################################################
sub formvalue {
  my ($name, $default) = (@_);
  return Bugzilla->cgi->param($name) || $default || "";
}

##############################################################################
# End of subroutines
##############################################################################

my $has_editbugs   = $user->in_group('editbugs',   $product->id);
my $has_canconfirm = $user->in_group('canconfirm', $product->id);

# If a user is trying to clone a bug
#   Check that the user has authorization to view the parent bug
#   Create an instance of Bug that holds the info from the parent
$cloned_bug_id = $cgi->param('cloned_bug_id');

if ($cloned_bug_id) {
  $cloned_bug    = Bugzilla::Bug->check($cloned_bug_id);
  $cloned_bug_id = $cloned_bug->id;
}

## REDHAT EXTENSION START 2004788
## Skip this as it's never true and it caches massive component lists
# If there is only one active component, choose it
my @active; # = grep { $_->is_active } @{$product->components};
#if (scalar(@active) == 1) {
#  $cgi->param('component', $active[0]->name);
#}
## REDHAT EXTENSION END 2004788

# If there is only one active version, choose it
@active = grep { $_->is_active } @{$product->versions};
if (scalar(@active) == 1) {
  $cgi->param('version', $active[0]->name);
}

## REDHAT EXTENSION START 576320
my @sorted_components;
if (0) {    ## REDHAT EXTENSION START 2004788
## Skip this as it's done via AJAX and it caches massive component lists
  if (
    $product->component_count > 1
    && grep(lc($_->name) eq 'distribution' || lc($_->name) eq 'unspecified',
      @{$product->components})
    )
  {
    my @top_comps;
    foreach my $comp (@{$product->components}) {
      if (lc($comp->name) eq 'distribution' || lc($comp->name) eq 'unspecified') {
        push(@top_comps, $comp);
        next;
      }
      push(@sorted_components, $comp);
    }
    unshift @sorted_components, @top_comps if @top_comps;
  }
  else {
    @sorted_components = @{$product->components};
  }
}    ## REDHAT EXTENSION END 2004788

## REDHAT EXTENSION START 2004788
## If a component is supplied only load it
if (formvalue('component')) {
  my $comp = Bugzilla::Component->new(
    {product => $product, name => formvalue('component')});

  if ($comp) {
    push(@sorted_components, $comp);
  }
}
## REDHAT EXTENSION END 2004788

$vars->{'sorted_components'} = \@sorted_components;
## REDHAT EXTENSION END 576320

my %default;

$vars->{'product'} = $product;

$vars->{'priority'}     = get_legal_field_values('priority');
$vars->{'bug_severity'} = get_legal_field_values('bug_severity');
$vars->{'rep_platform'} = get_legal_field_values('rep_platform');
$vars->{'op_sys'}       = get_legal_field_values('op_sys');

$vars->{'assigned_to'}          = formvalue('assigned_to');
$vars->{'assigned_to_disabled'} = !$has_editbugs;
$vars->{'cc_disabled'}          = 0;

$vars->{'qa_contact'}          = formvalue('qa_contact');
$vars->{'qa_contact_disabled'} = !$has_editbugs;

## REDHAT EXTENSION START 876015
$vars->{'docs_contact'}          = formvalue('docs_contact');
$vars->{'docs_contact_disabled'} = !$has_editbugs;
## REDHAT EXTENSION END 876015
$vars->{'cloned_bug_id'} = $cloned_bug_id;

$vars->{'token'} = issue_session_token('create_bug');


my @enter_bug_fields = grep { $_->enter_bug } Bugzilla->active_custom_fields;
foreach my $field (@enter_bug_fields) {
  my $cf_name  = $field->name;
  my $cf_value = $cgi->param($cf_name);
  if (defined $cf_value) {
    if ($field->type == FIELD_TYPE_MULTI_SELECT) {
      $cf_value = [$cgi->param($cf_name)];
    }
    $default{$cf_name} = $vars->{$cf_name} = $cf_value;
  }
}

# This allows the Field visibility and value controls to work with the
# Classification and Product fields as a parent.
$default{'classification'} = $product->classification->name;
$default{'product'}        = $product->name;

## REDHAT EXTENSION START 1277621
my $lite = $cgi->param('lite');
if ($cloned_bug_id && $lite) {
  $vars->{'short_desc'} = $cloned_bug->short_desc;
  my $longdescs = $cloned_bug->comments({order => 'oldest_to_newest'});
  my $comment   = $longdescs->[0];
  $vars->{'comment'}            = $comment->body;
  $vars->{'comment_is_private'} = $comment->is_private;
  $vars->{'lite'}               = 1;
}
## REDHAT EXTENSION END 1277621
elsif ($cloned_bug_id) {

  ## REDHAT EXTENSION BEGIN 705808
  $default{'component_'} = $cloned_bug->all_components;
  ## REDHAT EXTENSION END 705808
  $default{'priority'}     = $cloned_bug->priority;
  $default{'bug_severity'} = $cloned_bug->bug_severity;
  $default{'rep_platform'} = $cloned_bug->rep_platform;
  $default{'op_sys'}       = $cloned_bug->op_sys;

  $vars->{'short_desc'}   = $cloned_bug->short_desc;
  $vars->{'bug_file_loc'} = $cloned_bug->bug_file_loc;
  $vars->{'keywords'}     = $cloned_bug->keywords;
  $vars->{'dependson'}    = join(", ", $cloned_bug_id, @{$cloned_bug->dependson});
  $vars->{'blocked'}      = join(", ", @{$cloned_bug->blocked});
  $vars->{'deadline'}     = $cloned_bug->deadline;
  $vars->{'estimated_time'} = $cloned_bug->estimated_time;

  ## REDHAT EXTENSION BEGIN 457668
  $vars->{'status_whiteboard'} = $cloned_bug->{'status_whiteboard'};
  ## REDHAT EXTENSION END 457668
  ## REDHAT EXTENSION BEGIN 800295
  # This will only get external bugs that the user can see
  $vars->{'external_bugs'} = $cloned_bug->external_bugs;
  ## REDHAT EXTENSION END 800295

  if (scalar @{$cloned_bug->cc}) {
    $vars->{'cc'} = join(", ", @{$cloned_bug->cc});
  }
  else {
    $vars->{'cc'} = formvalue('cc');
  }

  ## REDHAT EXTENSION 876015: Add docs contact
  foreach my $role (qw(reporter assigned_to qa_contact docs_contact)) {
    if ( defined($cloned_bug->$role)
      && $cloned_bug->$role->id != $user->id
      && none { $_ eq $cloned_bug->$role->login } @{$cloned_bug->cc})
    {
      $vars->{'cc'} = join(", ", $cloned_bug->$role->login, $vars->{'cc'});
    }
  }

  foreach my $field (@enter_bug_fields) {
    my $field_name = $field->name;
    $vars->{$field_name} = $cloned_bug->$field_name;
  }

  ## REDHAT EXTENSION START 406781
  if (grep($_->name eq 'cf_clone_of', @enter_bug_fields)) {
    $vars->{'cf_clone_of'} = $cloned_bug_id;
  }
  ## REDHAT EXTENSION END 406781

  ## REDHAT EXTENSION BEGIN 823680
  # Copy all comments, not just the first one

  # We need to ensure that we respect the 'insider' status of each comment.
  # Either way, make a note that this bug was cloned from another bug.
  # We cannot use $cloned_bug->longdescs because this method
  # depends on the "comment_sort_order" user pref, and we
  # really want the first comment of the bug.
  my $longdescs = $cloned_bug->comments({order => 'oldest_to_newest'});
  my $comment   = "";
  my $count     = 0;
  my $isprivate = 0;

  foreach my $comment_ref (@$longdescs) {
    if (!$comment_ref->is_private || Bugzilla->user->is_insider) {
      if ($count > 0) {
        $comment
          .= "\n\n--- Additional comment from "
          . $comment_ref->author->name . " on "
          . format_time($comment_ref->creation_ts)
          . " ---\n\n";
      }
      $comment .= $comment_ref->body;
      $isprivate = 1 if $comment_ref->is_private; # Whole comment is private if one old comment is private
      $count++;
    }
  }

  $vars->{'comment'}            = $comment;
  $vars->{'comment_is_private'} = $isprivate;
  ## REDHAT EXTENSION END 823680

  ## REDHAT EXTENSION 653316
  if (Bugzilla->params->{usesubcomponents}) {
    $vars->{sub_component} = $cloned_bug->rh_sub_components;
    $vars->{cloned_bug}    = $cloned_bug;
    my $new_component = Bugzilla::Component->match(
      {product_id => $product->id, name => $cloned_bug->component});
    if (defined($new_component) && scalar(@$new_component)) {
      $vars->{new_component} = $new_component->[0];
    }
  }
}    # end of cloned bug entry form

else {
  $default{'component_'} = formvalue('component');
  $default{'priority'}
    = formvalue('priority', Bugzilla->params->{'defaultpriority'});
  $default{'bug_severity'}
    = formvalue('bug_severity', Bugzilla->params->{'defaultseverity'});
  $default{'rep_platform'} = formvalue('rep_platform',
    Bugzilla->params->{'defaultplatform'} || detect_platform());
  $default{'op_sys'}
    = formvalue('op_sys', Bugzilla->params->{'defaultopsys'} || detect_op_sys());

  $vars->{'alias'}          = formvalue('alias');
  $vars->{'short_desc'}     = formvalue('short_desc');
  $vars->{'bug_file_loc'}   = formvalue('bug_file_loc', "http://");
  $vars->{'keywords'}       = formvalue('keywords');
  $vars->{'dependson'}      = formvalue('dependson');
  $vars->{'blocked'}        = formvalue('blocked');
  $vars->{'deadline'}       = formvalue('deadline');
  $vars->{'estimated_time'} = formvalue('estimated_time');
  $vars->{'see_also'}       = formvalue('see_also');

  $vars->{'cc'} = join(', ', $cgi->param('cc'));

  $vars->{'comment'}            = formvalue('comment');
  $vars->{'comment_is_private'} = formvalue('comment_is_private');

  ## REDHAT EXTENSION BEGIN 457668
  $vars->{'status_whiteboard'} = formvalue('status_whiteboard');
  ## REDHAT EXTENSION END 457668

  ## REDHAT EXTENSION BEGIN 602563
  my @open_bug_states = BUG_STATE_OPEN();
  $vars->{'open_bug_states'} = \@open_bug_states;
  ## REDHAT EXTENSION END 602563

  ## REDHAT EXTENSION 653316
  $vars->{sub_component} = $cgi->param('sub_component');

  ## REDHAT EXTENSION START 2004788
  ## Set new_component so sub components load
  if (Bugzilla->params->{usesubcomponents} && formvalue('component')) {
    my $new_component = Bugzilla::Component->match(
      {product_id => $product->id, name => formvalue('component')});
    if (defined($new_component) && scalar(@$new_component)) {
      $vars->{new_component} = $new_component->[0];
    }
  }
  ## REDHAT EXTENSION START 2004788
}    # end of normal/bookmarked entry form


# IF this is a cloned bug,
# AND the clone's product is the same as the parent's
#   THEN use the version from the parent bug
# ELSE IF a version is supplied in the URL
#   THEN use it
# ELSE IF there is a version in the cookie
#   THEN use it (Posting a bug sets a cookie for the current version.)
# ELSE
#   The default version is the last one in the list (which, it is
#   hoped, will be the most recent one).
#
# Eventually maybe each product should have a "current version"
# parameter.
$vars->{'version'} = $product->versions;

my $version_cookie = $cgi->cookie("VERSION-" . $product->name);

if (($cloned_bug_id) && ($product->name eq $cloned_bug->product)) {
  ## REDHAT EXTENSION BEGIN 705808
  $default{'version'} = $cloned_bug->all_versions;
  ## REDHAT EXTENSION END 705808
}
elsif (formvalue('version')) {
  $default{'version'} = formvalue('version');
}
elsif (defined $version_cookie
  and grep { $_->name eq $version_cookie } @{$vars->{'version'}})
{
  $default{'version'} = $version_cookie;
}
else {
  $default{'version'} = '---'; ## REDHAT EXTENSION 1825064
}

# Get list of milestones.
if (Bugzilla->params->{'usetargetmilestone'}) {
  $vars->{'target_milestone'} = $product->milestones;
  if (($cloned_bug_id) && ($product->name eq $cloned_bug->product)) {
    $default{'target_milestone'} = $cloned_bug->target_milestone;
  }
  elsif (formvalue('target_milestone')) {
    $default{'target_milestone'} = formvalue('target_milestone');
  }
  else {
    $default{'target_milestone'} = $product->default_milestone;
  }
}

# Get list of releases.
if (Bugzilla->params->{'usetargetrelease'}) {
  $vars->{'target_release'} = $product->releases;
  if (($cloned_bug_id) && ($product->name eq $cloned_bug->product)) {
    ## REDHAT EXTENSION BEGIN 705808
    $default{'target_release'} = $cloned_bug->target_release;
    ## REDHAT EXTENSION END 705808
  }
  elsif (formvalue('target_release')) {
    $default{'target_release'} = formvalue('target_release');
  }
  else {
    $default{'target_release'} = $product->default_release;
  }
}

# Construct the list of allowable statuses.
my @statuses = @{Bugzilla::Bug->new_bug_statuses($product)};

# Exclude closed states from the UI, even if the workflow allows them.
# The back-end code will still accept them, though.
# XXX We should remove this when the UI accepts closed statuses and update
# Bugzilla::Bug->default_bug_status.
@statuses = grep { $_->is_open } @statuses;

scalar(@statuses) || ThrowUserError('no_initial_bug_status');

$vars->{'bug_status'} = \@statuses;

# Get the default from a template value if it is legitimate.
# Otherwise, and only if the user has privs, set the default
# to the first confirmed bug status on the list, if available.

my $picked_status = formvalue('bug_status');
if ($picked_status and grep($_->name eq $picked_status, @statuses)) {
  $default{'bug_status'} = formvalue('bug_status');
}
else {
  $default{'bug_status'} = Bugzilla::Bug->default_bug_status(@statuses);
}

my @groups = $cgi->param('groups');
if ($cloned_bug) {
  my @clone_groups = map { $_->name } @{$cloned_bug->groups_in};

  # It doesn't matter if there are duplicate names, since all we check
  # for in the template is whether or not the group is set.
  push(@groups, @clone_groups);
}
$default{'groups'} = \@groups;

Bugzilla::Hook::process('enter_bug_entrydefaultvars', {vars => $vars});

$vars->{'default'} = \%default;

my $format = $template->get_format(
  "bug/create/create",
  scalar $cgi->param('format'),
  scalar $cgi->param('ctype')
);

print $cgi->header($format->{'ctype'});
$template->process($format->{'template'}, $vars)
  || ThrowTemplateError($template->error());