class UserMerger
  def initialize(source_user, target_user)
    @source_user = source_user
    @target_user = target_user
  end

  def merge!
    update_notifications
    move_posts
    update_user_ids
    merge_given_daily_likes
    merge_post_timings
    merge_user_visits
    update_site_settings
    merge_user_attributes

    DiscourseEvent.trigger(:merging_users, @source_user, @target_user)
    update_user_stats

    delete_source_user
    delete_source_user_references
  end

  protected

  def update_notifications
    params = {
      source_user_id: @source_user.id,
      source_username: @source_user.username,
      target_username: @target_user.username,
      notification_types_with_correct_user_id: [
        Notification.types[:granted_badge],
        Notification.types[:group_message_summary]
      ],
      invitee_accepted_notification_type: Notification.types[:invitee_accepted]
    }

    Notification.exec_sql(<<~SQL, params)
      UPDATE notifications AS n
      SET data = (data :: JSONB ||
                  jsonb_strip_nulls(
                      jsonb_build_object(
                          'original_username', CASE data :: JSONB ->> 'original_username'
                                               WHEN :source_username
                                                 THEN :target_username
                                               ELSE NULL END,
                          'display_username', CASE data :: JSONB ->> 'display_username'
                                              WHEN :source_username
                                                THEN :target_username
                                              ELSE NULL END,
                          'username', CASE data :: JSONB ->> 'username'
                                      WHEN :source_username
                                        THEN :target_username
                                      ELSE NULL END
                      )
                  )) :: JSON
      WHERE EXISTS(
                SELECT 1
                FROM posts AS p
                WHERE p.topic_id = n.topic_id
                      AND p.post_number = n.post_number
                      AND p.user_id = :source_user_id)
            OR (n.notification_type IN (:notification_types_with_correct_user_id) AND n.user_id = :source_user_id)
            OR (n.notification_type = :invitee_accepted_notification_type
                AND EXISTS(
                    SELECT 1
                    FROM invites i
                    WHERE i.user_id = :source_user_id AND n.user_id = i.invited_by_id
                )
            )
    SQL
  end

  def move_posts
    posts = Post.with_deleted
      .where(user_id: @source_user.id)
      .order(:topic_id, :post_number)
      .pluck(:topic_id, :id)

    last_topic_id = nil
    post_ids = []

    posts.each do |current_topic_id, current_post_id|
      if last_topic_id != current_topic_id && post_ids.any?
        change_post_owner(last_topic_id, post_ids)
        post_ids = []
      end

      last_topic_id = current_topic_id
      post_ids << current_post_id
    end

    change_post_owner(last_topic_id, post_ids) if post_ids.any?
  end

  def change_post_owner(topic_id, post_ids)
    PostOwnerChanger.new(
      topic_id: topic_id,
      post_ids: post_ids,
      new_owner: @target_user,
      acting_user: Discourse.system_user,
      skip_revision: true
    ).change_owner!
  end

  def merge_given_daily_likes
    sql = <<~SQL
      INSERT INTO given_daily_likes AS g (user_id, likes_given, given_date, limit_reached)
        SELECT
          :target_user_id                AS user_id,
          COUNT(1)                       AS likes_given,
          a.created_at::DATE             AS given_date,
          COUNT(1) >= :max_likes_per_day AS limit_reached
        FROM post_actions AS a
        WHERE a.user_id = :target_user_id
              AND a.deleted_at IS NULL
              AND EXISTS(
                  SELECT 1
                  FROM given_daily_likes AS g
                  WHERE g.user_id = :source_user_id AND a.created_at::DATE = g.given_date
              )
        GROUP BY given_date
      ON CONFLICT (user_id, given_date)
        DO UPDATE
          SET likes_given = EXCLUDED.likes_given,
            limit_reached = EXCLUDED.limit_reached
    SQL

    GivenDailyLike.exec_sql(sql,
                            source_user_id: @source_user.id,
                            target_user_id: @target_user.id,
                            max_likes_per_day: SiteSetting.max_likes_per_day,
                            action_type_id: PostActionType.types[:like])
  end

  def merge_post_timings
    update_user_id(:post_timings, conditions: ["x.topic_id = y.topic_id",
                                               "x.post_number = y.post_number"])
    sql = <<~SQL
      UPDATE post_timings AS t
      SET msecs = t.msecs + s.msecs
      FROM post_timings AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
            AND t.topic_id = s.topic_id AND t.post_number = s.post_number
    SQL

    PostTiming.exec_sql(sql, source_user_id: @source_user.id, target_user_id: @target_user.id)
  end

  def merge_user_visits
    update_user_id(:user_visits, conditions: "x.visited_at = y.visited_at")

    sql = <<~SQL
      UPDATE user_visits AS t
      SET posts_read = t.posts_read + s.posts_read,
        mobile       = t.mobile OR s.mobile,
        time_read    = t.time_read + s.time_read
      FROM user_visits AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
            AND t.visited_at = s.visited_at
    SQL

    UserVisit.exec_sql(sql, source_user_id: @source_user.id, target_user_id: @target_user.id)
  end

  def update_site_settings
    SiteSetting.all_settings(true).each do |setting|
      if setting[:type] == "username" && setting[:value] == @source_user.username
        SiteSetting.set_and_log(setting[:setting], @target_user.username)
      end
    end
  end

  def update_user_stats
    # topics_entered
    UserStat.exec_sql(<<~SQL, target_user_id: @target_user.id)
      UPDATE user_stats
      SET topics_entered = (
        SELECT COUNT(topic_id)
        FROM topic_views
        WHERE user_id = :target_user_id
      )
      WHERE user_id = :target_user_id
    SQL

    # time_read and days_visited
    UserStat.exec_sql(<<~SQL, target_user_id: @target_user.id)
      UPDATE user_stats
      SET time_read  = COALESCE(x.time_read, 0),
        days_visited = COALESCE(x.days_visited, 0)
      FROM (
             SELECT
               SUM(time_read) AS time_read,
               COUNT(1)       AS days_visited
             FROM user_visits
             WHERE user_id = :target_user_id
           ) AS x
      WHERE user_id = :target_user_id
    SQL

    # posts_read_count
    UserStat.exec_sql(<<~SQL, target_user_id: @target_user.id)
      UPDATE user_stats
      SET posts_read_count = (
        SELECT COUNT(1)
        FROM post_timings AS pt
        WHERE pt.user_id = :target_user_id AND EXISTS(
            SELECT 1
            FROM topics AS t
            WHERE t.archetype = 'regular' AND t.deleted_at IS NULL
        ))
      WHERE user_id = :target_user_id
    SQL

    # likes_given, likes_received, new_since, read_faq, first_post_created_at
    UserStat.exec_sql(<<~SQL, source_user_id: @source_user.id, target_user_id: @target_user.id)
      UPDATE user_stats AS t
      SET likes_given         = t.likes_given + s.likes_given,
        likes_received        = t.likes_received + s.likes_received,
        new_since             = LEAST(t.new_since, s.new_since),
        read_faq              = LEAST(t.read_faq, s.read_faq),
        first_post_created_at = LEAST(t.first_post_created_at, s.first_post_created_at)
      FROM user_stats AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
    SQL
  end

  def merge_user_attributes
    User.exec_sql(<<~SQL, source_user_id: @source_user.id, target_user_id: @target_user.id)
      UPDATE users AS t
      SET created_at              = LEAST(t.created_at, s.created_at),
        updated_at                = LEAST(t.updated_at, s.updated_at),
        seen_notification_id      = GREATEST(t.seen_notification_id, s.seen_notification_id),
        last_posted_at            = GREATEST(t.last_seen_at, s.last_seen_at),
        last_seen_at              = GREATEST(t.last_seen_at, s.last_seen_at),
        admin                     = t.admin OR s.admin,
        last_emailed_at           = GREATEST(t.last_emailed_at, s.last_emailed_at),
        trust_level               = GREATEST(t.trust_level, s.trust_level),
        previous_visit_at         = GREATEST(t.previous_visit_at, s.previous_visit_at),
        date_of_birth             = COALESCE(t.date_of_birth, s.date_of_birth),
        ip_address                = COALESCE(t.ip_address, s.ip_address),
        moderator                 = t.moderator OR s.moderator,
        title                     = COALESCE(t.title, s.title),
        primary_group_id          = COALESCE(t.primary_group_id, s.primary_group_id),
        registration_ip_address   = COALESCE(t.registration_ip_address, s.registration_ip_address),
        first_seen_at             = LEAST(t.first_seen_at, s.first_seen_at),
        group_locked_trust_level  = GREATEST(t.group_locked_trust_level, s.group_locked_trust_level),
        manual_locked_trust_level = GREATEST(t.manual_locked_trust_level, s.manual_locked_trust_level)
      FROM users AS s
      WHERE t.id = :target_user_id AND s.id = :source_user_id
    SQL

    UserProfile.exec_sql(<<~SQL, source_user_id: @source_user.id, target_user_id: @target_user.id)
      UPDATE user_profiles AS t
      SET location           = COALESCE(t.location, s.location),
        website              = COALESCE(t.website, s.website),
        bio_raw              = COALESCE(t.bio_raw, s.bio_raw),
        bio_cooked           = COALESCE(t.bio_cooked, s.bio_cooked),
        bio_cooked_version   = COALESCE(t.bio_cooked_version, s.bio_cooked_version),
        profile_background   = COALESCE(t.profile_background, s.profile_background),
        dismissed_banner_key = COALESCE(t.dismissed_banner_key, s.dismissed_banner_key),
        badge_granted_title  = t.badge_granted_title OR s.badge_granted_title,
        card_background      = COALESCE(t.card_background, s.card_background),
        card_image_badge_id  = COALESCE(t.card_image_badge_id, s.card_image_badge_id),
        views                = t.views + s.views
      FROM user_profiles AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
    SQL
  end

  def update_user_ids
    Category.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:category_users, conditions: ["x.category_id = y.category_id"])

    update_user_id(:developers)

    update_user_id(:draft_sequences, conditions: "x.draft_key = y.draft_key")
    update_user_id(:drafts, conditions: "x.draft_key = y.draft_key")

    EmailLog.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    GroupHistory.where(acting_user_id: @source_user.id).update_all(acting_user_id: @target_user.id)
    GroupHistory.where(target_user_id: @source_user.id).update_all(target_user_id: @target_user.id)

    update_user_id(:group_users, conditions: "x.group_id = y.group_id")

    IncomingEmail.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    IncomingLink.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    IncomingLink.where(current_user_id: @source_user.id).update_all(current_user_id: @target_user.id)

    Invite.with_deleted.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    Invite.with_deleted.where(invited_by_id: @source_user.id).update_all(invited_by_id: @target_user.id)
    Invite.with_deleted.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)

    update_user_id(:muted_users, conditions: "x.muted_user_id = y.muted_user_id")
    update_user_id(:muted_users, user_id_column_name: "muted_user_id", conditions: "x.user_id = y.user_id")

    Notification.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:post_actions, conditions: ["x.post_id = y.post_id",
                                               "x.post_action_type_id = y.post_action_type_id",
                                               "x.targets_topic = y.targets_topic"])

    PostAction.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)
    PostAction.where(deferred_by_id: @source_user.id).update_all(deferred_by_id: @target_user.id)
    PostAction.where(agreed_by_id: @source_user.id).update_all(agreed_by_id: @target_user.id)
    PostAction.where(disagreed_by_id: @source_user.id).update_all(disagreed_by_id: @target_user.id)

    PostRevision.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    Post.with_deleted.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)
    Post.with_deleted.where(last_editor_id: @source_user.id).update_all(last_editor_id: @target_user.id)
    Post.with_deleted.where(locked_by_id: @source_user.id).update_all(locked_by_id: @target_user.id)
    Post.with_deleted.where(reply_to_user_id: @source_user.id).update_all(reply_to_user_id: @target_user.id)

    QueuedPost.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    QueuedPost.where(approved_by_id: @source_user.id).update_all(approved_by_id: @target_user.id)
    QueuedPost.where(rejected_by_id: @source_user.id).update_all(rejected_by_id: @target_user.id)

    SearchLog.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:tag_users, conditions: "x.tag_id = y.tag_id")

    Theme.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:topic_allowed_users, conditions: "x.topic_id = y.topic_id")

    TopicEmbed.with_deleted.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)

    TopicLink.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    TopicLinkClick.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    TopicTimer.with_deleted.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)

    update_user_id(:topic_timers, conditions: ["x.status_type = y.status_type",
                                               "x.topic_id = y.topic_id",
                                               "y.deleted_at IS NULL"])

    update_user_id(:topic_users, conditions: "x.topic_id = y.topic_id")

    update_user_id(:topic_views, conditions: "x.topic_id = y.topic_id")

    Topic.with_deleted.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)

    UnsubscribeKey.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    Upload.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:user_archived_messages, conditions: "x.topic_id = y.topic_id")

    update_user_id(:user_actions,
                   user_id_column_name: "user_id",
                   conditions: ["x.action_type = y.action_type",
                                "x.target_topic_id IS NOT DISTINCT FROM y.target_topic_id",
                                "x.target_post_id IS NOT DISTINCT FROM y.target_post_id",
                                "x.acting_user_id IN (:source_user_id, :target_user_id)"])
    update_user_id(:user_actions,
                   user_id_column_name: "acting_user_id",
                   conditions: ["x.action_type = y.action_type",
                                "x.user_id = y.user_id",
                                "x.target_topic_id IS NOT DISTINCT FROM y.target_topic_id",
                                "x.target_post_id IS NOT DISTINCT FROM y.target_post_id"])

    update_user_id(:user_badges, conditions: ["x.badge_id = y.badge_id",
                                              "x.seq = y.seq",
                                              "x.post_id IS NOT DISTINCT FROM y.post_id"])

    UserBadge.where(granted_by_id: @source_user.id).update_all(granted_by_id: @target_user.id)

    update_user_id(:user_custom_fields, conditions: "x.name = y.name")

    update_user_id(:user_emails, conditions: "x.email = y.email OR y.primary = false", updates: '"primary" = false')

    UserExport.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    UserHistory.where(target_user_id: @source_user.id).update_all(target_user_id: @target_user.id)
    UserHistory.where(acting_user_id: @source_user.id).update_all(acting_user_id: @target_user.id)

    UserProfileView.where(user_profile_id: @source_user.id).update_all(user_profile_id: @target_user.id)
    UserProfileView.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    UserWarning.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    UserWarning.where(created_by_id: @source_user.id).update_all(created_by_id: @target_user.id)

    User.where(approved_by_id: @source_user.id).update_all(approved_by_id: @target_user.id)
  end

  def delete_source_user
    @source_user.reload
    @source_user.update_attribute(:admin, false)
    UserDestroyer.new(Discourse.system_user).destroy(@source_user)
  end

  def delete_source_user_references
    Developer.where(user_id: @source_user.id).delete_all
    DraftSequence.where(user_id: @source_user.id).delete_all
    GivenDailyLike.where(user_id: @source_user.id).delete_all
    MutedUser.where(user_id: @source_user.id).or(MutedUser.where(muted_user_id: @source_user.id)).delete_all
    UserAuthTokenLog.where(user_id: @source_user.id).delete_all
    UserAvatar.where(user_id: @source_user.id).delete_all
    UserAction.where(acting_user_id: @source_user.id).delete_all
  end

  def update_user_id(table_name, opts = {})
    builder = update_user_id_sql_builder(table_name, opts)
    builder.exec(source_user_id: @source_user.id, target_user_id: @target_user.id)
  end

  def update_user_id_sql_builder(table_name, opts = {})
    user_id_column_name = opts[:user_id_column_name] || :user_id
    conditions = Array.wrap(opts[:conditions])
    updates = Array.wrap(opts[:updates])

    builder = SqlBuilder.new(<<~SQL)
      UPDATE #{table_name} AS x
      /*set*/
      WHERE x.#{user_id_column_name} = :source_user_id AND NOT EXISTS(
          SELECT 1
          FROM #{table_name} AS y
          /*where*/
      )
    SQL

    builder.set("#{user_id_column_name} = :target_user_id")
    updates.each { |u| builder.set(u) }

    builder.where("y.#{user_id_column_name} = :target_user_id")
    conditions.each { |c| builder.where(c) }

    builder
  end
end