class Avo::Fields::BaseField

def apply_update_using(record, key, value, resource)
  return value if @update_using.nil?
  Avo::ExecutionContext.new(
    target: @update_using,
    record:,
    key:,
    value:,
    resource:,
    field: self,
    include: self.class.included_modules
  ).handle
end

def assign_value(record:, value:)
  id = (type == "belongs_to") ? foreign_key : database_id
  if record.send(id).nil?
    record.send(:"#{id}=", value)
  end
end

def custom?
  !method(:initialize).source_location.first.include?("lib/avo/field")
rescue
  true
end

def custom_name?
  !@name.nil?
end

def database_id
  foreign_key
rescue
  id
end

def default_name
  @id.to_s.humanize(keep_id_suffix: true)
end

def execute_block
  Avo::ExecutionContext.new(
    target: block,
    record: record,
    resource: resource,
    view: view,
    field: self,
    include: self.class.included_modules
  ).handle
end

def fill_field(record, key, value, params)
  key = @for_attribute.to_s if @for_attribute.present?
  return record unless has_attribute?(record, key)
  record.public_send(:"#{key}=", apply_update_using(record, key, value, resource))
  record
end

def form_field_label
  id
end

def get_resource_by_model_class(model_class)
  resource = Avo.resource_manager.get_resource_by_model_class(model_class)
  resource || (raise Avo::MissingResourceError.new(model_class, self))
end

def has_attribute?(record, attribute)
  record.methods.include? attribute.to_sym
end

def has_own_panel?
  false
end

def hidden_in_reflection?
  !visible_in_reflection?
end

def in_action?
  @action.present?
end

def initialize(id, **args, &block)
  @id = id
  @name = args[:name]
  @translation_key = args[:translation_key]
  @block = block
  @required = args.dig(:required) # Value if :required present on args, nil otherwise
  @readonly = args[:readonly] || false
  @disabled = args[:disabled] || false
  @sortable = args[:sortable] || false
  @summarizable = args[:summarizable] || false
  @nullable = args[:nullable] || false
  @null_values = args[:null_values] || [nil, ""]
  @format_using = args[:format_using] || nil
  @update_using = args[:update_using] || nil
  @placeholder = args[:placeholder]
  @autocomplete = args[:autocomplete] || nil
  @help = args[:help] || nil
  @default = args[:default] || nil
  @visible = args[:visible]
  @as_avatar = args[:as_avatar] || false
  @html = args[:html] || nil
  @view = Avo::ViewInquirer.new(args[:view]) || nil
  @value = args[:value] || nil
  @stacked = args[:stacked] || nil
  @for_presentation_only = args[:for_presentation_only] || false
  @resource = args[:resource]
  @action = args[:action]
  @components = args[:components] || {}
  @for_attribute = args[:for_attribute]
  @meta = args[:meta]
  @copyable = args[:copyable] || false
  @args = args
  @computable = true
  @computed = block.present?
  @computed_value = nil
  post_initialize if respond_to?(:post_initialize)
end

def is_model?(model)
  model_or_class(model) == "model"
end

def meta
  Avo::ExecutionContext.new(target: @meta, record: record, resource: @resource, view: @view).handle
end

def model_or_class(model)
  model.instance_of?(String) ? "class" : "model"
end

def name
  if custom_name?
    Avo::ExecutionContext.new(target: @name).handle
  elsif translation_key
    translated_name default: default_name
  else
    default_name
  end
end

def on_create?
  @view.in?(%w[new create])
end

def options_for_filter
  options
end

def placeholder
  Avo::ExecutionContext.new(target: @placeholder || name, record: record, resource: @resource, view: @view).handle
end

def plural_name
  default = name.pluralize
  if translation_key
    translated_plural_name default: default
  else
    default
  end
end

def record_errors
  record.present? ? record.errors : {}
end

def resolve_attribute(value)
  value
end

def should_fill_with_default_value?
  on_create? || in_action?
end

def table_header_label
  @table_header_label ||= name
end

def to_permitted_param
  id.to_sym
end

def translated_name(default:)
  t(translation_key, count: 1, default: default).humanize
end

def translated_plural_name(default:)
  t(translation_key, count: 2, default: default).humanize
end

def translation_key
  @translation_key || "avo.field_translations.#{@id}"
end

def type
  @type ||= self.class.name.demodulize.to_s.underscore.gsub("_field", "")
end

def updatable
  !is_disabled? && visible?
end

def value(property = nil)
  return @value if @value.present?
  property ||= @for_attribute || id
  # Get record value
  final_value = record.send(property) if is_model?(record) && record.respond_to?(property)
  # On new views and actions modals we need to prefill the fields with the default value if value is nil
  if final_value.nil? && should_fill_with_default_value? && default.present?
    final_value = computed_default_value
  end
  # Run computable callback block if present
  if computable && block.present?
    final_value = execute_block
  end
  # Run the value through resolver if present
  if format_using.present?
    final_value = Avo::ExecutionContext.new(
      target: format_using,
      value: final_value,
      record: record,
      resource: resource,
      view: view,
      field: self,
      include: self.class.included_modules
    ).handle
  end
  final_value
end

def visible_in_reflection?
  true
end