module PIM::Services::DataModelService

# File services.rb, line 948
def __data_model_service
  __service(:dataModelService)
end

# File services.rb, line 636
def add_all array, values
  return if PIM.is_empty?(values)
  values = [values] unless PIM.is_array?(values)
  values.each do |value|
    array << value unless value.nil?
  end
end

# File services.rb, line 688
def add_non_existing_category data_module, value
  PIM.log_trace "setting category #{value} as non existing"
  @non_existing_categories ||= {}
  non_existing_module_categories = @non_existing_categories[data_module.to_s]
  if non_existing_module_categories.nil?
    non_existing_module_categories = []
    @non_existing_categories[data_module.to_s] = non_existing_module_categories
  end
  return false if non_existing_module_categories.include?(value.to_s)
  non_existing_module_categories << value.to_s
  return true
end

# File services.rb, line 606
def create_attributes data_module, attribute_names

  # Only get and create attributes which do not exist yet
  attribute_names = attribute_names.reject { |a| data_module.exists_attribute?(a) }
  return if PIM.is_empty?(attribute_names)

  # Load data model attributes from Java backend
  data_model_attributes = get_data_model_attributes(data_module, *attribute_names)

  # Load and create sub attributes, if necessary
  sub_attribute_names = []
  data_model_attributes.each do |data_model_attribute|
    add_all(sub_attribute_names, PIM.get_value(data_model_attribute, :members))
    add_all(sub_attribute_names, PIM.get_value(data_model_attribute, :key_members))
    add_all(sub_attribute_names, PIM.get_value(data_model_attribute, :value_members))
    params = PIM.get_value(data_model_attribute, :params)
    if params
      params = PIM.symbolized_snakeized_hash(params)
      add_all(sub_attribute_names, PIM.get_value(params, :value_attribute))
    end
  end
  create_attributes data_module, sub_attribute_names if not sub_attribute_names.empty?

  # Create Ruby attributes
  data_model_attributes.each do |data_model_attribute|
    data_module.create_attribute(data_model_attribute)
  end

end

# File services.rb, line 813
def create_validation_rules data_module, rule_names: nil, tags: nil, attributes: nil

  if not PIM.is_empty?(rule_names)

    # Only get and create validation rules which do not exist yet
    rule_names = rule_names.reject { |v| data_module.exists_validation_rule?(v) }
    return [] if rule_names.empty?

    # Get all missing validation rules
    validation_rules = nil
    PIM::Utils.timed(group: "validation",
                     key: "create_validation_rules-load",
                     message: "Loaded #{rule_names.size} validation rule(s)") do
      validation_rules = get_validation_rules(data_module, *rule_names)
    end

    # Create Ruby validation rules
    PIM::Utils.timed(group: "validation",
                     key: "create_validation_rules-create",
                     message: "Created #{validation_rules.size} validation rule(s)") do
      validation_rules.each do |validation_rule|
        data_module.create_validation_rule(validation_rule)
      end
    end

    return validation_rules

  elsif not PIM.is_empty?(tags) or not PIM.is_empty?(attributes)

    # Determine the rule names to create
    found_rule_names = nil
    PIM::Utils.timed(group: "validation",
                     key: "create_validation_rules-get",
                     message: proc { "Got #{found_rule_names.size} validation rules name(s)" }) do
      found_rule_names = get_validation_rule_names_by_tags_and_attributes(data_module, tags: tags, attributes: attributes)
    end

    return [] if found_rule_names.nil? or found_rule_names.empty?

    # Actually create the rules, if necessary
    return create_validation_rules(data_module, rule_names: found_rule_names)

  else

    return []

  end

end

# File services.rb, line 555
def find_category data_module, value

  PIM.log_trace "find_category: #{data_module} -> #{value}"

  # Check if both parameters are not empty
  return nil if data_module.nil? or PIM.is_empty?(value)

  # Check if category already exists
  category = data_module.category(value)
  return category unless category.nil?

  # Check if value has already been queried and no category could be found
  if is_non_existing_category?(data_module, value)
    PIM.log_trace "find_category: category #{value} was already set as non existing"
    return nil
  end

  # Load data model category from Java backend and create Ruby attributes and category
  data_model_category = get_data_model_category(data_module, value)
  PIM.log_trace "find_category: found: #{data_model_category}"
  if data_model_category

    # If category was found for a 'different' name, then check again if it already exists
    category_name = PIM.get_value(data_model_category, 'name')
    if category_name != value
      category = data_module.category(category_name)
      PIM.log_trace "find_category: found #{data_model_category} for category name '#{category_name}'"
      return category unless category.nil?
    end

    # Ensure, parent categories are created first if necessary
    parent_value = PIM.get_value(data_model_category, 'parent')
    parent_category = find_category(data_module, parent_value)
    if parent_category.nil?
      PIM.log_warn "Cannot create category '#{category_name}' because parent '#{parent_value}' does not exist"
      return nil
    end

    attributes = PIM.get_value(data_model_category, 'attributes')
    create_attributes(data_module, attributes) unless PIM.is_empty?(attributes)
    category = data_module.create_category(data_model_category)
    PIM.log_trace "find_category: created category #{category.as_json}"

  end

  # Add query to list of non existing categories if it could not be found
  add_non_existing_category(data_module, value) if category.nil?

  return category
