module Lutaml::Model::Schema::Templates::SimpleType

def create_simple_types(simple_types)
  setup_supported_types
  simple_types.each do |name, properties|
    klass_name = Utils.camel_case(name)
    @simple_types[name] = if @simple_types.key?(properties[:base_class]) && properties.one?
                            ref_template(properties, klass_name)
                          elsif properties&.key_exist?(:union)
                            union_template(properties, klass_name)
                          else
                            model_template(properties, klass_name)
                          end
  end
  @simple_types
end

def extract_parent_class(base_class)
  klass = if SUPPORTED_DATA_TYPES[base_class.to_sym]&.key?(:class_name)
            parent = false
            SUPPORTED_DATA_TYPES.dig(base_class.to_sym, :class_name)
          else
            parent = true
            Utils.camel_case(base_class.to_s)
          end
  [klass, parent]
end

def model_template(properties, klass_name)
  base_class = properties.base_class.split(":")&.last
  parent_class, require_parent = extract_parent_class(base_class)
  values = properties[:values] if properties.key_exist?(:values)
  MODEL_TEMPLATE.result(binding)
end

def ref_template(properties, klass_name)
  parent_class = properties.base_class
  require_parent = true unless properties[:base_class].include?("Lutaml::Model::")
  REF_TEMPLATE.result(binding)
end

def resolve_required_files(unions)
  unions.map do |union|
    next if DEFAULT_CLASSES.include?(union.base_class.split(":").last)
    Utils.snake_case(union.base_class.split(":").last)
  end
end

def setup_supported_types
  @simple_types = MappingHash.new
  indent = "    "
  SUPPORTED_DATA_TYPES.each do |klass_name, properties|
    validations = properties[:validations] || {}
    next if properties[:skippable]
    @simple_types[klass_name] = SUPPORTED_TYPES_TEMPLATE.result(binding)
  end
end

def union_template(properties, klass_name)
  unions = properties.union
  UNION_TEMPLATE.result(binding)
end