# 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::FlagType;

use 5.10.1;
use strict;
use warnings;

=head1 NAME

Bugzilla::FlagType - A module to deal with Bugzilla flag types.

=head1 SYNOPSIS

FlagType.pm provides an interface to flag types as stored in Bugzilla.
See below for more information.

=head1 NOTES

=over

=item *

Use of private functions/variables outside this module may lead to
unexpected results after an upgrade.  Please avoid using private
functions in other files/modules.  Private functions are functions
whose names start with _ or are specifically noted as being private.

=back

=cut

use Bugzilla::Constants;
use Bugzilla::Error;
use Bugzilla::Util;
use Bugzilla::Group;

use Email::Address;
use List::MoreUtils qw(uniq);

use parent qw(Bugzilla::Object);

###############################
####    Initialization     ####
###############################

use constant DB_TABLE   => 'flagtypes';
use constant LIST_ORDER => 'sortkey, name';

use constant DB_COLUMNS => qw(
  id
  name
  description
  cc_list
  target_type
  sortkey
  is_active
  is_requestable
  is_requesteeble
  is_multiplicable
  grant_group_id
  request_group_id
);

use constant UPDATE_COLUMNS => qw(
  name
  description
  cc_list
  sortkey
  is_active
  is_requestable
  is_requesteeble
  is_multiplicable
  grant_group_id
  request_group_id
);

use constant VALIDATORS => {
  name             => \&_check_name,
  description      => \&_check_description,
  cc_list          => \&_check_cc_list,
  target_type      => \&_check_target_type,
  sortkey          => \&_check_sortkey,
  is_active        => \&Bugzilla::Object::check_boolean,
  is_requestable   => \&Bugzilla::Object::check_boolean,
  is_requesteeble  => \&Bugzilla::Object::check_boolean,
  is_multiplicable => \&Bugzilla::Object::check_boolean,
  grant_group      => \&_check_group,
  request_group    => \&_check_group,
};

use constant UPDATE_VALIDATORS =>
  {grant_group_id => \&_check_group, request_group_id => \&_check_group,};
###############################

sub create {
  my $class = shift;
  my $dbh   = Bugzilla->dbh;

  $dbh->bz_start_transaction();

  $class->check_required_create_fields(@_);
  my $params = $class->run_create_validators(@_);

  # In the DB, only the first character of the target type is stored.
  $params->{target_type} = substr($params->{target_type}, 0, 1);

  # Extract everything which is not a valid column name.
  $params->{grant_group_id}   = delete $params->{grant_group};
  $params->{request_group_id} = delete $params->{request_group};
  my $inclusions = delete $params->{inclusions};
  my $exclusions = delete $params->{exclusions};

  my $flagtype = $class->insert_create_data($params);

  $flagtype->set_clusions({inclusions => $inclusions, exclusions => $exclusions});
  $flagtype->update();

  $dbh->bz_commit_transaction();
  return $flagtype;
}

sub update {
  my $self    = shift;
  my $dbh     = Bugzilla->dbh;
  my $flag_id = $self->id;

  $dbh->bz_start_transaction();
  my $changes = $self->SUPER::update(@_);

  # Update the flaginclusions and flagexclusions tables.
  foreach my $category ('inclusions', 'exclusions') {
    next unless delete $self->{"_update_$category"};

    $dbh->do("DELETE FROM flag$category WHERE type_id = ?", undef, $flag_id);

    my $sth = $dbh->prepare(
      "INSERT INTO flag$category
                                (type_id, product_id, component_id) VALUES (?, ?, ?)"
    );

    foreach my $prod_comp (values %{$self->{$category}}) {
      my ($prod_id, $comp_id) = split(':', $prod_comp);
      $prod_id ||= undef;
      $comp_id ||= undef;
      $sth->execute($flag_id, $prod_id, $comp_id);
    }
    $changes->{$category} = [0, 1];
  }

  # Clear existing flags for bugs/attachments in categories no longer on
  # the list of inclusions or that have been added to the list of exclusions.
  my $flag_ids = $dbh->selectcol_arrayref(
    'SELECT DISTINCT flags.id
                                               FROM flags
                                         INNER JOIN bugs
                                                 ON flags.bug_id = bugs.bug_id
                                          LEFT JOIN flaginclusions AS i
                                                 ON (flags.type_id = i.type_id
                                                     AND (bugs.product_id = i.product_id
                                                          OR i.product_id IS NULL)
                                                     AND (bugs.component_id = i.component_id
                                                          OR i.component_id IS NULL))
                                              WHERE flags.type_id = ?
                                                AND i.type_id IS NULL', undef,
    $self->id
  );
  Bugzilla::Flag->force_retarget($flag_ids);

  $flag_ids = $dbh->selectcol_arrayref(
    'SELECT DISTINCT flags.id
                                            FROM flags
                                      INNER JOIN bugs
                                              ON flags.bug_id = bugs.bug_id
                                      INNER JOIN flagexclusions AS e
                                              ON flags.type_id = e.type_id
                                           WHERE flags.type_id = ?
                                             AND (bugs.product_id = e.product_id
                                                  OR e.product_id IS NULL)
                                             AND (bugs.component_id = e.component_id
                                                  OR e.component_id IS NULL)',
    undef, $self->id
  );
  Bugzilla::Flag->force_retarget($flag_ids);

  # Silently remove requestees from flags which are no longer
  # specifically requestable.
  if (!$self->is_requesteeble) {
    my $ids
      = $dbh->selectcol_arrayref(
      'SELECT id FROM flags WHERE type_id = ? AND requestee_id IS NOT NULL',
      undef, $self->id);

    if (@$ids) {
      $dbh->do(
        'UPDATE flags SET requestee_id = NULL WHERE ' . $dbh->sql_in('id', $ids));
      foreach my $id (@$ids) {
        Bugzilla->memcached->clear({table => 'flags', id => $id});
      }
    }
  }

  $dbh->bz_commit_transaction();
  return $changes;
}

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

