# frozen_string_literal: true

module JSONAPI

# A tree structure representing the resource structure of the requested resource(s). This is an intermediate structure

# used to keep track of the resources, by identity, found at different included relationships. It will be flattened and

# the resource instances will be fetched from the cache or the record store.

class ResourceTree

attr_reader :fragments, :related_resource_trees

# Gets the related Resource Id Tree for a relationship, and creates it first if it does not exist

#

# @param relationship [JSONAPI::Relationship]

#

# @return [JSONAPI::RelatedResourceTree] the new or existing resource id tree for the requested relationship

def get_related_resource_tree(relationship)

relationship_name = relationship.name.to_sym

@related_resource_trees[relationship_name] ||= RelatedResourceTree.new(relationship, self)

end

# Adds each Resource Fragment to the Resources hash

#

# @param fragments [Hash]

# @param include_related [Hash]

#

# @return [null]

def add_resource_fragments(fragments, include_related)

fragments.each_value do |fragment|

add_resource_fragment(fragment, include_related)

end

end

# Adds a Resource Fragment to the fragments hash

#

# @param fragment [JSONAPI::ResourceFragment]

# @param include_related [Hash]

#

# @return [null]

def add_resource_fragment(fragment, include_related)

init_included_relationships(fragment, include_related)

@fragments[fragment.identity] = fragment

end

# Adds each Resource to the fragments hash

#

# @param resource [Hash]

# @param include_related [Hash]

#

# @return [null]

def add_resources(resources, include_related)

resources.each do |resource|

add_resource_fragment(JSONAPI::ResourceFragment.new(resource.identity, resource: resource), include_related)

end

end

# Adds a Resource to the fragments hash

#

# @param fragment [JSONAPI::ResourceFragment]

# @param include_related [Hash]

#

# @return [null]

def add_resource(resource, include_related)

add_resource_fragment(JSONAPI::ResourceFragment.new(resource.identity, resource: resource), include_related)

end

private

def init_included_relationships(fragment, include_related)

include_related && include_related.each_key do |relationship_name|

fragment.initialize_related(relationship_name)

end

end

def load_included(resource_klass, source_resource_tree, include_related, options)

include_related.try(:each_key) do |key|

relationship = resource_klass._relationship(key)

relationship_name = relationship.name.to_sym

find_related_resource_options = options.except(:filters, :sort_criteria, :paginator)

find_related_resource_options[:sort_criteria] = relationship.resource_klass.default_sort

find_related_resource_options[:cache] = resource_klass.caching?

related_fragments = resource_klass.find_included_fragments(source_resource_tree.fragments.values,

relationship_name,

find_related_resource_options)

related_resource_tree = source_resource_tree.get_related_resource_tree(relationship)

related_resource_tree.add_resource_fragments(related_fragments, include_related[key][:include_related])

# Now recursively get the related resources for the currently found resources

load_included(relationship.resource_klass,

related_resource_tree,

include_related[relationship_name][:include_related],

options)

end

end

def add_resources_to_tree(resource_klass,

tree,

resources,

include_related,

source_rid: nil,

source_relationship_name: nil,

connect_source_identity: true)

fragments = {}

resources.each do |resource|

next unless resource

# fragments[resource.identity] ||= ResourceFragment.new(resource.identity, resource: resource)

# resource_fragment = fragments[resource.identity]

# ToDo: revert when not needed for testing

resource_fragment = if fragments[resource.identity]

fragments[resource.identity]

else

fragments[resource.identity] = ResourceFragment.new(resource.identity, resource: resource)

fragments[resource.identity]

end

if resource.class.caching?

resource_fragment.cache = resource.cache_field_value

end

linkage_relationships = resource_klass.to_one_relationships_for_linkage(resource.class, include_related)

linkage_relationships.each do |relationship_name|

related_resource = resource.send(relationship_name)

resource_fragment.add_related_identity(relationship_name, related_resource&.identity)

end

if source_rid && connect_source_identity

resource_fragment.add_related_from(source_rid)

source_klass = source_rid.resource_klass

related_relationship_name = source_klass._relationships[source_relationship_name].inverse_relationship

if related_relationship_name

resource_fragment.add_related_identity(related_relationship_name, source_rid)

end

end

end

tree.add_resource_fragments(fragments, include_related)

end

end

class PrimaryResourceTree < ResourceTree

# Creates a PrimaryResourceTree with no resources and no related ResourceTrees

def initialize(fragments: nil, resources: nil, resource: nil, include_related: nil, options: nil)

@fragments ||= {}

@related_resource_trees ||= {}

if fragments || resources || resource

if fragments

add_resource_fragments(fragments, include_related)

end

if resources

add_resources(resources, include_related)

end

if resource

add_resource(resource, include_related)

end

complete_includes!(include_related, options)

end

end

# Adds a Resource Fragment to the fragments hash

#

# @param fragment [JSONAPI::ResourceFragment]

# @param include_related [Hash]

#

# @return [null]

def add_resource_fragment(fragment, include_related)

fragment.primary = true

super(fragment, include_related)

end

def complete_includes!(include_related, options)

# ToDo: can we skip if more than one resource_klass found?

resource_klasses = Set.new

@fragments.each_key { |identity| resource_klasses << identity.resource_klass }

resource_klasses.each { |resource_klass| load_included(resource_klass, self, include_related, options)}

self

end

end

class RelatedResourceTree < ResourceTree

attr_reader :parent_relationship, :source_resource_tree

# Creates a RelatedResourceTree with no resources and no related ResourceTrees. A connection to the parent

# ResourceTree is maintained.

#

# @param parent_relationship [JSONAPI::Relationship]

# @param source_resource_tree [JSONAPI::ResourceTree]

#

# @return [JSONAPI::RelatedResourceTree] the new or existing resource id tree for the requested relationship

def initialize(parent_relationship, source_resource_tree)

@fragments ||= {}

@related_resource_trees ||= {}

@parent_relationship = parent_relationship

@parent_relationship_name = parent_relationship.name.to_sym

@source_resource_tree = source_resource_tree

end

# Adds a Resource Fragment to the fragments hash

#

# @param fragment [JSONAPI::ResourceFragment]

# @param include_related [Hash]

#

# @return [null]

def add_resource_fragment(fragment, include_related)

init_included_relationships(fragment, include_related)

fragment.related_from.each do |rid|

@source_resource_tree.fragments[rid].add_related_identity(parent_relationship.name, fragment.identity)

end

if @fragments[fragment.identity]

@fragments[fragment.identity].related_from.merge(fragment.related_from)

fragment.related.each_pair do |relationship_name, rids|

if rids

@fragments[fragment.identity].merge_related_identities(relationship_name, rids)

end

end

else

@fragments[fragment.identity] = fragment

end

end

end

end