end

# File services.rb, line 644
def get_data_model_attributes data_module, *attribute_names
  return data_module.get_data_model_attributes(*attribute_names) if data_module.respond_to?(:get_data_model_attributes)
  if is_java_service_available?
    return get_data_model_attributes_from_java(data_module, *attribute_names)
  elsif is_yaml_definition_available?(data_module)
    data_module.extend PIM::Services::DataModelServiceYaml
    return data_module.get_data_model_attributes_from_yaml(*attribute_names)
  else
    raise "Cannot get data model attributes, because JAVA services are not available and classification YAML file is not specified"
  end
end

# File services.rb, line 656
def get_data_model_attributes_from_java data_module, *attribute_names
  return __data_model_service.getDataModelAttributesForService(data_module.service_name, PIM.stringified_value(attribute_names.compact))
end

# File services.rb, line 665
def get_data_model_categories data_module, *category_names
  return data_module.get_data_model_categories(*category_names) if data_module.respond_to?(:get_data_model_categories)
  if is_java_service_available?
    return get_data_model_categories_from_java(data_module, *category_names)
  elsif is_yaml_definition_available?(data_module)
    data_module.extend PIM::Services::DataModelServiceYaml
    return data_module.get_data_model_categories_from_yaml(*category_names)
  else
    raise "Cannot get data model categories, because JAVA services are not available and classification YAML file is not specified"
  end
end

# File services.rb, line 677
def get_data_model_categories_from_java data_module, *category_names
  return __data_model_service.getDataModelCategoriesForService(data_module.service_name, PIM.stringified_value(category_names.compact))
end

# File services.rb, line 660
def get_data_model_category data_module, category_name
  categories = get_data_model_categories(data_module, category_name)
  return categories.first unless categories.nil?
end

# File services.rb, line 802
def get_data_model_option_lists_from_java service_name, *option_list_names
  return __data_model_service.getDataModelOptionListsForService(service_name, PIM.stringified_value(option_list_names.compact))
end

# File services.rb, line 701
def get_data_model_options service, option_list_name, *option_names

  if PIM.has_module?(service)
    data_module = service
    service_name = data_module.service_name
    cache = data_module.cache
  else
    data_module = nil
    service_name = service
    cache = {}
  end

  option_list_name = option_list_name.to_s

  option_lists_cache = cache['option_lists'] ||= {}
  option_list_cache = option_lists_cache[option_list_name] ||= {}
  options_cache = option_list_cache['options'] ||= {}

  # 'Flag' to determine, if all options were already retrieved
  has_all_options = option_list_cache['all_options']

  result_map = {}
  missing_option_names = []

  option_names.each do |option_name|

    option_name = option_name.to_s
    option = options_cache[option_name]

    if option == false
      # Ignore non existing option
      next
    elsif not option.nil?
      # Add to result
      result_map[option_name] = option
    elsif not has_all_options
      # Add to list of missing options
      missing_option_names << option_name
    end

  end

  if not missing_option_names.empty? or (option_names.empty? and !has_all_options)

    if is_java_service_available?

      # Retrieve missing options from service
      options = get_data_model_options_from_java(service_name, option_list_name, *missing_option_names)

    elsif is_yaml_definition_available?(data_module)

      # Load option list from YAML
      data_module.extend PIM::Services::DataModelServiceYaml
      option_lists = data_module.get_data_model_option_lists_from_yaml(option_list_name)
      option_list = option_lists.first unless option_lists.nil?

      if option_list.nil?
        options = nil
      elsif option_names.empty?
        options = option_list.options
      else
        options = option_list.options.select { |o| missing_option_names.include?(o.name) }
      end

    else
      raise "Cannot get data model options, because JAVA services are not available and classification YAML file is not specified"
    end

    unless options.nil?

      options.each do |option|

        # Add to result
        next if result_map.include?(option.name)
        result_map[option.name] = option

        # Add to cache
        options_cache[option.name] = option

        # Remove from missing
        missing_option_names.delete(option.name)

      end

      option_list_cache['all_options'] = true if option_names.empty?

    end

    # Cache all unavailable options as non existent
    missing_option_names.each do |option_name|
      options_cache[option_name] = false
    end

  elsif has_all_options and not options_cache.empty?
    result_map = options_cache
  end

  return result_map.values