=head2 METHODS

=over

=item C<id>

Returns the ID of the flagtype.

=item C<name>

Returns the name of the flagtype.

=item C<description>

Returns the description of the flagtype.

=item C<cc_list>

Returns the concatenated CC list for the flagtype, as a single string.

=item C<target_type>

Returns whether the flagtype applies to bugs or attachments.

=item C<is_active>

Returns whether the flagtype is active or disabled. Flags being
in a disabled flagtype are not deleted. It only prevents you from
adding new flags to it.

=item C<is_requestable>

Returns whether you can request for the given flagtype
(i.e. whether the '?' flag is available or not).

=item C<is_requesteeble>

Returns whether you can ask someone specifically or not.

=item C<is_multiplicable>

Returns whether you can have more than one flag for the given
flagtype in a given bug/attachment.

=item C<sortkey>

Returns the sortkey of the flagtype.

=back

=cut

sub id          { return $_[0]->{'id'}; }
sub name        { return $_[0]->{'name'}; }
sub description { return $_[0]->{'description'}; }
sub cc_list     { return $_[0]->{'cc_list'}; }
sub target_type { return $_[0]->{'target_type'} eq 'b' ? 'bug' : 'attachment'; }
sub is_active   { return $_[0]->{'is_active'}; }
sub is_requestable   { return $_[0]->{'is_requestable'}; }
sub is_requesteeble  { return $_[0]->{'is_requesteeble'}; }
sub is_multiplicable { return $_[0]->{'is_multiplicable'}; }
sub sortkey          { return $_[0]->{'sortkey'}; }
sub request_group_id { return $_[0]->{'request_group_id'}; }
sub grant_group_id   { return $_[0]->{'grant_group_id'}; }

################################
# Validators
################################

sub _check_name {
  my ($invocant, $name) = @_;

  $name = trim($name);
  ($name && $name !~ /[\s,]/ && length($name) <= 50)
    || ThrowUserError('flag_type_name_invalid', {name => $name});
  return $name;
}

sub _check_description {
  my ($invocant, $desc) = @_;

  $desc = trim($desc);
  $desc || ThrowUserError('flag_type_description_invalid');
  return $desc;
}

sub _check_cc_list {
  my ($invocant, $cc_list) = @_;

  length($cc_list) <= 200
    || ThrowUserError('flag_type_cc_list_invalid', {cc_list => $cc_list});

  my @addresses = split(/[,\s]+/, $cc_list);
  my $addr_spec = $Email::Address::addr_spec;

  # We do not call check_email_syntax() because these addresses do not
  # require to match 'emailregexp' and do not depend on 'emailsuffix'.
  foreach my $address (@addresses) {
    ($address !~ /\P{ASCII}/ && $address =~ /^$addr_spec$/)
      || ThrowUserError('illegal_email_address', {addr => $address, default => 1});
  }
  return $cc_list;
}

sub _check_target_type {
  my ($invocant, $target_type) = @_;

  ($target_type eq 'bug' || $target_type eq 'attachment')
    || ThrowCodeError('flag_type_target_type_invalid',
    {target_type => $target_type});
  return $target_type;
}

