class ActiveStorage::Blob

def allowed_inline?
  ActiveStorage.content_types_allowed_inline.include?(content_type)
end

def audio?
  content_type.start_with?("audio")
end

def build_after_unfurling(key: nil, io:, filename:, content_type: nil, metadata: nil, service_name: nil, identify: true, record: nil) # :nodoc:
  new(key: key, filename: filename, content_type: content_type, metadata: metadata, service_name: service_name).tap do |blob|
    blob.unfurl(io, identify: identify)
  end
end

def combine_signed_id_purposes(purpose) # :nodoc:
  purpose.to_s
end

def compose(blobs, filename:, content_type: nil, metadata: nil)
  raise ActiveRecord::RecordNotSaved, "All blobs must be persisted." if blobs.any?(&:new_record?)
  content_type ||= blobs.pluck(:content_type).compact.first
  new(filename: filename, content_type: content_type, metadata: metadata, byte_size: blobs.sum(&:byte_size)).tap do |combined_blob|
    combined_blob.compose(blobs.pluck(:key))
    combined_blob.save!
  end
end

def compose(keys) # :nodoc:
  self.composed = true
  service.compose(keys, key, **service_metadata)
end

def compute_checksum_in_chunks(io)
  OpenSSL::Digest::MD5.new.tap do |checksum|
    while chunk = io.read(5.megabytes)
      checksum << chunk
    end
    io.rewind
  end.base64digest
end

def content_type=(value)
  unless ActiveStorage.silence_invalid_content_types_warning
    if INVALID_VARIABLE_CONTENT_TYPES_DEPRECATED_IN_RAILS_7.include?(value)
      ActiveSupport::Deprecation.warn(<<-MSG.squish)
        #{value} is not a valid content type, it should not be used when creating a blob, and support for it will be removed in Rails 7.1.
        If you want to keep supporting this content type past Rails 7.1, add it to `config.active_storage.variable_content_types`.
        Dismiss this warning by setting `config.active_storage.silence_invalid_content_types_warning = true`.
      MSG
    end
    if INVALID_VARIABLE_CONTENT_TYPES_TO_SERVE_AS_BINARY_DEPRECATED_IN_RAILS_7.include?(value)
      ActiveSupport::Deprecation.warn(<<-MSG.squish)
        #{value} is not a valid content type, it should not be used when creating a blob, and support for it will be removed in Rails 7.1.
        If you want to keep supporting this content type past Rails 7.1, add it to `config.active_storage.content_types_to_serve_as_binary`.
        Dismiss this warning by setting `config.active_storage.silence_invalid_content_types_warning = true`.
      MSG
    end
  end
  super
end

def content_type_for_serving # :nodoc:
  forcibly_serve_as_binary? ? ActiveStorage.binary_content_type : content_type
end

def create_after_unfurling!(key: nil, io:, filename:, content_type: nil, metadata: nil, service_name: nil, identify: true, record: nil) # :nodoc:
  build_after_unfurling(key: key, io: io, filename: filename, content_type: content_type, metadata: metadata, service_name: service_name, identify: identify).tap(&:save!)
end

def create_and_upload!(key: nil, io:, filename:, content_type: nil, metadata: nil, service_name: nil, identify: true, record: nil)
  create_after_unfurling!(key: key, io: io, filename: filename, content_type: content_type, metadata: metadata, service_name: service_name, identify: identify).tap do |blob|
    blob.upload_without_unfurling(io)
  end
end

def create_before_direct_upload!(key: nil, filename:, byte_size:, checksum:, content_type: nil, metadata: nil, service_name: nil, record: nil)
  create! key: key, filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type, metadata: metadata, service_name: service_name
end

def custom_metadata
  self[:metadata][:custom] || {}
end

def custom_metadata=(metadata)
  self[:metadata] = self[:metadata].merge(custom: metadata)
end

def delete
  service.delete(key)
  service.delete_prefixed("variants/#{key}/") if image?
