class ActiveModelSerializers::Adapter::JsonApi

def self.default_key_transform
  :dash
end

def self.fragment_cache(cached_hash, non_cached_hash, root = true)
  core_cached       = cached_hash.first
  core_non_cached   = non_cached_hash.first
  no_root_cache     = cached_hash.delete_if { |key, _value| key == core_cached[0] }
  no_root_non_cache = non_cached_hash.delete_if { |key, _value| key == core_non_cached[0] }
  cached_resource   = (core_cached[1]) ? core_cached[1].deep_merge(core_non_cached[1]) : core_non_cached[1]
  hash = root ? { root => cached_resource } : cached_resource
  hash.deep_merge no_root_non_cache.deep_merge no_root_cache
end

def attributes_for(serializer, fields)
  serializer.attributes(fields).except(:id)
end

def failure_document
  hash = {}
  # PR Please :)
  # Jsonapi.add!(hash)
  # toplevel_errors
  # definition:
  #   array of unique items of type 'error'
  # structure:
  #   [
  #     error,
  #     error
  #   ]
  if serializer.respond_to?(:each)
    hash[:errors] = serializer.flat_map do |error_serializer|
      Error.resource_errors(error_serializer, instance_options)
    end
  else
    hash[:errors] = Error.resource_errors(serializer, instance_options)
  end
  hash
end

def fragment_cache(cached_hash, non_cached_hash)
  root = !instance_options.include?(:include)
  self.class.fragment_cache(cached_hash, non_cached_hash, root)
end

def initialize(serializer, options = {})
  super
  @include_directive = JSONAPI::IncludeDirective.new(options[:include], allow_wildcard: true)
  @fieldset = options[:fieldset] || ActiveModel::Serializer::Fieldset.new(options.delete(:fields))
end

def links_for(serializer)
  serializer._links.each_with_object({}) do |(name, value), hash|
    result = Link.new(serializer, value).as_json
    hash[name] = result if result
  end
end

def meta_for(serializer)
  Meta.new(serializer).as_json
end

def pagination_links_for(serializer)
  PaginationLinks.new(serializer.object, instance_options).as_json
end

def process_relationship(serializer, include_directive)
  if serializer.respond_to?(:each)
    serializer.each { |s| process_relationship(s, include_directive) }
    return
  end
  return unless serializer && serializer.object
  return unless process_resource(serializer, false)
  process_relationships(serializer, include_directive)
end

def process_relationships(serializer, include_directive)
  serializer.associations(include_directive).each do |association|
    process_relationship(association.serializer, include_directive[association.key])
  end
end

def process_resource(serializer, primary)
  resource_identifier = ResourceIdentifier.new(serializer, instance_options).as_json
  return false unless @resource_identifiers.add?(resource_identifier)
  resource_object = resource_object_for(serializer)
  if primary
    @primary << resource_object
  else
    @included << resource_object
  end
  true
end

def relationships_for(serializer, requested_associations)
  include_directive = JSONAPI::IncludeDirective.new(
    requested_associations,
    allow_wildcard: true
  )
  serializer.associations(include_directive).each_with_object({}) do |association, hash|
    hash[association.key] = Relationship.new(
      serializer,
      association.serializer,
      instance_options,
      options: association.options,
      links: association.links,
      meta: association.meta
    ).as_json
  end
end

def resource_object_for(serializer)
  resource_object = serializer.fetch(self) do
    resource_object = ResourceIdentifier.new(serializer, instance_options).as_json
    requested_fields = fieldset && fieldset.fields_for(resource_object[:type])
    attributes = attributes_for(serializer, requested_fields)
    resource_object[:attributes] = attributes if attributes.any?
    resource_object
  end
  requested_associations = fieldset.fields_for(resource_object[:type]) || '*'
  relationships = relationships_for(serializer, requested_associations)
  resource_object[:relationships] = relationships if relationships.any?
  links = links_for(serializer)
  # toplevel_links
  # definition:
  #   allOf
  #      ☐ links
  #      ☐ pagination
  #
  # description:
  #  Link members related to the primary data.
  # structure:
  #   links.merge!(pagination)
  # prs:
  #   https://github.com/rails-api/active_model_serializers/pull/1247
  #   https://github.com/rails-api/active_model_serializers/pull/1018
  resource_object[:links] = links if links.any?
  # toplevel_meta
  #   alias meta
  # definition:
  #   meta
  # structure
  #   {
  #     :'git-ref' => 'abc123'
  #   }
  meta = meta_for(serializer)
  resource_object[:meta] = meta unless meta.blank?
  resource_object
end

def resource_objects_for(serializers)
  @primary = []
  @included = []
  @resource_identifiers = Set.new
  serializers.each { |serializer| process_resource(serializer, true) }
  serializers.each { |serializer| process_relationships(serializer, @include_directive) }
  [@primary, @included]
end

def serializable_hash(*)
  document = if serializer.success?
               success_document
             else
               failure_document
             end
  self.class.transform_key_casing!(document, instance_options)
end

def success_document
  is_collection = serializer.respond_to?(:each)
  serializers = is_collection ? serializer : [serializer]
  primary_data, included = resource_objects_for(serializers)
  hash = {}
  # toplevel_data
  # definition:
  #   oneOf
  #     resource
  #     array of unique items of type 'resource'
  #     null
  #
  # description:
  #   The document's "primary data" is a representation of the resource or collection of resources
  #   targeted by a request.
  #
  #   Singular: the resource object.
  #
  #   Collection: one of an array of resource objects, an array of resource identifier objects, or
  #   an empty array ([]), for requests that target resource collections.
  #
  #   None: null if the request is one that might correspond to a single resource, but doesn't currently.
  # structure:
  #  if serializable_resource.resource?
  #    resource
  #  elsif serializable_resource.collection?
  #    [
  #      resource,
  #      resource
  #    ]
  #  else
  #    nil
  #  end
  hash[:data] = is_collection ? primary_data : primary_data[0]
  # toplevel_included
  #   alias included
  # definition:
  #   array of unique items of type 'resource'
  #
  # description:
  #   To reduce the number of HTTP requests, servers **MAY** allow
  #   responses that include related resources along with the requested primary
  #   resources. Such responses are called "compound documents".
  # structure:
  #     [
  #       resource,
  #       resource
  #     ]
  hash[:included] = included if included.any?
  Jsonapi.add!(hash)
  if instance_options[:links]
    hash[:links] ||= {}
    hash[:links].update(instance_options[:links])
  end
  if is_collection && serializer.paginated?
    hash[:links] ||= {}
    hash[:links].update(pagination_links_for(serializer))
  end
  hash[:meta] = instance_options[:meta] unless instance_options[:meta].blank?
  hash
end