sub _check_sortkey {
  my ($invocant, $sortkey) = @_;

  (detaint_natural($sortkey) && $sortkey <= MAX_SMALLINT)
    || ThrowUserError('flag_type_sortkey_invalid', {sortkey => $sortkey});
  return $sortkey;
}

sub _check_group {
  my ($invocant, $group) = @_;
  return unless $group;

  trick_taint($group);
  $group = Bugzilla::Group->check($group);
  return $group->id;
}

###############################
####       Methods         ####
###############################

sub set_name                        { $_[0]->set('name',             $_[1]); }
sub set_description                 { $_[0]->set('description',      $_[1]); }
sub set_cc_list                     { $_[0]->set('cc_list',          $_[1]); }
sub set_sortkey                     { $_[0]->set('sortkey',          $_[1]); }
sub set_is_active                   { $_[0]->set('is_active',        $_[1]); }
sub set_is_requestable              { $_[0]->set('is_requestable',   $_[1]); }
sub set_is_specifically_requestable { $_[0]->set('is_requesteeble',  $_[1]); }
sub set_is_multiplicable            { $_[0]->set('is_multiplicable', $_[1]); }
sub set_grant_group                 { $_[0]->set('grant_group_id',   $_[1]); }
sub set_request_group               { $_[0]->set('request_group_id', $_[1]); }

sub set_clusions {
  my ($self, $list) = @_;
  my $user = Bugzilla->user;
  my %products;
  my $params = {};

  # If the user has editcomponents privs, then we only need to make sure
  # that the product exists.
  if ($user->in_group('editcomponents')) {
    $params->{allow_inaccessible} = 1;
  }

  foreach my $category (keys %$list) {
    my %clusions;
    my %clusions_as_hash;

    foreach my $prod_comp (@{$list->{$category} || []}) {
      my ($prod_id, $comp_id) = split(':', $prod_comp);
      my $prod_name = '__Any__';
      my $comp_name = '__Any__';

      # Does the product exist?
      if ($prod_id) {
        detaint_natural($prod_id)
          || ThrowCodeError('param_must_be_numeric',
          {function => 'Bugzilla::FlagType::set_clusions'});

        if (!$products{$prod_id}) {
          $params->{id} = $prod_id;
          $products{$prod_id} = Bugzilla::Product->check($params);
        }
        $prod_name = $products{$prod_id}->name;

        # Does the component belong to this product?
        if ($comp_id) {
          detaint_natural($comp_id)
            || ThrowCodeError('param_must_be_numeric',
            {function => 'Bugzilla::FlagType::set_clusions'});

          my ($component) = grep { $_->id == $comp_id } @{$products{$prod_id}->components}
            or ThrowUserError('product_unknown_component',
            {product => $prod_name, comp_id => $comp_id});
          $comp_name = $component->name;
        }
        else {
          $comp_id = 0;
        }
      }
      else {
        $prod_id = 0;
        $comp_id = 0;
      }
      $clusions{"$prod_name:$comp_name"} = "$prod_id:$comp_id";
      $clusions_as_hash{$prod_id}->{$comp_id} = 1;
    }

    # Check the user has the editcomponent permission on products that are changing
    if (!$user->in_group('editcomponents')) {
      my $current_clusions = $self->$category;
      my ($removed, $added)
        = diff_arrays([values %$current_clusions], [values %clusions]);
      my @changed_product_ids = uniq map { substr($_, 0, index($_, ':')) } @$removed,
        @$added;
      foreach my $product_id (@changed_product_ids) {
        $user->in_group('editcomponents', $product_id)
          || ThrowUserError('product_access_denied',
          {name => $products{$product_id}->name});
      }
    }

    # Set the changes
    $self->{$category}             = \%clusions;
    $self->{"${category}_as_hash"} = \%clusions_as_hash;
    $self->{"_update_$category"}   = 1;
  }
}

=pod

=over

=item C<grant_list>

Returns a reference to an array of users who have permission to grant this flag type.
The arrays are populated with hashrefs containing the login, identity and visibility of users.

=item C<grant_group>

Returns the group (as a Bugzilla::Group object) in which a user
must be in order to grant or deny a request.

=item C<request_group>

Returns the group (as a Bugzilla::Group object) in which a user
must be in order to request or clear a flag.

=item C<flag_count>

Returns the number of flags belonging to the flagtype.

=item C<inclusions>

Return a hash of product/component IDs and names
explicitly associated with the flagtype.

=item C<exclusions>

Return a hash of product/component IDs and names
explicitly excluded from the flagtype.

=back

=cut

