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(io:, filename:, content_type: nil, metadata: nil, identify: true) #:nodoc:
  new(filename: filename, content_type: content_type, metadata: metadata).tap do |blob|
    blob.unfurl(io, identify: identify)
  end
end

def build_after_upload(io:, filename:, content_type: nil, metadata: nil, identify: true)
  new(filename: filename, content_type: content_type, metadata: metadata).tap do |blob|
    blob.upload(io, identify: identify)
  end
end

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

def content_type_for_service_url
  forcibly_serve_as_binary? ? ActiveStorage.binary_content_type : content_type
end

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

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

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

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

def download(&block)
  service.download key, &block
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)
  find ActiveStorage.verifier.verify(id, purpose: :blob_id)
end

def forced_disposition_for_service_url
  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
  SecureRandom.base36(28)
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
end

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

def purge
  destroy
  delete
rescue ActiveRecord::InvalidForeignKey
end

def purge_later
  ActiveStorage::PurgeJob.perform_later(self)
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
end

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

def service_url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline, filename: nil, **options)
  filename = ActiveStorage::Filename.wrap(filename || self.filename)
  service.url key, expires_in: expires_in, filename: filename, content_type: content_type_for_service_url,
    disposition: forced_disposition_for_service_url || disposition, **options
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
end

def signed_id
  ActiveStorage.verifier.generate(id, purpose: :blob_id)
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 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 video?
  content_type.start_with?("video")
end