class Ariadne::Forms::Dsl::Input

def add_input_aria(key, value)
  @input_attributes[:aria] ||= {}
  @input_attributes[:aria][key] = if space_delimited_aria_attribute?(key)
    aria_join(@input_attributes[:aria][key], *Array(value))
  else
    value
  end
end

def add_input_classes(*class_names)
  input_attributes[:class] = merge_class_names(
    input_attributes[:class], *class_names
  )
end

def add_input_data(key, value)
  input_data[key] = value
end

def aria_join(*values)
  values = values.flat_map { |v| v.to_s.split }
  values.reject!(&:empty?)
  values.join(" ")
end

def autofocus!
  @input_attributes[:autofocus] = true
end

def caption?
  caption.present?
end

def caption_id
  ids[:caption]
end

def caption_template?
  return false unless form
  form.caption_template?(caption_template_name)
end

def caption_template_name
  return unless name
  @caption_template_name ||= if respond_to?(:value)
    :"#{name}_#{value}"
  else
    name.to_sym
  end
end

def disabled?
  @disabled.present?
end

def focusable?
  false
end

def hidden?
  !!input_attributes[:hidden]
end

def id
  @input_attributes[:id]
end

def initialize(builder:, form:, **options)
  @builder = builder
  @form = form
  @options = options.dup
  @input_attributes = @options.delete(:html_attrs) || {}
  @input_attributes.delete(:id) if @input_attributes[:id].blank?
  @label_attributes = @options[:label_html_attributes] || {}
  @label_attributes[:for] = id if id.present?
  @label_attributes[:class] = merge_class_names(
    @label_attributes[:class],
    @options.delete(:visually_hide_label) ? "sr-only" : nil,
  )
  @input_attributes.delete(:class) if @input_attributes[:class].blank?
  @label_attributes.delete(:class) if @label_attributes[:class].blank?
  @caption = @options.delete(:caption)
  @placeholder = @options.delete(:placeholder)
  @disabled = @options.delete(:disabled)
  @validation_message = @options.delete(:validation_message)
  @invalid = @options.delete(:invalid)
  @full_width = @options.delete(:full_width) { true }
  # If scope_name_to_model is false, the name of the input for eg. `my_field`
  # will be `my_field` instead of the Rails default of `model[my_field]`.
  #
  # We achieve this by passing the `name` option to Rails form builder
  # methods. These methods will use the passed name if provided instead
  # of generating a scoped one.
  #
  unless @options.delete(:scope_name_to_model) { true }
    @input_attributes[:name] = name
  end
  # rubocop:enable Style/IfUnlessModifier
  # If scope_id_to_model is false, the name of the input for eg. `my_field`
  # will be `my_field` instead of the Rails default of `model_my_field`.
  #
  # We achieve this by passing the `id` option to Rails form builder
  # methods. These methods will use the passed id if provided instead
  # of generating a scoped one. The id is the name of the field unless
  # explicitly provided in system_arguments.
  #
  # rubocop:disable Style/IfUnlessModifier
  unless @options.delete(:scope_id_to_model) { true }
    @input_attributes[:id] = @input_attributes.delete(:id) { name }
  end
  # rubocop:enable Style/IfUnlessModifier
  # Whether or not to wrap the component in a FormControl, which renders a
  # label above and validation message beneath the input.
  @form_control = @options.delete(:form_control) { true }
  @options[:invalid] = "true" if invalid?
  @base_id = Ariadne::BaseComponent.generate_id(base_name: "ariadne-form-input")
  @ids = {}.tap do |id_map|
    id_map[:validation] = "validation-#{@base_id}" if supports_validation?
    id_map[:caption] = "caption-#{@base_id}" if caption? || caption_template?
  end
  if required?
    input_attributes[:required] = true
    add_input_aria(:required, true)
  end
  add_input_aria(:invalid, true) if invalid?
  add_input_aria(:describedby, ids.values) if ids.any?
end

def input?
  true
end

def input_data
  @input_attributes[:data] ||= {}
end

def invalid?
  supports_validation? && !valid?
end

def label
  raise_for_abstract_method!(__method__)
end

def merge_input_attributes!(arguments)
  arguments.each do |k, v|
    case k
    when :class, :classes, "class", "classes"
      add_input_classes(v)
    when :aria, "aria"
      v.each do |aria_k, aria_v|
        add_input_aria(aria_k, aria_v)
      end
    when :data, "data"
      v.each do |data_k, data_v|
        add_input_data(data_k, data_v)
      end
    else
      @input_attributes[k] = v
    end
  end
end

def name
  raise_for_abstract_method!(__method__)
end

def raise_for_abstract_method!(method_name)
  raise NotImplementedError, "subclasses must implement ##{method_name}."
end

def remove_input_data(key)
  input_data.delete(key)
end

def render_caption_template
  form.render_caption_template(caption_template_name)
end

def required?
  @options[:required] ||
    input_attributes[:aria_required] ||
    input_attributes[:"aria-required"] ||
    input_attributes.dig(:aria, :required)
end

def size
  @size ||= SIZE_MAPPINGS.include?(@size) ? @size : DEFAULT_SIZE
end

def space_delimited_aria_attribute?(attrib)
  SPACE_DELIMITED_ARIA_ATTRIBUTES.include?(attrib)
end

def supports_validation?
  true
end

def to_component
  raise_for_abstract_method!(__method__)
end

def type
  raise_for_abstract_method!(__method__)
end

def valid?
  supports_validation? && validation_messages.empty? && !@invalid
end

def validation_arguments
  {
    class: "FormControl-inlineValidation",
    id: validation_id,
    hidden: valid? || validation_messages.empty?,
  }
end

def validation_error_icon_target
  ""
end

def validation_id
  ids[:validation]
end

def validation_message_arguments
  {}
end

def validation_messages
  @validation_messages ||=
    if validation_message
      [validation_message]
    elsif builder.object.respond_to?(:errors)
      name ? builder.object.errors.full_messages_for(name) : []
    else
      []
    end
end

def validation_success_icon_target
  ""
end