sub grant_list {
  my $self = shift;
  require Bugzilla::User;
  my @custusers;
  my @allusers = @{Bugzilla->user->get_userlist};
  foreach my $user (@allusers) {
    my $user_obj = new Bugzilla::User({name => $user->{login}});
    push(@custusers, $user) if $user_obj->can_set_flag($self);
  }
  return \@custusers;
}

sub grant_group {
  my $self = shift;

  if (!defined $self->{'grant_group'} && $self->{'grant_group_id'}) {
    $self->{'grant_group'} = new Bugzilla::Group($self->{'grant_group_id'});
  }
  return $self->{'grant_group'};
}

sub request_group {
  my $self = shift;

  if (!defined $self->{'request_group'} && $self->{'request_group_id'}) {
    $self->{'request_group'} = new Bugzilla::Group($self->{'request_group_id'});
  }
  return $self->{'request_group'};
}

sub flag_count {
  my $self = shift;

  if (!defined $self->{'flag_count'}) {
    $self->{'flag_count'} = Bugzilla->dbh->selectrow_array(
      'SELECT COUNT(*) FROM flags
                                            WHERE type_id = ?', undef, $self->{'id'}
    );
  }
  return $self->{'flag_count'};
}

sub inclusions {
  my $self = shift;

  if (!defined $self->{inclusions}) {
    ($self->{inclusions}, $self->{inclusions_as_hash})
      = get_clusions($self->id, 'in');
  }
  return $self->{inclusions};
}

sub inclusions_as_hash {
  my $self = shift;

  $self->inclusions unless defined $self->{inclusions_as_hash};
  return $self->{inclusions_as_hash};
}

sub exclusions {
  my $self = shift;

  if (!defined $self->{exclusions}) {
    ($self->{exclusions}, $self->{exclusions_as_hash})
      = get_clusions($self->id, 'ex');
  }
  return $self->{exclusions};
}

sub exclusions_as_hash {
  my $self = shift;

  $self->exclusions unless defined $self->{exclusions_as_hash};
  return $self->{exclusions_as_hash};
}

######################################################################
# Public Functions
######################################################################

=pod

=head1 PUBLIC FUNCTIONS/METHODS

=over

=item C<get_clusions($id, $type)>

Return a hash of product/component IDs and names
associated with the flagtype:
$clusions{'product_name:component_name'} = "product_ID:component_ID"

=back

=cut

sub get_clusions {
  my ($id, $type) = @_;
  my $dbh = Bugzilla->dbh;

  my $list = $dbh->selectall_arrayref(
    "SELECT products.id, products.name,
                                         components.id, components.name
                                    FROM flagtypes
                              INNER JOIN flag${type}clusions
                                      ON flag${type}clusions.type_id = flagtypes.id
                               LEFT JOIN products
                                      ON flag${type}clusions.product_id = products.id
                               LEFT JOIN components
                                      ON flag${type}clusions.component_id = components.id
                                   WHERE flagtypes.id = ?", undef, $id
  );
  my (%clusions, %clusions_as_hash);
  foreach my $data (@$list) {
    my ($product_id, $product_name, $component_id, $component_name) = @$data;
    $product_id     ||= 0;
    $product_name   ||= "__Any__";
    $component_id   ||= 0;
    $component_name ||= "__Any__";
    $clusions{"$product_name:$component_name"} = "$product_id:$component_id";
    $clusions_as_hash{$product_id}->{$component_id} = 1;
  }
  return (\%clusions, \%clusions_as_hash);
}

=pod

=over

=item C<match($criteria)>

Queries the database for flag types matching the given criteria
and returns a list of matching flagtype objects.

=back

=cut

sub match {
  my ($criteria) = @_;
  my $dbh = Bugzilla->dbh;

  # Depending on the criteria, we may have to append additional tables.
  my $tables   = [DB_TABLE];
  my @criteria = sqlify_criteria($criteria, $tables);
  $tables   = join(' ',     @$tables);
  $criteria = join(' AND ', @criteria);

  my $flagtype_ids
    = $dbh->selectcol_arrayref("SELECT id FROM $tables WHERE $criteria");

  return Bugzilla::FlagType->new_from_list($flagtype_ids);
}

=pod

=over

=item C<count($criteria)>

Returns the total number of flag types matching the given criteria.

=back

=cut

sub count {
  my ($criteria) = @_;
  my $dbh = Bugzilla->dbh;

  # Depending on the criteria, we may have to append additional tables.
  my $tables   = [DB_TABLE];
  my @criteria = sqlify_criteria($criteria, $tables);
  $tables   = join(' ',     @$tables);
  $criteria = join(' AND ', @criteria);

  my $count = $dbh->selectrow_array(
    "SELECT COUNT(flagtypes.id)
                                       FROM $tables WHERE $criteria"
  );
  return $count;
}

