module RubyXL::OOXMLObjectClassMethods

def accessorize(str)
  acc = str.to_s.dup
  acc.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
  acc.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
  acc.gsub!(':','_')
  acc.downcase.to_sym
end

def define_attribute(attr_name, attr_type, extra_params = {})
  attrs = obtain_class_variable(:@@ooxml_attributes)
  attr_hash = extra_params.merge({ :attr_type => attr_type })
  attr_hash[:accessor] ||= accessorize(attr_name)
  attrs[attr_name.to_s] = attr_hash
  self.send(:attr_accessor, attr_hash[:accessor]) unless attr_hash[:computed]
end

def define_child_node(klass, extra_params = {})
  child_nodes = obtain_class_variable(:@@ooxml_child_nodes)
  child_node_name = (extra_params[:node_name] || klass.class_variable_get(:@@ooxml_tag_name)).to_s
  accessor = (extra_params[:accessor] || accessorize(child_node_name)).to_sym
  child_nodes[child_node_name] = {
    :class => klass,
    :is_array => extra_params[:collection],
    :accessor => accessor
  }
  define_count_attribute if extra_params[:collection] == :with_count
  self.send(:attr_accessor, accessor)
end

def define_count_attribute
  define_attribute(:count, :uint, :required => true)
end

def define_element_name(element_name)
  self.class_variable_set(:@@ooxml_tag_name, element_name)
end

def obtain_class_variable(var_name, default = {})
  self.class_variable_get(var_name)
rescue NameError
  self.class_variable_set(var_name, default)
end

def parse(node, known_namespaces = nil)
  case node
  when String, IO, Zip::InputStream then node = Nokogiri::XML.parse(node)
  end
  if node.is_a?(Nokogiri::XML::Document) then
    node = node.root
     ignorable_attr = node.attributes['Ignorable']
     @ignorables << ignorable_attr.value if ignorable_attr
  end
  obj = self.new
  obj.local_namespaces = node.namespace_definitions
  known_attributes = obtain_class_variable(:@@ooxml_attributes)
  content_params = known_attributes['_']
  process_attribute(obj, node.text, content_params) if content_params
  node.attributes.each_pair { |attr_name, attr|
    attr_name = if attr.namespace then "#{attr.namespace.prefix}:#{attr.name}"
                else attr.name
                end
    attr_params = known_attributes[attr_name]
    next if attr_params.nil?
    # raise "Unknown attribute [#{attr_name}] for element [#{node.name}]" if attr_params.nil?
    process_attribute(obj, attr.value, attr_params) unless attr_params[:computed]
  }
  known_child_nodes = obtain_class_variable(:@@ooxml_child_nodes)
  unless known_child_nodes.empty?
    known_namespaces ||= obtain_class_variable(:@@ooxml_namespaces)
    node.element_children.each { |child_node|
      ns = child_node.namespace
      prefix = if known_namespaces.has_key?(ns.href) then known_namespaces[ns.href]
               else ns.prefix
               end
      child_node_name = case prefix
                        when '', nil then child_node.name
                        else "#{prefix}:#{child_node.name}"
                        end
      child_node_params = known_child_nodes[child_node_name]
      raise "Unknown child node [#{child_node_name}] for element [#{node.name}]" if child_node_params.nil?
      parsed_object = child_node_params[:class].parse(child_node, known_namespaces)
      if child_node_params[:is_array] then
        index = parsed_object.index_in_collection
        collection = if (self < RubyXL::OOXMLContainerObject) then obj
                     else obj.send(child_node_params[:accessor])
                     end
        if index.nil? then
          collection << parsed_object
        else
          collection[index] = parsed_object
        end
      else
        obj.send("#{child_node_params[:accessor]}=", parsed_object)
      end
    }
  end
  obj
end

def process_attribute(obj, raw_value, params)
  val = raw_value &&
          case params[:attr_type]
          when :double then Float(raw_value)  # http://www.datypic.com/sc/xsd/t-xsd_double.html
          when :string then raw_value
          when Array   then raw_value # Case of Simple Types
          when :sqref  then RubyXL::Sqref.new(raw_value)
          when :ref    then RubyXL::Reference.new(raw_value)
          when :bool   then ['1', 'true'].include?(raw_value)  # http://www.datypic.com/sc/xsd/t-xsd_boolean.html
          when :int    then Integer(raw_value)
          when :uint   then
            v = Integer(raw_value)
            raise ArgumentError.new("invalid value for unsigned Integer(): \"#{raw_value}\"") if v < 0
            v
          end
  obj.send("#{params[:accessor]}=", val)
end