# 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.

# This module represents the tests that get run on a single
# operator/field combination for Bugzilla::Test::Search.
# This is where all the actual testing happens.
package Bugzilla::Test::Search::FieldTest;

use strict;
use warnings;
use Bugzilla::Search;
use Bugzilla::Test::Search::Constants;
use Bugzilla::Util qw(trim);

use Data::Dumper;
use Scalar::Util qw(blessed);
use Test::More;
use Test::Exception;

###############
# Constructor #
###############

sub new {
  my ($class, $operator_test, $field, $test) = @_;
  return bless {
    operator_test => $operator_test,
    field_object  => $field,
    raw_test      => $test
  }, $class;
}

#############
# Accessors #
#############

sub num_tests { return TESTS_PER_RUN }

# The Bugzilla::Test::Search::OperatorTest that this is a child of.
sub operator_test { return $_[0]->{operator_test} }

# The Bugzilla::Field being tested.
sub field_object { return $_[0]->{field_object} }

# The name of the field being tested, which we need much more often
# than we need the object.
sub field {
  my ($self) = @_;
  $self->{field_name} ||= $self->field_object->name;
  return $self->{field_name};
}

# The Bugzilla::Test::Search object that this is a child of.
sub search_test { return $_[0]->operator_test->search_test }

# The operator being tested
sub operator { return $_[0]->operator_test->operator }

# The bugs currently being tested by Bugzilla::Test::Search.
sub bugs { return $_[0]->search_test->bugs }

sub bug {
  my $self = shift;
  return $self->search_test->bug(@_);
}

sub number {
  my ($self, $id) = @_;
  foreach my $number (1 .. NUM_BUGS) {
    return $number if $self->search_test->bug($number)->id == $id;
  }
  return 0;
}

# The name displayed for this test by Test::More. Used in test descriptions.
sub name {
  my ($self)   = @_;
  my $field    = $self->field;
  my $operator = $self->operator;
  my $value    = $self->main_value;

  my $name = "$field-$operator-$value";
  if (my $extra_name = $self->test->{extra_name}) {
    $name .= "-$extra_name";
  }
  return $name;
}

# The appropriate value from the TESTS constant for this test, taking
# into account overrides.
sub test {
  my $self = shift;
  return $self->{test} if $self->{test};

  my %test = %{$self->{raw_test}};

  # We have field name overrides...
  my $override = $test{override}->{$self->field};

  # And also field type overrides.
  if (!$override) {
    $override = $test{override}->{$self->field_object->type} || {};
  }

  foreach my $key (%$override) {
    $test{$key} = $override->{$key};
  }

  $self->{test} = \%test;
  return $self->{test};
}

# All the values for all the bugs for this field.
sub _field_values {
  my ($self) = @_;
  return $self->{field_values} if $self->{field_values};

  my %field_values;
  foreach my $number (1 .. NUM_BUGS) {
    $field_values{$number} = $self->_field_values_for_bug($number);
  }
  $self->{field_values} = \%field_values;
  return $self->{field_values};
}

# The values for this field for the numbered bug.
sub bug_values {
  my ($self, $number) = @_;
  return @{$self->_field_values->{$number}};
}

# The untranslated, non-overriden value--used in the name of the test
# and other places.
sub main_value { return $_[0]->{raw_test}->{value} }

# The untranslated test value, taking into account overrides.
sub test_value { return $_[0]->test->{value} }

# The value translated appropriately for passing to Bugzilla::Search.
sub translated_value {
  my $self = shift;
  if (!exists $self->{translated_value}) {
    my $value = $self->search_test->value_translation_cache($self);
    if (!defined $value) {
      $value = $self->_translate_value();
      $self->search_test->value_translation_cache($self, $value);
    }
    $self->{translated_value} = $value;
  }
  return $self->{translated_value};
}

# Used in failure diagnostic messages.
sub debug_fail {
  my ($self, $number, $results, $sql) = @_;
  my @expected = @{$self->test->{contains}};
  my @results  = sort map { $self->number($_) } map { $_->[0] } @$results;
  return
      "   Value: '"
    . $self->translated_value . "'\n"
    . "Expected: ["
    . join(',', @expected) . "]\n"
    . " Results: ["
    . join(',', @results) . "]\n"
    . trim($sql) . "\n";
}

# True for a bug if we ran the "transform" function on it and the
# result was equal to its first value.
sub transformed_value_was_equal {
  my ($self, $number, $value) = @_;
  if (@_ > 2) {
    $self->{transformed_value_was_equal}->{$number} = $value;
    $self->search_test->was_equal_cache($self, $number, $value);
  }
  my $cached = $self->search_test->was_equal_cache($self, $number);
  return $cached if defined $cached;
  return $self->{transformed_value_was_equal}->{$number};
}

