class GdsApi::PublishingApiV2

def content_url(content_id, params = {})
  validate_content_id(content_id)
  query = query_string(params)
  "#{endpoint}/v2/content/#{content_id}#{query}"
end

def discard_draft(content_id, options = {})
  optional_keys = [
    :locale,
    :previous_version,
  ]
  params = merge_optional_keys({}, options, optional_keys)
  post_json(discard_url(content_id), params)
end

def discard_url(content_id)
  validate_content_id(content_id)
  "#{endpoint}/v2/content/#{content_id}/discard-draft"
end

def get_content(content_id, params = {})
  get_json(content_url(content_id, params))
end

def get_content!(*)
  raise "`PublishingApiV2#get_content!` is deprecated. Use `PublishingApiV2#get_content`"
end

def get_content_items(params)
  query = query_string(params)
  get_json("#{endpoint}/v2/content#{query}")
end

def get_editions(params = {})
  get_json(get_editions_url(params))
end

def get_editions_url(params)
  query = query_string(params)
  "#{endpoint}/v2/editions#{query}"
end

def get_expanded_links(content_id, with_drafts: true, generate: false)
  params = {}
  params[:with_drafts] = "false" unless with_drafts
  params[:generate] = "true" if generate
  query = query_string(params)
  validate_content_id(content_id)
  get_json("#{endpoint}/v2/expanded-links/#{content_id}#{query}")
end

def get_linkables(document_type: nil)
  if document_type.nil?
    raise ArgumentError.new("Please provide a `document_type`")
  end
  get_json("#{endpoint}/v2/linkables?document_type=#{document_type}")
end

def get_linked_items(content_id, params = {})
  query = query_string(params)
  validate_content_id(content_id)
  get_json("#{endpoint}/v2/linked/#{content_id}#{query}")
end

def get_links(content_id)
  get_json(links_url(content_id))
end

def get_links_changes(params)
  get_json(links_changes_url(params))
end

def get_links_for_content_ids(content_ids)
  post_json("#{endpoint}/v2/links/by-content-id", content_ids: content_ids).to_hash
end

def get_paged_editions(params = {})
  Enumerator.new do |yielder|
    next_link = get_editions_url(params)
    while next_link
      yielder.yield begin
        response = get_json(next_link)
      end
      next_link_info = response['links'].select { |link| link['rel'] == 'next' }.first
      next_link = next_link_info && next_link_info['href']
    end
  end
end

def import(content_id, locale, content_items)
  params = {
    history: content_items,
  }
  post_json("#{endpoint}/v2/content/#{content_id}/import?locale=#{locale}", params)
end

def links_changes_url(params = {})
  query = query_string(params)
  "#{endpoint}/v2/links/changes#{query}"
end

def links_url(content_id)
  validate_content_id(content_id)
  "#{endpoint}/v2/links/#{content_id}"
end

def lookup_content_id(base_path:, exclude_document_types: nil, exclude_unpublishing_types: nil)
  lookups = lookup_content_ids(
    base_paths: [base_path],
    exclude_document_types: exclude_document_types,
    exclude_unpublishing_types: exclude_unpublishing_types
  )
  lookups[base_path]
end

def lookup_content_ids(base_paths:, exclude_document_types: nil, exclude_unpublishing_types: nil)
  options = { base_paths: base_paths }
  options[:exclude_document_types] = exclude_document_types if exclude_document_types
  options[:exclude_unpublishing_types] = exclude_unpublishing_types if exclude_unpublishing_types
  response = post_json("#{endpoint}/lookup-by-base-path", options)
  response.to_hash
end

def merge_optional_keys(params, options, optional_keys)
  optional_keys.each_with_object(params) do |optional_key, hash|
    hash.merge!(optional_key => options[optional_key]) if options[optional_key]
  end
end

def patch_links(content_id, params)
  payload = {
    links: params.fetch(:links)
  }
  payload = merge_optional_keys(payload, params, [:previous_version, :bulk_publishing])
  patch_json(links_url(content_id), payload)
end

def publish(content_id, update_type = nil, options = {})
  params = {
    update_type: update_type
  }
  optional_keys = [
    :locale,
    :previous_version,
  ]
  params = merge_optional_keys(params, options, optional_keys)
  post_json(publish_url(content_id), params)
end

def publish_url(content_id)
  validate_content_id(content_id)
  "#{endpoint}/v2/content/#{content_id}/publish"
end

def put_content(content_id, payload)
  put_json(content_url(content_id), payload)
end

def unpublish(content_id, type:, explanation: nil, alternative_path: nil, discard_drafts: false, allow_draft: false, previous_version: nil, locale: nil, unpublished_at: nil, redirects: nil)
  params = {
    type: type
  }
  params[:explanation] = explanation if explanation
  params[:alternative_path] = alternative_path if alternative_path
  params[:previous_version] = previous_version if previous_version
  params[:discard_drafts] = discard_drafts if discard_drafts
  params[:allow_draft] = allow_draft if allow_draft
  params[:locale] = locale if locale
  params[:unpublished_at] = unpublished_at.utc.iso8601 if unpublished_at
  params[:redirects] = redirects if redirects
  post_json(unpublish_url(content_id), params)
end

def unpublish_url(content_id)
  validate_content_id(content_id)
  "#{endpoint}/v2/content/#{content_id}/unpublish"
end

def validate_content_id(content_id)
  raise ArgumentError, "content_id cannot be nil" unless content_id
end