end

def download(&block)
  service.download key, &block
end

def download_chunk(range)
  service.download_chunk key, range
end

def extract_content_type(io)
  Marcel::MimeType.for io, name: filename.to_s, declared_type: content_type
end

def filename
  ActiveStorage::Filename.new(self[:filename])
end

def find_signed(id, record: nil, purpose: :blob_id)
  super(id, purpose: purpose)
end

def find_signed!(id, record: nil, purpose: :blob_id)
  super(id, purpose: purpose)
end

def forced_disposition_for_serving # :nodoc:
  if forcibly_serve_as_binary? || !allowed_inline?
    :attachment
  end
end

def forcibly_serve_as_binary?
  ActiveStorage.content_types_to_serve_as_binary.include?(content_type)
end

def generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
  SecureRandom.base36(length)
end

def image?
  content_type.start_with?("image")
end

def key
  # We can't wait until the record is first saved to have a key for it
  self[:key] ||= self.class.generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
end

def mirror_later # :nodoc:
  ActiveStorage::MirrorJob.perform_later(key, checksum: checksum) if service.respond_to?(:mirror)
end

def open(tmpdir: nil, &block)
  service.open(
    key,
    checksum: checksum,
    verify: !composed,
    name: [ "ActiveStorage-#{id}-", filename.extension_with_delimiter ],
    tmpdir: tmpdir,
    &block
  )
end

def purge
  destroy
  delete if previously_persisted?
rescue ActiveRecord::InvalidForeignKey
end

def purge_later
  ActiveStorage::PurgeJob.perform_later(self)
end

def scope_for_strict_loading # :nodoc:
  if strict_loading_by_default? && ActiveStorage.track_variants
    includes(variant_records: { image_attachment: :blob }, preview_image_attachment: :blob)
  else
    all
  end
end

def service
  services.fetch(service_name)
end

def service_headers_for_direct_upload
  service.headers_for_direct_upload key, filename: filename, content_type: content_type, content_length: byte_size, checksum: checksum, custom_metadata: custom_metadata
end

def service_metadata
  if forcibly_serve_as_binary?
    { content_type: ActiveStorage.binary_content_type, disposition: :attachment, filename: filename, custom_metadata: custom_metadata }
  elsif !allowed_inline?
    { content_type: content_type, disposition: :attachment, filename: filename, custom_metadata: custom_metadata }
  else
    { content_type: content_type, custom_metadata: custom_metadata }
  end
end

def service_url_for_direct_upload(expires_in: ActiveStorage.service_urls_expire_in)
  service.url_for_direct_upload key, expires_in: expires_in, content_type: content_type, content_length: byte_size, checksum: checksum, custom_metadata: custom_metadata
end

def signed_id(purpose: :blob_id, expires_in: nil)
  super
end

def signed_id_verifier # :nodoc:
  @signed_id_verifier ||= ActiveStorage.verifier
end

def text?
  content_type.start_with?("text")
end

def unfurl(io, identify: true) # :nodoc:
  self.checksum     = compute_checksum_in_chunks(io)
  self.content_type = extract_content_type(io) if content_type.nil? || identify
  self.byte_size    = io.size
  self.identified   = true
end

def update_service_metadata
  service.update_metadata key, **service_metadata if service_metadata.any?
end

def upload(io, identify: true)
  unfurl io, identify: identify
  upload_without_unfurling io
end

def upload_without_unfurling(io) # :nodoc:
  service.upload key, io, checksum: checksum, **service_metadata
end

def url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline, filename: nil, **options)
  service.url key, expires_in: expires_in, filename: ActiveStorage::Filename.wrap(filename || self.filename),
    content_type: content_type_for_serving, disposition: forced_disposition_for_serving || disposition, **options
end

def video?
  content_type.start_with?("video")
end

def web_image?
  ActiveStorage.web_image_content_types.include?(content_type)
end