# 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::Extension::PhabBugz::Feed;

use 5.10.1;

use IO::Async::Timer::Periodic;
use IO::Async::Loop;
use IO::Async::Signal;
use List::Util qw(first);
use List::MoreUtils qw(any uniq);
use Moo;
use Try::Tiny;
use Type::Params qw( compile );
use Type::Utils;
use Types::Standard qw( :types );

use Bugzilla::Constants;
use Bugzilla::Error;
use Bugzilla::Field;
use Bugzilla::Logging;
use Bugzilla::Mailer;
use Bugzilla::Search;
use Bugzilla::Util qw(diff_arrays format_time with_writable_database with_readonly_database);
use Bugzilla::Types qw(:types);
use Bugzilla::Extension::PhabBugz::Types qw(:types);
use Bugzilla::Extension::PhabBugz::Constants;
use Bugzilla::Extension::PhabBugz::Policy;
use Bugzilla::Extension::PhabBugz::Revision;
use Bugzilla::Extension::PhabBugz::User;
use Bugzilla::Extension::PhabBugz::Util qw(
    create_revision_attachment
    get_bug_role_phids
    is_attachment_phab_revision
    request
    set_phab_user
);

has 'is_daemon' => ( is => 'rw', default => 0 );

my $Invocant = class_type { class => __PACKAGE__ };

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

    my $sig_alarm =  IO::Async::Signal->new(
        name => 'ALRM',
        on_receipt => sub {
            FATAL("Timeout reached");
            exit;
        },
    );
    # Query for new revisions or changes
    my $feed_timer = IO::Async::Timer::Periodic->new(
        first_interval => 0,
        interval       => PHAB_FEED_POLL_SECONDS,
        reschedule     => 'drift',
        on_tick        => sub {
            try {
                with_writable_database {
                    alarm(PHAB_TIMEOUT);
                    $self->feed_query();
                };
            }
            catch {
                FATAL($_);
            }
            finally {
                alarm(0);
                Bugzilla->_cleanup();
            };
        },
    );

    # Query for new users
    my $user_timer = IO::Async::Timer::Periodic->new(
        first_interval => 0,
        interval       => PHAB_USER_POLL_SECONDS,
        reschedule     => 'drift',
        on_tick        => sub {
            try {
                with_writable_database {
                    alarm(PHAB_TIMEOUT);
                    $self->user_query();
                };
            }
            catch {
                FATAL($_);
            }
            finally {
                alarm(0);
                Bugzilla->_cleanup();
            };
        },
    );

    # Update project membership in Phabricator based on Bugzilla groups
    my $group_timer = IO::Async::Timer::Periodic->new(
        first_interval => 0,
        interval       => PHAB_GROUP_POLL_SECONDS,
        reschedule     => 'drift',
        on_tick        => sub {
            try {
                with_writable_database {
                    alarm(PHAB_TIMEOUT);
                    $self->group_query();
                };
            }
            catch {
                FATAL($_);
            }
            finally {
                alarm(0);
                Bugzilla->_cleanup();
            };

        },
    );

    my $loop = IO::Async::Loop->new;
    $loop->add($feed_timer);
    $loop->add($user_timer);
    $loop->add($group_timer);
    $loop->add($sig_alarm);
    $feed_timer->start;
    $user_timer->start;
    $group_timer->start;
    $loop->run;
}

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

    local Bugzilla::Logging->fields->{type} = 'FEED';

    # Ensure Phabricator syncing is enabled
    if (!Bugzilla->params->{phabricator_enabled}) {
        WARN("PHABRICATOR SYNC DISABLED");
        return;
    }

    # PROCESS NEW FEED TRANSACTIONS

    INFO("Fetching new stories");

    my $story_last_id = $self->get_last_id('feed');

    # Check for new transctions (stories)
    my $new_stories = $self->new_stories($story_last_id);
    INFO("No new stories") unless @$new_stories;

    # Process each story
    foreach my $story_data (@$new_stories) {
        my $story_id    = $story_data->{id};
        my $story_phid  = $story_data->{phid};
        my $author_phid = $story_data->{authorPHID};
        my $object_phid = $story_data->{objectPHID};
        my $story_text  = $story_data->{text};

        TRACE("STORY ID: $story_id");
        TRACE("STORY PHID: $story_phid");
        TRACE("AUTHOR PHID: $author_phid");
        TRACE("OBJECT PHID: $object_phid");
        INFO("STORY TEXT: $story_text");

        # Only interested in changes to revisions for now.
        if ($object_phid !~ /^PHID-DREV/) {
            INFO("SKIPPING: Not a revision change");
            $self->save_last_id($story_id, 'feed');
            next;
        }

        # Skip changes done by phab-bot user
        # If changer does not exist in bugzilla database
        # we use the phab-bot account as the changer
        my $author = Bugzilla::Extension::PhabBugz::User->new_from_query(
          { phids => [ $author_phid  ] }
        );

        if ($author && $author->bugzilla_id) {
            if ($author->bugzilla_user->login eq PHAB_AUTOMATION_USER) {
                INFO("SKIPPING: Change made by phabricator user");
                $self->save_last_id($story_id, 'feed');
                next;
            }
        }
        else {
            my $phab_user = Bugzilla::User->new( { name => PHAB_AUTOMATION_USER } );
            $author = Bugzilla::Extension::PhabBugz::User->new_from_query(
                {
                    ids => [ $phab_user->id ]
                }
            );
        }
        # Load the revision from Phabricator
        my $revision = Bugzilla::Extension::PhabBugz::Revision->new_from_query({ phids => [ $object_phid ] });
        $self->process_revision_change($revision, $author, $story_text);
        $self->save_last_id($story_id, 'feed');
    }

    # Process any build targets as well.
    my $dbh = Bugzilla->dbh;

    INFO("Checking for revisions in draft mode");
    my $build_targets = $dbh->selectall_arrayref(
        "SELECT name, value FROM phabbugz WHERE name LIKE 'build_target_%'",
        { Slice => {} }
    );

    my $delete_build_target = $dbh->prepare(
        "DELETE FROM phabbugz WHERE name = ? AND VALUE = ?"
    );

    foreach my $target (@$build_targets) {
        my ($revision_id) = ($target->{name} =~ /^build_target_(\d+)$/);
        my $build_target  = $target->{value};

        next unless $revision_id && $build_target;

        INFO("Processing revision $revision_id with build target $build_target");

        my $revision =
          Bugzilla::Extension::PhabBugz::Revision->new_from_query(
            {
              ids => [ int($revision_id) ]
            }
        );

        $self->process_revision_change( $revision, $revision->author, " created D" . $revision->id );

        # Set the build target to a passing status to
        # allow the revision to exit draft state
        request( 'harbormaster.sendmessage', {
            buildTargetPHID => $build_target,
            type            => 'pass'
        } );

        $delete_build_target->execute($target->{name}, $target->{value});
     }

    if (Bugzilla->datadog) {
      my $dd = Bugzilla->datadog();
      $dd->increment('bugzilla.phabbugz.feed_query_count');
    }
}

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

    local Bugzilla::Logging->fields->{type} = 'USERS';

    # Ensure Phabricator syncing is enabled
    if (!Bugzilla->params->{phabricator_enabled}) {
        WARN("PHABRICATOR SYNC DISABLED");
        return;
    }

    # PROCESS NEW USERS

    INFO("Fetching new users");

    my $user_last_id = $self->get_last_id('user');

    # Check for new users
    my $new_users = $self->new_users($user_last_id);
    INFO("No new users") unless @$new_users;

    # Process each new user
    foreach my $user_data (@$new_users) {
        my $user_id       = $user_data->{id};
        my $user_login    = $user_data->{fields}{username};
        my $user_realname = $user_data->{fields}{realName};
        my $object_phid   = $user_data->{phid};

        TRACE("ID: $user_id");
        TRACE("LOGIN: $user_login");
        TRACE("REALNAME: $user_realname");
        TRACE("OBJECT PHID: $object_phid");

        with_readonly_database {
            $self->process_new_user($user_data);
        };
        $self->save_last_id($user_id, 'user');
    }

    if (Bugzilla->datadog) {
      my $dd = Bugzilla->datadog();
      $dd->increment('bugzilla.phabbugz.user_query_count');
    }
}

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

    local Bugzilla::Logging->fields->{type} = 'GROUPS';

    # Ensure Phabricator syncing is enabled
    if ( !Bugzilla->params->{phabricator_enabled} ) {
        WARN("PHABRICATOR SYNC DISABLED");
        return;
    }

    # PROCESS SECURITY GROUPS

    INFO("Updating group memberships");

    # Loop through each group and perform the following:
    #
    # 1. Load flattened list of group members
    # 2. Check to see if Phab project exists for 'bmo-<group_name>'
    # 3. Create if does not exist with locked down policy.
    # 4. Set project members to exact list including phab-bot user
    # 5. Profit

    my $sync_groups = Bugzilla::Group->match( { isactive => 1, isbuggroup => 1 } );

    # Load phab-bot Phabricator user to add as a member of each project group later
    my $phab_bmo_user = Bugzilla::User->new( { name => PHAB_AUTOMATION_USER, cache => 1 } );
    my $phab_user =
      Bugzilla::Extension::PhabBugz::User->new_from_query(
        {
            ids => [ $phab_bmo_user->id ]
        }
    );

    # secure-revision project that will be used for bmo group projects
    my $secure_revision =
      Bugzilla::Extension::PhabBugz::Project->new_from_query(
        {
          name => 'secure-revision'
        }
    );

    foreach my $group (@$sync_groups) {
        # Create group project if one does not yet exist
        my $phab_project_name = 'bmo-' . $group->name;
        my $project =
          Bugzilla::Extension::PhabBugz::Project->new_from_query(
            {
              name => $phab_project_name
            }
        );

        if ( !$project ) {
            INFO("Project $phab_project_name not found. Creating.");
            $project = Bugzilla::Extension::PhabBugz::Project->create(
              {
                name        => $phab_project_name,
                description => 'BMO Security Group for ' . $group->name,
                view_policy => $secure_revision->phid,
                edit_policy => $secure_revision->phid,
                join_policy => $secure_revision->phid
              }
            );
        }
        else {
            # Make sure that the group project permissions are set properly
            INFO("Updating permissions on $phab_project_name");
            $project->set_policy( 'view', $secure_revision->phid );
            $project->set_policy( 'edit', $secure_revision->phid );
            $project->set_policy( 'join', $secure_revision->phid );
        }

        # Make sure phab-bot also a member of the new project group so that it can
        # make policy changes to the private revisions
        INFO( "Checking project members for " . $project->name );
        my $set_members          = $self->get_group_members($group);
        my @set_member_phids     = uniq map { $_->phid } ( @$set_members, $phab_user );
        my @current_member_phids = uniq map { $_->phid } @{ $project->members };
        my ( $removed, $added )  = diff_arrays( \@current_member_phids, \@set_member_phids );

        if (@$added) {
            INFO( 'Adding project members: ' . join( ',', @$added ) );
            $project->add_member($_) foreach @$added;
        }

        if (@$removed) {
            INFO( 'Removing project members: ' . join( ',', @$removed ) );
            $project->remove_member($_) foreach @$removed;
        }

        if (@$added || @$removed) {
            my $result = $project->update();
            local Bugzilla::Logging->fields->{api_result} = $result;
            INFO( "Project " . $project->name . " updated" );
        }
    }

    if (Bugzilla->datadog) {
      my $dd = Bugzilla->datadog();
      $dd->increment('bugzilla.phabbugz.group_query_count');
    }
}

