module GdsApi::TestHelpers::PublishingApiV2

def assert_publishing_api(verb, url, attributes_or_matcher = nil, times = 1)
  if attributes_or_matcher.is_a?(Hash)
    matcher = request_json_matches(attributes_or_matcher)
  else
    matcher = attributes_or_matcher
  end
  if matcher
    assert_requested(verb, url, times: times, &matcher)
  else
    assert_requested(verb, url, times: times)
  end
end

def assert_publishing_api_discard_draft(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/discard-draft"
  assert_publishing_api(:post, url, attributes_or_matcher, times)
end

def assert_publishing_api_patch_links(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/links/" + content_id
  assert_publishing_api(:patch, url, attributes_or_matcher, times)
end

def assert_publishing_api_publish(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/publish"
  assert_publishing_api(:post, url, attributes_or_matcher, times)
end

def assert_publishing_api_put_content(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/" + content_id
  assert_publishing_api(:put, url, attributes_or_matcher, times)
end

def assert_publishing_api_put_content_links_and_publish(body, content_id = nil, publish_body = nil)
  content_id ||= body[:content_id]
  if publish_body.nil?
    publish_body = { update_type: body.fetch(:update_type) }
    publish_body[:locale] = body[:locale] if body[:locale]
  end
  assert_publishing_api_put_content(content_id, body.except(:links))
  assert_publishing_api_patch_links(content_id, body.slice(:links)) unless body.slice(:links).empty?
  assert_publishing_api_publish(content_id, publish_body)
end

def assert_publishing_api_unpublish(content_id, attributes_or_matcher = nil, times = 1)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/unpublish"
  assert_publishing_api(:post, url, attributes_or_matcher, times)
end

def deep_stringify_keys(hash)
  deep_transform_keys(hash, &:to_s)
end

def deep_transform_keys(object, &block)
  case object
  when Hash
    object.each_with_object({}) do |(key, value), result|
      result[yield(key)] = deep_transform_keys(value, &block)
    end
  when Array
    object.map { |item| deep_transform_keys(item, &block) }
  else
    object
  end
end

def publishing_api_does_not_have_item(content_id)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/" + content_id
  stub_request(:get, url).to_return(status: 404, body: resource_not_found(content_id, "content item").to_json, headers: {})
end

def publishing_api_does_not_have_links(content_id)
  url = PUBLISHING_API_V2_ENDPOINT + "/links/" + content_id
  stub_request(:get, url).to_return(status: 404, body: resource_not_found(content_id, "link set").to_json, headers: {})
end

def publishing_api_get_editions(editions, params = {})
  url = PUBLISHING_API_V2_ENDPOINT + "/editions"
  results = editions.map do |edition|
    next edition unless params[:fields]
    edition.select { |k| params[:fields].include?(k) }
  end
  per_page = (params[:per_page] || 100).to_i
  results = results.take(per_page)
  body = {
    results: results,
    links: [
      { rel: "self", href: "#{PUBLISHING_API_V2_ENDPOINT}/editions" },
    ],
  }
  stub_request(:get, url)
    .with(query: params)
    .to_return(status: 200, body: body.to_json, headers: {})
end

def publishing_api_has_content(items, params = {})
  url = PUBLISHING_API_V2_ENDPOINT + "/content"
  if params.respond_to? :fetch
    per_page = params.fetch(:per_page, 50)
    page = params.fetch(:page, 1)
  else
    per_page = 50
    page = 1
  end
  start_position = (page - 1) * per_page
  page_items = items.slice(start_position, per_page) || []
  number_of_pages =
    if items.count < per_page
      1
    else
      (items.count / per_page.to_f).ceil
    end
  body = {
    results: page_items,
    total: items.count,
    pages: number_of_pages,
    current_page: page
  }
  stub_request(:get, url)
    .with(query: params)
    .to_return(status: 200, body: body.to_json, headers: {})
end

def publishing_api_has_expanded_links(links, with_drafts: true)
  links = deep_transform_keys(links, &:to_sym)
  query = with_drafts ? "" : "?with_drafts=false"
  url = PUBLISHING_API_V2_ENDPOINT + "/expanded-links/" + links[:content_id] + query
  stub_request(:get, url).to_return(status: 200, body: links.to_json, headers: {})
end

def publishing_api_has_fields_for_document(document_type, items, fields)
  body = Array(items).map { |item|
    deep_stringify_keys(item).slice(*fields)
  }
  query_params = fields.map { |f|
    "&fields%5B%5D=#{f}"
  }
  url = PUBLISHING_API_V2_ENDPOINT + "/content?document_type=#{document_type}#{query_params.join('')}"
  stub_request(:get, url).to_return(status: 200, body: { results: body }.to_json, headers: {})
end

def publishing_api_has_item(item, params = {})
  item = deep_transform_keys(item, &:to_sym)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/" + item[:content_id]
  stub_request(:get, url)
    .with(query: hash_including(params))
    .to_return(status: 200, body: item.to_json, headers: {})
end

def publishing_api_has_item_in_sequence(content_id, items)
  items = items.each { |item| deep_transform_keys(item, &:to_sym) }
  url = PUBLISHING_API_V2_ENDPOINT + "/content/" + content_id
  calls = -1
  stub_request(:get, url).to_return do |_request|
    calls += 1
    item = items[calls] || items.last
    { status: 200, body: item.to_json, headers: {} }
  end
end

def publishing_api_has_linkables(linkables, document_type:)
  url = PUBLISHING_API_V2_ENDPOINT + "/linkables?document_type=#{document_type}"
  stub_request(:get, url).to_return(status: 200, body: linkables.to_json, headers: {})
end

def publishing_api_has_linked_items(items, params = {})
  content_id = params.fetch(:content_id)
  link_type = params.fetch(:link_type)
  fields = params.fetch(:fields, %w(base_path content_id document_type title))
  url = Plek.current.find('publishing-api') + "/v2/linked/#{content_id}"
  request_parmeters = {
    "fields" => fields,
    "link_type" => link_type,
  }
  stub_request(:get, url)
    .with(query: request_parmeters)
    .and_return(
      body: items.to_json,
      status: 200
    )
end

def publishing_api_has_links(links)
  links = deep_transform_keys(links, &:to_sym)
  url = PUBLISHING_API_V2_ENDPOINT + "/links/" + links[:content_id]
  stub_request(:get, url).to_return(status: 200, body: links.to_json, headers: {})
end

def publishing_api_has_links_for_content_ids(links)
  url = PUBLISHING_API_V2_ENDPOINT + "/links/by-content-id"
  stub_request(:post, url).with(body: { content_ids: links.keys }).to_return(status: 200, body: links.to_json, headers: {})
end

def publishing_api_has_lookups(lookup_hash)
  url = Plek.current.find('publishing-api') + '/lookup-by-base-path'
  stub_request(:post, url).to_return(body: lookup_hash.to_json)
end

def publishing_api_isnt_available
  stub_request(:any, /#{PUBLISHING_API_V2_ENDPOINT}\/.*/).to_return(status: 503)
end

def request_json_includes(required_attributes)
  ->(request) do
    data = JSON.parse(request.body)
    deep_stringify_keys(required_attributes).
      to_a.all? { |key, value| data[key] == value }
  end
end

def request_json_matches(required_attributes)
  ->(request) do
    data = JSON.parse(request.body)
    deep_stringify_keys(required_attributes) == data
  end
end

def resource_not_found(content_id, type)
  {
    error: {
      code: 404,
      message: "Could not find #{type} with content_id: #{content_id}",
    }
  }
end

def stub_any_publishing_api_call
  stub_request(:any, %r{\A#{PUBLISHING_API_V2_ENDPOINT}})
end

def stub_any_publishing_api_call_to_return_not_found
  stub_request(:any, %r{\A#{PUBLISHING_API_V2_ENDPOINT}})
    .to_return(status: 404, headers: { "Content-Type" => "application/json; charset=utf-8" })
end

def stub_any_publishing_api_discard_draft
  stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/discard-draft})
end

def stub_any_publishing_api_patch_links
  stub_request(:patch, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/links/})
end

def stub_any_publishing_api_publish
  stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/publish})
end

def stub_any_publishing_api_put_content
  stub_request(:put, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/})
end

def stub_any_publishing_api_unpublish
  stub_request(:post, %r{\A#{PUBLISHING_API_V2_ENDPOINT}/content/.*/unpublish})
end

def stub_publishing_api_discard_draft(content_id)
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/discard-draft"
  stub_request(:post, url).to_return(status: 200, headers: { "Content-Type" => "application/json; charset=utf-8" })
end

def stub_publishing_api_patch(*args)
  stub_publishing_api_postlike_call(:patch, *args)
end

def stub_publishing_api_patch_links(content_id, body)
  stub_publishing_api_patch(content_id, body, '/links')
end

def stub_publishing_api_postlike_call(method, content_id, body, resource_path, override_response_hash = {})
  response_hash = { status: 200, body: '{}', headers: { "Content-Type" => "application/json; charset=utf-8" } }
  response_hash.merge!(override_response_hash)
  response_hash[:body] = response_hash[:body].to_json if response_hash[:body].is_a?(Hash)
  url = PUBLISHING_API_V2_ENDPOINT + resource_path + "/" + content_id
  stub_request(method, url).with(body: body).to_return(response_hash)
end

def stub_publishing_api_publish(content_id, body, response_hash = {})
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/publish"
  response = {
    status: 200,
    body: '{}',
    headers: { "Content-Type" => "application/json; charset=utf-8" }
  }.merge(response_hash)
  stub_request(:post, url).with(body: body).to_return(response)
end

def stub_publishing_api_put(*args)
  stub_publishing_api_postlike_call(:put, *args)
end

def stub_publishing_api_put_content(content_id, body, response_hash = {})
  stub_publishing_api_put(content_id, body, '/content', response_hash)
end

def stub_publishing_api_put_content_links_and_publish(body, content_id = nil, publish_body = nil)
  content_id ||= body[:content_id]
  if publish_body.nil?
    publish_body = { update_type: body.fetch(:update_type) }
    publish_body[:locale] = body[:locale] if body[:locale]
  end
  stubs = []
  stubs << stub_publishing_api_put_content(content_id, body.except(:links))
  stubs << stub_publishing_api_patch_links(content_id, body.slice(:links)) unless body.slice(:links).empty?
  stubs << stub_publishing_api_publish(content_id, publish_body)
  stubs
end

def stub_publishing_api_unpublish(content_id, params, response_hash = {})
  url = PUBLISHING_API_V2_ENDPOINT + "/content/#{content_id}/unpublish"
  response = {
    status: 200,
    body: '{}',
    headers: { "Content-Type" => "application/json; charset=utf-8" }
  }.merge(response_hash)
  stub_request(:post, url).with(params).to_return(response)
end