gem 'staging_table'

# 1. Create a staging table that mirrors the 'users' table
StagingTable.stage(User) do |staging|
  
  # 2. Bulk insert data (Hashes, AR Objects, or Relations)
  staging.insert([
    { name: 'John Doe', email: 'john@example.com' },
    { name: 'Jane Doe', email: 'jane@example.com' }
  ])
  
  # 3. The 'staging' object is a real ActiveRecord model!
  #    You can query it, validate it, or massage data.
  puts "Staged count: #{staging.count}"
  staging.where(email: nil).delete_all
  
  # 4. When the block exits, data is automatically transferred 
  #    to the 'users' table using a single SQL statement.
end

StagingTable.stage(User) do |staging|
  # 🍎 Array of Hashes
  staging.insert([
    { name: 'John', email: 'john@example.com' },
    { name: 'Jane', email: 'jane@example.com' }
  ])

  # 🍊 Array of ActiveRecord objects
  staging.insert(User.where(active: true).to_a)

  # 🍇 ActiveRecord::Relation (Lazy loading)
  staging.insert(User.where(role: 'admin'))
end

StagingTable.stage(User) do |staging|
  # Processes in batches of 1000 (configurable)
  staging.insert_from_query(User.where(needs_migration: true))
end

StagingTable.stage(User,
  transfer_strategy: :upsert,    # Default is :insert
  conflict_target: [:email],     # Column(s) to check for conflicts
  conflict_action: :update       # :update (overwrite) or :ignore (skip)
) do |staging|
  staging.insert(records)
end

StagingTable.stage(User,
  extra_columns: {
    priority: :integer,                              # Simple type
    processed: {type: :boolean, default: false},    # With options
    import_batch: {type: :string, default: "batch_1"}
  }
) do |staging|
  # Insert with extra column values
  staging.insert([
    {name: "John", email: "john@example.com", priority: 1},
    {name: "Jane", email: "jane@example.com", priority: 2}
  ])

  # Query using extra columns
  staging.where(priority: 1).find_each do |record|
    # Process high priority records first
  end

  # Mark as processed
  staging.where(processed: false).update_all(processed: true)

  # Extra columns are automatically excluded during transfer
end

StagingTable.stage(User,
  extra_columns: {priority: :integer, score: :integer},
  insert_on_conflict: {
    target: [:email],           # Column(s) to detect conflicts
    update: {
      priority: :greatest,      # Keep the higher value
      score: :sum,              # Add values together
      name: :new,               # Use the incoming value
      age: :existing            # Keep the existing value (skip update)
    }
  }
) do |staging|
  # First batch
  staging.insert([
    {email: "john@example.com", name: "John", priority: 1, score: 10}
  ])

  # Second batch - conflicts are resolved automatically
  staging.insert([
    {email: "john@example.com", name: "Johnny", priority: 5, score: 20}
  ])

  # Result: priority=5 (greatest), score=30 (sum), name="Johnny" (new)
end

result = StagingTable.stage(User) do |staging|
  staging.insert(records)
end

puts result.inserted  # => 450  (new records)
puts result.updated   # => 50   (updated via upsert)
puts result.skipped   # => 10   (ignored conflicts)
puts result.total     # => 510  (total processed)
puts result.success?  # => true (any inserts or updates?)

# Also available as a hash
result.to_h # => { inserted: 450, updated: 50, skipped: 10, total: 510 }

StagingTable.stage(User,
  before_insert: ->(session) {
    Rails.logger.info "Starting import..."
  },
  after_insert: ->(session, records) {
    Rails.logger.info "Staged #{records.count} records"
  },
  before_transfer: ->(session) {
    # Clean up invalid data before transfer
    session.where(email: nil).delete_all
    session.where(status: 'banned').delete_all
  },
  after_transfer: ->(session, result) {
    Rails.logger.info "Imported #{result.inserted} new, updated #{result.updated}"
  }
) do |staging|
  staging.insert(records)
end

# Subscribe to transfer events
StagingTable::Instrumentation.subscribe(:transfer) do |event|
  Rails.logger.info "[StagingTable] Transfer to #{event.payload[:source_table]} " \
                    "completed in #{event.duration.round(2)}ms"
  StatsD.measure('staging_table.transfer.duration', event.duration)
  StatsD.increment('staging_table.transfer.inserted', event.payload[:result].inserted)
end

# Subscribe to all StagingTable events
StagingTable::Instrumentation.subscribe_all do |event|
  Rails.logger.debug "[StagingTable] #{event.name}: #{event.duration.round(2)}ms"
end

ActiveSupport::Notifications.subscribe('staging_table.transfer') do |event|
  # Your monitoring code here
end

# Create the session
session = StagingTable::Session.new(User, excluded_columns: %w[created_at updated_at])
session.create_table

begin
  # Insert data in chunks
  session.insert(batch_1)
  session.insert(batch_2)
  
  # Run some sanity checks
  if session.where(status: 'banned').exists?
    raise "Whoa there! No banned users allowed."
  end
  
  # Commit to the real table
  result = session.transfer
  puts "Transferred #{result.total} records"
ensure
  # Always clean up your mess
  session.drop_table
end

StagingTable.configure do |config|
  config.default_batch_size = 2000
  config.default_transfer_strategy = :insert # or :upsert
end

# Gemfile
gem 'steep', group: :development

# Steepfile
target :lib do
  signature "sig"
  check "lib"
  library "activerecord"
  library "activesupport"
end