sub process_revision_change {
    state $check = compile($Invocant, Revision, LinkedPhabUser, Str);
    my ($self, $revision, $changer, $story_text) = $check->(@_);

    # NO BUG ID
    if (!$revision->bug_id) {
        if ($story_text =~ /\s+created\s+D\d+/) {
            # If new revision and bug id was omitted, make revision public
            INFO("No bug associated with new revision. Marking public.");
            $revision->make_public();
            $revision->update();
            INFO("SUCCESS");
            return;
        }
        else {
            INFO("SKIPPING: No bug associated with revision change");
            return;
        }
    }


    my $log_message = sprintf(
        "REVISION CHANGE FOUND: D%d: %s | bug: %d | %s | %s",
        $revision->id,
        $revision->title,
        $revision->bug_id,
        $changer->name,
        $story_text);
    INFO($log_message);

    # change to the phabricator user, which returns a guard that restores the previous user.
    my $restore_prev_user = set_phab_user();
    my $bug = $revision->bug;

    # Check to make sure bug id is valid and author can see it
    if ($bug->{error}
        ||!$revision->author->bugzilla_user->can_see_bug($revision->bug_id))
    {
        if ($story_text =~ /\s+created\s+D\d+/) {
            INFO('Invalid bug ID or author does not have access to the bug. ' .
                 'Waiting til next revision update to notify author.');
            return;
        }

        INFO('Invalid bug ID or author does not have access to the bug');
        my $phab_error_message = "";
        Bugzilla->template->process('revision/comments.html.tmpl',
                                    { message => 'invalid_bug_id' },
                                    \$phab_error_message);
        $revision->add_comment($phab_error_message);
        $revision->update();
        return;
    }

    # REVISION SECURITY POLICY

    # If bug is public then remove privacy policy
    if (!@{ $bug->groups_in }) {
        INFO('Bug is public so setting view/edit public');
        $revision->make_public();
    }
    # else bug is private.
    else {
        # Here we create a new custom policy containing the project
        # groups that are mapped to bugzilla groups.
        my $set_project_names = [ map { "bmo-" . $_->name } @{ $bug->groups_in } ];

        # If current policy projects matches what we want to set, then
        # we leave the current policy alone.
        my $current_policy;
        if ($revision->view_policy =~ /^PHID-PLCY/) {
            INFO("Loading current policy: " . $revision->view_policy);
            $current_policy
                = Bugzilla::Extension::PhabBugz::Policy->new_from_query({ phids => [ $revision->view_policy ]});
            my $current_project_names = [ map { $_->name } @{ $current_policy->rule_projects } ];
            INFO("Current policy projects: " . join(", ", @$current_project_names));
            my ($added, $removed) = diff_arrays($current_project_names, $set_project_names);
            if (@$added || @$removed) {
                INFO('Project groups do not match. Need new custom policy');
                $current_policy = undef;
            }
            else {
                INFO('Project groups match. Leaving current policy as-is');
            }
        }

        if (!$current_policy) {
            INFO("Creating new custom policy: " . join(", ", @$set_project_names));
            $revision->make_private($set_project_names);
        }

        # Subscriber list of the private revision should always match
        # the bug roles such as assignee, qa contact, and cc members.
        my $subscribers = get_bug_role_phids($bug);
        $revision->set_subscribers($subscribers);
    }

    my ($timestamp) = Bugzilla->dbh->selectrow_array("SELECT NOW()");

    INFO('Checking for revision attachment');
    my $rev_attachment = create_revision_attachment($bug, $revision, $timestamp, $revision->author->bugzilla_user);
    INFO('Attachment ' . $rev_attachment->id . ' created or already exists.');

    # ATTACHMENT OBSOLETES

    # fixup attachments on current bug
    my @attachments =
      grep { is_attachment_phab_revision($_) } @{ $bug->attachments() };

    foreach my $attachment (@attachments) {
        my ($attach_revision_id) = ($attachment->filename =~ PHAB_ATTACHMENT_PATTERN);
        next if $attach_revision_id != $revision->id;

        my $make_obsolete = $revision->status eq 'abandoned' ? 1 : 0;
        INFO('Updating obsolete status on attachmment ' . $attachment->id);
        $attachment->set_is_obsolete($make_obsolete);

        if ($revision->title ne $attachment->description) {
            INFO('Updating description on attachment ' . $attachment->id);
            $attachment->set_description($revision->title);
        }

        $attachment->update($timestamp);
    }

    # fixup attachments with same revision id but on different bugs
    my %other_bugs;
    my $other_attachments = Bugzilla::Attachment->match({
        mimetype => PHAB_CONTENT_TYPE,
        filename => 'phabricator-D' . $revision->id . '-url.txt',
        WHERE    => { 'bug_id != ? AND NOT isobsolete' => $bug->id }
    });
    foreach my $attachment (@$other_attachments) {
        $other_bugs{$attachment->bug_id}++;
        INFO('Updating obsolete status on attachment ' .
             $attachment->id . " for bug " . $attachment->bug_id);
        $attachment->set_is_obsolete(1);
        $attachment->update($timestamp);
    }

    # FINISH UP

    $bug->update($timestamp);
    $revision->update();

    # Email changes for this revisions bug and also for any other
    # bugs that previously had these revision attachments
    foreach my $bug_id ($revision->bug_id, keys %other_bugs) {
        Bugzilla::BugMail::Send($bug_id, { changer => $changer->bugzilla_user });
    }

    INFO('SUCCESS: Revision D' . $revision->id . ' processed');
}

