class Eco::API::UseCases::DefaultCases::RestoreDBCase < Eco::API::Common::Loaders::UseCase
  name "restore-db"
  type :sync

  def main(entries, people, session, options, usecase)
    micro    = session.micro
    require_people_as_entries!(entries)

    restart  = session.new_job("main", "restart", :create, usecase) if options.dig(:include, :create)
    update   = session.new_job("main", "update",  :update, usecase)
    delete   = session.new_job("main", "delete",  :update, usecase)

    if options.dig(:include, :delete)
      micro.with_each_leaver(entries, people, options) do |person|
        delete.add(person)
      end
    end

    re_starters = []

    micro.with_each(entries, people, options) do |entry, person|
      if person.new? && !options.dig(:include, :create)
        re_starters.push(entry);
        next
      end

      person.new? ? restart.add(person) : update.add(person)

      core_copy(entry, person, options) unless options.dig(:exclude, :core)
      person.details = entry.details    unless options.dig(:exclude, :details)

      unless options.dig(:exclude, :account) || !entry.account
        person.account ||= {}
        account_copy(entry.account, person.account, options)
      end
    end

    report_re_starters(re_starters, session.logger)
  end

  private

  def core_copy(entry, person, options)
    person.external_id   = entry.external_id   unless options.dig(:exclude, :external_id)
    person.name          = entry.name          unless options.dig(:exclude, :name)
    person.email         = entry.email         unless options.dig(:exclude, :email)
    person.supervisor_id = entry.supervisor_id unless options.dig(:exclude, :supervisor)
    person.filter_tags   = entry.filter_tags   unless options.dig(:exclude, :filter_tags)
    person.freemium      = entry.freemium
  end

  def account_copy(src, dst, options)
    if src = entry.account
      dst.default_tag        = src.default_tag      unless options.dig(:exclude, :filter_tags)
      dst.policy_group_ids   = src.policy_group_ids unless options.dig(:exclude, :policy_groups)

      unless options.dig(:exclude, :abilities)
        dst.permissions_preset = src.permissions_preset
        dst.permissions_custom = src.permissions_custom
      end

      dst.login_provider_ids = src.login_provider_ids
      dst.accept_eula        = src.accept_eula

      if src.preferences
        dst.doc["preferences"] = JSON.parse((src.doc["preferences"] || {}).to_json)
      end

      dst.starred_ids        = src.starred_ids
      dst.landing_page_id    = src.landing_page_id
      dst&.send_invites      = options[:send_invites] if options.key?(:send_invites)
    end
  end

  def require_people_as_entries!(entries, logger)
    unless entries.is_a?(Eco::API::Organization::People)
      logger.error("Your input should be an 'Eco::API::Organization::People' object. Got: #{entries.class}")
      exit(1)
    end
  end

  def report_re_starters(re_starters, logger)
    unless re_starters.empty?
      logger.error("There were #{re_starters.length} entries of the backup that do not exist in the (filtered?) people manager")
      logger.error("Some examples:")
      re_starters.slice(0, 4).each_with_index do |entry, i|
        logger.error("This person does not exist: #{entry.name} (#{entry.email})")
      end
    end
  end

end