# True if this test is supposed to contain the numbered bug.
sub bug_is_contained {
  my ($self, $number) = @_;
  my $contains = $self->test->{contains};
  if ($self->transformed_value_was_equal($number)
    and !$self->test->{override}->{$self->field}->{contains})
  {
    $contains = $self->test->{if_equal}->{contains};
  }
  return grep($_ == $number, @$contains) ? 1 : 0;
}

###################################################
# Accessors: Ways of doing SKIP and TODO on tests #
###################################################

# The tests we know are broken for this operator/field combination.
sub _known_broken {
  my ($self, $constant, $skip_pg_check) = @_;

  $constant ||= KNOWN_BROKEN;
  my $field      = $self->field;
  my $type       = $self->field_object->type;
  my $operator   = $self->operator;
  my $value      = $self->main_value;
  my $value_name = "$operator-$value";
  if (my $extra_name = $self->test->{extra_name}) {
    $value_name .= "-$extra_name";
  }

  my $value_broken = $constant->{$value_name}->{$field};
  $value_broken ||= $constant->{$value_name}->{$type};
  return $value_broken if $value_broken;
  my $operator_broken = $constant->{$operator}->{$field};
  $operator_broken ||= $constant->{$operator}->{$type};
  return $operator_broken if $operator_broken;
  return {};
}

# True if the "contains" search for the numbered bug is broken.
# That is, either the result is supposed to contain it and doesn't,
# or the result is not supposed to contain it and does.
sub contains_known_broken {
  my ($self, $number) = @_;
  my $field    = $self->field;
  my $operator = $self->operator;

  my $contains_broken = $self->_known_broken->{contains} || [];
  if (grep($_ == $number, @$contains_broken)) {
    return "$field $operator contains $number is known to be broken";
  }
  return undef;
}

# Used by subclasses. Checks both bug_is_contained and contains_known_broken
# to tell you whether or not the bug will *actually* be found by the test.
sub will_actually_contain_bug {
  my ($self, $number) = @_;
  my $is_contained = $self->bug_is_contained($number)      ? 1 : 0;
  my $is_broken    = $self->contains_known_broken($number) ? 1 : 0;

  # If the test is supposed to contain the bug and *isn't* broken,
  # then the test will contain the bug.
  return 1 if ($is_contained and !$is_broken);

  # If this test is *not* supposed to contain the bug, but that test is
  # broken, then this test *will* contain the bug.
  return 1 if (!$is_contained and $is_broken);

  return 0;
}

# Returns a string if creating a Bugzilla::Search object throws an error,
# with this field/operator/value combination.
sub search_known_broken {
  my ($self)   = @_;
  my $field    = $self->field;
  my $operator = $self->operator;
  if ($self->_known_broken->{search}) {
    return "Bugzilla::Search for $field $operator is known to be broken";
  }
  return undef;
}

# Returns a string if we haven't yet implemented the tests for this field,
# but we plan to in the future.
sub field_not_yet_implemented {
  my ($self) = @_;
  my $skip_this_field = grep { $_ eq $self->field } SKIP_FIELDS;
  if ($skip_this_field) {
    my $field = $self->field;
    return "$field testing not yet implemented";
  }
  return undef;
}

# Returns a message if this field/operator combination can't ever be run.
# At no time in the future will this field/operator combination ever work.
sub invalid_field_operator_combination {
  my ($self)   = @_;
  my $field    = $self->field;
  my $operator = $self->operator;

  if ($field eq 'content' && $operator !~ /matches/) {
    return "content field does not support $operator";
  }
  elsif ($operator =~ /matches/ && $field ne 'content') {
    return "matches operator does not support fields other than content";
  }
  return undef;
}

# True if this field is broken in an OR combination.
sub join_broken {
  my ($self, $or_broken_map) = @_;
  my $or_broken = $or_broken_map->{$self->field . '-' . $self->operator};
  if (!$or_broken) {

    # See if this is a comment field, and in that case, if there's
    # a generic entry for all comment fields.
    my $is_comment_field = COMMENT_FIELDS->{$self->field};
    if ($is_comment_field) {
      $or_broken = $or_broken_map->{'longdescs.-' . $self->operator};
    }
  }
  return $or_broken;
}

#########################################
# Accessors: Bugzilla::Search Arguments #
#########################################

# The data that will get passed to Bugzilla::Search as its arguments.
sub search_params {
  my ($self) = @_;
  return $self->{search_params} if $self->{search_params};

  my %params = (
    "field0-0-0" => $self->field,
    "type0-0-0"  => $self->operator,
    "value0-0-0" => $self->translated_value,
  );

  $self->{search_params} = \%params;
  return $self->{search_params};
}