sub process_new_user {
    state $check = compile($Invocant, HashRef);
    my ( $self, $user_data ) = $check->(@_);

    # Load the user data into a proper object
    my $phab_user = Bugzilla::Extension::PhabBugz::User->new($user_data);

    if (!$phab_user->bugzilla_id) {
        WARN("SKIPPING: No bugzilla id associated with user");
        return;
    }

    my $bug_user  = $phab_user->bugzilla_user;

    # Pre setup before querying DB
    my $restore_prev_user = set_phab_user();

    # CHECK AND WARN FOR POSSIBLE USERNAME SQUATTING
    INFO("Checking for username squatters");
    my $dbh     = Bugzilla->dbh;
    my $regexp  = $dbh->quote( ":?:" . quotemeta($phab_user->name) . "[[:>:]]" );
    my $results = $dbh->selectall_arrayref( "
        SELECT userid, login_name, realname
          FROM profiles
         WHERE userid != ? AND " . $dbh->sql_regexp( 'realname', $regexp ),
        { Slice => {} },
        $bug_user->id );
    if (@$results) {
        # The email client will display the Date: header in the desired timezone,
        # so we can always use UTC here.
        my $timestamp = Bugzilla->dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)');
        $timestamp = format_time($timestamp, '%a, %d %b %Y %T %z', 'UTC');

        foreach my $row (@$results) {
            WARN(
                'Possible username squatter: ',
                'phab user login: ' . $phab_user->name,
                ' phab user realname: ' . $phab_user->realname,
                ' bugzilla user id: ' . $row->{userid},
                ' bugzilla login: ' . $row->{login_name},
                ' bugzilla realname: ' . $row->{realname}
            );

            my $vars = {
                date               => $timestamp,
                phab_user_login    => $phab_user->name,
                phab_user_realname => $phab_user->realname,
                bugzilla_userid    => $bug_user->id,
                bugzilla_login     => $bug_user->login,
                bugzilla_realname  => $bug_user->name,
                squat_userid       => $row->{userid},
                squat_login        => $row->{login_name},
                squat_realname     => $row->{realname}
            };

            my $message;
            my $template = Bugzilla->template;
            $template->process("admin/email/squatter-alert.txt.tmpl", $vars, \$message)
                || ThrowTemplateError($template->error());

            MessageToMTA($message);
        }
    }

    # ADD SUBSCRIBERS TO REVSISIONS FOR CURRENT PRIVATE BUGS

    my $params = {
        f3  => 'OP',
        j3  => 'OR',

        # User must be either reporter, assignee, qa_contact
        # or on the cc list of the bug
        f4  => 'cc',
        o4  => 'equals',
        v4  => $bug_user->login,

        f5  => 'assigned_to',
        o5  => 'equals',
        v5  => $bug_user->login,

        f6  => 'qa_contact',
        o6  => 'equals',
        v6  => $bug_user->login,

        f7  => 'reporter',
        o7  => 'equals',
        v7  => $bug_user->login,

        f9  => 'CP',

        # The bug needs to be private
        f10 => 'bug_group',
        o10 => 'isnotempty',

        # And the bug must have one or more attachments
        # that are connected to revisions
        f11 => 'attachments.filename',
        o11 => 'regexp',
        v11 => '^phabricator-D[[:digit:]]+-url.txt$',
    };

    my $search = Bugzilla::Search->new( fields => [ 'bug_id' ],
                                        params => $params,
                                        order  => [ 'bug_id' ] );
    my $data = $search->data;

    # the first value of each row should be the bug id
    my @bug_ids = map { shift @$_ } @$data;

    INFO("Updating subscriber values for old private bugs");

    foreach my $bug_id (@bug_ids) {
        INFO("Processing bug $bug_id");

        my $bug = Bugzilla::Bug->new({ id => $bug_id, cache => 1 });

        my @attachments =
            grep { is_attachment_phab_revision($_) } @{ $bug->attachments() };

        foreach my $attachment (@attachments) {
            my ($revision_id) = ($attachment->filename =~ PHAB_ATTACHMENT_PATTERN);

            if (!$revision_id) {
                WARN("Skipping " . $attachment->filename . " on bug $bug_id. Filename should be fixed.");
                next;
            }

            INFO("Processing revision D$revision_id");

            my $revision = Bugzilla::Extension::PhabBugz::Revision->new_from_query(
                { ids => [ int($revision_id) ] });

            $revision->add_subscriber($phab_user->phid);
            $revision->update();

            INFO("Revision $revision_id updated");
        }
    }

    INFO('SUCCESS: User ' . $phab_user->id . ' processed');
}

