require "rails_helper"

RSpec.describe Notification, type: :model do
  let(:user)            { create(:user) }
  let(:user2)           { create(:user) }
  let(:user3)           { create(:user) }
  let(:organization)    { create(:organization) }
  let(:article)         { create(:article, :with_notification_subscription, user_id: user.id, page_views_count: 4000, positive_reactions_count: 70) }
  let(:follow_instance) { user.follow(user2) }
  let(:badge_achievement) { create(:badge_achievement) }

  it { is_expected.to validate_uniqueness_of(:user_id).scoped_to(%i[organization_id notifiable_id notifiable_type action]) }

  describe "when trying to create duplicate notifications" do
    # Duplicate notifications are not allowed even when validations are skipped
    it "doesn't allow to create a duplicate notification via import" do
      create(:notification, user: user, notifiable: article, action: "Reaction")
      duplicate_notification = build(:notification, user: user, notifiable: article, action: "Reaction")
      expect do
        described_class.import([duplicate_notification],
                               on_duplicate_key_update: {
                                 conflict_target: %i[notifiable_id notifiable_type user_id action],
                                 index_predicate: "action IS NOT NULL",
                                 columns: %i[json_data notified_at read]
                               })
      end.not_to change(described_class, :count)
    end

    it "updates when trying to create a duplicate notification via import" do
      notification = create(:notification, user: user, notifiable: article, action: "Reaction", json_data: { "user_id" => 1 })
      duplicate_notification = build(:notification, user: user, notifiable: article, action: "Reaction", json_data: { "user_id" => 2 })
      described_class.import([duplicate_notification],
                             on_duplicate_key_update: {
                               conflict_target: %i[notifiable_id notifiable_type user_id action],
                               index_predicate: "action IS NOT NULL",
                               columns: %i[json_data notified_at read]
                             })
      notification.reload
      expect(notification.json_data["user_id"]).to eq(2)
    end

    it "doesn't allow to create a duplicate organization notification via import" do
      create(:notification, organization: organization, notifiable: article, action: "Reaction")
      duplicate_notification = build(:notification, organization: organization, notifiable: article, action: "Reaction")
      expect do
        described_class.import([duplicate_notification],
                               on_duplicate_key_update: {
                                 conflict_target: %i[notifiable_id notifiable_type organization_id action],
                                 index_predicate: "action IS NOT NULL",
                                 columns: %i[json_data notified_at read]
                               })
      end.not_to change(described_class, :count)
    end

    describe "when notifiable is a Comment" do
      let!(:comment) { create(:comment, commentable: article) }

      it "doesn't allow to create a duplicate user notification via import when action is nil" do
        notification_attributes = { user: user, notifiable: comment, action: nil }
        create(:notification, notification_attributes)
        duplicate_notification = build(:notification, notification_attributes)
        expect do
          described_class.import([duplicate_notification],
                                 on_duplicate_key_update: {
                                   conflict_target: %i[notifiable_id notifiable_type user_id],
                                   index_predicate: "action IS NULL",
                                   columns: %i[json_data notified_at read]
                                 })
        end.not_to change(described_class, :count)
      end

      it "doesn't allow to create a duplicate org notification via import when action is nil" do
        notification_attributes = { organization: organization, notifiable: comment, action: nil }
        create(:notification, notification_attributes)
        duplicate_notification = build(:notification, notification_attributes)
        expect do
          described_class.import([duplicate_notification],
                                 on_duplicate_key_update: {
                                   conflict_target: %i[notifiable_id notifiable_type organization_id],
                                   index_predicate: "action IS NULL",
                                   columns: %i[json_data notified_at read]
                                 })
        end.not_to change(described_class, :count)
      end
    end
  end

  describe "when trying to #send_new_follower_notification after following a tag" do
    let(:tag) { create(:tag) }
    let(:tag_follow) { user.follow(tag) }

    it "runs fine" do
      perform_enqueued_jobs do
        described_class.send_new_follower_notification(tag_follow)
      end
    end

    it "doesn't create a notification" do
      perform_enqueued_jobs do
        expect do
          described_class.send_new_follower_notification(tag_follow)
        end.not_to change(described_class, :count)
      end
    end
  end

  describe "#send_new_follower_notification" do
    before do
      perform_enqueued_jobs do
        described_class.send_new_follower_notification(follow_instance)
      end
    end

    it "sets the notifiable_at column upon creation" do
      expect(described_class.last.notified_at).not_to eq nil
    end

    context "when a user follows another user" do
      it "creates a notification belonging to the person being followed" do
        expect(described_class.first.user_id).to eq user2.id
      end

      it "creates a notification from the follow instance" do
        notifiable_data = { notifiable_id: described_class.first.notifiable_id, notifiable_type: described_class.first.notifiable_type }
        follow_data = { notifiable_id: follow_instance.id, notifiable_type: follow_instance.class.name }
        expect(notifiable_data).to eq follow_data
      end
    end

    context "when a user follows an organization" do
      let(:follow_instance) { user.follow(organization) }

      it "creates a notification belonging to the organization" do
        expect(described_class.first.organization_id).to eq organization.id
      end

      it "does not create a notification belonging to a user" do
        expect(described_class.first.user_id).to eq nil
      end

      it "creates a notification from the follow instance" do
        notifiable_data = { notifiable_id: described_class.first.notifiable_id, notifiable_type: described_class.first.notifiable_type }
        follow_data = { notifiable_id: follow_instance.id, notifiable_type: follow_instance.class.name }
        expect(notifiable_data).to eq follow_data
      end
    end

    context "when a user unfollows another user" do
      it "destroys the follow notification" do
        follow_instance = user.stop_following(user2)
        perform_enqueued_jobs do
          described_class.send_new_follower_notification(follow_instance)
        end
        expect(described_class.count).to eq 0
      end
    end
  end

  describe "#send_new_comment_notifications" do
    context "when all commenters are subscribed" do
      it "sends a notification to the author of the article" do
        comment = create(:comment, user: user2, commentable: article)
        described_class.send_new_comment_notifications_without_delay(comment)
        expect(user.notifications.count).to eq 1
      end

      it "does not send a notification to the author of the article if the commenter is the author" do
        comment = create(:comment, user: user, commentable: article)
        described_class.send_new_comment_notifications_without_delay(comment)
        expect(user.notifications.count).to eq 0
      end

      it "does not send a notification to the author of the comment" do
        comment = create(:comment, user: user2, commentable: article)
        described_class.send_new_comment_notifications_without_delay(comment)
        expect(user2.notifications.count).to eq 0
      end

      it "sends a notification to the author of the article about the child comment" do
        parent_comment = create(:comment, user: user2, commentable: article)
        child_comment = create(:comment, user: user3, commentable: article, ancestry: parent_comment.id.to_s)
        described_class.send_new_comment_notifications_without_delay(child_comment)
        expect(user.notifications.count).to eq(1)
      end

      it "sends a notification to the organization" do
        org = create(:organization)
        create(:organization_membership, user: user, organization: org)
        article.update(organization: org)
        comment = create(:comment, user: user2, commentable: article)
        described_class.send_new_comment_notifications_without_delay(comment)
        expect(org.notifications.count).to eq 1
      end
    end

    context "when the author of the article is not subscribed" do
      let!(:comment) { create(:comment, user: user2, commentable: article) }

      before do
        article.update(receive_notifications: false)
        article.notification_subscriptions.delete_all
      end

      it "does not send a notification to the author of the article" do
        described_class.send_new_comment_notifications_without_delay(comment)
        expect(user.notifications.count).to eq 0
      end

      it "doesn't send a notification to the author of the article about the child comment" do
        child_comment = create(:comment, user: user3, commentable: article, ancestry: comment.id.to_s)
        described_class.send_new_comment_notifications_without_delay(child_comment)
        expect(user.notifications.count).to eq 0
      end
    end

    context "when the author of a comment is not subscribed" do
      let(:parent_comment) { create(:comment, user: user2, commentable: article) }
      let!(:child_comment) { create(:comment, user: user3, commentable: article, ancestry: parent_comment.id.to_s) }

      before do
        parent_comment.update(receive_notifications: false)
      end

      it "does not send a notification to the author of the comment" do
        described_class.send_new_comment_notifications_without_delay(child_comment)
        expect(user2.notifications.count).to eq 0
      end

      it "sends a notification to the author of the article" do
        described_class.send_new_comment_notifications_without_delay(child_comment)
        expect(user.notifications.count).to eq(1)
      end
    end
  end

  describe "#send_reaction_notification" do
    context "when reactable is receiving notifications" do
      it "sends a notification to the author of a comment" do
        comment = create(:comment, user: user2, commentable: article)
        reaction = create(:reaction, reactable: comment, user: user)
        perform_enqueued_jobs do
          described_class.send_reaction_notification(reaction, reaction.reactable.user)
          expect(user2.notifications.count).to eq 1
        end
      end

      it "sends a notification to the author of an article" do
        reaction = create(:reaction, reactable: article, user: user2)
        perform_enqueued_jobs do
          described_class.send_reaction_notification(reaction, reaction.reactable.user)
          expect(user.notifications.count).to eq 1
        end
      end
    end

    context "when a reaction is destroyed" do
      let(:comment) { create(:comment, user: user2, commentable: article) }
      let!(:notification) { create(:notification, user: user, notifiable: comment, action: "Reaction") }

      it "destroys the notification if it exists" do
        reaction = create(:reaction, reactable: comment, user: user)
        reaction.destroy
        described_class.send_reaction_notification_without_delay(reaction, article.user)
        expect(described_class.where(id: notification.id)).not_to be_any
      end

      it "keeps the notification if siblings exist" do
        reaction = create(:reaction, reactable: comment, user: user)
        create(:reaction, reactable: comment, user: user3)
        reaction.destroy
        described_class.send_reaction_notification_without_delay(reaction, article.user)
        notification.reload
        expect(notification).to be_persisted
      end

      it "doesn't keep data of the destroyed reaction in the notification" do
        reaction = create(:reaction, reactable: comment, user: user)
        create(:reaction, reactable: comment, user: user3)
        reaction.destroy
        described_class.send_reaction_notification_without_delay(reaction, article.user)
        notification.reload
        expect(notification.json_data["reaction"]["aggregated_siblings"].map { |s| s["user"]["id"] }).to eq([user3.id])
        # not the user of the destroyed reaction!
        expect(notification.json_data["user"]["id"]).to eq(user3.id)
      end
    end

    context "when reactable is not receiving notifications" do
      it "does not send a notification to the author of a comment" do
        comment = create(:comment, user: user2, commentable: article)
        comment.update(receive_notifications: false)
        reaction = create(:reaction, reactable: comment, user: user)
        described_class.send_reaction_notification_without_delay(reaction, reaction.reactable.user)
        expect(user2.notifications.count).to eq 0
      end

      it "does not send a notification to the author of an article" do
        article.update(receive_notifications: false)
        reaction = create(:reaction, reactable: article, user: user2)
        described_class.send_reaction_notification_without_delay(reaction, reaction.reactable.user)
        expect(user.notifications.count).to eq 0
      end
    end

    context "when the reactable is an organization's article" do
      let(:org) { create(:organization) }

      before do
        create(:organization_membership, user: user, organization: org, type_of_user: "admin")
        article.update(organization: org)
      end

      it "creates a notification with the organization's ID" do
        reaction = create(:reaction, reactable: article, user: user2)
        described_class.send_reaction_notification_without_delay(reaction, reaction.reactable.organization)
        expect(org.notifications.count).to eq 1
      end
    end

    it "creates positive reaction notification" do
      reaction = article.reactions.create!(
        user_id: user2.id,
        category: "like",
      )
      perform_enqueued_jobs do
        expect do
          described_class.send_reaction_notification(reaction, reaction.reactable.user)
        end.to change(described_class, :count).by(1)
      end
    end

    it "does not create negative notification" do
      user2.add_role(:trusted)
      reaction = article.reactions.create!(
        user_id: user2.id,
        category: "vomit",
      )
      perform_enqueued_jobs do
        expect do
          described_class.send_reaction_notification(reaction, reaction.reactable.user)
        end.not_to change(described_class, :count)
      end
    end

    it "destroys the notification properly" do
      reaction = create(:reaction, user: user2, reactable: article, category: "like")
      perform_enqueued_jobs do
        described_class.send_reaction_notification(reaction, reaction.reactable.user)
        reaction.destroy!
        described_class.send_reaction_notification(reaction, reaction.reactable.user)
        expect(described_class.count).to eq 0
      end
    end
  end

  describe "#send_to_followers" do
    context "when the notifiable is an article from a user" do
      before do
        user2.follow(user)
        perform_enqueued_jobs { described_class.send_to_followers(article, "Published") }
      end

      it "sends a notification to the author's followers" do
        expect(described_class.first.user_id).to eq user2.id
      end
    end

    context "when the notifiable is an article from an organization" do
      let(:article) { create(:article, organization_id: organization.id, user_id: user.id) }

      before do
        user2.follow(user)
        user3.follow(organization)
        perform_enqueued_jobs { described_class.send_to_followers(article, "Published") }
      end

      it "sends a notification to author's followers" do
        expect(user2.notifications.count).to eq 1
      end

      it "sends a notification to the organization's followers" do
        expect(user3.notifications.count).to eq 1
      end
    end
  end

  describe "#update_notifications" do
    context "when there are article notifications to update" do
      before do
        user2.follow(user)
        perform_enqueued_jobs { described_class.send_to_followers(article, "Published") }
      end

      it "updates the notification with the new article title" do
        new_title = "hehehe hohoho!"
        article.update_column(:title, new_title)
        article.reload
        perform_enqueued_jobs do
          described_class.update_notifications(article, "Published")
          first_notification_article_title = described_class.first.json_data["article"]["title"]
          expect(first_notification_article_title).to eq new_title
        end
      end

      it "adds organization data when the article now belongs to an org" do
        article.update_column(:organization_id, organization.id)
        article.reload
        perform_enqueued_jobs do
          described_class.update_notifications(article.reload, "Published")
          first_notification_organization_id = described_class.first.json_data["organization"]["id"]
          expect(first_notification_organization_id).to eq organization.id
        end
      end
    end
  end

  describe "#aggregated?" do
    it "returns true if a notification's action is 'Reaction'" do
      notification = build(:notification, action: "Reaction")
      expect(notification.aggregated?).to eq true
    end

    it "returns true if a notification's action is 'Follow'" do
      notification = build(:notification, action: "Follow")
      expect(notification.aggregated?).to eq true
    end

    it "returns false if a notification's action is not 'Reaction' or 'Follow'" do
      notification = build(:notification, action: "Published")
      expect(notification.aggregated?).to eq false
    end
  end

  describe "#send_new_badge_achievement_notification" do
    it "enqueues a new badge achievement job" do
      assert_enqueued_with(job: Notifications::NewBadgeAchievementJob, args: [badge_achievement.id]) do
        described_class.send_new_badge_achievement_notification(badge_achievement)
      end
    end
  end

  describe "#send_new_badge_notification (deprecated)" do
    it "enqueues a new badge achievement job" do
      assert_enqueued_with(job: Notifications::NewBadgeAchievementJob, args: [badge_achievement.id]) do
        described_class.send_new_badge_notification(badge_achievement)
      end
    end
  end

  describe "#remove_all" do
    let(:mention) { create(:mention, user_id: user.id, mentionable_id: comment.id, mentionable_type: "Comment") }
    let(:comment) { create(:comment, user_id: user.id, commentable_id: article.id) }
    let(:notifiable_collection) { [mention] }

    before do
      create(:notification, user_id: mention.user_id, notifiable_id: mention.id, notifiable_type: "Mention")
    end

    it "removes all mention related notifications" do
      perform_enqueued_jobs do
        expect do
          described_class.remove_all(notifiable_ids: mention.id, notifiable_type: "Mention")
        end.to change(described_class, :count).by(-1)
      end
    end
  end
end