sub search_columns {
  my ($self)        = @_;
  my $field         = $self->field;
  my @search_fields = qw(bug_id);
  if ($self->field_object->buglist) {
    my $col_name = COLUMN_TRANSLATION->{$field} || $field;
    push(@search_fields, $col_name);
  }
  return \@search_fields;
}


################
# Field Values #
################

sub _field_values_for_bug {
  my ($self, $number) = @_;
  my $field = $self->field;

  my @values;

  if ($field =~ /^attach.+\.(.+)$/) {
    my $attach_field = $1;
    $attach_field = ATTACHMENT_FIELDS->{$attach_field} || $attach_field;
    @values       = $self->_values_for($number, 'attachments', $attach_field);
  }
  elsif (my $flag_field = FLAG_FIELDS->{$field}) {
    @values = $self->_values_for($number, 'flags', $flag_field);
  }
  elsif (my $translation = COMMENT_FIELDS->{$field}) {
    @values = $self->_values_for($number, 'comments', $translation);

    # We want the last value to come first, so that single-value
    # searches use the last comment.
    @values = reverse @values;
  }
  elsif ($field eq 'longdescs.count') {
    @values = scalar(@{$self->bug($number)->comments});
  }
  elsif ($field eq 'work_time') {
    @values = $self->_values_for($number, 'actual_time');
  }
  elsif ($field eq 'bug_group') {
    @values = $self->_values_for($number, 'groups_in', 'name');
  }
  elsif ($field eq 'keywords') {
    @values = $self->_values_for($number, 'keyword_objects', 'name');
  }
  elsif ($field eq 'content') {
    @values = $self->_values_for($number, 'short_desc');
  }
  elsif ($field eq 'see_also') {
    @values = $self->_values_for($number, 'see_also', 'name');
  }
  elsif ($field eq 'tag') {
    @values = $self->_values_for($number, 'tags');
  }

  # Bugzilla::Bug truncates creation_ts, but we need the full value
  # from the database. This has no special value for changedfrom,
  # because it never changes.
  elsif ($field eq 'creation_ts') {
    my $bug = $self->bug($number);
    my $creation_ts
      = Bugzilla->dbh->selectrow_array(
      'SELECT creation_ts FROM bugs WHERE bug_id = ?',
      undef, $bug->id);
    @values = ($creation_ts);
  }
  else {
    @values = $self->_values_for($number, $field);
  }

  # We convert user objects to their login name, here, all in one
  # block for simplicity.
  if (grep { $_ eq $field } USER_FIELDS) {

    # requestees.login_name is empty for most bugs (but checking
    # blessed(undef) handles that.
    # Values that come from %original_values aren't User objects.
    @values = map  { blessed($_) ? $_->login : $_ } @values;
    @values = grep { defined $_ } @values;
  }

  return \@values;
}

sub _values_for {
  my ($self, $number, $bug_field, $item_field) = @_;

  my $item;
  if ($self->operator eq 'changedfrom') {
    $item = $self->search_test->bug_create_value($number, $bug_field);
  }
  else {
    my $bug = $self->bug($number);
    $item = $bug->$bug_field;
  }

  if ($item_field) {
    if ($bug_field eq 'flags' and $item_field eq 'name') {
      return (map { $_->name . $_->status } @$item);
    }
    return (map { $self->_get_item($_, $item_field) } @$item);
  }

  return @$item if ref($item) eq 'ARRAY';
  return $item  if defined $item;
  return ();
}

sub _get_item {
  my ($self, $from, $field) = @_;
  if (blessed($from)) {
    return $from->$field;
  }
  return $from->{$field};
}

#####################
# Value Translation #
#####################

# This function translates the "value" specified in TESTS into an actual
# search value to pass to Search.pm. This means that we get the value
# from the current bug (or, in the case of changedfrom, from %original_values)
# and then we insert it as required into the "value" from TESTS. (For example,
# <1> becomes the value for the field from bug 1.)
sub _translate_value {
  my $self  = shift;
  my $value = $self->test_value;
  foreach my $number (1 .. NUM_BUGS) {
    $value = $self->_translate_value_for_bug($number, $value);
  }

  # Sanity check to make sure that none of the <> stuff was left in.
  if ($value =~ /<\d/) {
    die $self->name . ": value untranslated: $value\n";
  }
  return $value;
}

