class Lutaml::Model::Xml::MappingRule

def content_key
  cdata ? "#cdata-section" : "text"
end

def content_mapping?
  name.nil?
end

def deep_dup
  self.class.new(
    name.dup,
    to: to,
    render_nil: render_nil,
    render_default: render_default,
    with: Utils.deep_dup(custom_methods),
    delegate: delegate,
    namespace: namespace.dup,
    prefix: prefix.dup,
    mixed_content: mixed_content,
    cdata: cdata,
    namespace_set: namespace_set?,
    prefix_set: prefix_set?,
    attribute: attribute,
    polymorphic: polymorphic.dup,
    default_namespace: default_namespace.dup,
    transform: transform.dup,
    render_empty: render_empty.dup,
    value_map: Utils.deep_dup(@value_map),
  )
end

def initialize(
  name,
  to:,
  render_nil: false,
  render_default: false,
  render_empty: false,
  treat_nil: nil,
  treat_empty: nil,
  treat_omitted: nil,
  with: {},
  delegate: nil,
  namespace: nil,
  prefix: nil,
  mixed_content: false,
  cdata: false,
  namespace_set: false,
  prefix_set: false,
  attribute: false,
  default_namespace: nil,
  polymorphic: {},
  polymorphic_map: {},
  transform: {},
  value_map: {}
)
  super(
    name,
    to: to,
    render_nil: render_nil,
    render_default: render_default,
    render_empty: render_empty,
    treat_nil: treat_nil,
    treat_empty: treat_empty,
    treat_omitted: treat_omitted,
    with: with,
    delegate: delegate,
    attribute: attribute,
    polymorphic: polymorphic,
    polymorphic_map: polymorphic_map,
    transform: transform,
    value_map: value_map,
  )
  @namespace = if namespace.to_s == "inherit"
               # we are using inherit_namespace in xml builder by
               # default so no need to do anything here.
               else
                 namespace
               end
  @prefix = prefix
  @mixed_content = mixed_content
  @cdata = cdata
  @default_namespace = default_namespace
  @namespace_set = namespace_set
  @prefix_set = prefix_set
end

def mixed_content?
  !!@mixed_content
end

def namespace_set?
  !!@namespace_set
end

def namespaced_name(parent_namespace = nil, name = self.name)
  if name.to_s == "lang"
    "#{prefix}:#{name}"
  elsif namespace_set? || @attribute
    [namespace, name].compact.join(":")
  elsif default_namespace
    "#{default_namespace}:#{name}"
  else
    [parent_namespace, name].compact.join(":")
  end
end

def namespaced_names(parent_namespace = nil)
  if multiple_mappings?
    name.map { |rule_name| namespaced_name(parent_namespace, rule_name) }
  else
    [namespaced_name(parent_namespace)]
  end
end

def prefix_set?
  !!@prefix_set
end

def prefixed_name
  rule_name = multiple_mappings? ? name.first : name
  if prefix
    "#{prefix}:#{rule_name}"
  else
    rule_name
  end
end