end

# File services.rb, line 806
def get_data_model_options_from_java service_name, option_list_name, *option_names
  return __data_model_service.getDataModelOptionListOptionsForService(service_name,
                                                                      option_list_name,
                                                                      nil,
                                                                      PIM.stringified_value(option_names.compact))
end

# File services.rb, line 893
def get_validation_rule_names_by_attributes data_module, *attributes

  # Convert to array of compacted unique strings
  attributes = PIM.stringified_compact_unique_array(*attributes)

  if is_java_service_available?
    return get_validation_rule_names_by_attributes_from_java(data_module, *attributes)
  elsif is_yaml_definition_available?(data_module)
    data_module.extend PIM::Services::DataModelServiceYaml
    return data_module.get_validation_rule_names_by_attributes_from_yaml(*attributes)
  else
    raise "Cannot get data model validation rules, because JAVA services are not available and classification YAML file is not specified"
  end
end

# File services.rb, line 932
def get_validation_rule_names_by_attributes_from_java data_module, *attributes
  return __data_model_service.getValidationRuleNamesByAttributes(data_module.service_name, attributes)
end

# File services.rb, line 878
def get_validation_rule_names_by_tags data_module, *tags

  # Convert to array of compacted unique strings
  tags = PIM.stringified_compact_unique_array(*tags)

  if is_java_service_available?
    return get_validation_rule_names_by_tags_from_java(data_module, *tags)
  elsif is_yaml_definition_available?(data_module)
    data_module.extend PIM::Services::DataModelServiceYaml
    return data_module.get_validation_rule_names_by_tags_from_yaml(*tags)
  else
    raise "Cannot get data model validation rules, because JAVA services are not available and classification YAML file is not specified"
  end
end

# File services.rb, line 908
def get_validation_rule_names_by_tags_and_attributes data_module, tags: nil, attributes: nil

  # Convert to arrays of compacted unique strings
  tags = PIM.stringified_compact_unique_array(*tags)
  attributes = PIM.stringified_compact_unique_array(*attributes)

  if is_java_service_available?
    return get_validation_rule_names_by_tags_and_attributes_from_java(data_module, tags, attributes)
  elsif is_yaml_definition_available?(data_module)
    data_module.extend PIM::Services::DataModelServiceYaml
    return data_module.get_validation_rule_names_by_tags_and_attributes_from_yaml(tags: tags, attributes: attributes)
  else
    raise "Cannot get data model validation rules, because JAVA services are not available and classification YAML file is not specified"
  end
end

# File services.rb, line 936
def get_validation_rule_names_by_tags_and_attributes_from_java data_module, tags, attributes
  return __data_model_service.getValidationRuleNamesByTagsAndAttributes(data_module.service_name, tags, attributes)
end

# File services.rb, line 928
def get_validation_rule_names_by_tags_from_java data_module, *tags
  return __data_model_service.getValidationRuleNamesByTags(data_module.service_name, tags)
end

# File services.rb, line 863
def get_validation_rules data_module, *validation_rule_names

  # Convert to array of compacted unique strings
  validation_rule_names = PIM.stringified_compact_unique_array(*validation_rule_names)

  if is_java_service_available?
    return get_validation_rules_from_java(data_module, *validation_rule_names)
  elsif is_yaml_definition_available?(data_module)
    data_module.extend PIM::Services::DataModelServiceYaml
    return data_module.get_validation_rules_from_yaml(*validation_rule_names)
  else
    raise "Cannot get data model validation rules, because JAVA services are not available and classification YAML file is not specified"
  end
end

# File services.rb, line 924
def get_validation_rules_from_java data_module, *names
  return __data_model_service.getValidationRules(data_module.service_name, names)
end

# File services.rb, line 940
def is_java_service_available?
  return (PIM::Services.is_java_services_available? and not __data_model_service.nil?)
end

# File services.rb, line 681
def is_non_existing_category? data_module, value
  return false if @non_existing_categories.nil?
  non_existing_module_categories = @non_existing_categories[data_module.to_s]
  return false if non_existing_module_categories.nil?
  return non_existing_module_categories.include?(value.to_s)
end

# File services.rb, line 944
def is_yaml_definition_available? data_module
  return (not data_module.nil? and not data_module.data_model_definitions_yaml.nil?)
end