module Post
  class Create
    attr_reader :record, :user, :tags, :discussion_topic, :payment

    def initialize(user:, params:)
      @user = user
      @tags = params.delete(:tags)
      @record = Post.new(params)
    end

    def call
      return false unless valid?

      ActiveRecord::Base.transaction do
        setup!
      end

      notify_users! if record.waiting?
      notify_admins! if needs_approval?
    end

    private

    def valid?
      user.blogs.include?(draft.blog)
    end

    def setup!
      create_post!
      create_payment! if is_freelancer?
      create_discussion_topic!
      create_tags! if tags.present?
      close_draft! if draft.auto_close?
    end

    def close_draft!
      Draft::Close.call(draft)
    end

    def create_post!
      record.status = default_status
      record.user = user
      record.save!
    end

    def create_payment!
      @payment = Payment::Create.call(value: record.draft.amount, post: record)
    end

    def create_discussion_topic!
      @discussion_topic = DiscussionTopic::Create.call(post_id: record.id, topic_type: :main)
    end

    def create_tags!
      tags.each do |attr|
        PostTag::Create.call(attr.merge(post_id: record.id))
      end
    end

    def notify_users!
      subscribers.each do |subscriber|
        Notifications::NewPostNotification.call(subscriber.user, record)
      end
    end

    def notify_admins!
      admins.each do |admin|
        Notifications::NewPostApprovalNotification.call(record, admin)
      end
    end

    def is_published?
      record.published?
    end

    def is_freelancer?
      User::Query::Resolver.is_freelancer?(user)
    end

    def default_status
      needs_approval? ? :moderating : :waiting
    end

    def needs_approval?
      is_guest_writer? && blog_has_approval_feature?
    end

    def is_guest_writer?
      user.guest_writer?
    end

    def blog_has_approval_feature?
      blog.features.approval.exists?
    end

    def subscribers
      @subscribers ||= blog.subscribers.active.with_user([ :admin ])
    end

    def blog
      @blog ||= draft.blog
    end

    def draft
      @draft ||= Draft.find(record.draft_id)
    end

    def admins
      @admins ||= Blog::AdminsQuery.new(blog: blog, roles: :admin).items
    end
  end
end