class Lutaml::Model::Xml::Builder::Ox

def self.build(options = {})
  if block_given?
    ::Ox::Builder.new(options) do |xml|
      yield(new(xml, options))
    end
  else
    new(::Ox::Builder.new(options), options)
  end
end

def <<(text)
  xml.text(text)
end

def add_attribute(element, name, value)
  element[name] = value
end

def add_cdata(element, value)
  element.cdata(value)
end

def add_element(element, child)
  element << child
end

def add_namespace_prefix(prefix)
  @current_namespace = prefix
  self
end

def add_text(element, text, cdata: false)
  text = text&.encode(encoding) if encoding && text.is_a?(String)
  return element.cdata(text) if cdata
  element.text(text)
end

def add_xml_fragment(element, content)
  element.raw(content)
end

def create_and_add_element(element_name, prefix: nil, attributes: {})
  element_name = element_name.first if element_name.is_a?(Array)
  prefixed_name = set_prefixed_name(element_name, prefix)
  if block_given?
    xml.element(prefixed_name, attributes) do |element|
      yield(self.class.new(element, { encoding: encoding }))
    end
  else
    xml.element(prefixed_name, attributes)
  end
  @current_namespace = nil
end

def create_element(name, attributes = {})
  if @current_namespace && !name.start_with?("#{@current_namespace}:")
    name = "#{@current_namespace}:#{name}"
  end
  if block_given?
    xml.element(name, attributes) do |element|
      yield(self.class.new(element, { encoding: encoding }))
    end
  else
    xml.element(name, attributes)
  end
end

def initialize(xml, options = {})
  @xml = xml
  @encoding = options[:encoding]
  @current_namespace = nil
end

def method_missing(method_name, *args)
  if block_given?
    xml.public_send(method_name, *args) do
      yield(xml)
    end
  else
    xml.public_send(method_name, *args)
  end
end

def parent
  xml
end

def respond_to_missing?(method_name, include_private = false)
  xml.respond_to?(method_name) || super
end

def set_prefixed_name(element_name, prefix)
  if prefix
    "#{prefix}:#{element_name}"
  elsif @current_namespace && !element_name.start_with?("#{@current_namespace}:")
    "#{@current_namespace}:#{element_name}"
  else
    element_name
  end
end