module PIM::Services::DataModelServiceYaml

# File services.rb, line 1152
def get_data_model_attributes_from_yaml *attribute_names
  return nil unless load_data_model_definitions_yaml
  attributes = []
  attribute_names.each do |attribute_name|
    attribute = @attribute_by_name[attribute_name.to_s]
    attributes << attribute unless attribute.nil?
  end
  attributes
end

# File services.rb, line 1163
def get_data_model_categories_from_yaml *category_names
  return nil unless load_data_model_definitions_yaml
  categories = []
  category_names.each do |category_name|
    category = @category_by_name[category_name.to_s]
    category = @category_by_code[category_name.to_s] if category.nil?
    categories << category unless category.nil?
  end
  categories
end

# File services.rb, line 1175
def get_data_model_option_lists_from_yaml *option_list_names
  return nil unless load_data_model_definitions_yaml
  option_lists = []
  option_list_names.each do |option_list_name|
    option_list = @option_list_by_name[option_list_name.to_s]
    option_lists << option_list unless option_list.nil?
  end
  option_lists
end

# File services.rb, line 1207
def get_validation_rule_names_by_attributes_from_yaml *attributes
  return nil unless load_data_model_definitions_yaml
  validation_rule_names = Set.new
  attributes.each do |attribute|
    validation_rule_names += (@validation_rule_names_by_attribute[attribute.to_s] || [])
  end
  validation_rule_names
end

# File services.rb, line 1217
def get_validation_rule_names_by_tags_and_attributes_from_yaml tags: nil, attributes: nil

  rule_names_by_tags = get_validation_rule_names_by_tags_from_yaml(*tags) unless PIM.is_empty?(tags)
  rule_names_by_attributes = get_validation_rule_names_by_attributes_from_yaml(*attributes) unless PIM.is_empty?(attributes)

  return rule_names_by_tags if rule_names_by_attributes.nil?
  return rule_names_by_attributes if rule_names_by_tags.nil?

  return rule_names_by_tags & rule_names_by_attributes

end

# File services.rb, line 1197
def get_validation_rule_names_by_tags_from_yaml *tags
  return nil unless load_data_model_definitions_yaml
  validation_rule_names = Set.new
  tags.each do |tag|
    validation_rule_names += (@validation_rule_names_by_tag[tag.to_s] || [])
  end
  validation_rule_names
end

# File services.rb, line 1186
def get_validation_rules_from_yaml *validation_rule_names
  return nil unless load_data_model_definitions_yaml
  validation_rules = []
  validation_rule_names.each do |validation_rule_name|
    validation_rule = @validation_rule_by_name[validation_rule_name.to_s]
    validation_rules << validation_rule unless validation_rule.nil?
  end
  validation_rules
end

# File services.rb, line 981
def load_data_model_definitions_yaml

  return true if @data_model_definitions_loaded
  return false if data_model_definitions_yaml.nil?

  filename = data_model_definitions_yaml
  if not File.readable?(filename)
    PIM.log_warn "Data model definitions not found in '#{filename}'"
    return false
  end

  PIM.log_info "Loading data model definitions from '#{filename}'"
  extension = File.extname(filename)
  if extension == '.json'
    data_model_definitions = JSON.load_file(filename)
  else
    data_model_definitions = YAML.load_file(filename)
  end

  @attribute_by_name = {}
  @category_by_name = {}
  @category_by_code = {}
  @option_list_by_name = {}
  @validation_rule_by_name = {}
  @validation_rule_names_by_tag = {}
  @validation_rule_names_by_attribute = {}

  attributes = PIM.get_value(data_model_definitions, :attributes) || []
  attributes.each do |attribute|
    name = PIM.get_value(attribute, :name)
    @attribute_by_name[name.to_s] = attribute
  end

  categories = PIM.get_value(data_model_definitions, :categories) || []
  categories.each do |category|
    name = PIM.get_value(category, :name)
    code = PIM.get_value(category, :code)
    @category_by_name[name.to_s] = category
    @category_by_code[code.to_s] = category unless code.nil?
  end

  option_lists = PIM.get_value(data_model_definitions, :option_lists) || []
  option_lists.each do |option_list|

    option_list_name = PIM.get_value(option_list, :name)

    options = PIM.get_value(option_list, :options)
    if PIM.is_array?(options)

      options = options.map do |value|
        option = OptionListOption.new(
          name: value,
          label: value
        )
        option
      end

    elsif PIM.is_hash?(options)

      options = options.each_pair.map do |key, value|

        option = OptionListOption.new(
          name: key
        )

        if PIM.is_hash?(value)

          value.each_pair do |k, v|
            case k.to_sym
            when :label then option.label = v.to_s
            when :labels then option.labels = v
            when :icon then option.icon = v.to_s
            when :icons then option.icons = v.to_s
            when :custom_values then option.custom_values = v
            else
              option.custom_values ||= {}
              option.custom_values[k] = v
            end
          end

        elsif not value.nil?
          option.label = value.to_s
        end

        option

      end

    else
      options = []
    end

    groups = PIM.get_value(option_list, :groups)
    if PIM.is_hash?(groups)
      groups = groups.each_pair.map do |key, value|

        group = OptionListGroup.new(
          name: key
        )

        if PIM.is_array?(value)
          group.options = value
        end

        group

      end
    else
      groups = []
    end

    unless options.empty? or groups.empty?

      # Add groups to options
      options_map = options.map { |o| [o.name, o] }.to_h
      groups.each do |group|

        next if group.options.nil?
        group.options.each do |option_name|
          option = options_map[option_name]
          next if option.nil?
          option.groups ||= []
          option.groups << group.name unless option.groups.include?(group.name)
        end

      end

    end

    option_list = OptionList.new(
      name: option_list_name,
      options: options,
      groups: groups
    )

    @option_list_by_name[option_list.name] = option_list

  end

  validation_rules = PIM.get_value(data_model_definitions, :validation_rules) || []
  validation_rules.each do |validation_rule|

    validation_rule = ValidationRule.new(validation_rule)

    name = validation_rule.name.to_s
    @validation_rule_by_name[name] = validation_rule

    tags = validation_rule.tags
    unless tags.nil? or tags.empty?
      tags.each do |tag|
        @validation_rule_names_by_tag[tag.to_s] ||= []
        @validation_rule_names_by_tag[tag.to_s] << name.to_s
      end
    end

    all_attributes = Set.new
    all_attributes += (validation_rule.validated_attributes || [])
    all_attributes += (validation_rule.dependent_attributes || [])
    all_attributes.each do |attribute|
      @validation_rule_names_by_attribute[attribute.to_s] ||= []
      @validation_rule_names_by_attribute[attribute.to_s] << name.to_s
    end

  end

  @data_model_definitions_loaded = true

  return true
end