gem "delayable"

# app/jobs/application_job.rb
class ApplicationJob < ActiveJob::Base
  # Your job configuration
end

# app/models/current.rb
class Current < ActiveSupport::CurrentAttributes
  attribute :user, :request_id, :user_agent
  # Add other attributes as needed
end

class DataProcessor
  include Delayable

  def process_csv_import(file_path, user_id)
    user = User.find(user_id)
    CSV.foreach(file_path, headers: true) do |row|
      user.records.create!(row.to_h)
    end
  end
  delay :process_csv_import

  def sync_external_data(api_endpoint, last_sync_time)
    # Fetch and process data from external API
    ExternalApiClient.new(api_endpoint).sync_data_since(last_sync_time)
  end
  delay :sync_external_data
end

# Usage
processor = DataProcessor.new
processor.process_csv_import_later("/tmp/users.csv", 123)
processor.sync_external_data_later("https://api.example.com/data", 1.hour.ago)

class ReportGenerator
  include Delayable

  def self.generate_monthly_report(month, year)
    # Generate report logic
  end
  delay :generate_monthly_report, class_method: true

  def self.cleanup_old_reports!
    # Cleanup logic
  end
  delay :cleanup_old_reports!, class_method: true
end

# Usage
ReportGenerator.generate_monthly_report_later(12, 2023)
ReportGenerator.cleanup_old_reports_later!

class DataProcessor
  include Delayable

  def process_data!
    # Processing logic
  end
  delay :process_data!
end

# Usage - note the bang is preserved in the delayed method name
processor = DataProcessor.new
processor.process_data_later!  # Creates ProcessDataBangJob

class DataProcessor
  include Delayable

  def process_csv_import(file_path)
    # Large CSV processing logic
  end
  delay :process_csv_import, queue: :data_processing

  def sync_external_api(endpoint)
    # API synchronization logic
  end
  delay :sync_external_api, queue: :integrations
end

class CacheManager
  include Delayable

  def warm_cache(cache_key)
    # Pre-populate cache logic
  end
  delay :warm_cache, wait: 5.minutes

  def cleanup_expired_entries
    # Cache cleanup logic
  end
  delay :cleanup_expired_entries, wait: 1.hour
end

# You can also override the delay at call time
manager = CacheManager.new
manager.warm_cache_later("user_stats", wait: 30.seconds)  # Overrides the 5.minutes default

class ResourceIntensiveTask
  include Delayable

  def process_large_file(file_path)
    # Heavy processing that should be limited
  end
  delay :process_large_file, limits_concurrency: { to: 2 }

  def generate_report(report_type)
    # Report generation that should run one at a time
  end
  delay :generate_report, limits_concurrency: { to: 1, key: -> { "report_#{arguments.first}" } }
end

class AuditLogger
  include Delayable

  def log_action(action, resource_id)
    AuditLog.create!(
      action: action,
      resource_id: resource_id,
      user: Current.user,      # This will be preserved from the original request
      request_id: Current.request_id
    )
  end
  delay :log_action
end

# In a controller
class PostsController < ApplicationController
  def create
    Current.user = current_user
    Current.request_id = request.id
    
    post = Post.create!(post_params)
    
    # The job will have access to Current.user and Current.request_id
    AuditLogger.new.log_action_later("create", post.id)
  end
end

class User < ApplicationRecord
  include Delayable

  def update_profile_completeness
    score = calculate_completeness_score
    update!(profile_completeness: score)
  end
  delay :update_profile_completeness

  def calculate_metrics!
    update!(
      total_posts: posts.count,
      total_comments: comments.count,
      last_activity: Time.current
    )
  end
  delay :calculate_metrics!

  def archive_old_data!
    # Archive user's old posts, comments, etc.
    posts.where('created_at < ?', 1.year.ago).update_all(archived: true)
    comments.where('created_at < ?', 1.year.ago).delete_all
  end
  delay :archive_old_data!
end

# Usage
user = User.find(123)
user.update_profile_completeness_later
user.calculate_metrics_later!
user.archive_old_data_later!

# In your ApplicationJob
class ApplicationJob < ActiveJob::Base
  retry_on StandardError, wait: :exponentially_longer, attempts: 5
  discard_on ActiveRecord::RecordNotFound
  
  rescue_from SomeCustomError do |error|
    # Custom error handling
  end
end

require 'test_helper'

class DataProcessorTest < ActiveSupport::TestCase
  include ActiveJob::TestHelper

  test "CSV import is enqueued" do
    processor = DataProcessor.new
    
    assert_enqueued_jobs 1, only: DataProcessor::ProcessCsvImportJob do
      processor.process_csv_import_later("/tmp/data.csv", 123)
    end
  end

  test "CSV data is imported" do
    processor = DataProcessor.new
    
    perform_enqueued_jobs do
      processor.process_csv_import_later("/tmp/data.csv", 123)
    end
    
    # Assert data was imported
    user = User.find(123)
    assert user.records.count > 0
  end

  test "current attributes are preserved" do
    Current.user = users(:admin)
    
    perform_enqueued_jobs do
      AuditLogger.new.log_action_later("test", 123)
    end
    
    log = AuditLog.last
    assert_equal users(:admin), log.user
  end
end

class ComplexProcessor
  include Delayable

  def process_batch(batch_id, options = {})
    # Complex processing logic
  end
  delay :process_batch, 
        queue: :batch_processing,
        wait: 30.seconds,
        limits_concurrency: { to: 3, key: -> { "batch_#{arguments.first}" } }
end

class NotificationSender
  include Delayable

  def send_reminder(user_id, urgency = :normal)
    # Send reminder logic
  end
  delay :send_reminder

  def send_reminder_with_delay(user_id, urgency = :normal)
    delay_time = case urgency
    when :urgent then 0.seconds
    when :normal then 1.hour
    when :low then 1.day
    end
    
    send_reminder_later(user_id, urgency, wait: delay_time)
  end
end

# In rails console
DataProcessor::ProcessCsvImportJob.new.class.name
# => "DataProcessor::ProcessCsvImportJob"

DataProcessor::ProcessCsvImportJob.queue_name
# => "default"