##################
# Helper Methods #
##################

sub new_stories {
    my ( $self, $after ) = @_;
    my $data = { view => 'text' };
    $data->{after} = $after if $after;

    my $result = request( 'feed.query_id', $data );

    unless ( ref $result->{result}{data} eq 'ARRAY'
        && @{ $result->{result}{data} } )
    {
        return [];
    }

    # Guarantee that the data is in ascending ID order
    return [ sort { $a->{id} <=> $b->{id} } @{ $result->{result}{data} } ];
}

sub new_users {
    my ( $self, $after ) = @_;
    my $data = {
        order       => [ "id" ],
        attachments => {
            'external-accounts' => 1
        }
    };
    $data->{before} = $after if $after;

    my $result = request( 'user.search', $data );

    unless ( ref $result->{result}{data} eq 'ARRAY'
        && @{ $result->{result}{data} } )
    {
        return [];
    }

    # Guarantee that the data is in ascending ID order
    return [ sort { $a->{id} <=> $b->{id} } @{ $result->{result}{data} } ];
}

sub get_last_id {
    my ( $self, $type ) = @_;
    my $type_full = $type . "_last_id";
    my $last_id   = Bugzilla->dbh->selectrow_array( "
        SELECT value FROM phabbugz WHERE name = ?", undef, $type_full );
    $last_id ||= 0;
    TRACE(uc($type_full) . ": $last_id" );
    return $last_id;
}

sub save_last_id {
    my ( $self, $last_id, $type ) = @_;

    # Store the largest last key so we can start from there in the next session
    my $type_full = $type . "_last_id";
    TRACE("UPDATING " . uc($type_full) . ": $last_id" );
    Bugzilla->dbh->do( "REPLACE INTO phabbugz (name, value) VALUES (?, ?)",
        undef, $type_full, $last_id );
}

sub get_group_members {
    state $check = compile( $Invocant, Group | Str );
    my ( $self, $group ) = $check->(@_);
    my $group_obj =
      ref $group ? $group : Bugzilla::Group->check( { name => $group, cache => 1 } );

    my $flat_list = join(',',
      @{ Bugzilla::Group->flatten_group_membership( $group_obj->id ) } );

    my $user_query = "
      SELECT DISTINCT profiles.userid
        FROM profiles, user_group_map AS ugm
       WHERE ugm.user_id = profiles.userid
             AND ugm.isbless = 0
             AND ugm.group_id IN($flat_list)";
    my $user_ids = Bugzilla->dbh->selectcol_arrayref($user_query);

    # Return matching users in Phabricator
    return Bugzilla::Extension::PhabBugz::User->match(
      {
        ids => $user_ids
      }
    );
}

1;