class Lutaml::Model::Schema::XmlCompiler::SimpleType

def down_union_class_name(union)
  Utils.snake_case(last_of_split(union))
end

def extended_indent
  (@indent || "  ") * 2
end

def initialize(name, unions = [])
  @class_name = name
  @unions = unions
end

def klass_name
  @klass_name ||= Utils.camel_case(class_name)
end

def last_of_split(field)
  field&.split(":")&.last
end

def parent_class
  type_info = SUPPORTED_DATA_TYPES[base_class&.to_sym]
  return type_info[:class_name] if type_info&.dig(:skippable)
  return Utils.camel_case(base_class.to_s) if !!!type_info&.dig(:skippable) && Utils.present?(base_class)
  LUTAML_VALUE_CLASS_NAME
end

def require_parent?
  return false if Utils.blank?(base_class)
  !!!SUPPORTED_DATA_TYPES[base_class&.to_sym]&.dig(:skippable)
end

def required_files
  files = Array(instance&.required_files)
  files << "require_relative \"#{Utils.snake_case(parent_class)}\"" if require_parent?
  files.join("\n")
end

def setup_options(options)
  @indent = " " * options&.fetch(:indent, 2)
end

def setup_restriction(base_class, validations)
  return unless validations
  Restriction.new.tap do |restriction|
    restriction.base_class = base_class
    restriction.min_inclusive = validations[:min_inclusive]
    restriction.max_inclusive = validations[:max_inclusive]
    restriction.pattern = validations[:pattern]
    restriction.transform = validations[:transform]
  end
end

def setup_supported_types
  SUPPORTED_DATA_TYPES
    .reject { |_, simple_type| simple_type[:skippable] }
    .each_with_object({}) do |(name, simple_type), hash|
    str_name = name.to_s
    new(str_name).tap do |instance|
      instance.base_class = Utils.base_class_snake_case(simple_type[:class_name])
      instance.instance = setup_restriction(instance.base_class, simple_type[:validations])
      hash[str_name] = instance
    end
  end
end

def skippable?(type)
  SUPPORTED_DATA_TYPES.dig(type&.to_sym, :skippable)
end

def to_class(options: {})
  setup_options(options)
  template = unions&.any? ? UNION_MODEL_TEMPLATE : INSTANCE_MODEL_TEMPLATE
  template.result(binding)
end

def union_class_method_body
  unions.map do |union|
    "#{extended_indent}register.get_class(:#{down_union_class_name(union)}).cast(value, options)"
  end.join(" ||\n  ")
end

def union_required_files
  unions.filter_map do |union|
    next if SUPPORTED_DATA_TYPES.dig(last_of_split(union).to_sym, :skippable)
    "require_relative \"#{down_union_class_name(union)}\""
  end.join("\n")
end