class Lutaml::Xml::NamespaceNeeds

def add_child(name, child_needs)
  unless child_needs.is_a?(NamespaceNeeds)
    raise ArgumentError,
          "Expected NamespaceNeeds, got #{child_needs.class}"
  end
  @children[name] = child_needs
end

def add_namespace(key, usage)
  unless usage.is_a?(NamespaceUsage)
    raise ArgumentError, "Expected NamespaceUsage, got #{usage.class}"
  end
  @namespaces[key] = usage
end

def add_namespace_scope_config(config)
  unless config.is_a?(NamespaceScopeConfig)
    raise ArgumentError,
          "Expected NamespaceScopeConfig, got #{config.class}"
  end
  @namespace_scope_configs << config
end

def add_type_attribute_namespace(ns_class)
  @type_attribute_namespaces << ns_class
  @type_namespace_classes << ns_class
end

def add_type_element_namespace(ns_class)
  @type_element_namespaces << ns_class
  @type_namespace_classes << ns_class
end

def add_type_namespace(attr_name, ns_class)
  @type_namespaces[attr_name] = ns_class
  @type_namespace_classes << ns_class
end

def add_type_ref(reference)
  unless reference.is_a?(TypeNamespace::Reference)
    raise ArgumentError,
          "Expected TypeNamespace::Reference, got #{reference.class}"
  end
  @type_refs << reference
end

def all_namespace_classes
  namespace_classes = Set.new(@namespaces.values.map(&:namespace_class))
  namespace_classes.merge(@type_namespace_classes)
end

def child(name)
  @children[name]
end

def clear_type_refs
  @type_refs.clear
end

def empty?
  @namespaces.empty? &&
    @children.empty? &&
    @type_refs.empty? &&
    @type_namespaces.empty? &&
    @namespace_scope_configs.empty?
end

def initialize
  @namespaces = {} # Hash<String, NamespaceUsage>
  @children = {} # Hash<Symbol, NamespaceNeeds>
  @type_namespaces = {} # Hash<Symbol, Class>
  @type_namespace_classes = Set.new # Set<Class>
  @type_attribute_namespaces = Set.new # Set<Class>
  @type_element_namespaces = Set.new # Set<Class>
  @type_refs = [] # Array<TypeNamespace::Reference>
  @namespace_scope_configs = [] # Array<NamespaceScopeConfig>
end

def merge(other)
  unless other.is_a?(NamespaceNeeds)
    raise ArgumentError, "Expected NamespaceNeeds, got #{other.class}"
  end
  # Merge namespaces
  other.namespaces.each do |key, usage|
    if @namespaces.key?(key)
      @namespaces[key].merge(usage)
    else
      @namespaces[key] = usage
    end
  end
  # Merge children
  other.children.each do |name, child_needs|
    if @children.key?(name)
      @children[name].merge(child_needs)
    else
      @children[name] = child_needs
    end
  end
  # Merge type namespaces
  @type_namespaces.merge!(other.type_namespaces)
  @type_namespace_classes.merge(other.type_namespace_classes)
  @type_attribute_namespaces.merge(other.type_attribute_namespaces)
  @type_element_namespaces.merge(other.type_element_namespaces)
  # Merge type refs
  @type_refs.concat(other.type_refs)
  # Merge namespace scope configs (avoiding duplicates)
  other.namespace_scope_configs.each do |config|
    unless @namespace_scope_configs.any? do |c|
      c.namespace_class == config.namespace_class
    end
      @namespace_scope_configs << config
    end
  end
  self
end

def namespace(key)
  @namespaces[key]
end

def scope_config_for(ns_class)
  @namespace_scope_configs.find do |config|
    config.namespace_class == ns_class
  end
end

def validate!
  # Type attribute and element namespaces should be mutually exclusive
  overlap = @type_attribute_namespaces & @type_element_namespaces
  unless overlap.empty?
    raise "Type namespaces appear in both attribute and element contexts: #{overlap.to_a}"
  end
  # All type namespace classes should be in type_namespace_classes
  @type_attribute_namespaces.each do |ns_class|
    unless @type_namespace_classes.include?(ns_class)
      raise "Type attribute namespace #{ns_class} not in type_namespace_classes"
    end
  end
  @type_element_namespaces.each do |ns_class|
    unless @type_namespace_classes.include?(ns_class)
      raise "Type element namespace #{ns_class} not in type_namespace_classes"
    end
  end
  true
end