sub _translate_value_for_bug {
  my ($self, $number, $value) = @_;

  my $bug = $self->bug($number);

  my $bug_id = $bug->id;
  $value =~ s/<$number-id>/$bug_id/g;
  my $bug_delta = $bug->delta_ts;
  $value =~ s/<$number-delta>/$bug_delta/g;
  my $reporter = $bug->reporter->login;
  $value =~ s/<$number-reporter>/$reporter/g;
  if ($value =~ /<$number-bug_group>/) {
    my @bug_groups = map { $_->name } @{$bug->groups_in};
    @bug_groups = grep { $_ =~ /^\d+-group-/ } @bug_groups;
    my $group = $bug_groups[0];
    $value =~ s/<$number-bug_group>/$group/g;
  }

  my @bug_values = $self->bug_values($number);
  return $value if !@bug_values;

  if ($self->operator =~ /substr/) {
    @bug_values = map { $self->_substr_value($_) } @bug_values;
  }

  my $string_value = $bug_values[0];
  if ($self->operator =~ /word/) {
    $string_value = join(' ', @bug_values);
  }
  if (my $func = $self->test->{transform}) {
    my $transformed = $func->(@bug_values);
    my $is_equal    = $transformed eq $bug_values[0] ? 1 : 0;
    $self->transformed_value_was_equal($number, $is_equal);
    $string_value = $transformed;
  }

  if ($self->test->{escape}) {
    $string_value = quotemeta($string_value);
  }
  $value =~ s/<$number>/$string_value/g;

  return $value;
}

sub _substr_value {
  my ($self, $value) = @_;
  my $field       = $self->field;
  my $type        = $self->field_object->type;
  my $substr_size = SUBSTR_SIZE;
  if (exists FIELD_SUBSTR_SIZE->{$field}) {
    $substr_size = FIELD_SUBSTR_SIZE->{$field};
  }
  elsif (exists FIELD_SUBSTR_SIZE->{$type}) {
    $substr_size = FIELD_SUBSTR_SIZE->{$type};
  }
  if ($substr_size > 0) {

    # The field name is included in every field value, and if it's
    # long, it might take up the whole substring, and we don't want that.
    if (!grep { $_ eq $field or $_ eq $type } SUBSTR_NO_FIELD_ADD) {
      $substr_size += length($field);
    }
    my $string = substr($value, 0, $substr_size);
    return $string;
  }
  return substr($value, $substr_size);
}

#####################
# Main Test Methods #
#####################

sub run {
  my ($self) = @_;

  my $invalid_combination   = $self->invalid_field_operator_combination;
  my $field_not_implemented = $self->field_not_yet_implemented;

SKIP: {
    skip($invalid_combination, $self->num_tests) if $invalid_combination;
  TODO: {
      todo_skip($field_not_implemented, $self->num_tests) if $field_not_implemented;
      $self->do_tests();
    }
  }
}

sub do_tests {
  my ($self) = @_;
  my $name = $self->name;

  my $search_broken = $self->search_known_broken;

  my $search = $self->_test_search_object_creation();

  my $sql;
TODO: {
    local $TODO = $search_broken if $search_broken;
    lives_ok { $sql = $search->_sql } "$name: generate SQL";
  }

  my $results;
SKIP: {
    skip "Can't run SQL without any SQL", 1 if !defined $sql;
    $results = $self->_test_sql($search);
  }

  $self->_test_content($results, $sql);
}

sub _test_search_object_creation {
  my ($self) = @_;
  my $name = $self->name;
  my @args = (fields => $self->search_columns, params => $self->search_params);
  my $search;
  lives_ok { $search = new Bugzilla::Search(@args) }
  "$name: create search object";
  return $search;
}

sub _test_sql {
  my ($self, $search) = @_;
  my $name = $self->name;
  my $results;
  lives_ok { $results = $search->data } "$name: Run SQL Query"
    or diag($search->_sql);
  return $results;
}

sub _test_content {
  my ($self, $results, $sql) = @_;

SKIP: {
    skip "Without results we can't test them", NUM_BUGS if !$results;
    foreach my $number (1 .. NUM_BUGS) {
      $self->_test_content_for_bug($number, $results, $sql);
    }
  }
}

sub _test_content_for_bug {
  my ($self, $number, $results, $sql) = @_;
  my $name = $self->name;

  my $contains_known_broken = $self->contains_known_broken($number);

  my %result_ids = map { $_->[0] => 1 } @$results;
  my $bug_id     = $self->bug($number)->id;

TODO: {
    local $TODO = $contains_known_broken if $contains_known_broken;
    if ($self->bug_is_contained($number)) {
      ok($result_ids{$bug_id}, "$name: contains bug $number ($bug_id)")
        or diag $self->debug_fail($number, $results, $sql);
    }
    else {
      ok(!$result_ids{$bug_id}, "$name: does not contain bug $number ($bug_id)")
        or diag $self->debug_fail($number, $results, $sql);
    }
  }
}

1;
