class Lutaml::UmlRepository::Queries::ClassQuery

def find_by_qname(qualified_name_string)
  if qualified_name_string.nil? || qualified_name_string.empty?
    return nil
  end
  indexes[:qualified_names][qualified_name_string]
end

def find_by_stereotype(stereotype)
  return [] if stereotype.nil? || stereotype.empty?
  indexes[:stereotypes][stereotype] || []
end

def in_package(package_path_string, recursive: false)
  return [] if package_path_string.nil? || package_path_string.empty?
  pkg_to_classes = indexes[:package_to_classes]
  if pkg_to_classes
    in_package_indexed(package_path_string, pkg_to_classes,
                       recursive: recursive)
  else
    in_package_scan(package_path_string, recursive: recursive)
  end
end

def in_package_indexed(package_path_string, pkg_to_classes, recursive:)
  is_absolute = package_path_string.start_with?("::")
  search_segs = package_path_string.split("::").reject(&:empty?)
  results = []
  pkg_to_classes.each do |path, classes|
    results.concat(classes) if indexed_path_matches?(
      path, package_path_string, is_absolute, search_segs, recursive
    )
  end
  results
end

def in_package_scan(package_path_string, recursive:)
  package_path = Lutaml::Uml::PackagePath.new(package_path_string)
  is_absolute = package_path.absolute?
  indexes[:qualified_names].each_value.select do |klass|
    scan_matches_package?(klass, package_path, is_absolute, recursive)
  end
end

def indexed_absolute_match?(path, package_path_string, recursive)
  if recursive
    path == package_path_string ||
      path.start_with?("#{package_path_string}::")
  else
    path == package_path_string
  end
end

def indexed_path_matches?(path, package_path_string, is_absolute,
                          search_segs, recursive)
  if is_absolute
    indexed_absolute_match?(path, package_path_string, recursive)
  else
    indexed_relative_match?(path.split("::"), search_segs, recursive)
  end
end

def indexed_relative_match?(path_segs, search_segs, recursive)
  if recursive
    segments_overlap?(path_segs, search_segs)
  else
    segments_end_with?(path_segs, search_segs)
  end
end

def match_absolute_path?(qname, package_path, recursive)
  qname = Lutaml::Uml::QualifiedName.new(qname)
  if recursive
    qname.package_path.starts_with?(package_path)
  else
    qname.package_path == package_path
  end
end

def match_relative_path?(qname_string, package_path, recursive)
  qname = Lutaml::Uml::QualifiedName.new(qname_string)
  class_pkg_segs = qname.package_path.segments
  search_segs = package_path.segments
  if recursive
    segments_overlap?(class_pkg_segs, search_segs)
  else
    segments_end_with?(class_pkg_segs, search_segs)
  end
end

def resolve_qname_for(klass)
  indexes[:qualified_names].find { |_, v| v == klass }&.first
end

def scan_matches_package?(klass, package_path, is_absolute, recursive)
  qname = resolve_qname_for(klass)
  return false unless qname
  if is_absolute
    match_absolute_path?(qname, package_path, recursive)
  else
    match_relative_path?(qname, package_path, recursive)
  end
end

def segments_end_with?(class_segs, search_segs)
  class_segs.size >= search_segs.size &&
    class_segs[-search_segs.size..] == search_segs
end

def segments_overlap?(class_segs, search_segs)
  (0..(class_segs.size - search_segs.size)).any? do |i|
    class_segs[i, search_segs.size] == search_segs
  end
end