######################################################################
# Private Functions
######################################################################

# Converts a hash of criteria into a list of SQL criteria.
# $criteria is a reference to the criteria (field => value),
# $tables is a reference to an array of tables being accessed
# by the query.

sub sqlify_criteria {
  my ($criteria, $tables) = @_;
  my $dbh = Bugzilla->dbh;

  # the generated list of SQL criteria; "1=1" is a clever way of making sure
  # there's something in the list so calling code doesn't have to check list
  # size before building a WHERE clause out of it
  my @criteria = ("1=1");

  if ($criteria->{name}) {
    if (ref($criteria->{name}) eq 'ARRAY') {
      my @names = map { $dbh->quote($_) } @{$criteria->{name}};

      # Detaint data as we have quoted it.
      foreach my $name (@names) {
        trick_taint($name);
      }
      push @criteria, $dbh->sql_in('flagtypes.name', \@names);
    }
    else {
      my $name = $dbh->quote($criteria->{name});
      trick_taint($name);    # Detaint data as we have quoted it.
      push(@criteria, "flagtypes.name = $name");
    }
  }
  if ($criteria->{target_type}) {

    # The target type is stored in the database as a one-character string
    # ("a" for attachment and "b" for bug), but this function takes complete
    # names ("attachment" and "bug") for clarity, so we must convert them.
    my $target_type = $criteria->{target_type} eq 'bug' ? 'b' : 'a';
    push(@criteria, "flagtypes.target_type = '$target_type'");
  }
  if (exists($criteria->{is_active})) {
    my $is_active = $criteria->{is_active} ? "1" : "0";
    push(@criteria, "flagtypes.is_active = $is_active");
  }
  if ($criteria->{product_id}) {
    my $product_id = $criteria->{product_id};
    detaint_natural($product_id)
      || ThrowCodeError('bad_arg',
      {argument => 'product_id', function => 'Bugzilla::FlagType::sqlify_criteria'});

    # Add inclusions to the query, which simply involves joining the table
    # by flag type ID and target product/component.
    push(@$tables,  "INNER JOIN flaginclusions AS i ON flagtypes.id = i.type_id");
    push(@criteria, "(i.product_id = $product_id OR i.product_id IS NULL)");

    # Add exclusions to the query, which is more complicated.  First of all,
    # we do a LEFT JOIN so we don't miss flag types with no exclusions.
    # Then, as with inclusions, we join on flag type ID and target product/
    # component.  However, since we want flag types that *aren't* on the
    # exclusions list, we add a WHERE criteria to use only records with
    # NULL exclusion type, i.e. without any exclusions.
    my $join_clause = "flagtypes.id = e.type_id ";

    my $addl_join_clause = "";
    if ($criteria->{component_id}) {
      my $component_id = $criteria->{component_id};
      detaint_natural($component_id) || ThrowCodeError('bad_arg',
        {argument => 'component_id', function => 'Bugzilla::FlagType::sqlify_criteria'}
      );

      push(@criteria, "(i.component_id = $component_id OR i.component_id IS NULL)");
      $join_clause
        .= "AND (e.component_id = $component_id OR e.component_id IS NULL) ";
    }
    else {
      $addl_join_clause
        = "AND e.component_id IS NULL OR (i.component_id = e.component_id) ";
    }
    $join_clause
      .= "AND ((e.product_id = $product_id $addl_join_clause) OR e.product_id IS NULL)";

    push(@$tables,  "LEFT JOIN flagexclusions AS e ON ($join_clause)");
    push(@criteria, "e.type_id IS NULL");
  }
  if ($criteria->{group}) {
    my $gid = $criteria->{group};
    detaint_natural($gid)
      || ThrowCodeError('bad_arg',
      {argument => 'group', function => 'Bugzilla::FlagType::sqlify_criteria'});

    push(@criteria,
      "(flagtypes.grant_group_id = $gid " . " OR flagtypes.request_group_id = $gid)");
  }

  return @criteria;
}

1;

=head1 B<Methods in need of POD>

=over

=item exclusions_as_hash

=item request_group_id

=item set_is_active

=item set_is_multiplicable

=item inclusions_as_hash

=item set_sortkey

=item grant_group_id

=item set_cc_list

=item set_request_group

=item set_name

=item set_is_specifically_requestable

=item set_grant_group

=item create

=item set_clusions

=item set_description

=item set_is_requestable

=item update

=back
